superlocalmemory 4.0.4 → 4.0.6

package/src/superlocalmemory/core/mutations.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 
 import logging
 import sqlite3
+import uuid
 from pathlib import Path
 from typing import Any
 
@@ -76,6 +77,30 @@ def _invalidate_context_cache_for_fact(
             pass
 
 
+def purge_profile_context_cache(engine: Any, profile_id: str) -> None:
+    """Best-effort full-profile cache purge after a truth lifecycle change.
+
+    Apply and rollback can flip which of two immutable facts is current.  A
+    fact-ID substring delete is therefore insufficient: any cached prose for
+    the profile could contain the old current truth.  Read-side admission
+    remains the authoritative backstop if this post-commit cleanup is busy.
+    """
+    try:
+        db_parent = Path(engine._db.db_path).parent
+    except AttributeError:
+        return
+    try:
+        from superlocalmemory.core.context_cache import purge_profile_from_cache_db
+
+        for cache_path in (
+            db_parent / "context-cache" / "active_brain_cache.db",
+            db_parent / "active_brain_cache.db",
+        ):
+            purge_profile_from_cache_db(cache_path, profile_id)
+    except Exception:
+        logger.warning("Profile context cache purge failed after correction transition")
+
+
 def _sync_vector_ann(
     retrieval: Any,
     fact_id: str,
@@ -173,6 +198,83 @@ def _converge_update_projections(
         logger.warning("Derived projection update sync failed for %s", fact_id[:16])
 
 
+def _project_correction_successor(
+    engine: Any,
+    fact_id: str,
+    content: str,
+    profile_id: str,
+    embedding: list[float] | None,
+) -> None:
+    """Project a new successor without touching predecessor projections."""
+    retrieval = getattr(engine, "_retrieval_engine", None)
+    bm25 = getattr(retrieval, "_bm25", None) if retrieval else None
+    if bm25 is not None:
+        try:
+            bm25.add(fact_id, content, profile_id)
+        except Exception as exc:
+            logger.warning("BM25 successor projection failed for %s: %s", fact_id[:16], exc)
+    if retrieval is not None:
+        _sync_vector_ann(retrieval, fact_id, profile_id, embedding, operation="update")
+
+
+def _correction_ledger_available(engine: Any) -> bool:
+    try:
+        rows = engine._db.execute(
+            "SELECT 1 FROM sqlite_master WHERE type='table' AND name='correction_cases'"
+        )
+        return bool(rows)
+    except Exception:
+        return False
+
+
+def _propose_correction_case(
+    engine: Any,
+    *,
+    profile_id: str,
+    scope: str,
+    predecessor_fact_id: str,
+    successor_fact_id: str,
+    trusted_actor_id: str,
+    idempotency_key: str,
+) -> dict[str, Any]:
+    """Record a review-required M042 proposal after successor persistence.
+
+    The ledger deliberately lives on a separate short transaction from the
+    canonical writer.  A retry with the same deterministic identifiers is
+    idempotent; the predecessor remains untouched if the ledger is unavailable.
+    """
+    from superlocalmemory.storage.correction_cases import (
+        CorrectionActor,
+        CorrectionCaseStore,
+    )
+
+    actor = CorrectionActor(
+        actor_id=trusted_actor_id,
+        actor_kind="host_authenticated",
+        trust_tier="trusted",
+    )
+    case_id = uuid.uuid5(
+        uuid.NAMESPACE_URL,
+        f"slm-correction:{profile_id}:{predecessor_fact_id}:{successor_fact_id}",
+    ).hex
+    store = CorrectionCaseStore(
+        engine._db.db_path,
+        is_profile_active=lambda candidate: candidate == profile_id,
+        is_actor_trusted=lambda candidate: candidate == actor,
+    )
+    case = store.propose(
+        case_id=case_id,
+        profile_id=profile_id,
+        scope=scope,
+        predecessor_fact_id=predecessor_fact_id,
+        successor_fact_id=successor_fact_id,
+        reason_code="direct_content_correction",
+        actor=actor,
+        idempotency_key=idempotency_key,
+    )
+    return {"case_id": case.case_id, "status": case.status, "version": case.version}
+
+
 def _purge_delete_projections(
     engine: Any,
     fact_id: str,
@@ -498,7 +600,7 @@ def update_fact_authorized(
     canonical_runtime: Any | None = None,
     idempotency_key: str | None = None,
 ) -> dict[str, Any]:
-    """Authorize a fact correction and converge every derived projection."""
+    """Create a review-required correction successor without rewriting history."""
     if not content or not content.strip():
         return {"ok": False, "error": "content cannot be empty"}
     content = content.strip()
@@ -517,42 +619,70 @@ def update_fact_authorized(
     )
     if not rows:
         return {"ok": False, "error": f"Memory {fact_id} not found"}
-    old_content = dict(rows[0]).get("content", "")[:80]
-    updates: dict[str, Any] = {"content": content}
+    source = engine._db.get_fact(fact_id)
+    if source is None:
+        return {"ok": False, "error": f"Memory {fact_id} not found"}
+    if source.content == content:
+        return {"ok": True, "fact_id": fact_id, "content": content, "unchanged": True}
+    if not _correction_ledger_available(engine):
+        return {"ok": False, "error": "review-gated correction ledger is unavailable"}
+
+    request_key = idempotency_key or uuid.uuid4().hex
+    successor_fact_id = uuid.uuid5(
+        uuid.NAMESPACE_URL,
+        f"slm-correction-successor:{profile_id}:{fact_id}:{request_key}",
+    ).hex[:16]
     embedding: list[float] | None = None
+    fisher_mean: list[float] | None = None
+    fisher_variance: list[float] | None = None
     if engine._embedder:
         try:
             embedding = engine._embedder.embed(content)
             if embedding:
-                updates["embedding"] = embedding
                 fisher_mean, fisher_variance = (
                     engine._embedder.compute_fisher_params(embedding)
                 )
-                updates["fisher_mean"] = fisher_mean
-                updates["fisher_variance"] = fisher_variance
         except Exception as exc:
-            logger.warning("UPDATE embedding refresh failed: %s", exc)
-    if canonical_runtime is not None:
-        result = dict(canonical_runtime.update_fact(
-            profile_id,
-            fact_id,
-            updates,
-            idempotency_key=idempotency_key,
-        ))
-        if not result.get("ok"):
-            return {"ok": False, "error": f"Memory {fact_id} not found"}
-    else:
-        engine._db.update_fact(fact_id, updates, profile_id=profile_id)
-
-    # Converge every derived projection to the corrected content
-    _converge_update_projections(engine, fact_id, content, profile_id, embedding)
+            logger.warning("Correction successor embedding refresh failed: %s", exc)
+    if canonical_runtime is None:
+        return {
+            "ok": False,
+            "retryable": True,
+            "error": "canonical correction writer is temporarily unavailable",
+        }
+    result = dict(canonical_runtime.create_correction_successor(
+        profile_id,
+        fact_id,
+        successor_fact_id,
+        content,
+        embedding=embedding,
+        fisher_mean=fisher_mean,
+        fisher_variance=fisher_variance,
+        trusted_actor_id=trusted_actor_id,
+        idempotency_key=request_key,
+    ))
+    if not result.get("ok"):
+        return {"ok": False, "error": f"Memory {fact_id} not found"}
+    successor_fact_id = str(result["successor_fact_id"])
 
     engine._hooks.run_post("update", context)
     logger.info(
-        "UPDATE fact_id=%s actor=%s source_agent=%s old=%s new=%s",
-        fact_id[:16], trusted_actor_id, source_agent_id, old_content, content[:80],
+        "CORRECTION_PROPOSED predecessor=%s successor=%s actor=%s source_agent=%s",
+        fact_id[:16], successor_fact_id[:16], trusted_actor_id, source_agent_id,
     )
-    return {"ok": True, "fact_id": fact_id, "content": content}
+    return {
+        "ok": True,
+        "fact_id": successor_fact_id,
+        "content": content,
+        "predecessor_fact_id": fact_id,
+        "successor_fact_id": successor_fact_id,
+        "correction_case": {
+            "case_id": result["case_id"],
+            "status": result["status"],
+            "version": result["version"],
+        },
+        "review_required": True,
+    }
 
 
-__all__ = ["delete_fact_authorized", "update_fact_authorized"]
+__all__ = ["delete_fact_authorized", "purge_profile_context_cache", "update_fact_authorized"]

package/src/superlocalmemory/core/recall_pipeline.py

@@ -327,20 +327,16 @@ class _ReadOnlyLearningView:
 def _resolve_ranking_mode(env: "dict[str, str] | os._Environ[str]") -> str:
     """Map the ``SLM_RANKING`` env var to a canonical mode.
 
-    Legacy ``SLM_V2_PIPELINE_DISABLED=1`` and ``SLM_BANDIT_DISABLED=1``
-    are honoured for one-release back-compat. Explicit ``SLM_RANKING``
-    wins if both are set.
+    ``SLM_RANKING`` is an explicit operator policy.  In 4.0.5 the absence of
+    that policy is deliberately ``off``: old learning signals must not begin
+    altering recall merely because a user upgrades.  The legacy disable flags
+    remain harmless compatibility inputs, but cannot implicitly enable a
+    ranking mode.
     """
     raw = (env.get("SLM_RANKING", "") or "").strip().lower()
     if raw in _RANKING_MODES:
         return raw
-    if (env.get("SLM_V2_PIPELINE_DISABLED", "0") or "0").strip() == "1":
-        # v2 disabled → fall back to v1 adaptive only.
-        return "v1"
-    if (env.get("SLM_BANDIT_DISABLED", "0") or "0").strip() == "1":
-        # Bandit disabled → v2 without ensemble.
-        return "v2"
-    return "v2-ensemble"
+    return "off"
 
 
 def apply_ranking(

package/src/superlocalmemory/core/recall_worker.py

@@ -238,18 +238,39 @@ def _handle_update_memory(
     content: str,
     source_agent_id: str = "system",
 ) -> dict:
-    """Update a fact after capability-derived authorization."""
-    engine = _get_engine()
-    from superlocalmemory.core.engine_ingestion import local_trusted_actor_id
-    from superlocalmemory.core.mutations import update_fact_authorized
-
-    return update_fact_authorized(
-        engine,
-        fact_id,
-        content,
-        trusted_actor_id=local_trusted_actor_id("recall-worker"),
-        source_agent_id=source_agent_id,
-    )
+    """Update a fact after capability-derived authorization.
+
+    CORRECTIONS CANNOT BE PERFORMED FROM THIS WORKER, AND THAT IS BY DESIGN.
+
+    Since corrections became a review-gated lifecycle (M042) rather than an
+    in-place edit, update_fact_authorized() requires a canonical correction
+    writer. That writer is the daemon's single-writer mutation boundary
+    (CanonicalRememberRuntime, owned by unified_daemon and handed to the HTTP
+    route). A worker subprocess cannot own it: CanonicalRememberRuntime.ready
+    requires a live worker of its own, so constructing one here would nest
+    worker processes and hand a second writer the ownership context that is
+    supposed to be exclusive.
+
+    Previously this called through anyway, and mutations.py answered
+    "canonical correction writer is temporarily unavailable" with
+    retryable=True. Nothing about it was temporary — with the daemon down that
+    path can NEVER succeed, so a caller could retry forever. This is the
+    honest, non-retryable answer with the actual remedy: the daemon-backed
+    route (used automatically whenever the daemon is running) does support
+    corrections.
+    """
+    return {
+        "ok": False,
+        "retryable": False,
+        "error": (
+            "Corrections are review-gated and require the SuperLocalMemory "
+            "daemon, which owns the single correction writer. Start it with "
+            "`slm serve start` and retry — updates route through the daemon "
+            "automatically when it is running."
+        ),
+        "remedy": "slm serve start",
+        "fact_id": fact_id,
+    }
 
 
 def _handle_summarize(texts: list[str], mode: str) -> dict:

package/src/superlocalmemory/core/remember_runtime.py

@@ -105,7 +105,7 @@ class DaemonAlreadyServing(RuntimeError):
     """
 
 
-class CanonicalMutationConflict(ValueError):
+class CanonicalMutationConflict(WriteCoordinatorError, ValueError):
     """A mutation retry key was reused for different immutable input."""
 
 
@@ -337,6 +337,12 @@ class CanonicalRememberRuntime:
             self.coordinator.register_handler(CommandKind.ADMISSION, self._handle_admission)
             self.coordinator.register_handler(CommandKind.DELETE_FACT, self._handle_mutation)
             self.coordinator.register_handler(CommandKind.UPDATE_FACT, self._handle_mutation)
+            self.coordinator.register_handler(CommandKind.PROPOSE_CORRECTION, self._handle_mutation)
+            self.coordinator.register_handler(CommandKind.APPLY_CORRECTION, self._handle_mutation)
+            self.coordinator.register_handler(CommandKind.REJECT_CORRECTION, self._handle_mutation)
+            self.coordinator.register_handler(
+                CommandKind.ROLLBACK_CORRECTION, self._handle_mutation,
+            )
             self.coordinator.register_handler(CommandKind.ARCHIVE_FACT, self._handle_mutation)
             self.coordinator.register_handler(CommandKind.MERGE_FACT, self._handle_mutation)
             self.coordinator.register_handler(CommandKind.SET_FACT_SCOPE, self._handle_mutation)
@@ -484,6 +490,66 @@ class CanonicalRememberRuntime:
             idempotency_key=idempotency_key,
         )
 
+    def create_correction_successor(
+        self,
+        profile_id: str,
+        fact_id: str,
+        successor_fact_id: str,
+        content: str,
+        *,
+        embedding: list[float] | None = None,
+        fisher_mean: list[float] | None = None,
+        fisher_variance: list[float] | None = None,
+        trusted_actor_id: str = "canonical-runtime",
+        idempotency_key: str | None = None,
+    ) -> Mapping[str, Any]:
+        """Atomically create an immutable, review-required successor case."""
+        return self._submit_mutation(
+            CommandKind.PROPOSE_CORRECTION,
+            profile_id,
+            {
+                "fact_id": fact_id,
+                "successor_fact_id": successor_fact_id,
+                "content": content,
+                "embedding": _json_roundtrip({"value": embedding})["value"],
+                "fisher_mean": _json_roundtrip({"value": fisher_mean})["value"],
+                "fisher_variance": _json_roundtrip({"value": fisher_variance})["value"],
+                "trusted_actor_id": trusted_actor_id,
+            },
+            idempotency_key=idempotency_key,
+        )
+
+    def transition_correction(
+        self,
+        profile_id: str,
+        case_id: str,
+        *,
+        action: str,
+        expected_version: int,
+        actor_id: str,
+        event_valid_until: str | None = None,
+        idempotency_key: str | None = None,
+    ) -> Mapping[str, Any]:
+        """Apply, reject, or roll back one server-authorized correction case."""
+        command = {
+            "apply": CommandKind.APPLY_CORRECTION,
+            "reject": CommandKind.REJECT_CORRECTION,
+            "rollback": CommandKind.ROLLBACK_CORRECTION,
+        }.get(action)
+        if command is None:
+            raise ValueError("correction action must be apply, reject, or rollback")
+        return self._submit_mutation(
+            command,
+            profile_id,
+            {
+                "case_id": case_id,
+                "expected_version": expected_version,
+                "trusted_actor_id": actor_id,
+                "event_valid_until": event_valid_until,
+            },
+            idempotency_key=idempotency_key,
+        )
+
     def archive_fact(
         self, profile_id: str, fact_id: str, *, idempotency_key: str | None = None,
     ) -> Mapping[str, Any]:
@@ -569,6 +635,10 @@ class CanonicalRememberRuntime:
         )
         try:
             return dict(self.coordinator.submit(command, timeout=2.0).receipt)
+        except CanonicalMutationConflict:
+            # A deterministic lifecycle conflict is not a writer outage.  Let
+            # HTTP/CLI/MCP report the actionable 409/validation result.
+            raise
         except CommandConflictError as exc:
             raise CanonicalMutationConflict(
                 "idempotency key belongs to a different mutation request"
@@ -686,7 +756,9 @@ class CanonicalRememberRuntime:
             if profile_id != self._profile_id:
                 raise ValueError("mutation command targets a different profile")
             with self._db._bind_coordinator_connection(conn, capability):
-                receipt = _execute_mutation(self._db, command.kind, profile_id, payload)
+                receipt = _execute_mutation(
+                    self._db, command.kind, profile_id, payload, connection=conn
+                )
         receipt["operation_id"] = f"mutation:{command.kind.value}:{command.command_id}"
         return WriteResult.from_receipt(command, receipt)
 
@@ -730,8 +802,18 @@ def _execute_mutation(
     kind: CommandKind,
     profile_id: str,
     payload: Mapping[str, Any],
+    *,
+    connection: Any,
 ) -> dict[str, Any]:
     """Dispatch the finite mutation set; no policy, hooks, models, or I/O."""
+    if kind is CommandKind.PROPOSE_CORRECTION:
+        return _propose_correction_successor(db, profile_id, payload, connection=connection)
+    if kind in {
+        CommandKind.APPLY_CORRECTION,
+        CommandKind.REJECT_CORRECTION,
+        CommandKind.ROLLBACK_CORRECTION,
+    }:
+        return _transition_correction(db, kind, profile_id, payload, connection=connection)
     fact_id = _payload_text(payload, "fact_id")
     if kind is CommandKind.DELETE_FACT:
         return _delete_fact(db, fact_id, profile_id)
@@ -750,6 +832,26 @@ def _delete_fact(db: DatabaseManager, fact_id: str, profile_id: str) -> dict[str
     row = _fact_row(db, fact_id, profile_id)
     if row is None:
         return {"ok": False, "operation_id": f"delete:{fact_id}", "fact_id": fact_id}
+    # M042 deliberately retains immutable predecessor/successor history.
+    # SQLite's FK would reject a direct delete, but exposing that as a generic
+    # writer outage turns a real lifecycle conflict into a misleading 503.
+    # A dedicated erasure workflow owns ledger removal; ordinary forget never
+    # deletes a fact that is part of immutable correction history.
+    try:
+        protected = db.execute(
+            "SELECT 1 FROM correction_cases "
+            "WHERE profile_id=? AND (predecessor_fact_id=? OR successor_fact_id=?) LIMIT 1",
+            (profile_id, fact_id, fact_id),
+        )
+    except Exception as exc:
+        if "no such table" in str(exc).lower():
+            protected = []
+        else:
+            raise
+    if protected:
+        raise CanonicalMutationConflict(
+            "fact is protected by correction history; resolve the correction before forgetting it"
+        )
     db.delete_fact(fact_id, profile_id=profile_id)
     return {
         "ok": True,
@@ -782,6 +884,173 @@ def _update_fact(
     }
 
 
+def _propose_correction_successor(
+    db: DatabaseManager,
+    profile_id: str,
+    payload: Mapping[str, Any],
+    *,
+    connection: Any,
+) -> dict[str, Any]:
+    """Create successor and M042 proposal in one canonical writer transaction.
+
+    System time is represented by the new fact's ``created_at`` and temporal
+    knowledge anchor.  Event-time fields are copied exactly from the
+    predecessor because an edit payload has no trustworthy event-time claim.
+    """
+    fact_id = _payload_text(payload, "fact_id")
+    source = _fact_row(db, fact_id, profile_id)
+    if source is None:
+        return {"ok": False, "operation_id": f"correction:{fact_id}", "fact_id": fact_id}
+    successor_id = _payload_text(payload, "successor_fact_id")
+    content = _payload_text(payload, "content").strip()
+    if not content:
+        raise ValueError("correction successor content cannot be empty")
+    if successor_id == fact_id:
+        raise ValueError("correction successor must differ from predecessor")
+
+    from superlocalmemory.storage.models import AtomicFact, FactType, MemoryLifecycle, SignalType
+
+    def _list_payload(key: str) -> list[float] | None:
+        value = payload.get(key)
+        if value is None:
+            return None
+        if not isinstance(value, (list, tuple)) or not all(
+            isinstance(v, (int, float)) for v in value
+        ):
+            raise ValueError(f"correction successor {key} must be numeric or null")
+        return [float(v) for v in value]
+
+    now = datetime.now(timezone.utc).isoformat()
+    successor = AtomicFact(
+        fact_id=successor_id,
+        memory_id=str(source.get("memory_id") or ""),
+        profile_id=profile_id,
+        scope=str(source.get("scope") or "personal"),
+        shared_with=json.loads(source["shared_with"]) if source.get("shared_with") else None,
+        content=content,
+        fact_type=FactType(str(source.get("fact_type") or "semantic")),
+        entities=json.loads(source["entities_json"]) if source.get("entities_json") else [],
+        canonical_entities=(
+            json.loads(source["canonical_entities_json"])
+            if source.get("canonical_entities_json") else []
+        ),
+        observation_date=source.get("observation_date"),
+        referenced_date=source.get("referenced_date"),
+        interval_start=source.get("interval_start"),
+        interval_end=source.get("interval_end"),
+        confidence=float(source.get("confidence") or 0.0),
+        importance=float(source.get("importance") or 0.0),
+        evidence_count=1,
+        access_count=0,
+        source_turn_ids=(
+            json.loads(source["source_turn_ids_json"])
+            if source.get("source_turn_ids_json") else []
+        ),
+        session_id=str(source.get("session_id") or ""),
+        embedding=_list_payload("embedding"),
+        fisher_mean=_list_payload("fisher_mean"),
+        fisher_variance=_list_payload("fisher_variance"),
+        lifecycle=MemoryLifecycle.ACTIVE,
+        langevin_position=None,
+        emotional_valence=float(source.get("emotional_valence") or 0.0),
+        emotional_arousal=float(source.get("emotional_arousal") or 0.0),
+        signal_type=SignalType(str(source.get("signal_type") or "factual")),
+        created_at=now,
+    )
+    persisted_id = db.insert_fact_immutable(successor)
+    from superlocalmemory.storage.correction_cases import (
+        CorrectionActor,
+        propose_on_connection,
+    )
+
+    trusted_actor_id = _payload_text(payload, "trusted_actor_id")
+    actor = CorrectionActor(
+        actor_id=trusted_actor_id,
+        actor_kind="host_authenticated",
+        trust_tier="trusted",
+    )
+    case_id = uuid.uuid5(
+        uuid.NAMESPACE_URL,
+        f"slm-correction:{profile_id}:{fact_id}:{persisted_id}",
+    ).hex
+    case = propose_on_connection(
+        connection,
+        case_id=case_id,
+        profile_id=profile_id,
+        scope=str(source.get("scope") or "personal"),
+        predecessor_fact_id=fact_id,
+        successor_fact_id=persisted_id,
+        reason_code="direct_content_correction",
+        actor=actor,
+        idempotency_key=_payload_text(payload, "idempotency_key"),
+        is_profile_active=lambda candidate: candidate == profile_id,
+        is_actor_trusted=lambda candidate: candidate == actor,
+    )
+    return {
+        "ok": True,
+        "operation_id": f"correction:{fact_id}:{persisted_id}",
+        "predecessor_fact_id": fact_id,
+        "successor_fact_id": persisted_id,
+        "case_id": case.case_id,
+        "status": case.status,
+        "version": case.version,
+        "created_at": now,
+    }
+
+
+def _transition_correction(
+    db: DatabaseManager,
+    kind: CommandKind,
+    profile_id: str,
+    payload: Mapping[str, Any],
+    *,
+    connection: Any,
+) -> dict[str, Any]:
+    """Advance one correction case under the same receipt transaction."""
+    from superlocalmemory.storage.correction_cases import (
+        CorrectionActor,
+        transition_on_connection,
+    )
+
+    case_id = _payload_text(payload, "case_id")
+    version = payload.get("expected_version")
+    if not isinstance(version, int) or isinstance(version, bool) or version < 0:
+        raise ValueError("correction expected_version must be a non-negative integer")
+    actor = CorrectionActor(
+        actor_id=_payload_text(payload, "trusted_actor_id"),
+        actor_kind="host_authenticated",
+        trust_tier="trusted",
+    )
+    transitions = {
+        CommandKind.APPLY_CORRECTION: ("proposed", "applied", True),
+        CommandKind.REJECT_CORRECTION: ("proposed", "rejected", False),
+        CommandKind.ROLLBACK_CORRECTION: ("applied", "rolled_back", True),
+    }
+    from_status, to_status, mutate_temporal = transitions[kind]
+    case = transition_on_connection(
+        connection,
+        case_id=case_id,
+        expected_version=version,
+        actor=actor,
+        operation_id=_payload_text(payload, "idempotency_key"),
+        from_status=from_status,
+        to_status=to_status,
+        mutate_temporal=mutate_temporal,
+        event_valid_until=payload.get("event_valid_until"),
+        is_profile_active=lambda candidate: candidate == profile_id,
+        is_actor_trusted=lambda candidate: candidate == actor,
+    )
+    return {
+        "ok": True,
+        "operation_id": f"correction:{to_status}:{case.case_id}",
+        "case_id": case.case_id,
+        "predecessor_fact_id": case.predecessor_fact_id,
+        "successor_fact_id": case.successor_fact_id,
+        "status": case.status,
+        "version": case.version,
+    }
+
+
 def _archive_fact(
     db: DatabaseManager, fact_id: str, profile_id: str, payload: Mapping[str, Any],
 ) -> dict[str, Any]: