superlocalmemory 4.0.3 → 4.0.5

package/src/superlocalmemory/brain/truth.py

@@ -0,0 +1,348 @@
+"""The versioned, read-only Living Brain truth model.
+
+This module is deliberately below every transport surface.  CLI, MCP, HTTP,
+and the dashboard can serialize the same dictionary without importing an
+engine, attaching databases, or acquiring a writer lock.  Every store is read
+in its own short-lived, SQLite read-only connection; one store failing never
+turns a failed measurement into a fabricated zero for another store.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+BRAIN_TRUTH_V1 = "superlocalmemory.brain-truth/v1"
+
+_EXPLICIT_SIGNAL_TYPES = frozenset(
+    {"user_positive", "user_negative", "user_correction", "user_pin", "legacy_feedback"}
+)
+
+
+class BrainTruthService:
+    """Build one honest, profile-scoped observation snapshot.
+
+    ``memory.db`` and ``learning.db`` are intentionally passed separately.
+    This service never uses ``ATTACH``, starts no transaction, and must not be
+    used for recall, ranking, routing, correction application, or learning.
+    """
+
+    def __init__(self, *, memory_db_path: str | Path, learning_db_path: str | Path) -> None:
+        self._memory_db_path = Path(memory_db_path)
+        self._learning_db_path = Path(learning_db_path)
+
+    def snapshot(self, profile_id: str) -> dict[str, Any]:
+        """Return the stable BrainTruth v1 payload for ``profile_id``.
+
+        The payload intentionally reports unavailable measurements with
+        ``None`` values and a reason.  A missing table or locked/corrupt file
+        therefore cannot be mistaken for a real count of zero.
+        """
+        if not isinstance(profile_id, str) or not profile_id:
+            raise ValueError("profile_id must be a non-empty string")
+
+        memory = self._read_memory(profile_id)
+        learning = self._read_learning(profile_id)
+        return {
+            "contract": BRAIN_TRUTH_V1,
+            "profile_id": profile_id,
+            "generated_at": _utc_now(),
+            "control_plane": "observation_only",
+            "memory_activity": memory["memory_activity"],
+            "feedback": learning["feedback"],
+            "agent_experience": learning["agent_experience"],
+            "external_evidence": learning["external_evidence"],
+            "correction_quality": memory["correction_quality"],
+        }
+
+    def _read_memory(self, profile_id: str) -> dict[str, dict[str, Any]]:
+        conn, unavailable = _open_read_only(self._memory_db_path, source="memory.db")
+        if unavailable is not None:
+            return {
+                "memory_activity": _unavailable_activity(unavailable),
+                "correction_quality": _unavailable_corrections(unavailable),
+            }
+        assert conn is not None
+        try:
+            return {
+                "memory_activity": _memory_activity(conn, profile_id),
+                "correction_quality": _correction_quality(conn, profile_id),
+            }
+        finally:
+            conn.close()
+
+    def _read_learning(self, profile_id: str) -> dict[str, dict[str, Any]]:
+        conn, unavailable = _open_read_only(self._learning_db_path, source="learning.db")
+        if unavailable is not None:
+            return {
+                "feedback": _unavailable_feedback(unavailable),
+                "agent_experience": _unavailable_agent_experience(unavailable),
+                "external_evidence": _unavailable_external_evidence(unavailable),
+            }
+        assert conn is not None
+        try:
+            return {
+                "feedback": _feedback(conn, profile_id),
+                "agent_experience": _agent_experience(conn, profile_id),
+                "external_evidence": _external_evidence(conn, profile_id),
+            }
+        finally:
+            conn.close()
+
+
+def _open_read_only(
+    path: Path, *, source: str
+) -> tuple[sqlite3.Connection | None, dict[str, str] | None]:
+    """Open a single store without creating it or exposing SQLite errors."""
+    if not path.exists():
+        return None, _unavailable(source, "missing")
+    try:
+        conn = sqlite3.connect(f"{path.resolve().as_uri()}?mode=ro", uri=True, timeout=0.25)
+        conn.row_factory = sqlite3.Row
+        conn.execute("PRAGMA query_only=ON")
+        return conn, None
+    except sqlite3.Error:
+        return None, _unavailable(source, "read_failed")
+
+
+def _memory_activity(conn: sqlite3.Connection, profile_id: str) -> dict[str, Any]:
+    required = {"atomic_facts": {"profile_id", "lifecycle", "created_at"}}
+    if not _schema_has(conn, required):
+        return _unavailable_activity(_unavailable("memory.db:atomic_facts", "schema_unavailable"))
+    try:
+        rows = conn.execute(
+            "SELECT lifecycle, COUNT(*) AS count FROM atomic_facts "
+            "WHERE profile_id=? GROUP BY lifecycle ORDER BY lifecycle",
+            (profile_id,),
+        ).fetchall()
+        recent = conn.execute(
+            "SELECT COUNT(*) AS count FROM atomic_facts WHERE profile_id=? "
+            "AND created_at >= datetime('now', '-1 day')",
+            (profile_id,),
+        ).fetchone()
+    except sqlite3.Error:
+        return _unavailable_activity(_unavailable("memory.db:atomic_facts", "read_failed"))
+    by_lifecycle = {str(row["lifecycle"]): int(row["count"]) for row in rows}
+    return {
+        "availability": "available",
+        "source": "memory.db:atomic_facts",
+        "facts_total": sum(by_lifecycle.values()),
+        "facts_by_lifecycle": by_lifecycle,
+        "facts_created_last_24h": int(recent["count"]) if recent is not None else 0,
+    }
+
+
+def _feedback(conn: sqlite3.Connection, profile_id: str) -> dict[str, Any]:
+    required = {"learning_signals": {"profile_id", "signal_type"}}
+    if not _schema_has(conn, required):
+        return _unavailable_feedback(
+            _unavailable("learning.db:learning_signals", "schema_unavailable")
+        )
+    try:
+        rows = conn.execute(
+            "SELECT signal_type, COUNT(*) AS count FROM learning_signals "
+            "WHERE profile_id=? GROUP BY signal_type ORDER BY signal_type",
+            (profile_id,),
+        ).fetchall()
+    except sqlite3.Error:
+        return _unavailable_feedback(_unavailable("learning.db:learning_signals", "read_failed"))
+    by_type = {str(row["signal_type"]): int(row["count"]) for row in rows}
+    explicit = sum(count for kind, count in by_type.items() if kind in _EXPLICIT_SIGNAL_TYPES)
+    implicit = sum(count for kind, count in by_type.items() if kind not in _EXPLICIT_SIGNAL_TYPES)
+    return {
+        "availability": "available",
+        "source": "learning.db:learning_signals",
+        "signals_total": sum(by_type.values()),
+        "signals_by_type": by_type,
+        "explicit_signals": explicit,
+        "implicit_signals": implicit,
+    }
+
+
+def _agent_experience(conn: sqlite3.Connection, profile_id: str) -> dict[str, Any]:
+    required = {
+        "agent_experiences": {"profile_id", "verification_authority"},
+        "cognitive_turn_receipts": {"profile_id", "state"},
+    }
+    if not _schema_has(conn, required):
+        return _unavailable_agent_experience(
+            _unavailable("learning.db:M040_agent_experience_receipts", "schema_unavailable")
+        )
+    try:
+        claimed = conn.execute(
+            "SELECT COUNT(*) AS count FROM agent_experiences WHERE profile_id=?", (profile_id,)
+        ).fetchone()
+        turn_rows = conn.execute(
+            "SELECT state, COUNT(*) AS count FROM cognitive_turn_receipts "
+            "WHERE profile_id=? GROUP BY state ORDER BY state",
+            (profile_id,),
+        ).fetchall()
+    except sqlite3.Error:
+        return _unavailable_agent_experience(
+            _unavailable("learning.db:M040_agent_experience_receipts", "read_failed")
+        )
+    turns_by_state = {str(row["state"]): int(row["count"]) for row in turn_rows}
+    return {
+        "availability": "available",
+        "source": "learning.db:M040_agent_experience_receipts",
+        "claimed_experiences_total": int(claimed["count"]) if claimed is not None else 0,
+        # M040 validates a declared authority, but this read-only service has
+        # no independent verifier.  Calling those claims verified would be a
+        # product-quality lie, so this number is deliberately known to be zero.
+        "independently_verified_experiences_total": 0,
+        "verification_availability": "not_supported_by_read_model",
+        "cognitive_turns_total": sum(turns_by_state.values()),
+        "cognitive_turns_by_state": turns_by_state,
+    }
+
+
+def _external_evidence(conn: sqlite3.Connection, profile_id: str) -> dict[str, Any]:
+    required = {
+        "external_evidence_receipts": {
+            "profile_id",
+            "run_state",
+            "demonstration",
+            "eligible_for_learning",
+        }
+    }
+    if not _schema_has(conn, required):
+        return _unavailable_external_evidence(
+            _unavailable("learning.db:M041_external_evidence_receipts", "schema_unavailable")
+        )
+    try:
+        rows = conn.execute(
+            "SELECT run_state, COUNT(*) AS count FROM external_evidence_receipts "
+            "WHERE profile_id=? GROUP BY run_state ORDER BY run_state",
+            (profile_id,),
+        ).fetchall()
+        demo = conn.execute(
+            "SELECT COUNT(*) AS count FROM external_evidence_receipts "
+            "WHERE profile_id=? AND demonstration=1",
+            (profile_id,),
+        ).fetchone()
+        eligible = conn.execute(
+            "SELECT COUNT(*) AS count FROM external_evidence_receipts "
+            "WHERE profile_id=? AND eligible_for_learning=1",
+            (profile_id,),
+        ).fetchone()
+    except sqlite3.Error:
+        return _unavailable_external_evidence(
+            _unavailable("learning.db:M041_external_evidence_receipts", "read_failed")
+        )
+    by_state = {str(row["run_state"]): int(row["count"]) for row in rows}
+    return {
+        "availability": "available",
+        "source": "learning.db:M041_external_evidence_receipts",
+        "receipts_total": sum(by_state.values()),
+        "receipts_by_run_state": by_state,
+        "demonstrations_total": int(demo["count"]) if demo is not None else 0,
+        "eligible_for_learning_total": int(eligible["count"]) if eligible is not None else 0,
+        "control_plane": "observation_only",
+    }
+
+
+def _correction_quality(conn: sqlite3.Connection, profile_id: str) -> dict[str, Any]:
+    required = {"correction_cases": {"profile_id", "status"}}
+    if not _schema_has(conn, required):
+        return _unavailable_corrections(
+            _unavailable("memory.db:M042_correction_case_ledger", "schema_unavailable")
+        )
+    try:
+        rows = conn.execute(
+            "SELECT status, COUNT(*) AS count FROM correction_cases "
+            "WHERE profile_id=? GROUP BY status ORDER BY status",
+            (profile_id,),
+        ).fetchall()
+    except sqlite3.Error:
+        return _unavailable_corrections(
+            _unavailable("memory.db:M042_correction_case_ledger", "read_failed")
+        )
+    by_status = {str(row["status"]): int(row["count"]) for row in rows}
+    return {
+        "availability": "available",
+        "source": "memory.db:M042_correction_case_ledger",
+        "cases_total": sum(by_status.values()),
+        "cases_by_status": by_status,
+        # M042 is a ledger.  A policy owner must be supplied by a later host
+        # integration; this neutral reader cannot manufacture authorization.
+        "review_policy": {
+            "availability": "not_configured",
+            "automatic_application": False,
+            "reason": "host-authorized review policy is not attached",
+        },
+    }
+
+
+def _schema_has(conn: sqlite3.Connection, required: dict[str, set[str]]) -> bool:
+    try:
+        for table, columns in required.items():
+            rows = conn.execute(f"PRAGMA table_info({table})").fetchall()  # nosec B608
+            if not rows or not columns <= {str(row[1]) for row in rows}:
+                return False
+    except sqlite3.Error:
+        return False
+    return True
+
+
+def _unavailable(source: str, reason: str) -> dict[str, str]:
+    return {"availability": "unavailable", "source": source, "reason": reason}
+
+
+def _unavailable_activity(status: dict[str, str]) -> dict[str, Any]:
+    return {
+        **status,
+        "facts_total": None,
+        "facts_by_lifecycle": None,
+        "facts_created_last_24h": None,
+    }
+
+
+def _unavailable_feedback(status: dict[str, str]) -> dict[str, Any]:
+    return {
+        **status,
+        "signals_total": None,
+        "signals_by_type": None,
+        "explicit_signals": None,
+        "implicit_signals": None,
+    }
+
+
+def _unavailable_agent_experience(status: dict[str, str]) -> dict[str, Any]:
+    return {
+        **status,
+        "claimed_experiences_total": None,
+        "independently_verified_experiences_total": None,
+        "verification_availability": "unavailable",
+        "cognitive_turns_total": None,
+        "cognitive_turns_by_state": None,
+    }
+
+
+def _unavailable_external_evidence(status: dict[str, str]) -> dict[str, Any]:
+    return {
+        **status,
+        "receipts_total": None,
+        "receipts_by_run_state": None,
+        "demonstrations_total": None,
+        "eligible_for_learning_total": None,
+        "control_plane": "observation_only",
+    }
+
+
+def _unavailable_corrections(status: dict[str, str]) -> dict[str, Any]:
+    return {
+        **status,
+        "cases_total": None,
+        "cases_by_status": None,
+        "review_policy": {
+            "availability": "unavailable",
+            "automatic_application": False,
+            "reason": "correction ledger is unavailable",
+        },
+    }
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")

package/src/superlocalmemory/cli/commands.py

@@ -345,6 +345,7 @@ def dispatch(args: Namespace) -> None:
         "forget": cmd_forget,
         "delete": cmd_delete,
         "update": cmd_update,
+        "review-correction": cmd_review_correction,
         "status": cmd_status,
         "brain": cmd_brain,
         "health": cmd_health,
@@ -1799,21 +1800,64 @@ def cmd_update(args: Namespace) -> None:
         if use_json:
             from superlocalmemory.cli.json_output import json_print
             json_print("update", data={
-                "fact_id": fact_id,
-                "new_content": new_content[:120],
+                "predecessor_fact_id": result.get("predecessor_fact_id", fact_id),
+                "successor_fact_id": result.get("successor_fact_id"),
+                "correction_case": result.get("correction_case"),
+                "review_required": bool(result.get("review_required", False)),
             }, next_actions=[
                 {
-                    "command": "slm list --json",
-                    "description": "List recent memories",
+                    "command": "slm brain --json",
+                    "description": "Inspect the observation-only brain status",
                 },
             ])
         else:
-            print(f"New: {new_content[:100]}")
-            print(f"Updated: {fact_id}")
+            if result.get("review_required"):
+                case = result.get("correction_case", {})
+                print(f"Correction proposed: {case.get('case_id', 'unknown')}")
+                print(f"Predecessor remains current until review: {fact_id}")
+            else:
+                print(f"Unchanged: {fact_id}")
         return
     _daemon_unavailable("update", use_json)
 
 
+def cmd_review_correction(args: Namespace) -> None:
+    """Apply, reject, or roll back an explicitly reviewed correction case."""
+    from superlocalmemory.core.admission import gate_cli_mutation
+    from superlocalmemory.core.operation_request import OperationKind
+
+    gate_cli_mutation(OperationKind.CORRECT)
+    import urllib.parse
+
+    from superlocalmemory.cli.daemon import daemon_request, ensure_daemon, is_daemon_running
+
+    use_json = getattr(args, "json", False)
+    action = str(args.action).strip().lower()
+    if action not in {"apply", "reject", "rollback"}:
+        raise ValueError("action must be apply, reject, or rollback")
+    if not isinstance(args.expected_version, int) or args.expected_version < 0:
+        raise ValueError("expected_version must be a non-negative integer")
+    if not (is_daemon_running() or ensure_daemon()):
+        _daemon_unavailable("correction review", use_json)
+        return
+    payload: dict[str, object] = {"expected_version": args.expected_version}
+    if getattr(args, "event_valid_until", None):
+        payload["event_valid_until"] = args.event_valid_until
+    path = "/api/corrections/" + urllib.parse.quote(args.case_id, safe="") + "/" + action
+    result = daemon_request("POST", path, payload)
+    if not isinstance(result, dict) or not result.get("success"):
+        _daemon_unavailable("correction review", use_json)
+        return
+    if use_json:
+        from superlocalmemory.cli.json_output import json_print
+
+        json_print("review-correction", data=result)
+    else:
+        case = result.get("correction_case", {})
+        print(f"Correction {action}: {case.get('case_id', args.case_id)}")
+        print(f"State: {case.get('status', 'unknown')}")
+
+
 # -- Diagnostics (all support --json) -------------------------------------
 
 
@@ -2157,7 +2201,8 @@ _COMMAND_GROUPS: list[tuple[str, list[tuple[str, str]]]] = [
         ("recall", "Semantic + keyword search across memories"),
         ("search", "Exact keyword / full-text search"),
         ("list", "Show recent memories (-n N)"),
-        ("update", "Correct an existing memory by id"),
+        ("update", "Propose an immutable correction by id"),
+        ("review-correction", "Apply, reject, or roll back a correction case"),
         ("delete", "Delete a memory by id"),
         ("forget", "Run the decay cycle (preview first)"),
         ("trace", "Recall with a per-channel score breakdown"),
@@ -3690,25 +3735,22 @@ def cmd_session_context(args: Namespace) -> None:
 
 
 def cmd_brain(args: Namespace) -> None:
-    """Read the portable, profile-scoped Agent Experience evidence summary.
+    """Read the portable, profile-scoped Living Brain truth snapshot.
 
-    This command deliberately opens no memory engine and starts no daemon. It
-    is an indexed ``learning.db`` read, so support scripts and non-technical
-    users can inspect the Living Brain without affecting recall latency.
+    This command deliberately opens no memory engine and starts no daemon.
+    BrainTruth uses short read-only connections to keep the status view out of
+    recall and writer domains.
     """
+    from superlocalmemory.brain.truth import BrainTruthService
     from superlocalmemory.core.config import SLMConfig
     from superlocalmemory.infra.data_root import state_path
-    from superlocalmemory.storage.agent_experience import get_profile_receipt_summary
 
     config = SLMConfig.load()
     profile_id = config.active_profile
-    data = {
-        "profile_id": profile_id,
-        "agent_experience": get_profile_receipt_summary(
-            state_path("learning.db"), profile_id
-        ),
-        "control_plane": "observation_only",
-    }
+    data = BrainTruthService(
+        memory_db_path=state_path("memory.db"),
+        learning_db_path=state_path("learning.db"),
+    ).snapshot(profile_id)
     if getattr(args, "json", False):
         from superlocalmemory.cli.json_output import json_print
 
@@ -3716,18 +3758,33 @@ def cmd_brain(args: Namespace) -> None:
             {"command": "slm dashboard", "description": "Open the Living Brain dashboard"},
         ])
         return
+    memory = data["memory_activity"]
+    feedback = data["feedback"]
     evidence = data["agent_experience"]
+    external = data["external_evidence"]
+    corrections = data["correction_quality"]
     print("SuperLocalMemory Living Brain")
     print(f"  Profile: {profile_id}")
-    print(f"  Agent experiences: {evidence['experiences_total']}")
-    print(f"  Claimed evidence authority: {evidence['claimed_evidence_experiences']}")
-    print(f"  Cognitive turns: {evidence['turns_total']}")
-    if evidence["turns_by_state"]:
+    print(f"  Stored facts: {memory['facts_total']}")
+    print(f"  Feedback signals: {feedback['signals_total']}")
+    print(f"  Claimed agent experiences: {evidence['claimed_experiences_total']}")
+    print(
+        "  Independently verified experiences: "
+        f"{evidence['independently_verified_experiences_total']}"
+    )
+    print(f"  Cognitive turns: {evidence['cognitive_turns_total']}")
+    if evidence["cognitive_turns_by_state"]:
         states = ", ".join(
-            f"{state}: {count}" for state, count in sorted(evidence["turns_by_state"].items())
+            f"{state}: {count}"
+            for state, count in sorted(evidence["cognitive_turns_by_state"].items())
         )
         print(f"  Turn states: {states}")
-    print("  Retrieval control: observation only")
+    print(f"  Bounded Loop observations: {external['receipts_total']}")
+    print(f"  Correction cases: {corrections['cases_total']}")
+    print(
+        "  Retrieval control: observation only; does not change recall, "
+        "ranking, or model routing"
+    )
 
 
 def cmd_observe(args: Namespace) -> None:

package/src/superlocalmemory/cli/main.py

@@ -484,6 +484,18 @@ def main() -> None:
     update_p.add_argument("content", help="New content for the memory")
     update_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
 
+    correction_p = sub.add_parser(
+        "review-correction", help="Apply, reject, or roll back a reviewed correction case"
+    )
+    correction_p.add_argument("case_id", help="Correction case ID returned by slm update")
+    correction_p.add_argument("action", choices=("apply", "reject", "rollback"))
+    correction_p.add_argument("expected_version", type=int, help="Current case version (CAS guard)")
+    correction_p.add_argument(
+        "--event-valid-until",
+        help="Optional reviewer-approved RFC3339 event-time boundary (apply only)",
+    )
+    correction_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
+
     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)",

package/src/superlocalmemory/core/context_cache.py

@@ -385,6 +385,7 @@ def read_entry_fast(
     db_path: Path | None = None,
     home_dir: Path | None = None,
     profile_id: str | None = None,
+    require_current_admission: bool = False,
 ) -> CacheEntry | None:
     """Hot-path reader used by the UserPromptSubmit hook.
 
@@ -465,7 +466,7 @@ def read_entry_fast(
         except (ValueError, TypeError):
             fact_ids = []
 
-        return CacheEntry(
+        entry = CacheEntry(
             session_id=session_id,
             topic_sig=topic_sig,
             content=row[0],
@@ -474,10 +475,66 @@ def read_entry_fast(
             computed_at=int(row[3]),
             byte_size=int(row[4]),
         )
+        if require_current_admission and not _cache_fact_ids_are_current(home, entry.fact_ids):
+            return None
+        return entry
     except Exception:  # pragma: no cover — last-resort fail-open
         return None
 
 
+def _cache_fact_ids_are_current(home: Path, fact_ids: list[str]) -> bool:
+    """Prove cached source IDs remain current without loading the engine.
+
+    This is a cache-hit-only backstop for review-gated corrections.  It uses a
+    small read-only SQLite query and treats any unavailable or malformed memory
+    state as a cache miss.  Normal recall remains the authority after a miss.
+    """
+    if not fact_ids or not all(isinstance(fact_id, str) and fact_id for fact_id in fact_ids):
+        return False
+    memory_path = home / "memory.db"
+    if not memory_path.exists():
+        return False
+    try:
+        conn = sqlite3.connect(f"file:{memory_path}?mode=ro", uri=True, timeout=0.25)
+        try:
+            placeholders = ",".join("?" for _ in fact_ids)
+            tables = {
+                row[0]
+                for row in conn.execute(
+                    "SELECT name FROM sqlite_master WHERE type='table' "
+                    "AND name IN ('atomic_facts', 'fact_temporal_validity', 'correction_cases')"
+                )
+            }
+            if {"atomic_facts", "fact_temporal_validity"} - tables:
+                return False
+            correction_join = ""
+            correction_bad = "0"
+            if "correction_cases" in tables:
+                correction_join = (
+                    " LEFT JOIN correction_cases cc ON cc.successor_fact_id=f.fact_id "
+                    "AND cc.status IN ('proposed', 'rejected', 'rolled_back')"
+                )
+                correction_bad = "cc.successor_fact_id IS NOT NULL"
+            rows = conn.execute(
+                "SELECT f.fact_id, tv.system_expired_at, " + correction_bad + " AS correction_blocked "
+                "FROM atomic_facts f "
+                "LEFT JOIN fact_temporal_validity tv ON tv.fact_id=f.fact_id "
+                "AND tv.profile_id=f.profile_id "
+                + correction_join
+                + f" WHERE f.fact_id IN ({placeholders})",
+                tuple(fact_ids),
+            ).fetchall()
+        finally:
+            conn.close()
+    except sqlite3.Error:
+        return False
+    found = {str(row[0]) for row in rows}
+    return (
+        found == set(fact_ids)
+        and all(row[1] is None and not bool(row[2]) for row in rows)
+    )
+
+
 def purge_profile_from_cache_db(db_path: Path, profile_id: str) -> int:
     """Delete all ``context_entries`` rows for *profile_id* from a cache DB file.