devsper 2.1.7__tar.gz → 2.1.8__tar.gz

{devsper-2.1.7 → devsper-2.1.8}/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.1.8] — 2026-03-24
+
+### Changed
+
+- **Memory management** — Runtime lifecycle and retention tuned for lower steady-state memory use (agent/worker paths, caches, and long-run cleanup).
+
 ## [2.1.7] — 2026-03-18
 
 ### Added

{devsper-2.1.7 → devsper-2.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devsper
-Version: 2.1.7
+Version: 2.1.8
 Summary: Orchestrate distributed swarms of AI agents that collaboratively solve complex tasks.
 Project-URL: Homepage, https://github.com/devsper-com/runtime
 Project-URL: Documentation, https://docs.devsper.com
@@ -68,7 +68,7 @@ Provides-Extra: worker
 Description-Content-Type: text/markdown
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/rithulkamesh/devsper/refs/heads/main/branding/logo_bg.svg" alt="devsper" width="120" height="140" />
+  <img src="https://raw.githubusercontent.com/devsper-com/runtime/refs/heads/main/branding/logo.svg" alt="devsper" width="120" height="140" style="background:#fff; padding:12px; border-radius:10px; filter:invert(1);" />
 </p>
 
 <h1 align="center">devsper</h1>

{devsper-2.1.7 → devsper-2.1.8}/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="https://raw.githubusercontent.com/rithulkamesh/devsper/refs/heads/main/branding/logo_bg.svg" alt="devsper" width="120" height="140" />
+  <img src="https://raw.githubusercontent.com/devsper-com/runtime/refs/heads/main/branding/logo.svg" alt="devsper" width="120" height="140" style="background:#fff; padding:12px; border-radius:10px; filter:invert(1);" />
 </p>
 
 <h1 align="center">devsper</h1>

devsper-2.1.8/branding/logo.svg

@@ -0,0 +1,3 @@
+<svg width="796" height="583" viewBox="0 0 796 583" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M109.999 149.049C213.579 53.4691 359.089 14.2192 498.169 37.6292C660.529 64.9592 805.309 196.569 794.479 370.739C777.819 638.639 360.969 598.919 185.739 538.289C147.749 525.149 58.8887 459.529 29.8687 430.079C-11.9913 387.589 -8.84095 271.889 32.979 229.329C47.099 214.949 74.6887 209.779 77.6387 189.029C81.8087 159.639 71.5488 123.319 75.5088 92.8392C74.2888 86.6392 62.4288 80.8592 57.2388 74.3592C28.5488 38.4192 64.5488 -12.2908 108.239 2.69915C136.239 12.3092 146.359 49.4892 129.359 73.1192C125.319 78.7392 109.989 87.8091 109.989 92.7891V149.049H109.999ZM91.0088 34.6392C77.4188 36.5892 79.219 59.4391 94.919 57.2691C107.559 55.5191 106.439 32.4292 91.0088 34.6392ZM619.819 211.029C614.309 175.759 579.229 98.4692 546.379 83.5692C509.949 67.0392 431.269 61.7293 391.219 63.9793C378.359 64.6993 299.969 75.6292 296.039 83.6392L333.839 110.079C351.789 126.299 367.599 144.409 379.079 165.879C383.579 174.299 395.509 208.969 400.949 210.599C413.689 214.419 447.149 206.879 462.419 206.349C515.169 204.519 567.349 209.439 619.819 211.019V211.029ZM376.219 215.439C369.819 175.289 339.429 134.849 305.019 113.639C296.649 108.479 270.829 95.1192 262.169 94.4092C246.879 93.1592 178.579 135.229 164.029 146.809C157.269 152.199 116.869 188.409 121.479 194.939C159.499 198.249 181.829 231.399 192.749 264.919C209.559 316.579 207.659 419.479 160.579 455.629C151.539 462.569 139.999 464.549 132.969 472.769C155.319 484.189 175.289 495.459 198.999 504.359C217.709 511.379 256.219 525.129 274.819 527.339C279.329 527.879 282.219 528.829 286.789 526.719C295.239 522.829 327.199 477.729 323.579 472.829C283.529 460.149 249.339 422.139 245.529 379.769C240.769 326.759 248.699 275.109 295.299 243.609C320.669 226.459 347.149 222.529 376.219 215.429V215.439ZM649.679 514.109C685.779 509.179 717.399 477.099 735.079 446.819C792.989 347.639 761.959 248.689 686.489 170.799C662.499 146.039 631.189 120.889 599.169 107.729C607.749 125.499 618.289 142.059 625.529 160.569C630.439 173.099 637.119 205.239 643.999 213.279C649.259 219.429 666.519 222.709 675.649 227.559C751.649 267.899 749.069 394.439 701.159 454.249C686.909 472.029 684.069 467.459 667.419 475.629C654.679 481.879 656.599 502.809 649.679 514.119V514.109ZM87.0391 429.149C127.029 437.859 141.059 441.249 157.029 401.579C171.909 364.619 172.469 325.329 164.039 286.729C156.619 252.759 134.849 216.799 94.3687 233.309C74.8187 241.279 90.049 242.929 97.149 252.579C125.339 287.599 126.559 362.739 106.289 401.359L87.0391 429.149ZM54.2789 268.809C31.8589 272.789 32.749 334.979 34.129 352.339C35.479 369.449 44.2189 413.119 68.7789 393.689C84.6789 381.109 88.2687 341.359 87.1187 322.319C86.0987 305.429 78.3589 264.539 54.2789 268.819V268.809ZM619.289 294.139C572.689 299.459 577.849 405.859 620.929 406.299C671.199 406.809 672.469 288.059 619.289 294.139ZM377.169 303.669C352.459 328.529 358.179 412.999 402.219 405.719C437.079 399.959 439.229 336.489 422.759 310.489C412.359 294.069 391.329 289.419 377.159 303.669H377.169ZM638.189 481.999C575.279 490.409 512.219 492.709 448.639 491.259L347.719 479.619C345.669 479.589 344.539 480.829 343.109 482.019C334.899 488.809 320.389 525.109 309.799 534.779C411.509 553.719 520.819 559.009 620.559 528.079L638.189 482.009V481.999Z" fill="white"/>
+</svg>

{devsper-2.1.7 → devsper-2.1.8}/devsper/agents/agent.py

@@ -379,12 +379,14 @@ class Agent:
         message_bus=None,
         audit_logger=None,
         audit_run_id: str = "",
+        memory_namespace: str | None = None,
     ):
         self.model_name = model_name
         self.event_log = event_log or EventLog()
         self.use_tools = use_tools
         self.max_tool_iterations = max_tool_iterations
         self.memory_router = memory_router
+        self.memory_namespace = memory_namespace
         self.store_result_to_memory = store_result_to_memory
         self.reasoning_store = reasoning_store
         self.user_task = user_task
@@ -397,8 +399,14 @@ class Agent:
     def run(self, request: AgentRequest) -> AgentResponse:
         """Stateless run: all context in AgentRequest, all output in AgentResponse."""
         import time
+        from devsper.memory.context import attach_memory_context, detach_memory_context
+
         t0 = time.perf_counter()
         task_id = request.task.id
+        ctx = attach_memory_context(
+            getattr(self.memory_router, "store", None) if self.memory_router else None,
+            self.memory_namespace,
+        )
         try:
             self._emit(events.AGENT_STARTED, {"task_id": task_id})
             self._emit(events.TASK_STARTED, {"task_id": task_id})
@@ -503,6 +511,8 @@ class Agent:
                 error=str(e),
                 success=False,
             )
+        finally:
+            detach_memory_context(ctx)
 
     def build_request(
         self,
@@ -690,7 +700,7 @@ class Agent:
         index = getattr(self.memory_router, "index", None)
         if isinstance(index, MemoryIndex):
             record = index.ensure_embedding(record)
-        store.store(record)
+        store.store(record, namespace=self.memory_namespace)
 
     def _run_with_tools_for_request(
         self,

devsper-2.1.8/devsper/memory/context.py

@@ -0,0 +1,36 @@
+"""Process/async context for memory store + namespace (tools + agent execution)."""
+
+from __future__ import annotations
+
+from contextvars import ContextVar, Token
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    pass
+
+_current_store: ContextVar[object | None] = ContextVar("devsper_memory_store", default=None)
+_current_namespace: ContextVar[str | None] = ContextVar("devsper_memory_namespace", default=None)
+
+
+def attach_memory_context(store: object | None, namespace: str | None) -> tuple[Token[object | None], Token[str | None]]:
+    return (_current_store.set(store), _current_namespace.set(namespace))
+
+
+def detach_memory_context(tokens: tuple[Token[object | None], Token[str | None]]) -> None:
+    _current_store.reset(tokens[0])
+    _current_namespace.reset(tokens[1])
+
+
+def get_effective_memory_store():
+    """Prefer agent/router store when set; else process default SQLite store."""
+    s = _current_store.get()
+    if s is not None:
+        return s
+    from devsper.memory.memory_store import get_default_store
+
+    return get_default_store()
+
+
+def get_effective_memory_namespace() -> str | None:
+    """Active namespace for tool memory ops (None = legacy global/run default)."""
+    return _current_namespace.get()

{devsper-2.1.7 → devsper-2.1.8}/devsper/memory/memory_index.py

@@ -33,6 +33,7 @@ class MemoryIndex:
         top_k: int = 5,
         min_similarity: float = 0.0,
         include_archived: bool = False,
+        namespace: str | None = None,
     ) -> list[MemoryRecord]:
         """
         Semantic search: embed query, score against stored records with embeddings,
@@ -41,7 +42,9 @@ class MemoryIndex:
         Use min_similarity > 0 (e.g. 0.45) to avoid injecting barely-related memory.
         By default excludes archived records (consolidation).
         """
-        records = self.store.list_memory(limit=500, include_archived=include_archived)
+        records = self.store.list_memory(
+            limit=500, include_archived=include_archived, namespace=namespace
+        )
         if not records:
             return []
         query_emb = embed_text(text)
@@ -64,6 +67,7 @@ class MemoryIndex:
         min_similarity: float = 0.0,
         run_id_filter: str | None = None,
         include_archived: bool = False,
+        namespace: str | None = None,
     ) -> list[MemoryRecord]:
         """
         v1.8: Same as query_memory but over more records (all runs), optional run_id filter.
@@ -73,6 +77,7 @@ class MemoryIndex:
             limit=2000,
             include_archived=include_archived,
             run_id_filter=run_id_filter,
+            namespace=namespace,
         )
         if not records:
             return []

{devsper-2.1.7 → devsper-2.1.8}/devsper/memory/memory_router.py

@@ -20,11 +20,13 @@ class MemoryRouter:
         index: MemoryIndex | None = None,
         top_k: int = 10,
         min_similarity: float = 0.55,
+        default_namespace: str | None = None,
     ) -> None:
         self.store = store or MemoryStore()
         self.index = index or MemoryIndex(self.store)
         self.top_k = top_k
         self.min_similarity = min_similarity
+        self.default_namespace = default_namespace
 
     def get_relevant_memory(self, task: str) -> list[MemoryRecord]:
         """
@@ -35,6 +37,7 @@ class MemoryRouter:
             task,
             top_k=self.top_k,
             min_similarity=self.min_similarity,
+            namespace=self.default_namespace,
         )
 
     def get_memory_context(self, task: str) -> str:
@@ -44,7 +47,9 @@ class MemoryRouter:
         Empty if no memories meet the relevance threshold.
         """
         lines = []
-        inject_records = self.store.list_memory(tag_contains="user_injection", limit=10)
+        inject_records = self.store.list_memory(
+            tag_contains="user_injection", limit=10, namespace=self.default_namespace
+        )
         if inject_records:
             lines.append("USER INJECTIONS (high priority):")
             for r in inject_records:

{devsper-2.1.7 → devsper-2.1.8}/devsper/memory/memory_store.py

@@ -20,6 +20,13 @@ def _default_db_path() -> str:
     return os.path.join(base, "memory.db")
 
 
+def _norm_namespace(namespace: str | None) -> str:
+    """SQLite partition key; empty string means legacy default (same as namespace=None)."""
+    if namespace is None or namespace == "":
+        return ""
+    return namespace
+
+
 class MemoryStore:
     """Local persistent store for memory records. Uses SQLite."""
 
@@ -60,8 +67,17 @@ class MemoryStore:
                 conn.execute("ALTER TABLE memory ADD COLUMN archived INTEGER DEFAULT 0")
             except sqlite3.OperationalError:
                 pass
+            try:
+                conn.execute(
+                    "ALTER TABLE memory ADD COLUMN namespace TEXT NOT NULL DEFAULT ''"
+                )
+            except sqlite3.OperationalError:
+                pass
+            conn.execute(
+                "CREATE INDEX IF NOT EXISTS ix_memory_namespace ON memory(namespace)"
+            )
 
-    def store(self, record: MemoryRecord) -> str:
+    def store(self, record: MemoryRecord, namespace: str | None = None) -> str:
         """Store a memory record. Returns record id. Redacts PII if compliance.pii_redaction enabled."""
         content = record.content
         try:
@@ -84,12 +100,13 @@ class MemoryStore:
         embedding_json = json.dumps(emb) if emb is not None else None
         archived = row.get("archived", 0)
         run_id = row.get("run_id", "") or ""
+        ns = _norm_namespace(namespace)
         with self._conn() as conn:
             conn.execute(
                 """
                 INSERT OR REPLACE INTO memory
-                (memory_id, memory_type, content, tags, timestamp, source_task, embedding, run_id, archived)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                (memory_id, memory_type, content, tags, timestamp, source_task, embedding, run_id, archived, namespace)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                 """,
                 (
                     row["memory_id"],
@@ -101,27 +118,39 @@ class MemoryStore:
                     embedding_json,
                     run_id,
                     archived,
+                    ns,
                 ),
             )
         return row["memory_id"]
 
-    def retrieve(self, memory_id: str) -> MemoryRecord | None:
+    def retrieve(self, memory_id: str, namespace: str | None = None) -> MemoryRecord | None:
         """Retrieve a single record by id."""
+        ns = _norm_namespace(namespace)
         with self._conn() as conn:
             conn.row_factory = sqlite3.Row
             cur = conn.execute(
-                "SELECT memory_id, memory_type, content, tags, timestamp, source_task, embedding, run_id, archived FROM memory WHERE memory_id = ?",
-                (memory_id,),
+                """
+                SELECT memory_id, memory_type, content, tags, timestamp, source_task, embedding, run_id, archived,
+                       COALESCE(namespace, '') AS namespace
+                FROM memory WHERE memory_id = ? AND COALESCE(namespace, '') = ?
+                """,
+                (memory_id, ns),
             )
             row = cur.fetchone()
         if row is None:
             return None
-        return _row_to_record(dict(row))
+        d = dict(row)
+        d.pop("namespace", None)
+        return _row_to_record(d)
 
-    def delete(self, memory_id: str) -> bool:
+    def delete(self, memory_id: str, namespace: str | None = None) -> bool:
         """Delete a record. Returns True if something was deleted."""
+        ns = _norm_namespace(namespace)
         with self._conn() as conn:
-            cur = conn.execute("DELETE FROM memory WHERE memory_id = ?", (memory_id,))
+            cur = conn.execute(
+                "DELETE FROM memory WHERE memory_id = ? AND COALESCE(namespace, '') = ?",
+                (memory_id, ns),
+            )
             return cur.rowcount > 0
 
     def list_memory(
@@ -132,12 +161,14 @@ class MemoryStore:
         tag_contains: str | None = None,
         include_archived: bool = False,
         run_id_filter: str | None = None,
+        namespace: str | None = None,
     ) -> list[MemoryRecord]:
-        """List records, optionally filtered by type, tag, archived, run_id, with limit/offset."""
+        """List records, optionally filtered by type, tag, archived, run_id, namespace, with limit/offset."""
+        ns = _norm_namespace(namespace)
         with self._conn() as conn:
             conn.row_factory = sqlite3.Row
-            conditions = []
-            params = []
+            conditions = ["COALESCE(namespace, '') = ?"]
+            params: list = [ns]
             if memory_type is not None:
                 conditions.append("memory_type = ?")
                 params.append(memory_type.value)
@@ -149,40 +180,64 @@ class MemoryStore:
             if run_id_filter is not None:
                 conditions.append("run_id = ?")
                 params.append(run_id_filter)
-            where = (" WHERE " + " AND ".join(conditions)) if conditions else ""
+            where = " WHERE " + " AND ".join(conditions)
             params.extend([limit, offset])
             cur = conn.execute(
                 f"""
                 SELECT memory_id, memory_type, content, tags, timestamp, source_task, embedding,
-                       COALESCE(run_id, '') as run_id, COALESCE(archived, 0) as archived
+                       COALESCE(run_id, '') as run_id, COALESCE(archived, 0) as archived,
+                       COALESCE(namespace, '') as namespace
                 FROM memory{where} ORDER BY timestamp DESC LIMIT ? OFFSET ?
                 """,
                 params,
             )
             rows = cur.fetchall()
-        return [_row_to_record(dict(r)) for r in rows]
+        out = []
+        for r in rows:
+            d = dict(r)
+            d.pop("namespace", None)
+            out.append(_row_to_record(d))
+        return out
 
-    def list_all_ids(self, memory_type: MemoryType | None = None) -> list[str]:
+    def list_all_ids(self, memory_type: MemoryType | None = None, namespace: str | None = None) -> list[str]:
         """List all memory ids (for index sync)."""
+        ns = _norm_namespace(namespace)
         with self._conn() as conn:
             if memory_type is not None:
                 cur = conn.execute(
-                    "SELECT memory_id FROM memory WHERE memory_type = ?",
-                    (memory_type.value,),
+                    """
+                    SELECT memory_id FROM memory
+                    WHERE memory_type = ? AND COALESCE(namespace, '') = ?
+                    """,
+                    (memory_type.value, ns),
                 )
             else:
-                cur = conn.execute("SELECT memory_id FROM memory")
+                cur = conn.execute(
+                    "SELECT memory_id FROM memory WHERE COALESCE(namespace, '') = ?",
+                    (ns,),
+                )
             return [r[0] for r in cur.fetchall()]
 
-    def set_archived(self, memory_id: str, archived: bool = True) -> bool:
+    def set_archived(self, memory_id: str, archived: bool = True, namespace: str | None = None) -> bool:
         """v1.8: Mark a record as archived (e.g. after consolidation)."""
+        ns = _norm_namespace(namespace)
         with self._conn() as conn:
             cur = conn.execute(
-                "UPDATE memory SET archived = ? WHERE memory_id = ?",
-                (1 if archived else 0, memory_id),
+                """
+                UPDATE memory SET archived = ?
+                WHERE memory_id = ? AND COALESCE(namespace, '') = ?
+                """,
+                (1 if archived else 0, memory_id, ns),
             )
             return cur.rowcount > 0
 
+    def purge_namespace(self, namespace: str) -> None:
+        """Remove all memory rows for a logical namespace (e.g. when a project is deleted)."""
+        if not namespace or not str(namespace).strip():
+            return
+        with self._conn() as conn:
+            conn.execute("DELETE FROM memory WHERE namespace = ?", (namespace,))
+
 
 def _row_to_record(row: dict) -> MemoryRecord:
     tags_str = row.get("tags") or ""

{devsper-2.1.7 → devsper-2.1.8}/devsper/memory/redis_memory.py

@@ -20,12 +20,15 @@ class RedisMemoryStore(MemoryStore):
     """
     Shared memory store backed by Redis hashes + sorted set.
 
-    Keys:
+    Keys (namespace None → same as legacy run-scoped layout):
       devsper:memory:{run_id}:records  (HASH) memory_id -> json row
       devsper:memory:{run_id}:index    (ZSET) memory_id -> timestamp score
+
+    With explicit namespace (e.g. project:uuid):
+      devsper:memory:{namespace}:records / :index
     """
 
-    def __init__(self, redis_url: str, run_id: str):
+    def __init__(self, redis_url: str, run_id: str, default_namespace: str | None = None):
         # Don't init sqlite schema; this store isn't sqlite-backed.
         self.db_path = ""
         try:
@@ -34,27 +37,39 @@ class RedisMemoryStore(MemoryStore):
             raise ImportError("RedisMemoryStore requires 'redis' package.") from e
         self._redis = redis.Redis.from_url(redis_url, decode_responses=True)
         self._run_id = run_id
-        self._records_key = f"devsper:memory:{run_id}:records"
-        self._index_key = f"devsper:memory:{run_id}:index"
+        self._default_namespace = default_namespace
+
+    def set_default_namespace(self, namespace: str | None) -> None:
+        """Switch logical partition for subsequent ops with namespace=None."""
+        self._default_namespace = namespace
 
-    def store(self, record: MemoryRecord) -> str:
+    def _keys(self, namespace: str | None) -> tuple[str, str]:
+        ns = namespace if namespace is not None else self._default_namespace
+        if ns is None or ns == "":
+            base = f"devsper:memory:{self._run_id}"
+        else:
+            base = f"devsper:memory:{ns}"
+        return f"{base}:records", f"{base}:index"
+
+    def store(self, record: MemoryRecord, namespace: str | None = None) -> str:
+        records_key, index_key = self._keys(namespace)
         row = record.to_store_row()
         row["run_id"] = record.run_id or self._run_id
         # embedding can be list[float] or None
         data = json.dumps(row)
         memory_id = row["memory_id"]
-        ts = row.get("timestamp") or datetime.now(timezone.utc).isoformat()
         score = time.time()
         pipe = self._redis.pipeline()
-        pipe.hset(self._records_key, memory_id, data)
-        pipe.zadd(self._index_key, {memory_id: score})
-        pipe.expire(self._records_key, 86400 * 7)
-        pipe.expire(self._index_key, 86400 * 7)
+        pipe.hset(records_key, memory_id, data)
+        pipe.zadd(index_key, {memory_id: score})
+        pipe.expire(records_key, 86400 * 7)
+        pipe.expire(index_key, 86400 * 7)
         pipe.execute()
         return memory_id
 
-    def retrieve(self, memory_id: str) -> MemoryRecord | None:
-        raw = self._redis.hget(self._records_key, memory_id)
+    def retrieve(self, memory_id: str, namespace: str | None = None) -> MemoryRecord | None:
+        records_key, _ = self._keys(namespace)
+        raw = self._redis.hget(records_key, memory_id)
         if not raw:
             return None
         try:
@@ -63,10 +78,11 @@ class RedisMemoryStore(MemoryStore):
         except Exception:
             return None
 
-    def delete(self, memory_id: str) -> bool:
+    def delete(self, memory_id: str, namespace: str | None = None) -> bool:
+        records_key, index_key = self._keys(namespace)
         pipe = self._redis.pipeline()
-        pipe.hdel(self._records_key, memory_id)
-        pipe.zrem(self._index_key, memory_id)
+        pipe.hdel(records_key, memory_id)
+        pipe.zrem(index_key, memory_id)
         res = pipe.execute()
         try:
             return bool(res and res[0] > 0)
@@ -81,14 +97,16 @@ class RedisMemoryStore(MemoryStore):
         tag_contains: str | None = None,
         include_archived: bool = False,
         run_id_filter: str | None = None,
+        namespace: str | None = None,
     ) -> list[MemoryRecord]:
-        ids = self._redis.zrevrange(self._index_key, 0, -1)
+        _, index_key = self._keys(namespace)
+        records_key, _ = self._keys(namespace)
+        ids = self._redis.zrevrange(index_key, 0, -1)
         if not ids:
             return []
-        # Apply offset/limit after filtering
         out: list[MemoryRecord] = []
         for mid in ids:
-            raw = self._redis.hget(self._records_key, mid)
+            raw = self._redis.hget(records_key, mid)
             if not raw:
                 continue
             try:
@@ -106,18 +124,19 @@ class RedisMemoryStore(MemoryStore):
                 if not any(tag_contains in t for t in (rec.tags or [])):
                     continue
             out.append(rec)
-        sliced = out[offset : offset + limit]
-        return sliced
+        return out[offset : offset + limit]
 
-    def list_all_ids(self, memory_type: MemoryType | None = None) -> list[str]:
-        ids = self._redis.zrevrange(self._index_key, 0, -1)
+    def list_all_ids(self, memory_type: MemoryType | None = None, namespace: str | None = None) -> list[str]:
+        _, index_key = self._keys(namespace)
+        records_key, _ = self._keys(namespace)
+        ids = self._redis.zrevrange(index_key, 0, -1)
         if not ids:
             return []
         if memory_type is None:
             return [str(i) for i in ids]
         out: list[str] = []
         for mid in ids:
-            raw = self._redis.hget(self._records_key, mid)
+            raw = self._redis.hget(records_key, mid)
             if not raw:
                 continue
             try:
@@ -129,3 +148,20 @@ class RedisMemoryStore(MemoryStore):
                 continue
         return out
 
+    def set_archived(self, memory_id: str, archived: bool = True, namespace: str | None = None) -> bool:
+        rec = self.retrieve(memory_id, namespace=namespace)
+        if rec is None:
+            return False
+        rec = rec.model_copy(update={"archived": archived})
+        self.store(rec, namespace=namespace)
+        return True
+
+    def purge_namespace(self, namespace: str) -> None:
+        if not namespace or not str(namespace).strip():
+            return
+        records_key, index_key = self._keys(namespace)
+        pipe = self._redis.pipeline()
+        pipe.delete(records_key)
+        pipe.delete(index_key)
+        pipe.execute()
+

devsper-2.1.8/devsper/memory/store.py

@@ -0,0 +1,10 @@
+"""
+Platform-facing memory storage API (namespaced MemoryStore).
+
+Implementation lives in ``memory_store``; this module is the stable import path
+for project/org/run-scoped isolation.
+"""
+
+from devsper.memory.memory_store import MemoryStore, generate_memory_id, get_default_store
+
+__all__ = ["MemoryStore", "generate_memory_id", "get_default_store"]

{devsper-2.1.7 → devsper-2.1.8}/devsper/nodes/worker.py

@@ -29,6 +29,7 @@ from devsper.cluster.registry import ClusterRegistry
 from devsper.swarm.prefetcher import PrefetchResult
 from devsper.tools.registry import ToolRegistry
 from devsper.memory.redis_memory import RedisMemoryStore
+from devsper.memory.memory_index import MemoryIndex
 
 log = logging.getLogger(__name__)
 
@@ -207,6 +208,7 @@ class WorkerNode:
         self._draining = False
         self._snapshot: dict | None = None
         self._tool_registry: ToolRegistry | None = None
+        self._redis_url: str | None = None
 
     async def start(self) -> None:
         await self.registry.register(self.node_info)
@@ -246,11 +248,11 @@ class WorkerNode:
         # Shared memory via Redis: point MemoryRouter.store to RedisMemoryStore for this run.
         redis_url = payload.get("redis_url")
         if redis_url:
+            self._redis_url = redis_url
             try:
                 # Replace store with shared redis-backed store, keep same MemoryRouter interface.
                 self.memory_router.store = RedisMemoryStore(redis_url=redis_url, run_id=run_id)
                 # MemoryIndex holds reference to store; rebuild index to point at shared store.
-                from devsper.memory.memory_index import MemoryIndex
                 self.memory_router.index = MemoryIndex(self.memory_router.store)
                 log.info("shared memory initialized run_id=%s backend=redis", run_id)
             except Exception as e:
@@ -317,6 +319,14 @@ class WorkerNode:
         self._current_tasks[task.id] = task
         start = time.monotonic()
         task_id_short = (task.id or "?")[:12]
+        mem_ns = f"project:{task.project_id}" if getattr(task, "project_id", None) else None
+        try:
+            st = self.memory_router.store
+            if isinstance(st, RedisMemoryStore):
+                st.set_default_namespace(mem_ns)
+        except Exception:
+            pass
+        self.memory_router.default_namespace = mem_ns
         try:
             prefetch = self.prefetcher.consume(task.id) if self.prefetcher else None
             request = _build_agent_request(
@@ -329,6 +339,11 @@ class WorkerNode:
                 score_store=self.score_store,
             )
             agent = self.agent_factory(self.config)
+            agent.memory_namespace = mem_ns
+            if getattr(agent, "memory_router", None) is None:
+                agent.memory_router = self.memory_router
+            elif agent.memory_router is not self.memory_router:
+                agent.memory_router = self.memory_router
             # Wire clarification requester for distributed mode.
             try:
                 loop = asyncio.get_running_loop()

devsper-2.1.8/devsper/runtime/executor.py

@@ -0,0 +1,5 @@
+"""Executor entrypoint; implementation is in ``devsper.swarm.executor``."""
+
+from devsper.swarm.executor import Executor
+
+__all__ = ["Executor"]

{devsper-2.1.7 → devsper-2.1.8}/devsper/swarm/executor.py

@@ -80,9 +80,11 @@ class Executor:
         hitl_notifier: object = None,
         hitl_resolver: object = None,
         clarification_bus: queue.Queue | None = None,
+        project_id: str | None = None,
     ) -> None:
         self.scheduler = scheduler
         self.agent = agent
+        self._project_id = project_id
         self.worker_count = worker_count
         self.event_log = event_log or EventLog()
         self.planner = planner
@@ -112,6 +114,15 @@ class Executor:
         self._pending_clarification_queues: dict[str, tuple[queue.Queue, str]] = {}  # request_id -> (response_queue, task_id)
         self._pending_clarification_lock = threading.Lock()
 
+    def _apply_project_memory_namespace(self) -> None:
+        ns = f"project:{self._project_id}" if getattr(self, "_project_id", None) else None
+        if self.agent is None:
+            return
+        self.agent.memory_namespace = ns
+        mr = getattr(self.agent, "memory_router", None)
+        if mr is not None:
+            mr.default_namespace = ns
+
     def request_clarification(self, req: ClarificationRequest) -> ClarificationResponse:
         """
         Called from agent thread. Puts request on clarification_bus, blocks until
@@ -252,6 +263,7 @@ class Executor:
                 )
             return task.id
 
+        self._apply_project_memory_namespace()
         self._publish_bus("task.started", task.to_dict())
         if self.audit_logger is not None and self.scheduler is not None:
             try: