superlocalmemory 3.6.13 → 3.6.15

package/src/superlocalmemory/server/unified_daemon.py

@@ -50,6 +50,8 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.middleware.gzip import GZipMiddleware
 from pydantic import BaseModel
 
+from superlocalmemory.core.config import CANONICAL_RECALL_LIMIT
+
 logger = logging.getLogger("superlocalmemory.unified_daemon")
 
 _DEFAULT_PORT = 8765
@@ -66,6 +68,24 @@ class RememberRequest(BaseModel):
     content: str
     tags: str = ""
     metadata: dict | None = None  # v3.4.26: pass-through from MCP pool_store
+    # v3.6.15 multi-scope: visibility of the new memory. ``None`` scope means
+    # "use the configured default_scope" (personal). shared_with is the list of
+    # profile_ids for scope='shared'.
+    scope: str | None = None
+    shared_with: list[str] | None = None
+
+
+class SessionOpenRequest(BaseModel):
+    # #49: local session-open warm (no model roundtrip needed)
+    project_path: str = ""
+    query: str = ""
+    max_results: int = 10
+
+
+class SessionCloseRequest(BaseModel):
+    # #49: local session-close (e.g. a Claude /quit hook). Empty session_id
+    # closes the most recent real session.
+    session_id: str = ""
 
 
 class ObserveRequest(BaseModel):
@@ -237,16 +257,32 @@ class ObserveBuffer:
         try:
             from superlocalmemory.hooks.auto_capture import AutoCapture
             auto = AutoCapture(engine=self._engine)
+            captured_count = 0
+            failed_count = 0
             for content in batch:
                 try:
                     decision = auto.evaluate(content)
                     if decision.capture:
                         auto.capture(content, category=decision.category)
-                except Exception:
-                    pass
-            logger.info("Observe debounce: processed %d observations", len(batch))
-        except Exception:
-            pass
+                        # Stage-9: count only what was actually WRITTEN to memory.
+                        # The prior 'processed N' counted skipped (capture=False)
+                        # items as successes — a false-positive write count.
+                        captured_count += 1
+                except Exception as exc:
+                    failed_count += 1
+                    logger.warning(
+                        "ObserveBuffer: auto.capture failed for content %.40r: %s",
+                        content,
+                        exc,
+                    )
+            logger.info(
+                "Observe debounce: evaluated=%d captured=%d failed=%d",
+                len(batch),
+                captured_count,
+                failed_count,
+            )
+        except Exception as exc:
+            logger.error("ObserveBuffer: flush batch failed: %s", exc)
 
     def flush_sync(self) -> None:
         """Force flush for shutdown."""
@@ -858,8 +894,14 @@ async def lifespan(application: FastAPI):
         from superlocalmemory.optimize.storage.db import CacheDB
         application.include_router(optimize_router)
 
-        # Restore persisted metrics counters on startup
-        MetricsPersistence().load(MetricsCollector.get_instance(), CacheDB())
+        # Restore persisted metrics counters on startup.
+        # #48 fix: build ONE CacheDB + MetricsPersistence and reuse them for the
+        # life of the daemon. The old code constructed a new CacheDB() on every
+        # 60s flush, which re-ran schema init ("Schema initialized" log spam),
+        # the corruption check, and AES-key derivation on every tick.
+        _metrics_db = CacheDB()
+        _metrics_persistence = MetricsPersistence()
+        _metrics_persistence.load(MetricsCollector.get_instance(), _metrics_db)
 
         # Periodic flush — every 60s (OPT-005: guard + task ref for shutdown)
         _metrics_flush_task = getattr(application.state, "_optimize_flush_task", None)
@@ -868,8 +910,8 @@ async def lifespan(application: FastAPI):
                 while True:
                     await asyncio.sleep(60)
                     try:
-                        MetricsPersistence().flush(
-                            MetricsCollector.get_instance(), CacheDB()
+                        _metrics_persistence.flush(
+                            MetricsCollector.get_instance(), _metrics_db
                         )
                     except Exception as e:
                         logger.warning("metrics flush error: %s", e)
@@ -1620,11 +1662,13 @@ def _register_daemon_routes(application: FastAPI) -> None:
     @application.get("/recall")
     async def recall(
         request: Request,
-        q: str = "", query: str = "", limit: int = 20,
+        q: str = "", query: str = "", limit: int = CANONICAL_RECALL_LIMIT,
         session_id: str = "",
         fast: bool = False,
         full: bool = False,
         include_source: bool = False,
+        include_global: bool | None = None,
+        include_shared: bool | None = None,
     ):
         _update_activity()
         search_query = q or query  # Accept both ?q= and ?query= for compatibility
@@ -1660,6 +1704,8 @@ def _register_daemon_routes(application: FastAPI) -> None:
                 engine.recall,
                 search_query, limit=limit, session_id=effective_sid,
                 fast=fast,
+                include_global=include_global,
+                include_shared=include_shared,
             )
             # v3.4.26: return the same field shape as recall_worker so
             # MCP processes proxying through the daemon get recall_trace-
@@ -1721,13 +1767,23 @@ def _register_daemon_routes(application: FastAPI) -> None:
         _update_activity()
         engine = _get_engine_or_503()
 
+        # v3.6.15 multi-scope: resolve the write scope. ``None`` (not specified
+        # by the caller) → the configured default_scope (personal). Shared
+        # memory is opt-in, so the default keeps every write private.
+        _scope_cfg = getattr(engine._config, "scope", None)
+        scope = req.scope or getattr(_scope_cfg, "default_scope", "personal")
+        shared_with = req.shared_with
+
         if wait:
             try:
                 metadata = {"tags": req.tags} if req.tags else {}
                 extra = getattr(req, "metadata", None)
                 if isinstance(extra, dict):
                     metadata.update(extra)
-                fact_ids = engine.store(req.content, metadata=metadata)
+                fact_ids = engine.store(
+                    req.content, metadata=metadata,
+                    scope=scope, shared_with=shared_with,
+                )
                 return {"ok": True, "fact_ids": fact_ids, "count": len(fact_ids)}
             except Exception as exc:
                 raise HTTPException(500, detail=str(exc))
@@ -1740,13 +1796,25 @@ def _register_daemon_routes(application: FastAPI) -> None:
             extra = getattr(req, "metadata", None)
             if isinstance(extra, dict):
                 meta.update(extra)
+            # v3.6.15 multi-scope: persist the resolved scope INSIDE the pending
+            # metadata so the materializer (_process_pending_memories) replays
+            # the write with the correct visibility instead of defaulting to
+            # personal. Non-personal only — keeps personal rows byte-identical
+            # to pre-3.6.15 so nothing downstream sees a new key by default.
+            if scope and scope != "personal":
+                meta["scope"] = scope
+                if shared_with:
+                    meta["shared_with"] = shared_with
             # v3.5.5 WRITE-THROUGH: synchronous verbatim insert → the memory is
             # keyword/BM25-recallable the instant this returns (~ms). Closes the
             # recall window so a parallel/next agent finds memories saved seconds
             # ago. Embedding/graph enrichment is deferred to the materializer.
             fact_ids: list[str] = []
             try:
-                fact_ids = engine.store_fast(req.content, metadata=meta)
+                fact_ids = engine.store_fast(
+                    req.content, metadata=meta,
+                    scope=scope, shared_with=shared_with,
+                )
             except Exception as fexc:
                 logger.warning("store_fast failed, falling back to pending-only: %s", fexc)
             # Enqueue for async enrichment (embedding + entities + graph). The
@@ -1883,6 +1951,65 @@ def _register_daemon_routes(application: FastAPI) -> None:
         os.kill(os.getpid(), signal.SIGTERM)
         return {"status": "stopping"}
 
+    @application.post("/session/open")
+    async def session_open(req: SessionOpenRequest):
+        """#49: Open a session locally — warm recall context with no model
+        roundtrip, so a shell/session-start hook can call it directly
+        (`slm session open`) instead of going through the MCP tool.
+        """
+        _update_activity()
+        engine = _get_engine_or_503()
+        if req.query:
+            query = req.query
+        elif req.project_path:
+            query = f"project context {req.project_path}"
+        else:
+            query = "recent important decisions"
+        try:
+            resp = engine.recall(query, limit=req.max_results)
+            results = (
+                getattr(resp, "results", None)
+                or getattr(resp, "memories", None)
+                or []
+            )
+            return {"ok": True, "query": query, "warmed": len(results)}
+        except Exception as exc:
+            # Warming is best-effort — never fail the session-open hook.
+            return {"ok": True, "query": query, "warmed": 0, "warning": str(exc)}
+
+    @application.post("/session/close")
+    async def session_close(req: SessionCloseRequest):
+        """#49: Close a session locally (e.g. a Claude /quit hook calling
+        `slm session close`). Creates per-entity temporal summary events.
+        An empty session_id closes the most recent real session.
+        """
+        _update_activity()
+        engine = _get_engine_or_503()
+        sid = req.session_id
+        if not sid:
+            # Fall back to the most recent session that has memories.
+            try:
+                db = getattr(engine, "_db", None) or getattr(engine, "db", None)
+                if db is not None and hasattr(db, "execute"):
+                    rows = db.execute(
+                        "SELECT session_id FROM memories "
+                        "WHERE session_id != '' ORDER BY created_at DESC LIMIT 1",
+                        (),
+                    )
+                    if rows:
+                        sid = str(rows[0][0])
+            except Exception as exc:
+                logger.debug("session_close fallback lookup failed: %s", exc)
+        if not sid:
+            return {"ok": True, "session_id": "", "summary_events_created": 0,
+                    "message": "no session to close"}
+        try:
+            created = engine.close_session(sid)
+            return {"ok": True, "session_id": sid,
+                    "summary_events_created": int(created)}
+        except Exception as exc:
+            raise HTTPException(500, detail=str(exc))
+
 
 def _update_activity():
     global _last_activity
@@ -1998,10 +2125,14 @@ def _start_pending_materializer() -> None:
                         # embedding, ENRICH it in place (compute embedding +
                         # upsert vector store) rather than skipping — otherwise
                         # the fact would never be semantically searchable.
+                        # v3.6.15: scope the dedup to THIS profile. Without the
+                        # profile_id filter, a memory whose verbatim text matches
+                        # another profile's fact was treated as a duplicate and
+                        # silently dropped — cross-profile data loss + leakage.
                         dup = engine._db.execute(
                             "SELECT fact_id, embedding FROM atomic_facts "
-                            "WHERE content = ? LIMIT 1",
-                            (content,),
+                            "WHERE content = ? AND profile_id = ? LIMIT 1",
+                            (content, engine._profile_id),
                         )
                         if dup:
                             try:
@@ -2032,6 +2163,12 @@ def _start_pending_materializer() -> None:
                             md = {}
                         if item.get("tags"):
                             md.setdefault("tags", item["tags"])
+                        # v3.6.15: replay the scope the async /remember path
+                        # stashed in metadata, so a queued non-personal write
+                        # materializes with the right visibility (not personal).
+                        _mscope = md.get("scope") or "personal"
+                        _mshared = md.get("shared_with")
+                        _shared_json = _json.dumps(_mshared) if _mshared else None
                         # Create memory row (FK target for atomic_facts)
                         from datetime import datetime, timezone
                         from superlocalmemory.storage.models import (
@@ -2042,17 +2179,20 @@ def _start_pending_materializer() -> None:
                             "INSERT OR IGNORE INTO memories "
                             "(memory_id, profile_id, content, "
                             "session_id, speaker, role, created_at, "
-                            "metadata_json) VALUES (?,?,?,?,?,?,?,?)",
+                            "metadata_json, scope, shared_with) "
+                            "VALUES (?,?,?,?,?,?,?,?,?,?)",
                             (mem_id, engine._profile_id, content,
                              "", "", "user",
                              datetime.now(timezone.utc).isoformat(),
-                             _json.dumps(md)),
+                             _json.dumps(md), _mscope, _shared_json),
                         )
                         fact = AtomicFact(
                             content=content,
                             fact_type=FactType.EPISODIC,
                             memory_id=mem_id,
                             profile_id=engine._profile_id,
+                            scope=_mscope,
+                            shared_with=_mshared,
                         )
                         engine.store_fact_direct(fact)
                         mark_done(item["id"])