Temporal and okf/merge prs

integrations/langgraph/langgraph_memanto/nodes.py

@@ -246,6 +246,9 @@ def remember_node(
             return {"messages": []}
 
         content = "\n\n".join(messages_to_remember)
+        max_content = 10_000
+        if len(content) > max_content:
+            content = content[-max_content:]
         title = content if len(content) <= 50 else content[:47] + "..."
 
         agent_client, agent_lock = _cache.get(resolved_agent_id)

integrations/langgraph/langgraph_memanto/store.py

@@ -403,9 +403,30 @@ def _do_list_namespaces(self, op: ListNamespacesOp) -> list[tuple[str, ...]]:
             logger.warning("MemantoStore: Failed to list agents: %s", e)
             return []
 
+        if isinstance(agents, dict):
+            agent_items = agents.get("agents")
+            if not isinstance(agent_items, list):
+                logger.warning(
+                    "MemantoStore: unexpected list_agents payload keys: %s",
+                    sorted(agents),
+                )
+                return []
+        elif isinstance(agents, list):
+            agent_items = agents
+        else:
+            logger.warning(
+                "MemantoStore: unexpected list_agents payload type: %s",
+                type(agents).__name__,
+            )
+            return []
+
         namespaces = []
-        for agent in agents:
+        for agent in agent_items:
+            if not isinstance(agent, dict):
+                continue
             agent_id = agent.get("agent_id") or agent.get("id") or ""
+            if not isinstance(agent_id, str):
+                continue
             if agent_id.startswith(self._agent_prefix):
                 ns_str = agent_id[len(self._agent_prefix) :]
                 if ns_str == "default":

memanto/app/config.py

@@ -190,3 +190,21 @@ def get_data_dir() -> Path:
         d.mkdir(parents=True, exist_ok=True)
         return d
     return base
+
+
+def get_conflicts_dir() -> Path:
+    """Return the shared directory for conflict reports."""
+    d = get_data_dir() / "conflicts"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def get_conflict_report_path(agent_id: str, date: str) -> Path:
+    """Return a safely constructed path for a conflict report, validating components against traversal."""
+    import re
+
+    if not re.match(r"^[\w\-]+$", agent_id):
+        raise ValueError(f"Invalid agent_id format: {agent_id}")
+    if not re.match(r"^\d{4}-\d{2}-\d{2}$", date):
+        raise ValueError(f"Invalid date format: {date}")
+    return get_conflicts_dir() / f"{agent_id}_{date}_conflicts.json"

memanto/app/constants.py

@@ -82,3 +82,14 @@
 }
 
 VALID_PATTERNS = {"support", "project", "tool"}
+
+# Trust fields removed from the schema. Must not be resurrected during update.
+REMOVED_TRUST_FIELDS = frozenset(
+    {
+        "superseded_by",
+        "supersedes",
+        "validated_at",
+        "validation_count",
+        "contradiction_detected",
+    }
+)

memanto/app/core.py

@@ -4,7 +4,7 @@
 
 import re
 import uuid
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from typing import Annotated, Any
 
 from pydantic import BaseModel, Field, StringConstraints, field_validator
@@ -130,6 +130,10 @@ def _normalize_title_newlines(cls, value: Any) -> Any:
     expired_at: datetime | None = None
     expired_by: BoundedExpiredBy | None = None
 
+    def set_ttl(self, ttl_seconds: int) -> None:
+        """Set expiration time based on a TTL in seconds."""
+        self.expired_at = datetime.now(timezone.utc) + timedelta(seconds=ttl_seconds)
+
     def to_moorcheh_document(self) -> dict[str, Any]:
         """
         Convert to Moorcheh document format with flat metadata fields.

memanto/app/main.py

@@ -97,6 +97,8 @@ def _validate_cors_settings(
     allow_credentials=settings.CORS_ALLOW_CREDENTIALS,
     allow_methods=["*"],
     allow_headers=["*"],
+    # Header-authenticated API clients must be able to read an auto-renewed
+    # token from the response. Custom response headers are not CORS-safelisted.
     expose_headers=["X-Session-Token"],
 )
 

memanto/app/models/__init__.py

@@ -53,6 +53,11 @@ class BatchRememberItem(BaseModel):
         "explicit_statement",
         description="How memory was obtained (explicit_statement, inferred, observed, etc.)",
     )
+    ttl_seconds: int | None = Field(
+        None,
+        ge=1,
+        description="Time-to-live in seconds. Memory expires after this duration.",
+    )
 
     @field_validator("content")
     @classmethod

memanto/app/routes/memory.py

@@ -48,7 +48,7 @@
 from memanto.app.services.policy_presets import PRESETS, list_presets, load_preset
 from memanto.app.utils.errors import (
     AuthorizationError,
-    MemoryError,
+    MemoryOperationError,
     map_error_to_http_exception,
 )
 from memanto.app.utils.temporal_helpers import (
@@ -462,6 +462,9 @@ async def remember(
             provenance=cast(ProvenanceType, request.provenance),
         )
 
+        if request.ttl_seconds:
+            memory.set_ttl(request.ttl_seconds)
+
         # Store memory in agent's namespace.
         result = await asyncio.to_thread(write_service.store_memory, memory)
         status = str(result.get("status", "unknown"))
@@ -541,6 +544,8 @@ async def batch_remember(
                 source=item.source,
                 provenance=cast(ProvenanceType, item.provenance),
             )
+            if item.ttl_seconds:
+                memory.set_ttl(item.ttl_seconds)
             memory_records.append(memory)
 
         # Store in batch
@@ -724,14 +729,14 @@ async def extract_memories_from_conversation(
         session_service = get_session_service()
 
         if not isinstance(result, dict):
-            raise MemoryError(
+            raise MemoryOperationError(
                 message="Data corruption detected: Received malformed batch result from storage layer.",
                 details={"item_preview": str(result)[:100]},
             )
 
         batch_results = result.get("results", [])
         if not isinstance(batch_results, list):
-            raise MemoryError(
+            raise MemoryOperationError(
                 message="Data corruption detected: Received malformed batch result array from storage layer.",
                 details={"item_preview": str(batch_results)[:100]},
             )
@@ -741,7 +746,7 @@ async def extract_memories_from_conversation(
             if item_result is not None and (
                 not isinstance(item_result, dict) or not item_result
             ):
-                raise MemoryError(
+                raise MemoryOperationError(
                     message="Data corruption detected: Received malformed batch result from storage layer.",
                     details={"item_preview": str(item_result)[:100]},
                 )

memanto/app/routes/sessions.py

@@ -179,8 +179,11 @@ async def delete_agent(
                 # and continue removing local metadata.
                 pass
 
-        agent_service.delete_agent(agent_id)
+        # Revoke the persisted token before removing agent metadata. If local
+        # session cleanup fails, abort the deletion so an apparently deleted
+        # agent cannot keep authorizing requests with its old token.
         get_session_service().delete_session(agent_id)
+        agent_service.delete_agent(agent_id)
         return {
             "message": (
                 f"Agent '{agent_id}' successfully deleted"

memanto/app/services/agent_service.py

@@ -18,7 +18,11 @@
 from memanto.app.core import agent_namespace
 from memanto.app.models.session import AgentCreate, AgentInfo, AgentList
 from memanto.app.utils.atomic_write import atomic_write_text
-from memanto.app.utils.errors import AgentAlreadyExistsError, AgentNotFoundError
+from memanto.app.utils.errors import (
+    AgentAlreadyExistsError,
+    AgentNotFoundError,
+    NamespaceError,
+)
 from memanto.app.utils.temporal_helpers import as_utc_aware
 from memanto.app.utils.validation import validate_safe_id
 
@@ -96,18 +100,18 @@ def create_agent(
             try:
                 client.namespaces.create(namespace, type="text")
                 print(f"[OK] Namespace created in Moorcheh: {namespace}")
-            except ConflictError:
-                print(f"[OK] Namespace already exists in Moorcheh: {namespace}")
             except Exception as exc:
                 message = str(exc).lower()
-                if (
+                if "limit" in message or "tier" in message or "quota" in message:
+                    raise NamespaceError(f"Moorcheh namespace limit reached: {exc}")
+                if isinstance(exc, ConflictError) or (
                     "namespace" in message and "already exists" in message
-                ) or "conflict" in message:
+                ):
                     print(f"[OK] Namespace already exists in Moorcheh: {namespace}")
                 else:
-                    raise Exception(
+                    raise NamespaceError(
                         f"Failed to create namespace '{namespace}' in Moorcheh: {exc}"
-                    )
+                    ) from exc
 
             agent = AgentInfo(
                 agent_id=agent_create.agent_id,