superlocalmemory 4.0.9 → 4.1.0

package/src/superlocalmemory/cli/db_migrate.py

@@ -35,6 +35,59 @@ def _resolve_paths(args: Namespace) -> tuple[Path, Path]:
     return Path(learning), Path(memory)
 
 
+def _end_state_disagreements(learning_db, memory_db) -> dict[str, str]:
+    """Migrations recorded complete whose own verification no longer passes.
+
+    ``--status`` reads ``migration_log``, which records what was *done*. The
+    daemon re-runs each completed migration's ``verify()`` on every start, which
+    checks whether what was done still *holds*. When those two answers differ
+    the log says ``complete`` and the health endpoint says the migration failed,
+    and until now nothing on any surface showed the two were even asking
+    different questions -- so the only available reading was that one of them
+    was lying. Reported as #125.
+
+    Read-only and fail-quiet: this is a diagnostic printed beside a status line,
+    and it must never be the reason a status command exits non-zero.
+    """
+    import sqlite3
+
+    from superlocalmemory.storage._migration_internals import _MODULES
+    from superlocalmemory.storage.migration_runner import MIGRATIONS
+
+    try:
+        from superlocalmemory.storage.migration_runner import DEFERRED_MIGRATIONS
+    except ImportError:  # pragma: no cover — older layouts
+        DEFERRED_MIGRATIONS = ()
+
+    out: dict[str, str] = {}
+    for migration in list(MIGRATIONS) + list(DEFERRED_MIGRATIONS):
+        verify_fn = getattr(_MODULES.get(migration.name), "verify", None)
+        if not callable(verify_fn):
+            continue
+        db_path = memory_db if migration.db_target != "learning" else learning_db
+        try:
+            conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
+        except sqlite3.Error:
+            continue
+        try:
+            row = conn.execute(
+                "SELECT status FROM migration_log WHERE name = ? LIMIT 1",
+                (migration.name,),
+            ).fetchone()
+            if not row or row[0] != "complete":
+                continue
+            if not bool(verify_fn(conn)):
+                out[migration.name] = "  <- recorded complete, end-state no longer holds"
+        except Exception:  # noqa: BLE001 — a diagnostic must not break status
+            pass
+        finally:
+            try:
+                conn.close()
+            except sqlite3.Error:  # pragma: no cover
+                pass
+    return out
+
+
 def cmd_db_migrate(args: Namespace) -> int:
     """Apply pending migrations or report status.
 
@@ -57,8 +110,25 @@ def cmd_db_migrate(args: Namespace) -> int:
         if not report:
             print("(no migrations registered)")
         else:
+            disagreements = _end_state_disagreements(learning_db, memory_db)
             for name, state in report.items():
-                print(f"  {name}: {state}")
+                note = disagreements.get(name, "")
+                print(f"  {name}: {state}{note}")
+            if disagreements:
+                print()
+                print(
+                    "  A migration marked complete is re-checked on every start "
+                    "by its own\n"
+                    "  verification. The ones flagged above are recorded as done "
+                    "and their\n"
+                    "  end-state no longer holds, which is what the daemon "
+                    "reports as a\n"
+                    "  migration failure while this log still reads complete. "
+                    "Run `slm db\n"
+                    "  migrate` to let each one try to repair itself, and see "
+                    "`migration_failure_reasons`\n"
+                    "  in `slm health --json` for what specifically did not hold."
+                )
         return 0
 
     dry_run = bool(getattr(args, "dry_run", False))

package/src/superlocalmemory/cli/gdpr_cmd.py

@@ -427,9 +427,14 @@ def _cmd_gdpr_erase(args: Namespace) -> None:
         sys.exit(1)
 
     complete = counts.get("erasure_complete", 0)
+    # Whether it can be SHOWN to have happened is a separate answer, and
+    # printing COMPLETE while the tamper-evident receipt failed to persist is
+    # how the command line came to disagree with the API about the same erasure.
+    provable = counts.get("erasure_provable", complete)
     result_data = {
         "profile": profile,
         "erasure_complete": bool(complete),
+        "erasure_provable": bool(provable),
         "counts": counts,
         "note": (
             "Erasure recorded in audit_chain.db. "
@@ -441,7 +446,15 @@ def _cmd_gdpr_erase(args: Namespace) -> None:
     if use_json:
         _print_json(_json_envelope("gdpr-erase", data=result_data))
     else:
-        status_str = "COMPLETE" if complete else "INCOMPLETE (check counts)"
+        if not complete:
+            status_str = "INCOMPLETE (check counts)"
+        elif not provable:
+            status_str = (
+                "COMPLETE, BUT NOT PROVABLE — the data is gone and the "
+                "tamper-evident receipt did not persist"
+            )
+        else:
+            status_str = "COMPLETE"
         print(f"Art.17 erasure for profile '{profile}': {status_str}")
         for k, v in counts.items():
             print(f"  {k}: {v}")
@@ -449,7 +462,7 @@ def _cmd_gdpr_erase(args: Namespace) -> None:
         print("  Backups/ contain outstanding obligation — see C1 gap.")
         print("  Verify receipts: slm gdpr verify --profile", profile)
 
-    if not complete:
+    if not complete or not provable:
         sys.exit(1)
 
 

package/src/superlocalmemory/cli/main.py

@@ -24,7 +24,10 @@ _os.environ.setdefault('TORCH_DEVICE', 'cpu')
 import argparse
 import sys
 
-from superlocalmemory.core.config import CANONICAL_RECALL_LIMIT
+from superlocalmemory.core.config import (
+    CANONICAL_LIST_LIMIT,
+    CANONICAL_RECALL_LIMIT,
+)
 
 _HELP_EPILOG = """\
 operating modes:
@@ -344,6 +347,19 @@ def main() -> None:
     db_scale_p.add_argument("--stage-id", help="Stage identifier required by verify/promote")
     db_scale_p.add_argument("--backup-id", help="Backup identifier required by rollback")
 
+    db_regraph_p = db_sub.add_parser(
+        "regraph",
+        help="Re-derive the graph copy of your memories from the store",
+    )
+    db_regraph_p.add_argument(
+        "--check", action="store_true",
+        help="Report how far the graph copy has drifted; change nothing",
+    )
+    db_regraph_p.add_argument(
+        "--profile", default="",
+        help="Workspace to re-derive. Default: all of them",
+    )
+
     db_reembed_p = db_sub.add_parser(
         "reembed",
         help="Backfill NULL embeddings (facts never embedded)",
@@ -503,7 +519,8 @@ def main() -> None:
 
     list_p = sub.add_parser("list", help="List recent memories chronologically (shows IDs for delete/update)")
     list_p.add_argument(
-        "--limit", "-n", type=int, default=20, help="Number of entries (default 20)",
+        "--limit", "-n", type=int, default=CANONICAL_LIST_LIMIT,
+        help=f"Number of entries (default {CANONICAL_LIST_LIMIT})",
     )
     list_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
 
@@ -530,6 +547,11 @@ def main() -> None:
         "--quick", action="store_true",
         help="Run only the fast checks (deps + config); skip daemon/embedding probes",
     )
+    doctor_p.add_argument(
+        "--deep", action="store_true",
+        help="Read every database page (PRAGMA integrity_check) instead of the "
+             "structural check; slow on a large store",
+    )
     doctor_p.add_argument(
         "--fix", action="store_true",
         help="Auto-repair fixable components (re-download missing models, "
@@ -977,7 +999,7 @@ def main() -> None:
 
     register_summary_parser(sub)
 
-    # Wave-3 / V4.0.6: GDPR subject-rights CLI (Art.15/17/20)
+    # V4.0.6: GDPR subject-rights CLI (Art.15/17/20)
     gdpr_p = sub.add_parser(
         "gdpr",
         help="GDPR subject rights: status, export (Art.15/20), erase (Art.17), verify",
@@ -1051,7 +1073,7 @@ def main() -> None:
         "--json", action="store_true", help="Output structured JSON",
     )
 
-    # Wave-3: operational recovery & admin remediation
+    # Operational recovery & admin remediation
     ops_p = sub.add_parser(
         "ops",
         help="Operational recovery: list failures, resolve stuck ops, check status",

package/src/superlocalmemory/code_graph/bridge/maintenance.py

@@ -103,6 +103,14 @@ def _fact_rows(
         # the pass linked happily in tests and would have linked NOTHING for any
         # actual user — 3,608 of 3,608 facts filtered out on this machine.
         sql += "AND COALESCE(archive_status, 'live') != 'archived' "
+    # Same reasoning for withheld rows: a model's non-answer has no code
+    # entities worth resolving, and a link from one would surface it in the
+    # bridge's enrichment text.
+    try:
+        if memory_db._has_quarantine_column():
+            sql += "AND COALESCE(quarantined, 0) = 0 "
+    except Exception:  # pragma: no cover - helper absent on an unusual manager
+        pass
 
     params: list[Any] = [profile_id]
     if since:

package/src/superlocalmemory/code_graph/database.py

@@ -37,6 +37,49 @@ _MAX_RETRIES = 5
 _RETRY_BASE_SECONDS = 0.1
 
 
+def _load_vector_extension(conn: sqlite3.Connection) -> bool:
+    """Make vector search available on this connection. Returns whether it loaded.
+
+    Without this the vector table cannot be created, so every semantic lookup
+    over the code graph returned nothing — not an error, just an empty result,
+    with one line in the maintenance log saying embeddings were disabled. The
+    extension was installed and working the whole time; no connection ever asked
+    for it.
+
+    Loaded per connection because that is the only scope SQLite offers: an
+    extension is bound to a connection, not to a database file, and this class
+    opens a fresh connection per statement.
+
+    The import stays inside the function. At module level it would make the
+    whole code graph unimportable wherever the wheel is unavailable, which is a
+    platform detail and not a reason to lose the rest of the feature.
+    """
+    try:
+        import sqlite_vec
+    except Exception as exc:  # ImportError, or a broken native build
+        logger.debug("vector search unavailable: %s", exc)
+        return False
+    try:
+        conn.enable_load_extension(True)
+    except AttributeError as exc:
+        # Python built against a SQLite without extension support.
+        logger.debug("this SQLite cannot load extensions: %s", exc)
+        return False
+    try:
+        sqlite_vec.load(conn)
+        return True
+    except Exception as exc:
+        logger.debug("vector extension failed to load: %s", exc)
+        return False
+    finally:
+        # Closed again either way. Leaving extension loading enabled on a
+        # connection widens what any later SQL on it is allowed to do.
+        try:
+            conn.enable_load_extension(False)
+        except Exception:  # pragma: no cover — defensive
+            pass
+
+
 class CodeGraphDatabase:
     """SQLite database manager for code_graph.db.
 
@@ -70,6 +113,7 @@ class CodeGraphDatabase:
         conn.execute("PRAGMA journal_mode=WAL")
         conn.execute("PRAGMA foreign_keys=ON")
         conn.execute("PRAGMA synchronous=NORMAL")
+        _load_vector_extension(conn)
         return conn
 
     def execute(