superlocalmemory 4.0.3 → 4.0.5

package/src/superlocalmemory/storage/migrations/M041_external_evidence_receipts.py

@@ -0,0 +1,189 @@
+"""M041 — typed, observation-only external evidence in ``learning.db``."""
+
+from __future__ import annotations
+
+import sqlite3
+
+NAME = "M041_external_evidence_receipts"
+DB_TARGET = "learning"
+
+DDL = """
+BEGIN IMMEDIATE;
+CREATE TABLE IF NOT EXISTS external_evidence_receipts (
+    profile_id TEXT NOT NULL,
+    contract_id TEXT NOT NULL,
+    workspace_id TEXT NOT NULL,
+    run_ref TEXT NOT NULL,
+    run_id TEXT NOT NULL,
+    outcome TEXT NOT NULL,
+    run_state TEXT NOT NULL,
+    demonstration INTEGER NOT NULL CHECK (demonstration IN (0, 1)),
+    eligible_for_learning INTEGER NOT NULL CHECK (eligible_for_learning IN (0, 1)),
+    terminal_at TEXT NOT NULL,
+    graph_digest TEXT NOT NULL,
+    plan_digest TEXT NOT NULL,
+    policy_digest TEXT NOT NULL,
+    receipt_sequence INTEGER NOT NULL,
+    receipt_head_digest TEXT NOT NULL,
+    receipt_trust TEXT NOT NULL,
+    nodes_json TEXT NOT NULL,
+    artifact_digests_json TEXT NOT NULL,
+    payload_sha256 TEXT NOT NULL,
+    observed_at TEXT NOT NULL,
+    PRIMARY KEY (profile_id, contract_id, workspace_id, run_ref)
+);
+CREATE INDEX IF NOT EXISTS idx_external_evidence_profile_terminal
+    ON external_evidence_receipts (profile_id, terminal_at DESC);
+CREATE INDEX IF NOT EXISTS idx_external_evidence_profile_workspace
+    ON external_evidence_receipts (profile_id, workspace_id, terminal_at DESC);
+COMMIT;
+"""
+
+_TABLE = "external_evidence_receipts"
+_COLUMNS = (
+    "profile_id",
+    "contract_id",
+    "workspace_id",
+    "run_ref",
+    "run_id",
+    "outcome",
+    "run_state",
+    "demonstration",
+    "eligible_for_learning",
+    "terminal_at",
+    "graph_digest",
+    "plan_digest",
+    "policy_digest",
+    "receipt_sequence",
+    "receipt_head_digest",
+    "receipt_trust",
+    "nodes_json",
+    "artifact_digests_json",
+    "payload_sha256",
+    "observed_at",
+)
+_TYPES = (
+    "TEXT",
+    "TEXT",
+    "TEXT",
+    "TEXT",
+    "TEXT",
+    "TEXT",
+    "TEXT",
+    "INTEGER",
+    "INTEGER",
+    "TEXT",
+    "TEXT",
+    "TEXT",
+    "TEXT",
+    "INTEGER",
+    "TEXT",
+    "TEXT",
+    "TEXT",
+    "TEXT",
+    "TEXT",
+    "TEXT",
+)
+_PRIMARY_KEY = ("profile_id", "contract_id", "workspace_id", "run_ref")
+_INDEXES = {
+    "idx_external_evidence_profile_terminal": (
+        "external_evidence_receipts", (("profile_id", False), ("terminal_at", True)),
+    ),
+    "idx_external_evidence_profile_workspace": (
+        "external_evidence_receipts",
+        (("profile_id", False), ("workspace_id", False), ("terminal_at", True)),
+    ),
+}
+
+
+def apply(conn: sqlite3.Connection) -> None:
+    """Install the additive receipt table atomically and idempotently."""
+    if _table_exists(conn) and not _table_is_valid(conn):
+        raise sqlite3.OperationalError(
+            "M041 external evidence table is malformed; refusing rebuild"
+        )
+    conn.executescript(DDL)
+    if not verify(conn):
+        repair(conn)
+    if not verify(conn):
+        raise sqlite3.OperationalError("M041 external evidence schema did not reach its end-state")
+
+
+def repair(conn: sqlite3.Connection) -> None:
+    """Restore only M041's derived indexes without touching stored evidence."""
+    if _table_exists(conn) and not _table_is_valid(conn):
+        raise sqlite3.OperationalError(
+            "M041 external evidence table is malformed; refusing rebuild"
+        )
+    if not _table_exists(conn):
+        apply(conn)
+        return
+    drops = "\n".join(f"DROP INDEX IF EXISTS {name};" for name in _INDEXES)
+    creates = "\n".join(
+        f"CREATE INDEX {name} ON {table} ({_index_sql_columns(columns)});"
+        for name, (table, columns) in _INDEXES.items()
+    )
+    conn.executescript(f"BEGIN IMMEDIATE;\n{drops}\n{creates}\nCOMMIT;")
+    if not verify(conn):
+        raise sqlite3.OperationalError("M041 index repair did not restore required end-state")
+
+
+def verify(conn: sqlite3.Connection) -> bool:
+    if not _table_is_valid(conn):
+        return False
+    for name, (table, columns) in _INDEXES.items():
+        row = conn.execute(
+            "SELECT tbl_name FROM sqlite_master WHERE type='index' AND name=?", (name,)
+        ).fetchone()
+        if row is None or row[0] != table:
+            return False
+        actual = tuple(
+            (item[2], bool(item[3]))
+            for item in conn.execute(f"PRAGMA index_xinfo({name})")
+            if item[5] and item[2] is not None
+        )
+        if actual != columns:
+            return False
+    return True
+
+
+def _table_exists(conn: sqlite3.Connection) -> bool:
+    return (
+        conn.execute(
+            "SELECT 1 FROM sqlite_master WHERE type='table' AND name=?", (_TABLE,)
+        ).fetchone()
+        is not None
+    )
+
+
+def _table_is_valid(conn: sqlite3.Connection) -> bool:
+    if not _table_exists(conn):
+        return False
+    info = conn.execute(f"PRAGMA table_info({_TABLE})").fetchall()
+    columns = tuple(row[1] for row in info)
+    types = tuple(str(row[2]).upper() for row in info)
+    primary_key = tuple(row[1] for row in sorted(info, key=lambda row: row[5]) if row[5])
+    not_null = {row[1] for row in info if row[3] or row[5]}
+    return (
+        columns == _COLUMNS
+        and types == _TYPES
+        and primary_key == _PRIMARY_KEY
+        and not_null == set(_COLUMNS)
+        and conn.execute(f"PRAGMA foreign_key_list({_TABLE})").fetchone() is None
+        and _required_checks_present(conn)
+    )
+
+
+def _required_checks_present(conn: sqlite3.Connection) -> bool:
+    row = conn.execute(
+        "SELECT sql FROM sqlite_master WHERE type='table' AND name=?", (_TABLE,)
+    ).fetchone()
+    sql = "" if row is None or row[0] is None else "".join(str(row[0]).lower().split())
+    return (
+        "check(demonstrationin(0,1))" in sql
+        and "check(eligible_for_learningin(0,1))" in sql
+    )
+
+
+def _index_sql_columns(columns: tuple[tuple[str, bool], ...]) -> str:
+    return ", ".join(column + (" DESC" if desc else "") for column, desc in columns)

package/src/superlocalmemory/storage/migrations/M042_correction_case_ledger.py

@@ -0,0 +1,245 @@
+"""M042 — review-gated correction cases in ``memory.db``.
+
+The ledger contains identifiers and lifecycle metadata only.  It never stores
+fact text.  The saved predecessor temporal tuple lets a reviewed rollback
+restore the exact lifecycle state without deleting fact history.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+
+NAME = "M042_correction_case_ledger"
+DB_TARGET = "memory"
+
+DDL = """
+BEGIN IMMEDIATE;
+CREATE TABLE IF NOT EXISTS correction_cases (
+    case_id TEXT PRIMARY KEY,
+    profile_id TEXT NOT NULL,
+    scope TEXT NOT NULL CHECK (scope IN ('personal', 'project', 'shared', 'global')),
+    predecessor_fact_id TEXT NOT NULL,
+    successor_fact_id TEXT NOT NULL,
+    reason_code TEXT NOT NULL,
+    status TEXT NOT NULL CHECK (status IN ('proposed', 'applied', 'rejected', 'rolled_back')),
+    version INTEGER NOT NULL CHECK (version >= 0),
+    idempotency_key TEXT NOT NULL,
+    proposed_by_actor_id TEXT NOT NULL,
+    proposed_by_actor_kind TEXT NOT NULL,
+    proposed_by_trust_tier TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    reviewed_by_actor_id TEXT,
+    reviewed_at TEXT,
+    applied_at TEXT,
+    system_effective_at TEXT,
+    event_valid_from TEXT,
+    event_valid_until TEXT,
+    predecessor_temporal_existed INTEGER,
+    predecessor_valid_from TEXT,
+    predecessor_valid_until TEXT,
+    predecessor_system_created_at TEXT,
+    predecessor_system_expired_at TEXT,
+    predecessor_invalidated_by TEXT,
+    predecessor_invalidation_reason TEXT,
+    UNIQUE (profile_id, idempotency_key),
+    FOREIGN KEY (predecessor_fact_id) REFERENCES atomic_facts(fact_id) ON DELETE RESTRICT,
+    FOREIGN KEY (successor_fact_id) REFERENCES atomic_facts(fact_id) ON DELETE RESTRICT
+);
+CREATE TABLE IF NOT EXISTS correction_events (
+    event_id TEXT PRIMARY KEY,
+    case_id TEXT NOT NULL,
+    profile_id TEXT NOT NULL,
+    scope TEXT NOT NULL CHECK (scope IN ('personal', 'project', 'shared', 'global')),
+    event_type TEXT NOT NULL
+        CHECK (event_type IN ('proposed', 'applied', 'rejected', 'rolled_back')),
+    operation_id TEXT NOT NULL,
+    actor_id TEXT NOT NULL,
+    actor_kind TEXT NOT NULL,
+    actor_trust_tier TEXT NOT NULL,
+    expected_version INTEGER,
+    resulting_version INTEGER NOT NULL CHECK (resulting_version >= 0),
+    system_occurred_at TEXT NOT NULL,
+    event_valid_from TEXT,
+    event_valid_until TEXT,
+    UNIQUE (case_id, operation_id),
+    FOREIGN KEY (case_id) REFERENCES correction_cases(case_id) ON DELETE RESTRICT
+);
+CREATE INDEX IF NOT EXISTS idx_correction_cases_profile_status
+    ON correction_cases (profile_id, status, updated_at DESC);
+CREATE INDEX IF NOT EXISTS idx_correction_events_case_sequence
+    ON correction_events (case_id, system_occurred_at ASC);
+CREATE INDEX IF NOT EXISTS idx_correction_cases_successor_admission
+    ON correction_cases (profile_id, successor_fact_id, status);
+CREATE UNIQUE INDEX IF NOT EXISTS uq_correction_cases_active_predecessor
+    ON correction_cases (profile_id, predecessor_fact_id)
+    WHERE status IN ('proposed', 'applied');
+COMMIT;
+"""
+
+_TABLES = frozenset({"correction_cases", "correction_events"})
+_FORBIDDEN_RAW_COLUMNS = frozenset({"content", "fact_text", "raw_text", "query"})
+_REQUIRED_CASE_COLUMNS = frozenset(
+    {
+        "case_id",
+        "profile_id",
+        "scope",
+        "predecessor_fact_id",
+        "successor_fact_id",
+        "reason_code",
+        "status",
+        "version",
+        "idempotency_key",
+        "proposed_by_actor_id",
+        "proposed_by_actor_kind",
+        "proposed_by_trust_tier",
+        "created_at",
+        "updated_at",
+        "reviewed_by_actor_id",
+        "reviewed_at",
+        "applied_at",
+        "system_effective_at",
+        "event_valid_from",
+        "event_valid_until",
+        "predecessor_temporal_existed",
+        "predecessor_valid_from",
+        "predecessor_valid_until",
+        "predecessor_system_created_at",
+        "predecessor_system_expired_at",
+        "predecessor_invalidated_by",
+        "predecessor_invalidation_reason",
+    }
+)
+_REQUIRED_EVENT_COLUMNS = frozenset(
+    {
+        "event_id",
+        "case_id",
+        "profile_id",
+        "scope",
+        "event_type",
+        "operation_id",
+        "actor_id",
+        "actor_kind",
+        "actor_trust_tier",
+        "expected_version",
+        "resulting_version",
+        "system_occurred_at",
+        "event_valid_from",
+        "event_valid_until",
+    }
+)
+_INDEX_SPECS = {
+    "idx_correction_cases_profile_status": (
+        "correction_cases",
+        ("profile_id", "status", "updated_at"),
+        False,
+        None,
+    ),
+    "idx_correction_events_case_sequence": (
+        "correction_events",
+        ("case_id", "system_occurred_at"),
+        False,
+        None,
+    ),
+    "idx_correction_cases_successor_admission": (
+        "correction_cases",
+        ("profile_id", "successor_fact_id", "status"),
+        False,
+        None,
+    ),
+    "uq_correction_cases_active_predecessor": (
+        "correction_cases",
+        ("profile_id", "predecessor_fact_id"),
+        True,
+        "wherestatusin('proposed','applied')",
+    ),
+}
+
+
+def apply(conn: sqlite3.Connection) -> None:
+    """Install the additive review ledger atomically and idempotently."""
+    if any(_table_exists(conn, table) for table in _TABLES) and not verify(conn):
+        raise sqlite3.OperationalError("M042 correction ledger is malformed; refusing rebuild")
+    conn.executescript(DDL)
+    if not verify(conn):
+        raise sqlite3.OperationalError("M042 correction ledger did not reach its end-state")
+
+
+def verify(conn: sqlite3.Connection) -> bool:
+    if not all(_table_exists(conn, table) for table in _TABLES):
+        return False
+    case_columns = _columns(conn, "correction_cases")
+    event_columns = _columns(conn, "correction_events")
+    if (
+        set(case_columns) != _REQUIRED_CASE_COLUMNS
+        or set(event_columns) != _REQUIRED_EVENT_COLUMNS
+        or _FORBIDDEN_RAW_COLUMNS & (set(case_columns) | set(event_columns))
+    ):
+        return False
+    if not _required_checks_present(conn):
+        return False
+    return all(_index_matches(conn, name, *spec) for name, spec in _INDEX_SPECS.items())
+
+
+def _table_exists(conn: sqlite3.Connection, table: str) -> bool:
+    return (
+        conn.execute(
+            "SELECT 1 FROM sqlite_master WHERE type='table' AND name=?", (table,)
+        ).fetchone()
+        is not None
+    )
+
+
+def _columns(conn: sqlite3.Connection, table: str) -> tuple[str, ...]:
+    return tuple(row[1] for row in conn.execute(f"PRAGMA table_info({table})"))
+
+
+def _required_checks_present(conn: sqlite3.Connection) -> bool:
+    statements: dict[str, str] = {}
+    for table in ("correction_cases", "correction_events"):
+        row = conn.execute(
+            "SELECT sql FROM sqlite_master WHERE type='table' AND name=?", (table,)
+        ).fetchone()
+        if row is None or row[0] is None:
+            return False
+        statements[table] = "".join(str(row[0]).lower().split())
+    case_sql = statements["correction_cases"]
+    event_sql = statements["correction_events"]
+    scope_check = "check(scopein('personal','project','shared','global'))"
+    return (
+        scope_check in case_sql
+        and scope_check in event_sql
+        and "check(statusin('proposed','applied','rejected','rolled_back'))" in case_sql
+        and "check(event_typein('proposed','applied','rejected','rolled_back'))" in event_sql
+        and "unique(profile_id,idempotency_key)" in case_sql
+        and "unique(case_id,operation_id)" in event_sql
+    )
+
+
+def _index_matches(
+    conn: sqlite3.Connection,
+    name: str,
+    table: str,
+    columns: tuple[str, ...],
+    unique: bool,
+    where_clause: str | None,
+) -> bool:
+    """Verify an index's table, ordered columns, uniqueness, and partial predicate."""
+    row = conn.execute(
+        "SELECT tbl_name, sql FROM sqlite_master WHERE type='index' AND name=?", (name,)
+    ).fetchone()
+    if row is None or row[0] != table:
+        return False
+    index_rows = conn.execute(f"PRAGMA index_xinfo({name})").fetchall()
+    indexed_columns = tuple(
+        entry[2] for entry in index_rows if entry[5] == 1 and entry[2] is not None
+    )
+    if indexed_columns != columns:
+        return False
+    index_list = conn.execute(f"PRAGMA index_list({table})").fetchall()
+    indexed = next((entry for entry in index_list if entry[1] == name), None)
+    if indexed is None or bool(indexed[2]) is not unique:
+        return False
+    if where_clause is None:
+        return True
+    return row[1] is not None and where_clause in "".join(str(row[1]).lower().split())

package/src/superlocalmemory/storage/migrations/__init__.py

@@ -31,6 +31,8 @@ from . import (
     M038_learning_feedback_channel,
     M039_scene_fact_members,
     M040_agent_experience_receipts,
+    M041_external_evidence_receipts,
+    M042_correction_case_ledger,
 )
 
 # ---------------------------------------------------------------------------
@@ -87,6 +89,8 @@ __all__ = (
     "M038_learning_feedback_channel",
     "M039_scene_fact_members",
     "M040_agent_experience_receipts",
+    "M041_external_evidence_receipts",
+    "M042_correction_case_ledger",
     # Legacy re-exports (backward compat):
     "CURRENT_SCHEMA_VERSION",
     "get_schema_version",

package/src/superlocalmemory/storage/write_coordinator.py

@@ -96,6 +96,10 @@ class CommandKind(StrEnum):
     ADMISSION = "admission"
     DELETE_FACT = "delete_fact"
     UPDATE_FACT = "update_fact"
+    PROPOSE_CORRECTION = "propose_correction"
+    APPLY_CORRECTION = "apply_correction"
+    REJECT_CORRECTION = "reject_correction"
+    ROLLBACK_CORRECTION = "rollback_correction"
     ARCHIVE_FACT = "archive_fact"
     MERGE_FACT = "merge_fact"
     SET_FACT_SCOPE = "set_fact_scope"

package/src/superlocalmemory/ui/js/brain.js

@@ -1135,7 +1135,15 @@
   // --------------------------------------------------------------------
   function cardLivingBrain(snapshot) {
     const data = snapshot || {};
-    const feedback = data.feedback || {};
+    // v4.0.5: BrainTruth is the canonical, unavailable-aware read model.
+    // Keep legacy fields below as fallbacks while old daemon versions remain
+    // in use during a rolling local upgrade.
+    const truth = data.brain_truth || {};
+    const memoryActivity = truth.memory_activity || {};
+    const feedback = truth.feedback || data.feedback || {};
+    const experience = truth.agent_experience || {};
+    const externalEvidence = truth.external_evidence || {};
+    const correctionQuality = truth.correction_quality || {};
     const clients = (data.connected_clients || {}).clients || [];
     const quality = data.source_quality || {};
     const graph = data.graph || {};
@@ -1143,9 +1151,18 @@
     wrap.appendChild(EL('h4', {text: 'Living Brain'}));
     wrap.appendChild(EL('p', {
       className: 'brain-help',
-      text: 'A local evidence view of what SLM has observed. It does not automatically change your model, tools, or memories.',
+      text: 'A local evidence view of memory activity, feedback, and reviewed quality. Evidence and observations do not change recall, ranking, or model routing.',
     }));
 
+    function countOrUnavailable(section, key, label) {
+      if (!section || section.availability === 'unavailable') {
+        const reason = section && section.reason ? ': ' + section.reason : '';
+        return 'Unavailable' + reason;
+      }
+      const value = section[key];
+      return value == null ? 'No data yet' : String(value) + (label ? ' ' + label : '');
+    }
+
     const clientText = clients.length
       ? clients.map((client) => {
         const seconds = Number(client.last_seen_seconds_ago || 0);
@@ -1153,10 +1170,29 @@
       }).join(' · ')
       : 'No client activity in the last 5 minutes';
     const grid = EL('div', {className: 'brain-stat-grid'});
+    grid.appendChild(statRow(
+      'Control plane',
+      truth.control_plane === 'observation_only' ? 'Observation only' : 'Legacy view',
+    ));
     grid.appendChild(statRow('Recent clients', clientText));
-    grid.appendChild(statRow('Explicit feedback', feedback.explicit_signals || 0));
-    grid.appendChild(statRow('Implicit signals', feedback.implicit_signals || 0));
-    grid.appendChild(statRow('Settled outcomes', feedback.settled_outcomes || 0));
+    grid.appendChild(statRow('Memory activity', countOrUnavailable(
+      memoryActivity, 'facts_total', 'facts',
+    )));
+    grid.appendChild(statRow('Feedback signals', countOrUnavailable(
+      feedback, 'signals_total', 'signals',
+    )));
+    grid.appendChild(statRow('Claimed evidence', countOrUnavailable(
+      experience, 'claimed_experiences_total', 'receipts',
+    )));
+    grid.appendChild(statRow('Independently verified evidence', countOrUnavailable(
+      experience, 'independently_verified_experiences_total', 'receipts',
+    )));
+    grid.appendChild(statRow('External observations', countOrUnavailable(
+      externalEvidence, 'receipts_total', 'receipts',
+    )));
+    grid.appendChild(statRow('Correction quality', countOrUnavailable(
+      correctionQuality, 'cases_total', 'review cases',
+    )));
     grid.appendChild(statRow(
       'Observed source quality',
       quality.mean_quality == null ? 'No evidence yet' : Number(quality.mean_quality).toFixed(3),
@@ -1175,8 +1211,8 @@
         : 'No feedback signals recorded yet. Report outcomes or use memory feedback to start the loop.',
     }));
     wrap.appendChild(badge(
-      data.is_real ? 'real' : 'stub',
-      data.source || 'local evidence',
+      truth.contract ? 'real' : (data.is_real ? 'real' : 'stub'),
+      truth.contract || data.source || 'local evidence',
     ));
     return wrap;
   }

package/src/superlocalmemory/ui/js/od-brain.js

@@ -227,9 +227,23 @@
     var healthColor = healthStatus === 'HEALTHY' ? 'var(--ok)'
       : healthStatus === 'ACTIVE' ? 'var(--cyan)' : undefined;
     var pCount = ((beh.patterns) || []).length;
-    var feedback = (living && living.feedback) || {};
+    // BrainTruth is the portable V4.0.5 source of truth.  Legacy sections
+    // remain a rolling-upgrade fallback only.
+    var truth = (living && living.brain_truth) || {};
+    var memoryActivity = truth.memory_activity || {};
+    var feedback = truth.feedback || (living && living.feedback) || {};
+    var experience = truth.agent_experience || (living && living.agent_experience) || {};
+    var externalEvidence = truth.external_evidence || experience.external_graph_evidence || {};
+    var correctionQuality = truth.correction_quality || {};
     var graph = (living && living.graph) || {};
-    var experience = (living && living.agent_experience) || {};
+
+    function truthCount(section, key, unit) {
+      if (!section || section.availability === 'unavailable') {
+        return 'Unavailable' + (section && section.reason ? ': ' + section.reason : '');
+      }
+      var value = section[key];
+      return value == null ? 'No data yet' : String(value) + (unit ? ' ' + unit : '');
+    }
 
     // KPI strip
     var strip = EL('div', { className: 'kpi-strip', style: 'margin-bottom:16px' });
@@ -313,11 +327,14 @@
       ['Models trained',    String(stats.models_trained || 0)],
       ['Verified active models', String(stats.models_active_verified || 0)],
       ['Sources tracked',   String(stats.tracked_sources || 0)],
-      ['Explicit feedback', String(feedback.explicit_signals || 0)],
-      ['Settled outcomes',  String(feedback.settled_outcomes || 0)],
-      ['Claimed evidence authority', String(experience.claimed_evidence_experiences || 0)],
-      ['Cognitive turns', String(experience.turns_total || 0) +
-        ' · ' + String((experience.turns_by_state || {}).finalized || 0) + ' finalized'],
+      ['Memory activity', truthCount(memoryActivity, 'facts_total', 'facts')],
+      ['Feedback signals', truthCount(feedback, 'signals_total', 'signals')],
+      ['Claimed evidence', truthCount(experience, 'claimed_experiences_total', 'receipts')],
+      ['Independently verified evidence', truthCount(
+        experience, 'independently_verified_experiences_total', 'receipts',
+      )],
+      ['External observations', truthCount(externalEvidence, 'receipts_total', 'receipts')],
+      ['Correction quality', truthCount(correctionQuality, 'cases_total', 'review cases')],
       ['Graph evidence', String(graph.fact_nodes || 0) + ' nodes · ' +
         String(graph.association_edges || 0) + ' edges'],
     ].forEach(function (row) {
@@ -351,17 +368,25 @@
       text: 'SLM records completed work when an integration supplies evidence. These records do not change recall, ranking, or model routing by themselves.',
     }));
     var evGrid = EL('div', { className: 'kpi-strip', style: 'margin:0' });
-    evGrid.appendChild(kpiCard('fact_check', 'Recorded experiences',
-      fmtNum(experience.experiences_total || 0), 'profile-scoped durable receipts',
-      Number(experience.experiences_total || 0) > 0, undefined, true));
-    evGrid.appendChild(kpiCard('verified', 'Claimed evidence authority',
-      fmtNum(experience.claimed_evidence_experiences || 0), 'declared by the producing host',
-      Number(experience.claimed_evidence_experiences || 0) > 0, undefined, true));
+    evGrid.appendChild(kpiCard('fact_check', 'Claimed evidence',
+      truthCount(experience, 'claimed_experiences_total', ''), 'profile-scoped durable receipts',
+      Number(experience.claimed_experiences_total || 0) > 0, undefined, true));
+    evGrid.appendChild(kpiCard('verified', 'Independently verified evidence',
+      truthCount(experience, 'independently_verified_experiences_total', ''),
+      experience.verification_availability === 'not_supported_by_read_model'
+        ? 'not supported by this read model' : 'independent verifier result',
+      Number(experience.independently_verified_experiences_total || 0) > 0, undefined, true));
     evGrid.appendChild(kpiCard('account_tree', 'Cognitive turns',
-      fmtNum(experience.turns_total || 0),
-      fmtNum((experience.turns_by_state || {}).open || 0) + ' open · ' +
-        fmtNum((experience.turns_by_state || {}).finalized || 0) + ' finalized',
-      Number(experience.turns_total || 0) > 0, undefined, true));
+      truthCount(experience, 'cognitive_turns_total', ''),
+      String((experience.cognitive_turns_by_state || {}).open || 0) + ' open · ' +
+        String((experience.cognitive_turns_by_state || {}).finalized || 0) + ' finalized',
+      Number(experience.cognitive_turns_total || 0) > 0, undefined, true));
+    evGrid.appendChild(kpiCard('account_tree', 'External observations',
+      truthCount(externalEvidence, 'receipts_total', ''),
+      externalEvidence.availability === 'available'
+        ? String(externalEvidence.demonstrations_total || 0) + ' demonstrations · no automatic learning'
+        : 'external evidence unavailable',
+      Number(externalEvidence.receipts_total || 0) > 0, undefined, true));
     evb.appendChild(evGrid);
     evc.appendChild(evb);
     sec.appendChild(evc);
@@ -845,8 +870,8 @@
       var head = EL('div', { className: 'page-head' });
       head.appendChild(EL('h2', { text: 'The living brain' }));
       head.appendChild(EL('p', {
-        text: 'How your memory is getting smarter — ranking phase, the reward signal it learns from, ' +
-              'and the behavioural patterns it has extracted. Everything trained on-device from your own usage.',
+        text: 'A local view of memory activity, feedback, and evidence. Observations are shown separately ' +
+              'from ranking and do not change recall, ranking, or model routing by themselves.',
       }));
 
       container.replaceChildren(