superlocalmemory 4.0.3 → 4.0.5

package/src/superlocalmemory/mcp/server.py

@@ -77,13 +77,13 @@ def reset_engine():
 
 # Register tools and resources -------------------------------------------------
 #
-# Essential-only default: 38 base tools + 8 mesh tools = 46 registered
+# Essential-only default: 41 base tools + 8 mesh tools = 49 registered.
 # when mesh is enabled. Set ``SLM_MCP_ALL_TOOLS=1`` to expose the full
 # toolset. Rationale: IDEs cap at 50-100 tools total (Cursor,
 # Antigravity, Windsurf) and a maximal SLM registration crowds out
 # other MCP servers the user may have installed.
 # Admin/diagnostics tools remain available via CLI (`slm <command>`).
-# Set SLM_MCP_ALL_TOOLS=1 to enable all 91 tools (power users).
+# Set SLM_MCP_ALL_TOOLS=1 to enable all 94 tools (power users).
 
 import os as _os_reg
 
@@ -100,6 +100,11 @@ _ESSENTIAL_TOOLS: set[str] = {
     # v4.0.2 portable Brain evidence: profile-scoped receipt reads/writes.
     "get_brain_evidence_status", "record_agent_experience",
     "record_cognitive_turn", "finalize_cognitive_turn",
+    # v4.0.4: explicit, optional observation from the separately installed
+    # Bounded Loops MCP producer. It never participates in recall/ranking.
+    "observe_bounded_loop_evidence",
+    # Update, review, and list form one core correction lifecycle.
+    "review_correction", "list_corrections",
     # Memory management (2)
     "forget", "run_maintenance",
     # NOTE: prestage_context IS registered (see register_prestage_tool below)

package/src/superlocalmemory/mcp/tools_brain.py

@@ -9,21 +9,29 @@ or changes a memory answer.
 
 from __future__ import annotations
 
+import asyncio
+import sqlite3
 from pathlib import Path
 from typing import Any, Callable
 
 from mcp.types import ToolAnnotations
 
+from superlocalmemory.brain.truth import BrainTruthService
 from superlocalmemory.core.admission import admits
 from superlocalmemory.core.operation_request import OperationKind
 from superlocalmemory.infra.data_root import state_path
+from superlocalmemory.integrations.bounded_loops_mcp import BridgeUnavailable, observe_installed
 from superlocalmemory.storage.agent_experience import (
     AgentExperienceConflictError,
     AgentExperienceStore,
     CognitiveTurnTransitionError,
     LearningWriteBusyError,
     ProfileAdmissionError,
-    get_profile_receipt_summary,
+)
+from superlocalmemory.storage.external_evidence import (
+    ExternalEvidenceConflictError,
+    ExternalEvidenceStore,
+    ExternalEvidenceValidationError,
 )
 
 
@@ -35,6 +43,56 @@ def _store_for(engine: Any) -> AgentExperienceStore:
     )
 
 
+def _external_store_for(engine: Any) -> ExternalEvidenceStore:
+    active_profile = engine.profile_id
+    return ExternalEvidenceStore(
+        Path(state_path("learning.db")),
+        is_profile_active=lambda profile_id: profile_id == active_profile,
+    )
+
+
+def _brain_truth_for(engine: Any) -> dict[str, Any]:
+    """Read the portable truth snapshot without opening an engine or a writer."""
+    return BrainTruthService(
+        memory_db_path=state_path("memory.db"),
+        learning_db_path=state_path("learning.db"),
+    ).snapshot(engine.profile_id)
+
+
+def _legacy_agent_experience(truth: dict[str, Any]) -> dict[str, Any]:
+    """Keep the v4.0.4 MCP alias during the one-release transition window."""
+    evidence = truth["agent_experience"]
+    available = evidence["availability"] == "available"
+    claimed = evidence["claimed_experiences_total"]
+    turns = evidence["cognitive_turns_total"]
+    states = evidence["cognitive_turns_by_state"]
+    return {
+        "is_real": available,
+        "availability": evidence["availability"],
+        "experiences_total": claimed if available else 0,
+        "turns_total": turns if available else 0,
+        "turns_by_state": states if available else {},
+        # The old name remains an alias only.  BrainTruth deliberately calls
+        # these declared claims, never independently verified learning.
+        "claimed_evidence_experiences": claimed if available else 0,
+        "source": evidence["source"],
+    }
+
+
+def _legacy_external_evidence(truth: dict[str, Any]) -> dict[str, Any]:
+    """Keep the v4.0.4 external-graph alias without a second database read."""
+    evidence = truth["external_evidence"]
+    available = evidence["availability"] == "available"
+    return {
+        "is_real": available,
+        "availability": evidence["availability"],
+        "total": evidence["receipts_total"] if available else 0,
+        "by_run_state": evidence["receipts_by_run_state"] if available else {},
+        "demonstrations": evidence["demonstrations_total"] if available else 0,
+        "control_plane": "observation_only",
+    }
+
+
 def _require_active_profile(engine: Any, payload: dict[str, Any]) -> str | None:
     supplied = payload.get("profile_id")
     if supplied != engine.profile_id:
@@ -42,6 +100,27 @@ def _require_active_profile(engine: Any, payload: dict[str, Any]) -> str | None:
     return None
 
 
+class _ExternalEvidenceWriteError(Exception):
+    """Preserve committed receipt count when a later snapshot item fails."""
+
+    def __init__(self, created: int, cause: Exception) -> None:
+        super().__init__(str(cause))
+        self.created = created
+        self.cause = cause
+
+
+def _record_external_evidence(store: ExternalEvidenceStore, observed: list[dict[str, Any]]) -> int:
+    """Write bounded evidence off the async MCP loop; return durable inserts."""
+    created = 0
+    for payload in observed:
+        try:
+            if store.record(payload):
+                created += 1
+        except Exception as exc:
+            raise _ExternalEvidenceWriteError(created, exc) from exc
+    return created
+
+
 def register_brain_tools(server: Any, get_engine: Callable[[], Any]) -> None:
     """Register transport-neutral receipt reads and writes.
 
@@ -52,15 +131,21 @@ def register_brain_tools(server: Any, get_engine: Callable[[], Any]) -> None:
 
     @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def get_brain_evidence_status() -> dict[str, Any]:
-        """Get profile-scoped Agent Experience and Cognitive Turn totals."""
+        """Get profile-scoped, observation-only Living Brain evidence totals.
+
+        ``brain_truth`` is the canonical v1 payload.  The legacy aliases are
+        retained for one release so existing hosts can move independently.
+        """
         engine = get_engine()
+        truth = _brain_truth_for(engine)
         return {
             "success": True,
             "profile_id": engine.profile_id,
-            "agent_experience": get_profile_receipt_summary(
-                state_path("learning.db"), engine.profile_id
-            ),
-            "control_plane": "observation_only",
+            "brain_truth": truth,
+            "agent_experience": _legacy_agent_experience(truth),
+            "external_evidence": truth["external_evidence"],
+            "external_graph_evidence": _legacy_external_evidence(truth),
+            "control_plane": truth["control_plane"],
         }
 
     @server.tool()
@@ -110,9 +195,7 @@ def register_brain_tools(server: Any, get_engine: Callable[[], Any]) -> None:
 
     @server.tool()
     @admits(OperationKind.REMEMBER)
-    async def finalize_cognitive_turn(
-        receipt_id: str, outcome: dict[str, Any]
-    ) -> dict[str, Any]:
+    async def finalize_cognitive_turn(receipt_id: str, outcome: dict[str, Any]) -> dict[str, Any]:
         """Finalize an active-profile cognitive turn with outcome evidence."""
         engine = get_engine()
         try:
@@ -130,3 +213,49 @@ def register_brain_tools(server: Any, get_engine: Callable[[], Any]) -> None:
         except (TypeError, ValueError) as exc:
             return {"success": False, "durable": False, "error": str(exc)}
         return {"success": True, "durable": True, "finalized": finalized}
+
+    @server.tool()
+    @admits(OperationKind.REMEMBER)
+    async def observe_bounded_loop_evidence(workspace: str) -> dict[str, Any]:
+        """Import one explicit, read-only snapshot from installed Bounded Loops.
+
+        Bounded Loops remains optional.  This tool negotiates its public MCP
+        contract at runtime, records only compatible terminal evidence, and
+        never changes recall, ranking, routing, or learned behaviour.
+        """
+        engine = get_engine()
+        created = 0
+        try:
+            observed = await observe_installed(workspace=workspace, profile_id=engine.profile_id)
+            store = _external_store_for(engine)
+            created = await asyncio.to_thread(_record_external_evidence, store, observed)
+        except _ExternalEvidenceWriteError as exc:
+            return {
+                "success": False,
+                "durable": exc.created > 0,
+                "created": exc.created,
+                "retryable": isinstance(exc.cause, LearningWriteBusyError),
+                "error": str(exc.cause),
+            }
+        except (
+            BridgeUnavailable,
+            ExternalEvidenceConflictError,
+            ExternalEvidenceValidationError,
+            ProfileAdmissionError,
+            sqlite3.Error,
+        ) as exc:
+            return {
+                "success": False,
+                "durable": created > 0,
+                "created": created,
+                "error": str(exc),
+            }
+        except LearningWriteBusyError as exc:
+            return {"success": False, "durable": False, "retryable": True, "error": str(exc)}
+        return {
+            "success": True,
+            "durable": True,
+            "observed": len(observed),
+            "created": created,
+            "control_plane": "observation_only",
+        }

package/src/superlocalmemory/mcp/tools_core.py

@@ -928,8 +928,11 @@ def register_core_tools(server, get_engine: Callable) -> None:
                 )
                 if isinstance(result, dict) and result.get("success"):
                     return {
-                        "success": True, "fact_id": fact_id,
-                        "content": content.strip(),
+                        "success": True,
+                        "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)),
                     }
                 return {
                     "success": False,
@@ -947,12 +950,94 @@ def register_core_tools(server, get_engine: Callable) -> None:
             })
             if result.get("ok"):
                 logger.info("Memory updated: %s by agent: %s", fact_id[:16], agent_id)
-                return {"success": True, "fact_id": fact_id, "content": content.strip()}
+                return {
+                    "success": True,
+                    "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)),
+                }
             return {"success": False, "error": result.get("error", "Update failed")}
         except Exception as exc:
             logger.exception("update_memory failed")
             return {"success": False, "error": str(exc)}
 
+    @server.tool(annotations=ToolAnnotations(idempotentHint=True))
+    @admits(OperationKind.CORRECT)
+    async def review_correction(
+        case_id: str,
+        action: str,
+        expected_version: int,
+        event_valid_until: str | None = None,
+    ) -> dict:
+        """Apply, reject, or roll back a review-gated correction case.
+
+        The active daemon derives reviewer identity and profile from its local
+        authenticated MCP boundary.  Clients provide only a case address, a
+        CAS version, and an optional reviewer-approved event-time boundary.
+        """
+        if action not in {"apply", "reject", "rollback"}:
+            return {"success": False, "error": "action must be apply, reject, or rollback"}
+        if not isinstance(expected_version, int) or isinstance(expected_version, bool):
+            return {"success": False, "error": "expected_version must be an integer"}
+        if expected_version < 0:
+            return {"success": False, "error": "expected_version must be non-negative"}
+        try:
+            import asyncio
+            import urllib.parse
+
+            from superlocalmemory.cli.daemon import daemon_request, is_daemon_running
+
+            if not await asyncio.to_thread(is_daemon_running):
+                return {
+                    "success": False,
+                    "retryable": True,
+                    "error": "correction review requires the resident canonical daemon",
+                }
+            payload: dict[str, object] = {"expected_version": expected_version}
+            if event_valid_until is not None:
+                payload["event_valid_until"] = event_valid_until
+            path = "/api/corrections/" + urllib.parse.quote(case_id, safe="") + "/" + action
+            result = await asyncio.to_thread(daemon_request, "POST", path, payload)
+            if isinstance(result, dict) and result.get("success"):
+                return result
+            return {
+                "success": False,
+                "retryable": True,
+                "error": "resident daemon rejected the correction review",
+            }
+        except Exception:
+            logger.exception("review_correction failed")
+            return {"success": False, "retryable": True, "error": "correction review unavailable"}
+
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
+    async def list_corrections(limit: int = 100) -> dict:
+        """List active-profile correction cases for a human or host reviewer."""
+        if not isinstance(limit, int) or isinstance(limit, bool) or not 1 <= limit <= 500:
+            return {"success": False, "error": "limit must be an integer from 1 to 500"}
+        try:
+            import asyncio
+
+            from superlocalmemory.cli.daemon import daemon_request, is_daemon_running
+
+            if not await asyncio.to_thread(is_daemon_running):
+                return {
+                    "success": False,
+                    "retryable": True,
+                    "error": "correction review requires the resident canonical daemon",
+                }
+            result = await asyncio.to_thread(daemon_request, "GET", f"/api/corrections?limit={limit}")
+            if isinstance(result, dict) and result.get("success"):
+                return result
+            return {
+                "success": False,
+                "retryable": True,
+                "error": "resident daemon rejected correction listing",
+            }
+        except Exception:
+            logger.exception("list_corrections failed")
+            return {"success": False, "retryable": True, "error": "correction listing unavailable"}
+
     @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def get_attribution() -> dict:
         """Get system attribution: author, version, license, and provenance metadata."""

package/src/superlocalmemory/retrieval/engine.py

@@ -29,6 +29,7 @@ from superlocalmemory.core.config import ChannelWeights, RetrievalConfig
 from superlocalmemory.retrieval.fusion import FusionResult, weighted_rrf
 from superlocalmemory.retrieval.strategy import QueryStrategy, QueryStrategyClassifier
 from superlocalmemory.retrieval.temporal_validity_filter import (
+    CorrectionAdmissionCache,
     admit_correction_candidates,
     admit_correction_fusion_results,
 )
@@ -232,6 +233,10 @@ class RetrievalEngine:
             include_unknown=include_unknown,
         )
         _em("run_channels")
+        # One request may need admission before fusion and again after optional
+        # bridge/scene expansion.  Cache only the IDs checked during this one
+        # request; every newly expanded candidate remains a hard DB lookup.
+        correction_admission = CorrectionAdmissionCache()
         if profile_hits:
             ch_results["profile"] = profile_hits
         # The profile shortcut bypasses _run_channels(), so it needs the same
@@ -241,6 +246,7 @@ class RetrievalEngine:
             known_as_of=known_as_of, valid_at=valid_at,
             include_unknown=include_unknown,
             include_global=include_global, include_shared=include_shared,
+            lifecycle_cache=correction_admission,
         )
         total = sum(len(v) for v in ch_results.values())
 
@@ -357,6 +363,7 @@ class RetrievalEngine:
             known_as_of=known_as_of, valid_at=valid_at,
             include_unknown=include_unknown,
             include_global=include_global, include_shared=include_shared,
+            lifecycle_cache=correction_admission,
         )
 
         _em("expand+entity_enh")
@@ -949,16 +956,6 @@ class RetrievalEngine:
                 except Exception as exc:
                     logger.warning("Post-retrieval filter failed: %s", exc)
 
-        # The legacy temporal filter preserves its score-demotion semantics for
-        # compatibility. Admission is separate and hard: no current
-        # system-superseded fact may seed fusion, bridge discovery, or rerank.
-        out = admit_correction_candidates(
-            out, profile_id, self._db, as_of=as_of,
-            known_as_of=known_as_of, valid_at=valid_at,
-            include_unknown=include_unknown,
-            include_global=include_global, include_shared=include_shared,
-        )
-
         return out
 
     def close(self, *, wait: bool = False) -> None:

package/src/superlocalmemory/retrieval/temporal_validity_filter.py

@@ -49,8 +49,12 @@ All demotions are non-destructive (P5-INT-01): facts stay in the candidate
 list but rank below valid facts. A factor of 0.0 restores the legacy hide
 behaviour (a score of zero is gated out by the evidence floor).
 
-Both lookups are bounded (candidate ids only), chunked, indexed, and
-fail-open: a DB error returns results unchanged.
+All correction-admission lookups are bounded (candidate ids only), chunked,
+and indexed.  Admission is deliberately **fail-closed**: if SLM cannot prove
+which candidates are invalidated, it returns no candidates rather than let an
+approved stale fact re-enter recall.  The legacy score-demotion filter follows
+the same rule for its system-invalidated lookup.  Event-time demotion remains a
+best-effort ranking signal; it is not the correction authority.
 
 Integrates with ChannelRegistry.register_filter() using the FilterFn signature:
     (all_channel_results, profile_id, context) -> filtered_results
@@ -62,6 +66,7 @@ License: AGPL-3.0-or-later
 from __future__ import annotations
 
 import logging
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
@@ -79,6 +84,21 @@ logger = logging.getLogger(__name__)
 _EVENT_TIME_DEMOTION_FACTOR: float = 0.5
 
 
+@dataclass
+class CorrectionAdmissionCache:
+    """Per-recall lifecycle admission cache.
+
+    The retrieval engine performs a mandatory second admission after bridge or
+    scene expansion.  Facts already checked before fusion do not need a second
+    database read in the *same* recall, while any newly expanded id is checked
+    immediately.  The cache never crosses requests, profiles, or DB writes.
+    """
+
+    checked_fact_ids: set[str] = field(default_factory=set)
+    inadmissible_fact_ids: set[str] = field(default_factory=set)
+    unavailable: bool = False
+
+
 def _normalized_as_of(as_of: str | None) -> str | None:
     """Normalize an optional transaction-time boundary at one boundary.
 
@@ -100,26 +120,69 @@ def _invalidated_candidate_ids(
     as_of: str | None = None,
     include_global: bool = False,
     include_shared: bool = False,
+    lifecycle_cache: CorrectionAdmissionCache | None = None,
 ) -> set[str] | None:
-    """Return admissibility failures, or ``None`` when the lookup is unhealthy.
+    """Return correction failures, or ``None`` when admission is unprovable.
 
-    ``None`` deliberately preserves the established fail-open availability
-    contract.  It is distinct from an empty set: a bad/mocked return value must
-    not accidentally exclude arbitrary candidates.
+    ``None`` is intentionally distinct from an empty set.  Callers MUST turn
+    it into an abstention (an empty candidate path), never treat it as "nothing
+    invalidated".  Treating an unavailable lifecycle read as an empty set is a
+    fail-open path through which an approved stale fact can be re-admitted.
     """
     if not fact_ids:
         return set()
+    if lifecycle_cache is not None and lifecycle_cache.unavailable:
+        return None
+    unchecked = (
+        fact_ids - lifecycle_cache.checked_fact_ids
+        if lifecycle_cache is not None
+        else fact_ids
+    )
+    if not unchecked:
+        return (
+            lifecycle_cache.inadmissible_fact_ids & fact_ids
+            if lifecycle_cache is not None
+            else set()
+        )
     try:
         kwargs: dict[str, Any] = {"as_of": _normalized_as_of(as_of)}
         if include_global:
             kwargs["include_global"] = True
         if include_shared:
             kwargs["include_shared"] = True
-        invalid = db.get_invalidated_fact_ids(list(fact_ids), profile_id, **kwargs)
+        # Do not infer support from a permissive mock's dynamic attributes.
+        # The concrete storage manager owns this optimized contract; older
+        # adapters continue through the two focused public queries below.
+        combined = getattr(type(db), "get_correction_inadmissible_fact_ids", None)
+        if callable(combined):
+            invalid = db.get_correction_inadmissible_fact_ids(
+                list(unchecked), profile_id, **kwargs,
+            )
+        else:
+            invalid = db.get_invalidated_fact_ids(list(unchecked), profile_id, **kwargs)
+            pending_successors = db.get_nonapplied_correction_successor_ids(
+                list(unchecked),
+                profile_id,
+                include_global=include_global,
+                include_shared=include_shared,
+            )
+            if not isinstance(pending_successors, set):
+                return None
+            invalid |= pending_successors
     except Exception as exc:
         logger.warning("Correction admission lookup failed: %s", exc)
+        if lifecycle_cache is not None:
+            lifecycle_cache.unavailable = True
         return None
-    return invalid if isinstance(invalid, set) else None
+    if not isinstance(invalid, set):
+        if lifecycle_cache is not None:
+            lifecycle_cache.unavailable = True
+        return None
+    if lifecycle_cache is not None:
+        lifecycle_cache.checked_fact_ids.update(unchecked)
+        lifecycle_cache.inadmissible_fact_ids.update(invalid)
+        return lifecycle_cache.inadmissible_fact_ids & fact_ids
+    return invalid
 
 
 def _strict_temporal_candidate_ids(
@@ -133,7 +196,7 @@ def _strict_temporal_candidate_ids(
     include_global: bool = False,
     include_shared: bool = False,
 ) -> set[str] | None:
-    """Return strict two-clock admission failures, fail-open on lookup error."""
+    """Return strict two-clock failures, or ``None`` when admission is unprovable."""
     if not fact_ids or (known_as_of is None and valid_at is None):
         return set()
     try:
@@ -151,6 +214,26 @@ def _strict_temporal_candidate_ids(
     return invalid if isinstance(invalid, set) else None
 
 
+def _abstain_candidates(
+    all_results: dict[str, list[tuple[str, float]]],
+    *,
+    stage: str,
+) -> dict[str, list[tuple[str, float]]]:
+    """Fail closed without changing the retrieval filter public contract.
+
+    ``ChannelRegistry`` and the retrieval engine both expect the original
+    channel-result shape.  Returning the same channel names with empty lists
+    is an explicit candidate-level abstention: downstream fusion naturally
+    produces no materializable facts, while callers keep their stable response
+    schema and can report ``no_confident_match``.
+    """
+    logger.error(
+        "Temporal correction admission unavailable at %s; abstaining from recall candidates",
+        stage,
+    )
+    return {channel_name: [] for channel_name in all_results}
+
+
 def admit_correction_candidates(
     all_results: dict[str, list[tuple[str, float]]],
     profile_id: str,
@@ -162,6 +245,7 @@ def admit_correction_candidates(
     include_unknown: bool = False,
     include_global: bool = False,
     include_shared: bool = False,
+    lifecycle_cache: CorrectionAdmissionCache | None = None,
 ) -> dict[str, list[tuple[str, float]]]:
     """Hard-exclude system-superseded facts before candidate fusion.
 
@@ -178,15 +262,20 @@ def admit_correction_candidates(
     invalid = _invalidated_candidate_ids(
         db, fact_ids, profile_id, as_of=as_of,
         include_global=include_global, include_shared=include_shared,
+        lifecycle_cache=lifecycle_cache,
     )
+    if invalid is None:
+        return _abstain_candidates(all_results, stage="pre_fusion.lifecycle")
     strict = _strict_temporal_candidate_ids(
         db, fact_ids, profile_id,
         known_as_of=known_as_of, valid_at=valid_at,
         include_unknown=include_unknown,
         include_global=include_global, include_shared=include_shared,
     )
+    if strict is None:
+        return _abstain_candidates(all_results, stage="pre_fusion.strict_temporal")
     if strict:
-        invalid = (invalid or set()) | strict
+        invalid |= strict
     if not invalid:
         return all_results
     return {
@@ -210,21 +299,35 @@ def admit_correction_fusion_results(
     include_unknown: bool = False,
     include_global: bool = False,
     include_shared: bool = False,
+    lifecycle_cache: CorrectionAdmissionCache | None = None,
 ) -> list[Any]:
     """Re-apply correction admission after graph/scene candidate expansion."""
     fact_ids = {result.fact_id for result in fused_results}
     invalid = _invalidated_candidate_ids(
         db, fact_ids, profile_id, as_of=as_of,
         include_global=include_global, include_shared=include_shared,
+        lifecycle_cache=lifecycle_cache,
     )
+    if invalid is None:
+        logger.error(
+            "Temporal correction admission unavailable at post_fusion.lifecycle; "
+            "abstaining from recall candidates",
+        )
+        return []
     strict = _strict_temporal_candidate_ids(
         db, fact_ids, profile_id,
         known_as_of=known_as_of, valid_at=valid_at,
         include_unknown=include_unknown,
         include_global=include_global, include_shared=include_shared,
     )
+    if strict is None:
+        logger.error(
+            "Temporal correction admission unavailable at post_fusion.strict_temporal; "
+            "abstaining from recall candidates",
+        )
+        return []
     if strict:
-        invalid = (invalid or set()) | strict
+        invalid |= strict
     if not invalid:
         return fused_results
     return [result for result in fused_results if result.fact_id not in invalid]
@@ -311,14 +414,11 @@ class TemporalValidityFilter:
         # When as_of is set: only supersessions that occurred AT OR BEFORE
         # as_of contribute (Phase 4b bi-temporal fix). Supersessions after
         # as_of are invisible — the fact was still valid at the query point.
-        try:
-            invalid = self._db.get_invalidated_fact_ids(
-                list(all_fact_ids), profile_id, as_of=as_of,
-            )
-        except Exception as exc:
-            # Fail-open: a validity-lookup error must never break retrieval.
-            logger.warning("Temporal validity lookup failed: %s", exc)
-            return all_results
+        invalid = _invalidated_candidate_ids(
+            self._db, all_fact_ids, profile_id, as_of=as_of,
+        )
+        if invalid is None:
+            return _abstain_candidates(all_results, stage="legacy_filter.lifecycle")
 
         # --- Axis 2: Event-time expiry (Phase 4 T1b) ---
         # Guard: skip event-time demotion when the caller signals it wants