superlocalmemory 3.8.13 → 4.0.0

package/src/superlocalmemory/core/engine_ingestion.py

@@ -151,14 +151,26 @@ def build_immediate_admission_handler(
         from datetime import UTC, datetime
 
         from superlocalmemory.core.ingest_gate import apply_ingest_gate
+        from superlocalmemory.core.ingest_policy import scrub_secrets_for_ingest
         from superlocalmemory.storage.models import AtomicFact, FactType, MemoryRecord
 
+        # Secrets are ALWAYS scrubbed at this shared queryable-write chokepoint,
+        # which both the canonical HTTP /remember runtime and the canonical_store
+        # Python/CLI path funnel through. A credential must never persist verbatim
+        # in any durable representation (memory rows, fact rows), regardless of
+        # ingress surface. The scrub is idempotent: content already scrubbed by an
+        # upstream caller is returned unchanged.
+        scrub = scrub_secrets_for_ingest(request.content)
+        content = scrub.content
+        if scrub.redacted:
+            logger.info("secret scrub: redacted credential material on queryable write")
+
         metadata = dict(request.metadata)
         metadata["ingestion_operation_id"] = operation_id
         if request.session_id:
             metadata.setdefault("session_id", request.session_id)
         gate = apply_ingest_gate(
-            request.content,
+            content,
             max_verbatim_chars=max_verbatim_chars,
             max_ingest_bytes=max_ingest_bytes,
         )
@@ -225,7 +237,7 @@ def build_immediate_admission_handler(
             record = MemoryRecord(
                 memory_id=memory_id,
                 profile_id=request.profile_id,
-                content=request.content,
+                content=content,
                 session_id=request.session_id,
                 session_date=observation_date,
                 speaker=request.speaker,
@@ -302,6 +314,15 @@ def canonical_store(
             error=ValueError("content rejected by local admission policy"),
         )
         return []
+    # Secrets are ALWAYS scrubbed pre-admission (not opt-in): a credential must
+    # never persist verbatim in any durable or queryable representation
+    # (facts, receipts, journal, exports, backups, mesh).
+    from superlocalmemory.core.ingest_policy import scrub_secrets_for_ingest
+
+    _secret_scrub = scrub_secrets_for_ingest(content)
+    if _secret_scrub.redacted:
+        content = _secret_scrub.content
+        logger.info("secret scrub: redacted credential material on ingest")
     # C4: opt-in PII redaction. When enabled (config.pii_redaction or
     # SLM_PII_REDACTION), scrub personal identifiers BEFORE the content is
     # extracted, embedded, or persisted — nothing sensitive ever reaches disk.
@@ -426,7 +447,19 @@ def build_engine_ingestion_command(engine: MemoryEngine) -> IngestionCommand:
     )
 
     def validate_admission(request: IngestionRequest) -> None:
-        """Apply trust policy before the journal or canonical transaction."""
+        """Apply trust policy before the journal or canonical transaction.
+
+        V4 Phase 4 addition: evaluate the OperationPolicyRegistry AFTER the
+        trust hook and BEFORE the coordinator transaction. This evaluation is
+        CPU-only (dict lookup + frozenset operations, no I/O) and runs in the
+        validate_admission slot which is already outside the SQLite writer.
+
+        The default registry allows every REMEMBER from an OWNER via the
+        INTERNAL transport in local mode — zero new rejections on the current
+        happy path. A denial raises ValueError, which propagates through
+        IngestionCommand.submit() to the caller exactly as existing slot
+        violations do.
+        """
         engine._hooks.run_pre("store", {
             "operation": "store",
             "agent_id": request.trusted_actor_id,
@@ -434,6 +467,35 @@ def build_engine_ingestion_command(engine: MemoryEngine) -> IngestionCommand:
             "content_preview": request.content[:100],
         })
 
+        # Phase 4: additive policy check — runs after the trust hook.
+        # Imports are lazy to avoid import-order coupling at module init.
+        from superlocalmemory.core.actor_context import ActorContext, ActorRole, Transport
+        from superlocalmemory.core.operation_policy_registry import _DEFAULT_REGISTRY
+        from superlocalmemory.core.operation_request import OperationKind
+
+        # A missing actor is rejected by the existing admission check with its
+        # canonical message; the policy layer is strictly additive and must not
+        # preempt that rejection, so it only evaluates when an actor is present.
+        if request.trusted_actor_id:
+            _actor = ActorContext(
+                # trusted_actor_id is already server-validated by the caller;
+                # it is NEVER taken from the request body here.
+                principal_id=request.trusted_actor_id,
+                roles=frozenset({ActorRole.OWNER}),
+                active_profile_id=request.profile_id,
+                transport=Transport.INTERNAL,
+                client_host="",   # in-process: always local
+            )
+            _decision = _DEFAULT_REGISTRY.evaluate(
+                OperationKind.REMEMBER,
+                _actor,
+                "local",  # internal Python-API path is always local/single-user
+            )
+            if not _decision.allowed:
+                raise ValueError(
+                    f"operation policy denied REMEMBER: {_decision.reason}"
+                )
+
     def resume_checkpoint(operation: IngestionOperation) -> MaterializationResult:
         """Repair only stages whose writes have an idempotent natural key."""
         state = dict(operation.derivation_state)

package/src/superlocalmemory/core/engine_wiring.py

@@ -264,7 +264,10 @@ def init_encoding(
         db, embedder, llm, config.encoding,
     )
     observation_builder = ObservationBuilder(db)
-    scene_builder = SceneBuilder(db, embedder)
+    # V3.2: VectorStore (Phase 1) -- sqlite-vec KNN. Scene assignment also
+    # consumes it, so initialize it before the encoding component is wired.
+    vector_store = _init_vector_store(config)
+    scene_builder = SceneBuilder(db, embedder, vector_store=vector_store)
     entropy_gate = EntropyGate(
         embedder, config.encoding.entropy_threshold,
     )
@@ -276,9 +279,6 @@ def init_encoding(
             db, config.math.sheaf_contradiction_threshold,
         )
 
-    # V3.2: VectorStore (Phase 1) -- sqlite-vec KNN
-    vector_store = _init_vector_store(config)
-
     # V3.2: AccessLog (Phase 1) -- fact access tracking
     access_log = _init_access_log(db)
 
@@ -486,6 +486,25 @@ def _init_spreading_activation(
         return None
 
 
+def _init_prompt_injector(config: SLMConfig, db: DatabaseManager) -> Any | None:
+    """Construct a profile-scoped PromptInjector for soft-prompt injection (P1-8).
+
+    Returns None when parameterization is disabled or construction fails.
+    Failure is fail-soft — soft-prompt absence must never block auto-invoke.
+    """
+    if not hasattr(config, "parameterization") or not config.parameterization.enabled:
+        return None
+    try:
+        from superlocalmemory.parameterization.prompt_injector import PromptInjector
+        from superlocalmemory.parameterization.soft_prompt_generator import SoftPromptGenerator
+
+        generator = SoftPromptGenerator(config.parameterization)
+        return PromptInjector(db=db, generator=generator, config=config.parameterization)
+    except Exception as exc:
+        logger.warning("PromptInjector init failed — soft-prompt injection disabled: %s", exc)
+        return None
+
+
 def _init_auto_invoker(
     config: SLMConfig,
     db: DatabaseManager,
@@ -493,20 +512,28 @@ def _init_auto_invoker(
     trust_scorer: Any,
     embedder: Any,
 ) -> Any | None:
-    """Create AutoInvoker for Phase 2 multi-signal retrieval."""
+    """Create AutoInvoker for Phase 2 multi-signal retrieval.
+
+    V3.3 (P1-8): A profile-scoped PromptInjector is constructed and wired in
+    so stored behavioral soft prompts are prepended to every session context.
+    The injector is fail-soft — its absence never blocks auto-invoke.
+    """
     if not hasattr(config, "auto_invoke") or not config.auto_invoke.enabled:
         return None
     try:
         from superlocalmemory.hooks.auto_invoker import AutoInvoker
+
+        prompt_injector = _init_prompt_injector(config, db)
         return AutoInvoker(
             db=db,
             vector_store=vector_store,
             trust_scorer=trust_scorer,
             embedder=embedder,
             config=config.auto_invoke,
+            prompt_injector=prompt_injector,
         )
     except Exception as exc:
-        logger.debug("AutoInvoker init failed: %s", exc)
+        logger.warning("AutoInvoker init failed — auto-invoke disabled: %s", exc)
         return None
 
 
@@ -580,9 +607,9 @@ def init_retrieval(
     trust_scorer: Any,
     vector_store: Any = None,
 ) -> Any:
-    """Create the RetrievalEngine — five candidate producers (semantic, BM25,
-    temporal, spreading_activation, hopfield) plus the entity graph used for
-    post-fusion score enhancement. Returns it."""
+    """Create the RetrievalEngine — six candidate producers (semantic, BM25,
+    entity_graph, temporal, spreading_activation, hopfield) fused via RRF.
+    Returns the engine."""
     from superlocalmemory.retrieval.engine import RetrievalEngine
     from superlocalmemory.retrieval.semantic_channel import SemanticChannel
     from superlocalmemory.retrieval.bm25_channel import BM25Channel

package/src/superlocalmemory/core/ingest_policy.py

@@ -0,0 +1,38 @@
+"""Pre-admission scrub policy that removes secret material from content.
+
+A single ordered stage that redacts secrets BEFORE content can reach any durable
+or queryable representation (atomic facts, memory records, ingestion receipts,
+journal, exports, backups, mesh). Unlike PII redaction — an opt-in operator
+policy — secret scrubbing is unconditional: a credential persisted verbatim at
+rest is always incorrect.
+
+The detector is the ``security_primitives.redact_secrets`` redactor; this module
+wraps it in an immutable result so callers can log the fact of redaction without
+ever handling the secret value.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from superlocalmemory.core.security_primitives import redact_secrets
+
+
+@dataclass(frozen=True, slots=True)
+class ScrubResult:
+    """Outcome of a pre-admission scrub. Never carries the original secret."""
+
+    content: str
+    redacted: bool
+
+
+def scrub_secrets_for_ingest(content: str) -> ScrubResult:
+    """Redact secret material from ``content`` before durable admission.
+
+    Returns a :class:`ScrubResult` whose ``content`` is safe to persist. When
+    nothing matched, ``content`` is returned unchanged and ``redacted`` is False,
+    so the caller can keep the original object and skip a log line.
+    """
+    if not content:
+        return ScrubResult(content=content, redacted=False)
+    scrubbed = redact_secrets(content)
+    return ScrubResult(content=scrubbed, redacted=scrubbed != content)

package/src/superlocalmemory/core/maintenance.py

@@ -36,6 +36,12 @@ _BACKFILL_BURN_IN_STEPS = 50
 _LANGEVIN_DIM = 8
 _MAX_NORM = 0.99
 
+# ELC zone vocabulary: EbbinghausCurve returns 'archive'/'forgotten' but
+# atomic_facts.lifecycle CHECK only allows 'active|warm|cold|archived'.
+# Remap at write boundary so ELC never triggers IntegrityError.
+_VALID_LIFECYCLE_ZONES: frozenset[str] = frozenset({"active", "warm", "cold", "archived"})
+_ELC_ZONE_REMAP: dict[str, str] = {"archive": "archived", "forgotten": "archived"}
+
 
 def _age_days(created_at: str | None) -> float:
     """Age in days from an ISO timestamp.
@@ -105,6 +111,86 @@ def _seed_langevin_position(
     return (direction / norm * r_eq).tolist()
 
 
+def close_stale_sessions(
+    db: DatabaseManager,
+    profile_id: str = "default",
+    *,
+    idle_hours: float = 24.0,
+    max_per_pass: int = 50,
+) -> int:
+    """Close application sessions idle longer than ``idle_hours``.
+
+    Nothing auto-calls ``close_session`` except the MCP tool — un-closed
+    sessions never get temporal summaries. This maintenance pass finds
+    sessions whose newest fact is older than the idle window and closes
+    them via ``run_close_session``.
+
+    Properties:
+      - Idempotent: already-summarised sessions are skipped (no double write).
+      - Bounded: at most ``max_per_pass`` sessions closed per call.
+      - Only sessions with entity-linked facts (summarisable) are selected.
+
+    Returns:
+        Number of sessions successfully summarised in this pass.
+    """
+    if idle_hours <= 0 or max_per_pass <= 0:
+        return 0
+
+    from superlocalmemory.core.store_pipeline import (
+        _session_already_summarised,
+        run_close_session,
+    )
+
+    cutoff = (datetime.now(UTC) - timedelta(hours=float(idle_hours))).isoformat()
+    # Over-fetch slightly so already-closed rows in the window do not starve
+    # the bounded close budget.
+    fetch_limit = max(int(max_per_pass) * 3, int(max_per_pass))
+    try:
+        rows = db.execute(
+            """
+            SELECT session_id, MAX(created_at) AS last_at
+              FROM atomic_facts
+             WHERE profile_id = ?
+               AND session_id IS NOT NULL
+               AND session_id != ''
+               AND canonical_entities_json IS NOT NULL
+               AND canonical_entities_json != '[]'
+             GROUP BY session_id
+            HAVING MAX(created_at) < ?
+             ORDER BY last_at ASC
+             LIMIT ?
+            """,
+            (profile_id, cutoff, fetch_limit),
+        )
+    except Exception as exc:  # pragma: no cover — defensive
+        logger.debug("stale session query failed: %s", exc)
+        return 0
+
+    closed = 0
+    for row in rows:
+        if closed >= int(max_per_pass):
+            break
+        d = dict(row)
+        sid = str(d.get("session_id") or "")
+        if not sid:
+            continue
+        if _session_already_summarised(db, profile_id, sid):
+            continue
+        try:
+            n = run_close_session(sid, profile_id, db=db)
+        except Exception as exc:
+            logger.warning("stale session close failed for %s: %s", sid, exc)
+            continue
+        if n > 0:
+            closed += 1
+    if closed:
+        logger.info(
+            "Closed %d stale session(s) (idle > %.1fh, profile=%s)",
+            closed, idle_hours, profile_id,
+        )
+    return closed
+
+
 def run_maintenance(
     db: DatabaseManager,
     config: SLMConfig,
@@ -130,13 +216,30 @@ def run_maintenance(
         "langevin_backfilled": 0,
         "langevin_updated": 0,
         "fisher_coupled": 0,
+        "fisher_posterior_updated": 0,       # P1-9: Fisher bayesian_update on access
+        "ebbinghaus_coupled": 0,             # Phase 5: Ebbinghaus-Langevin coupling
         "sheaf_checked": 0,
         "entity_summaries_consolidated": 0,  # V3.4.40
         "orphan_metadata_gc": 0,             # v3.6.4 (P1-3)
         "expansion_backfilled": 0,           # T3b
         "embeddings_backfilled": 0,          # v3.8.x NULL-embedding self-heal
+        "stale_sessions_closed": 0,          # v4: orphaned application sessions
     }
 
+    # Close idle application sessions so temporal summaries exist even when
+    # clients never call close_session. Bounded + idempotent; fail-soft.
+    try:
+        idle_hours = float(getattr(config, "session_idle_close_hours", 24.0) or 24.0)
+        max_close = int(getattr(config, "session_idle_close_max_per_pass", 50) or 50)
+        counts["stale_sessions_closed"] = close_stale_sessions(
+            db,
+            profile_id,
+            idle_hours=idle_hours,
+            max_per_pass=max_close,
+        )
+    except Exception as exc:  # pragma: no cover — defensive
+        logger.debug("stale session close skipped: %s", exc)
+
     # P1-3 (embeddings-vector-02): sweep orphaned embedding_metadata left by
     # any FK-off delete path, so the semantic channel never maps to dead facts.
     # Runs before the early-return so it sweeps even for empty profiles.
@@ -330,6 +433,158 @@ def run_maintenance(
         except Exception as exc:
             logger.warning("Fisher-Langevin coupling failed: %s", exc)
 
+    # 1c. Fisher posterior update (P1-9): tighten variance per new access event.
+    # Access-delta semantics: apply one Bayesian update per net-new access since
+    # the last maintenance run.  Zero new accesses → variance unchanged.
+    # This prevents idle-corpus drift that tick-based updates would cause.
+    # Inline schema migration: adds fisher_last_applied_access when absent.
+    # Gate: config.math.fisher_bayesian_update (default True).
+    if config.math.fisher_bayesian_update:
+        try:
+            import json as _json
+            from superlocalmemory.math.fisher import FisherRaoMetric
+
+            # Inline migration — harmless no-op if column already exists.
+            try:
+                db.execute(
+                    "ALTER TABLE atomic_facts "
+                    "ADD COLUMN fisher_last_applied_access INTEGER NOT NULL DEFAULT 0"
+                )
+            except Exception:
+                pass  # already migrated on a previous run
+
+            frm = FisherRaoMetric(temperature=config.math.fisher_temperature)
+            posterior_count = 0
+            for f in facts:
+                if f.fisher_variance is None:
+                    continue
+                rows = db.execute(
+                    "SELECT access_count, fisher_last_applied_access "
+                    "FROM atomic_facts WHERE fact_id = ?",
+                    (f.fact_id,),
+                )
+                if not rows:
+                    continue
+                r = dict(rows[0])
+                acc = r.get("access_count") or 0
+                last_applied = r.get("fisher_last_applied_access") or 0
+                delta = acc - last_applied
+                if delta <= 0:
+                    continue  # no new accesses — variance unchanged this run
+                # Apply min(delta, 100) unit-information Bayesian updates.
+                # One update per access: 1/v_new = 1/v_old + 1 (unit obs_var).
+                current_var = list(f.fisher_variance)
+                dim = len(current_var)
+                obs_var = [1.0] * dim
+                applied = min(delta, 100)
+                for _ in range(applied):
+                    current_var = frm.bayesian_update(current_var, obs_var)
+                # Single atomic write: variance + watermark together. Advance the
+                # watermark only by the number of updates ACTUALLY applied (not to
+                # acc), so accesses beyond the per-run cap are applied on subsequent
+                # runs instead of being silently dropped.
+                db.execute(
+                    "UPDATE atomic_facts "
+                    "SET fisher_variance = ?, fisher_last_applied_access = ? "
+                    "WHERE fact_id = ?",
+                    (_json.dumps(current_var), last_applied + applied, f.fact_id),
+                )
+                # Refresh in-memory so step 1d ELC sees the updated variance.
+                f.fisher_variance = current_var
+                posterior_count += 1
+            counts["fisher_posterior_updated"] = posterior_count
+        except Exception as exc:
+            logger.warning("Fisher posterior update failed: %s", exc)
+
+    # 1d. Ebbinghaus-Langevin coupling (Phase 5 — P1-ELC): combine forgetting
+    # drift with Fisher-Langevin dynamics to produce a unified lifecycle state.
+    # Updates the lifecycle zone of each fact based on Ebbinghaus retention.
+    # NOTE: this step overwrites the Langevin-only lifecycle set in step 1b.
+    #       The Ebbinghaus zone is intentionally authoritative when ELC is ON.
+    # Gate: config.math.ebbinghaus_langevin_coupling_enabled (default False).
+    if config.math.ebbinghaus_langevin_coupling_enabled:
+        try:
+            from superlocalmemory.dynamics.ebbinghaus_langevin_coupling import (
+                EbbinghausLangevinCoupling,
+            )
+            from superlocalmemory.dynamics.fisher_langevin_coupling import (
+                FisherLangevinCoupling,
+            )
+            from superlocalmemory.math.ebbinghaus import EbbinghausCurve
+            from superlocalmemory.math.langevin import LangevinDynamics
+
+            ebbinghaus = EbbinghausCurve(config.forgetting)
+            langevin = LangevinDynamics(
+                dim=_LANGEVIN_DIM,
+                dt=config.math.langevin_dt,
+                temperature=config.math.langevin_temperature,
+            )
+            fisher_coupling = FisherLangevinCoupling(
+                base_temperature=config.math.langevin_temperature,
+            )
+            coupling = EbbinghausLangevinCoupling(
+                ebbinghaus, langevin, fisher_coupling, config.forgetting,
+            )
+            import numpy as np
+
+            # Build fact_id → last_accessed_at lookup from fact_retention.
+            # Using real last-access time (not created_at) so hot facts are not
+            # mis-classified as forgotten due to old creation timestamps.
+            if facts:
+                retention_rows = db.execute(
+                    "SELECT fact_id, last_accessed_at FROM fact_retention "
+                    "WHERE fact_id IN ({})".format(",".join("?" * len(facts))),
+                    tuple(f.fact_id for f in facts),
+                )
+            else:
+                retention_rows = []
+            last_accessed_map: dict[str, str | None] = {
+                dict(r)["fact_id"]: dict(r)["last_accessed_at"]
+                for r in retention_rows
+            }
+
+            elc_count = 0
+            for f in facts:
+                if f.fisher_variance is None or f.langevin_position is None:
+                    continue
+                # Prefer real last-access timestamp; fall back to created_at.
+                raw_ts = last_accessed_map.get(f.fact_id) or f.created_at
+                hours_since = _age_days(raw_ts) * 24.0
+                state = coupling.compute_coupled_state(
+                    fact_id=f.fact_id,
+                    fisher_variance=np.asarray(f.fisher_variance, dtype=np.float64),
+                    langevin_radius=float(np.linalg.norm(f.langevin_position)),
+                    access_count=f.access_count,
+                    importance=f.importance,
+                    confirmation_count=f.evidence_count,
+                    emotional_salience=0.0,
+                    hours_since_last_access=hours_since,
+                )
+                # Remap ELC zone vocabulary to atomic_facts CHECK constraint.
+                # EbbinghausCurve returns 'archive'/'forgotten'; schema only allows
+                # 'active|warm|cold|archived'.
+                zone = _ELC_ZONE_REMAP.get(state.lifecycle_zone, state.lifecycle_zone)
+                if zone not in _VALID_LIFECYCLE_ZONES:
+                    logger.warning(
+                        "ELC returned unknown lifecycle zone %r for fact %s — skipping",
+                        state.lifecycle_zone, f.fact_id,
+                    )
+                    continue
+                # Count fact as processed regardless of whether we write.
+                elc_count += 1
+                # Skip write when zone hasn't changed — avoids O(N) UPDATEs per tick.
+                current_zone = (
+                    f.lifecycle.value
+                    if hasattr(f.lifecycle, "value")
+                    else str(f.lifecycle)
+                )
+                if zone == current_zone:
+                    continue
+                db.update_fact(f.fact_id, {"lifecycle": zone})
+            counts["ebbinghaus_coupled"] = elc_count
+        except Exception as exc:
+            logger.warning("Ebbinghaus-Langevin coupling failed: %s", exc)
+
     # 2. Sheaf batch consistency on recent facts (last 24h)
     if config.math.sheaf_at_encoding:
         try:

package/src/superlocalmemory/core/modes.py

@@ -2,12 +2,15 @@
 # Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
-"""SuperLocalMemory V3 — Mode System.
+"""SuperLocalMemory V4 mode capability descriptors.
 
 Three operating modes with clear capability boundaries.
-Mode A: EU AI Act FULL compliance (zero LLM).
-Mode B: EU AI Act FULL (local LLM only).
-Mode C: UNRESTRICTED — best models, full power, 90%+ target.
+Mode A: deterministic local extraction and local inference.
+Mode B: local LLM enrichment and local inference.
+Mode C: configured provider-assisted inference.
+
+An operating mode does not determine EU AI Act compliance.  That assessment
+depends on the deployment, intended use, operator role, and applicable duties.
 
 Part of Qualixar | Author: Varun Pratap Bhardwaj
 """
@@ -41,12 +44,20 @@ class ModeCapabilities:
     embedding_dimension: int       # Expected embedding dimension
 
     # Compliance
-    eu_ai_act_compliant: bool      # Full EU AI Act compliance?
+    eu_ai_act_compliant: bool | None  # None: requires deployment assessment
     data_stays_local: bool         # Does ALL data stay on device?
 
     # Description
     description: str = ""
 
+    @property
+    def data_locality_label(self) -> str:
+        """UI/API locality label derived from the mode record (single source).
+
+        Never invent a parallel mode→label map in the dashboard — consume this.
+        """
+        return "local-only" if self.data_stays_local else "provider-assisted"
+
 
 # ---------------------------------------------------------------------------
 # Mode Definitions
@@ -63,13 +74,13 @@ MODE_A = ModeCapabilities(
     cloud_reranker=False,
     cloud_embeddings=False,
     embedding_dimension=768,
-    eu_ai_act_compliant=True,
+    eu_ai_act_compliant=None,
     data_stays_local=True,
     description=(
         "Local Guardian — Zero LLM, zero cloud. "
         "Uses nomic-embed-text-v1.5 encoder (768d, 8K context) for embeddings. "
-        "spaCy + rules for extraction. ONNX cross-encoder reranking (~200MB). "
-        "Full EU AI Act compliance. Target: 65%+"
+        "Deterministic rules for extraction and a local PyTorch cross-encoder. "
+        "EU AI Act classification requires deployment assessment."
     ),
 )
 
@@ -84,13 +95,13 @@ MODE_B = ModeCapabilities(
     cloud_reranker=False,
     cloud_embeddings=False,
     embedding_dimension=768,
-    eu_ai_act_compliant=True,
+    eu_ai_act_compliant=None,
     data_stays_local=True,
     description=(
         "Smart Local — Local Ollama LLM (Phi-3, Llama 3.2). "
         "LLM-quality extraction and classification, fully local. "
-        "ONNX cross-encoder reranking (~200MB). "
-        "No cloud, no data export. EU AI Act compliant. Target: 75-80%"
+        "Local PyTorch cross-encoder reranking. No configured cloud inference. "
+        "EU AI Act classification requires deployment assessment."
     ),
 )
 
@@ -105,12 +116,13 @@ MODE_C = ModeCapabilities(
     cloud_reranker=True,
     cloud_embeddings=True,
     embedding_dimension=3072,
-    eu_ai_act_compliant=False,
+    eu_ai_act_compliant=None,
     data_stays_local=False,
     description=(
         "FULL POWER — UNRESTRICTED. Best embeddings (text-embedding-3-large, 3072-dim). "
         "Best configured cloud LLMs (e.g. GPT-5, Claude Opus 4). Agentic multi-round retrieval. "
-        "Cohere reranker option. No EU restriction. Target: 90%+"
+        "Cohere reranker option. Cloud processing requires deployment-specific "
+        "privacy, contractual, and EU AI Act assessment."
     ),
 )
 
@@ -121,6 +133,21 @@ def get_capabilities(mode: Mode) -> ModeCapabilities:
     return _map[mode]
 
 
+def dashboard_mode_fields(mode: Mode | str) -> dict[str, object]:
+    """Fields the dashboard API must surface from the mode record.
+
+    Keeps UI locality claims bound to :class:`ModeCapabilities` so Mode C
+    cannot be labeled local-only by a divergent hardcode.
+    """
+    if isinstance(mode, str):
+        mode = Mode(mode.strip().lower())
+    caps = get_capabilities(mode)
+    return {
+        "data_locality_label": caps.data_locality_label,
+        "data_stays_local": caps.data_stays_local,
+    }
+
+
 def validate_mode_config(mode: Mode, *, has_ollama: bool = False, has_cloud_llm: bool = False) -> list[str]:
     """Validate that required services are available for the chosen mode.