nexo-brain 7.27.3 → 7.28.0

package/src/db/_schema.py

@@ -1139,6 +1139,42 @@ def _m69_provider_runtime_metadata(conn):
         _migrate_add_index(conn, "idx_sessions_provider", "sessions", "session_provider")
 
 
+def _m70_commitments(conn):
+    """Durable promise/commitment index linked to existing action artifacts."""
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS commitments (
+            id TEXT PRIMARY KEY,
+            created_at REAL NOT NULL,
+            updated_at REAL NOT NULL,
+            closed_at REAL DEFAULT NULL,
+            source_type TEXT NOT NULL DEFAULT '',
+            source_id TEXT DEFAULT '',
+            memory_event_uid TEXT DEFAULT '',
+            session_id TEXT DEFAULT '',
+            conversation_id TEXT DEFAULT '',
+            project_key TEXT DEFAULT '',
+            statement TEXT NOT NULL,
+            owner TEXT DEFAULT 'agent',
+            deadline TEXT DEFAULT '',
+            status TEXT DEFAULT 'active',
+            confidence REAL DEFAULT 0.5,
+            action_ref_type TEXT DEFAULT '',
+            action_ref_id TEXT DEFAULT '',
+            outcome_id INTEGER DEFAULT NULL,
+            evidence_ref TEXT DEFAULT '',
+            dedupe_key TEXT DEFAULT '',
+            metadata_json TEXT DEFAULT '{}'
+        )
+        """
+    )
+    _migrate_add_index(conn, "idx_commitments_status", "commitments", "status, deadline, updated_at")
+    _migrate_add_index(conn, "idx_commitments_session", "commitments", "session_id, status, updated_at")
+    _migrate_add_index(conn, "idx_commitments_source", "commitments", "source_type, source_id")
+    _migrate_add_index(conn, "idx_commitments_action", "commitments", "action_ref_type, action_ref_id")
+    _migrate_add_index(conn, "idx_commitments_dedupe", "commitments", "dedupe_key")
+
+
 def _m42_v6_0_1_hotfix(conn):
     """v6.0.1 hotfix — last_heartbeat_ts on sessions + hook_inbox_reminders.
 
@@ -2200,6 +2236,528 @@ def _m68_memory_fabric_index(conn):
     )
 
 
+def _m71_causal_edge_candidates(conn):
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS causal_edge_candidates (
+            candidate_uid TEXT PRIMARY KEY,
+            created_at REAL NOT NULL,
+            updated_at REAL NOT NULL,
+            source_type TEXT NOT NULL,
+            source_ref TEXT NOT NULL,
+            relation TEXT NOT NULL,
+            target_type TEXT NOT NULL,
+            target_ref TEXT NOT NULL,
+            reason_public TEXT DEFAULT '',
+            evidence_refs_json TEXT DEFAULT '[]',
+            source_event_uid TEXT DEFAULT '',
+            producer TEXT NOT NULL,
+            project_key TEXT DEFAULT '',
+            privacy_level TEXT DEFAULT 'normal',
+            confidence REAL DEFAULT 0.5,
+            status TEXT DEFAULT 'proposed',
+            review_reason TEXT DEFAULT '',
+            promoted_edge_uid TEXT DEFAULT '',
+            metadata_json TEXT DEFAULT '{}'
+        )
+        """
+    )
+    conn.execute(
+        "CREATE INDEX IF NOT EXISTS idx_causal_candidates_status_updated "
+        "ON causal_edge_candidates(status, updated_at)"
+    )
+    conn.execute(
+        "CREATE INDEX IF NOT EXISTS idx_causal_candidates_source "
+        "ON causal_edge_candidates(source_type, source_ref, status)"
+    )
+    conn.execute(
+        "CREATE INDEX IF NOT EXISTS idx_causal_candidates_target "
+        "ON causal_edge_candidates(target_type, target_ref, status)"
+    )
+    conn.execute(
+        "CREATE INDEX IF NOT EXISTS idx_causal_candidates_project "
+        "ON causal_edge_candidates(project_key, status, updated_at)"
+    )
+
+
+def _m72_memory_utility(conn):
+    """Append-only memory usefulness ledger and idempotent delta applications."""
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS memory_use_events (
+            event_uid TEXT PRIMARY KEY,
+            created_at REAL NOT NULL,
+            retrieval_trace_id TEXT DEFAULT '',
+            route_event_id TEXT DEFAULT '',
+            session_id TEXT DEFAULT '',
+            conversation_id TEXT DEFAULT '',
+            project_key TEXT DEFAULT '',
+            client TEXT DEFAULT '',
+            consumer_ref TEXT DEFAULT '',
+            memory_ref TEXT NOT NULL,
+            memory_kind TEXT NOT NULL,
+            source_ref TEXT DEFAULT '',
+            query_hash TEXT DEFAULT '',
+            query_preview_redacted TEXT DEFAULT '',
+            context_kind TEXT DEFAULT '',
+            use_stage TEXT NOT NULL DEFAULT 'retrieved',
+            outcome TEXT NOT NULL DEFAULT 'unknown',
+            used_in_answer INTEGER NOT NULL DEFAULT 0,
+            cited_in_answer INTEGER NOT NULL DEFAULT 0,
+            acted_on INTEGER NOT NULL DEFAULT 0,
+            validated_by_ref TEXT DEFAULT '',
+            evidence_refs_json TEXT DEFAULT '[]',
+            reason_code TEXT DEFAULT '',
+            delta_json TEXT DEFAULT '{}',
+            policy_version TEXT DEFAULT 'memory_utility_v1',
+            confidence REAL DEFAULT 0.5,
+            privacy_level TEXT DEFAULT 'normal',
+            redaction_applied INTEGER NOT NULL DEFAULT 0,
+            metadata_json TEXT DEFAULT '{}'
+        )
+        """
+    )
+    _migrate_add_index(conn, "idx_memory_use_events_memory_created", "memory_use_events", "memory_ref, created_at")
+    _migrate_add_index(conn, "idx_memory_use_events_memory_reason", "memory_use_events", "memory_ref, reason_code, created_at")
+    _migrate_add_index(conn, "idx_memory_use_events_trace_stage", "memory_use_events", "retrieval_trace_id, use_stage")
+    _migrate_add_index(conn, "idx_memory_use_events_query_created", "memory_use_events", "query_hash, created_at")
+    _migrate_add_index(conn, "idx_memory_use_events_stage_outcome", "memory_use_events", "use_stage, outcome, created_at")
+    _migrate_add_index(conn, "idx_memory_use_events_policy_created", "memory_use_events", "policy_version, created_at")
+
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS memory_utility_applications (
+            application_uid TEXT PRIMARY KEY,
+            created_at REAL NOT NULL,
+            memory_ref TEXT NOT NULL,
+            memory_kind TEXT NOT NULL,
+            target_field TEXT NOT NULL,
+            policy_version TEXT NOT NULL,
+            reason_code TEXT NOT NULL,
+            event_uids_hash TEXT NOT NULL,
+            event_uids_json TEXT NOT NULL DEFAULT '[]',
+            old_value REAL,
+            new_value REAL,
+            delta REAL NOT NULL DEFAULT 0,
+            applied INTEGER NOT NULL DEFAULT 0,
+            rolled_back INTEGER NOT NULL DEFAULT 0,
+            rollback_ref TEXT DEFAULT '',
+            metadata_json TEXT DEFAULT '{}'
+        )
+        """
+    )
+    _migrate_add_index(conn, "idx_memory_utility_app_memory", "memory_utility_applications", "memory_ref, created_at")
+    _migrate_add_index(conn, "idx_memory_utility_app_policy", "memory_utility_applications", "policy_version, created_at")
+    _migrate_add_index(conn, "idx_memory_utility_app_rollback", "memory_utility_applications", "rolled_back, created_at")
+
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS memory_utility_application_events (
+            application_uid TEXT NOT NULL,
+            event_uid TEXT NOT NULL,
+            memory_ref TEXT NOT NULL,
+            target_field TEXT NOT NULL,
+            policy_version TEXT NOT NULL,
+            UNIQUE(event_uid, memory_ref, target_field, policy_version)
+        )
+        """
+    )
+    _migrate_add_index(conn, "idx_memory_utility_app_events_event", "memory_utility_application_events", "event_uid")
+
+
+def _m73_operational_state_snapshots(conn):
+    """Operational state policy snapshots by area/scope."""
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS operational_state_snapshots (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            policy_uid TEXT NOT NULL UNIQUE,
+            policy_version TEXT NOT NULL,
+            created_at REAL NOT NULL,
+            area_key TEXT NOT NULL,
+            scope_key TEXT NOT NULL,
+            task_type TEXT DEFAULT '',
+            caution_level TEXT NOT NULL,
+            communication_mode TEXT NOT NULL,
+            detail_mode TEXT NOT NULL,
+            verification_requirement TEXT NOT NULL,
+            autonomy_limit TEXT NOT NULL,
+            area_risk TEXT NOT NULL,
+            reason_codes_json TEXT NOT NULL DEFAULT '[]',
+            source_refs_json TEXT NOT NULL DEFAULT '[]',
+            privacy_level TEXT NOT NULL DEFAULT 'normal',
+            input_hash TEXT NOT NULL,
+            expires_at REAL NOT NULL,
+            decay_policy_json TEXT NOT NULL DEFAULT '{}'
+        )
+        """
+    )
+    _migrate_add_index(conn, "idx_operational_state_area_created", "operational_state_snapshots", "area_key, created_at")
+    _migrate_add_index(conn, "idx_operational_state_scope", "operational_state_snapshots", "scope_key, created_at")
+    _migrate_add_index(conn, "idx_operational_state_expires", "operational_state_snapshots", "expires_at")
+
+
+def _m74_entity_live_profiles(conn):
+    """EntityLiveProfile cache plus managed asset/context update bridges.
+
+    The tables below are deliberately non-authoritative. Entity identity,
+    artifacts, local evidence, and history remain owned by their existing
+    stores; this migration only adds cache/bridge/event surfaces.
+    """
+    _m11_artifact_registry(conn)
+    _m59_memory_events(conn)
+
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS entity_profile_cache (
+            profile_uid TEXT PRIMARY KEY,
+            profile_version TEXT NOT NULL DEFAULT 'entity_live_profile.v1',
+            entity_key TEXT NOT NULL,
+            canonical_kind TEXT DEFAULT '',
+            canonical_name TEXT DEFAULT '',
+            source_refs_hash TEXT NOT NULL,
+            input_hash TEXT NOT NULL,
+            profile_redacted_json TEXT NOT NULL DEFAULT '{}',
+            source_refs_json TEXT NOT NULL DEFAULT '[]',
+            stale_status TEXT NOT NULL DEFAULT 'unknown',
+            privacy_level TEXT NOT NULL DEFAULT 'normal',
+            allowed_surfaces_json TEXT NOT NULL DEFAULT '[]',
+            last_verified_at REAL,
+            expires_at REAL,
+            created_at REAL NOT NULL,
+            updated_at REAL NOT NULL,
+            UNIQUE(entity_key, profile_version, source_refs_hash, input_hash)
+        )
+        """
+    )
+    _migrate_add_index(conn, "idx_entity_profile_cache_entity", "entity_profile_cache", "entity_key, profile_version")
+    _migrate_add_index(conn, "idx_entity_profile_cache_expires", "entity_profile_cache", "expires_at")
+    _migrate_add_index(conn, "idx_entity_profile_cache_stale", "entity_profile_cache", "stale_status, expires_at")
+
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS nexo_managed_assets (
+            asset_uid TEXT PRIMARY KEY,
+            artifact_id INTEGER REFERENCES artifact_registry(id) ON DELETE SET NULL,
+            entity_key TEXT NOT NULL,
+            project_key TEXT DEFAULT '',
+            asset_kind TEXT NOT NULL DEFAULT 'other',
+            provider_ref TEXT DEFAULT '',
+            provider_redacted TEXT DEFAULT '',
+            external_ref_hash TEXT DEFAULT '',
+            status TEXT NOT NULL DEFAULT 'planned',
+            source_refs_json TEXT NOT NULL DEFAULT '[]',
+            privacy_level TEXT NOT NULL DEFAULT 'normal',
+            last_verified_at REAL,
+            created_at REAL NOT NULL,
+            updated_at REAL NOT NULL,
+            metadata_json TEXT NOT NULL DEFAULT '{}'
+        )
+        """
+    )
+    conn.execute(
+        """
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_nexo_managed_assets_provider_external
+        ON nexo_managed_assets(provider_ref, external_ref_hash)
+        WHERE provider_ref != '' AND external_ref_hash != ''
+        """
+    )
+    conn.execute(
+        """
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_nexo_managed_assets_artifact
+        ON nexo_managed_assets(artifact_id)
+        WHERE artifact_id IS NOT NULL
+        """
+    )
+    _migrate_add_index(conn, "idx_nexo_managed_assets_entity", "nexo_managed_assets", "entity_key")
+    _migrate_add_index(conn, "idx_nexo_managed_assets_project", "nexo_managed_assets", "project_key")
+    _migrate_add_index(conn, "idx_nexo_managed_assets_status", "nexo_managed_assets", "status")
+
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS asset_context_updated (
+            event_uid TEXT PRIMARY KEY,
+            entity_key TEXT NOT NULL,
+            asset_uid TEXT NOT NULL,
+            artifact_id INTEGER,
+            project_key TEXT DEFAULT '',
+            change_type TEXT NOT NULL,
+            source_refs_json TEXT NOT NULL DEFAULT '[]',
+            privacy_level TEXT NOT NULL DEFAULT 'normal',
+            redaction_applied INTEGER NOT NULL DEFAULT 1,
+            created_at REAL NOT NULL,
+            memory_event_uid TEXT DEFAULT ''
+        )
+        """
+    )
+    _migrate_add_index(conn, "idx_asset_context_updated_entity", "asset_context_updated", "entity_key, created_at")
+    _migrate_add_index(conn, "idx_asset_context_updated_asset", "asset_context_updated", "asset_uid, created_at")
+    _migrate_add_index(conn, "idx_asset_context_updated_artifact", "asset_context_updated", "artifact_id, created_at")
+
+
+def _m75_failure_prevention_ledger(conn):
+    """FailurePrevention ledger for autopsy candidates and antibody proposals.
+
+    This is deliberately a non-authoritative coordination layer. Canonical
+    rules, outcomes, guard checks, protocol debt, hook runs, corrections, and
+    memory events remain owned by their existing tables.
+    """
+    _m6_error_guard_tables(conn)
+    _m8_adaptive_log_and_somatic(conn)
+    _m22_protocol_discipline_tables(conn)
+    _m32_outcomes(conn)
+    _m39_hook_runs(conn)
+    _m56_session_correction_requirements(conn)
+    _m59_memory_events(conn)
+
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS failure_prevention_cases (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            failure_uid TEXT NOT NULL UNIQUE,
+            policy_version TEXT NOT NULL DEFAULT 'failure_prevention.v1',
+            failure_type TEXT NOT NULL DEFAULT 'other',
+            area TEXT DEFAULT '',
+            entity_refs_json TEXT NOT NULL DEFAULT '[]',
+            primary_source_type TEXT NOT NULL,
+            primary_source_ref TEXT NOT NULL,
+            source_event_refs_json TEXT NOT NULL DEFAULT '[]',
+            evidence_refs_json TEXT NOT NULL DEFAULT '[]',
+            symptom_json TEXT NOT NULL DEFAULT '{}',
+            trigger_json TEXT NOT NULL DEFAULT '{}',
+            missed_signal_json TEXT NOT NULL DEFAULT '{}',
+            wrong_assumption_json TEXT NOT NULL DEFAULT '{}',
+            root_cause_json TEXT NOT NULL DEFAULT '{}',
+            corrective_action_json TEXT NOT NULL DEFAULT '{}',
+            severity TEXT NOT NULL DEFAULT 'p3',
+            frequency_count INTEGER NOT NULL DEFAULT 0,
+            confidence REAL NOT NULL DEFAULT 0.0,
+            status TEXT NOT NULL DEFAULT 'candidate',
+            learning_resolution_json TEXT NOT NULL DEFAULT '{}',
+            antibody_refs_json TEXT NOT NULL DEFAULT '[]',
+            privacy_level TEXT NOT NULL DEFAULT 'normal',
+            allowed_surfaces_json TEXT NOT NULL DEFAULT '["debug_local","audit"]',
+            opened_at REAL NOT NULL,
+            updated_at REAL NOT NULL,
+            review_due_at REAL NOT NULL,
+            expires_at REAL NOT NULL,
+            false_positive_count INTEGER NOT NULL DEFAULT 0,
+            last_triggered_at REAL NOT NULL,
+            metadata_json TEXT NOT NULL DEFAULT '{}',
+            CHECK(severity IN ('p0','p1','p2','p3','p4')),
+            CHECK(status IN (
+                'candidate','analyzing','action_required','antibody_pending',
+                'verifying','verified','resolved','rejected','false_positive',
+                'expired','rolled_back','conflict_review'
+            )),
+            CHECK(privacy_level IN ('public','normal','private','sensitive','secret')),
+            CHECK(frequency_count >= 0),
+            CHECK(false_positive_count >= 0),
+            CHECK(confidence >= 0.0 AND confidence <= 1.0)
+        )
+        """
+    )
+    _migrate_add_index(conn, "idx_failure_cases_area_status", "failure_prevention_cases", "area, status")
+    _migrate_add_index(conn, "idx_failure_cases_severity_status", "failure_prevention_cases", "severity, status")
+    _migrate_add_index(conn, "idx_failure_cases_status_review", "failure_prevention_cases", "status, review_due_at")
+    _migrate_add_index(conn, "idx_failure_cases_updated", "failure_prevention_cases", "updated_at")
+
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS failure_source_events (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            source_event_uid TEXT NOT NULL UNIQUE,
+            failure_uid TEXT NOT NULL,
+            policy_version TEXT NOT NULL DEFAULT 'failure_prevention.v1',
+            source_type TEXT NOT NULL,
+            source_ref TEXT NOT NULL,
+            evidence_refs_json TEXT NOT NULL DEFAULT '[]',
+            observed_at REAL NOT NULL,
+            validated INTEGER NOT NULL DEFAULT 0,
+            validator TEXT DEFAULT '',
+            validation_error TEXT DEFAULT '',
+            privacy_level TEXT NOT NULL DEFAULT 'normal',
+            created_at REAL NOT NULL,
+            updated_at REAL NOT NULL,
+            metadata_json TEXT NOT NULL DEFAULT '{}',
+            FOREIGN KEY(failure_uid) REFERENCES failure_prevention_cases(failure_uid) ON DELETE CASCADE,
+            CHECK(validated IN (0, 1)),
+            CHECK(privacy_level IN ('public','normal','private','sensitive','secret'))
+        )
+        """
+    )
+    _migrate_add_index(conn, "idx_failure_source_events_failure", "failure_source_events", "failure_uid")
+    _migrate_add_index(conn, "idx_failure_source_events_type", "failure_source_events", "source_type")
+    _migrate_add_index(conn, "idx_failure_source_events_observed", "failure_source_events", "observed_at")
+    _migrate_add_index(conn, "idx_failure_source_events_ref", "failure_source_events", "source_type, source_ref")
+
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS antibody_actions (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            antibody_uid TEXT NOT NULL UNIQUE,
+            failure_uid TEXT NOT NULL,
+            policy_version TEXT NOT NULL DEFAULT 'failure_prevention.v1',
+            action_type TEXT NOT NULL,
+            target_system TEXT NOT NULL,
+            target_ref TEXT NOT NULL,
+            action_payload_ref TEXT DEFAULT '',
+            status TEXT NOT NULL DEFAULT 'proposed',
+            activation_policy TEXT NOT NULL DEFAULT 'candidate_only',
+            required_verification TEXT DEFAULT '',
+            verification_ref TEXT DEFAULT '',
+            verification_status TEXT NOT NULL DEFAULT 'missing',
+            approved_by TEXT DEFAULT '',
+            approved_ref TEXT DEFAULT '',
+            rollback_ref TEXT DEFAULT '',
+            review_due_at REAL NOT NULL,
+            expires_at REAL NOT NULL,
+            privacy_level TEXT NOT NULL DEFAULT 'normal',
+            created_at REAL NOT NULL,
+            updated_at REAL NOT NULL,
+            applied_at REAL,
+            verified_at REAL,
+            metadata_json TEXT NOT NULL DEFAULT '{}',
+            FOREIGN KEY(failure_uid) REFERENCES failure_prevention_cases(failure_uid) ON DELETE CASCADE,
+            CHECK(target_ref != ''),
+            CHECK(status IN ('proposed','approved','applied','verifying','verified','rejected','expired','rolled_back','false_positive')),
+            CHECK(activation_policy IN ('candidate_only','shadow','warn','block_after_verification','manual_approval_required')),
+            CHECK(verification_status IN ('missing','pending','passed','failed','not_applicable')),
+            CHECK(privacy_level IN ('public','normal','private','sensitive','secret'))
+        )
+        """
+    )
+    _migrate_add_index(conn, "idx_antibody_actions_failure", "antibody_actions", "failure_uid")
+    _migrate_add_index(conn, "idx_antibody_actions_status", "antibody_actions", "status")
+    _migrate_add_index(conn, "idx_antibody_actions_target", "antibody_actions", "action_type, target_system, target_ref")
+    _migrate_add_index(conn, "idx_antibody_actions_verification", "antibody_actions", "verification_status, review_due_at")
+
+
+def _m76_semantic_layers(conn):
+    """SemanticLayers cache for compact, source-backed continuity.
+
+    The tables are deliberately non-authoritative. Original facts remain owned
+    by diary, workflow, task, evidence, memory, transcript-index and continuity
+    stores; these rows only cache redacted views with source fingerprints.
+    """
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS session_diary (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT NOT NULL,
+            created_at TEXT DEFAULT (datetime('now')),
+            decisions TEXT NOT NULL DEFAULT '',
+            discarded TEXT,
+            pending TEXT,
+            context_next TEXT,
+            mental_state TEXT,
+            domain TEXT,
+            user_signals TEXT,
+            summary TEXT NOT NULL DEFAULT ''
+        )
+        """
+    )
+    _m4_session_diary_columns(conn)
+    _m7_diary_source_and_draft(conn)
+    _m22_protocol_discipline_tables(conn)
+    _m24_durable_workflow_runtime(conn)
+    _m25_workflow_goal_stack(conn)
+    _m30_hot_context_memory(conn)
+    _m54_continuity_snapshots(conn)
+    _m59_memory_events(conn)
+    _m60_memory_observations(conn)
+    _m66_transcript_index(conn)
+    _m70_commitments(conn)
+    _m74_entity_live_profiles(conn)
+    _m75_failure_prevention_ledger(conn)
+
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS semantic_layers (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            layer_uid TEXT NOT NULL UNIQUE,
+            scope_type TEXT NOT NULL,
+            scope_id TEXT NOT NULL,
+            layer_kind TEXT NOT NULL,
+            policy_version TEXT NOT NULL DEFAULT 'semantic_layers_v1',
+            status TEXT NOT NULL DEFAULT 'fresh',
+            quality_state TEXT NOT NULL DEFAULT 'complete',
+            value_redacted TEXT NOT NULL DEFAULT '',
+            value_ref TEXT NOT NULL DEFAULT '',
+            token_size INTEGER NOT NULL DEFAULT 0,
+            source_refs_json TEXT NOT NULL DEFAULT '[]',
+            evidence_refs_json TEXT NOT NULL DEFAULT '[]',
+            source_fingerprint TEXT NOT NULL,
+            content_hash TEXT NOT NULL,
+            privacy_level TEXT NOT NULL DEFAULT 'normal',
+            allowed_surfaces_json TEXT NOT NULL DEFAULT '[]',
+            confidence REAL NOT NULL DEFAULT 0.0,
+            coverage REAL NOT NULL DEFAULT 0.0,
+            generated_by TEXT NOT NULL DEFAULT '',
+            generator_version TEXT NOT NULL DEFAULT 'continuity_layer_builder_v1',
+            generated_at REAL NOT NULL,
+            updated_at REAL NOT NULL,
+            source_max_updated_at TEXT NOT NULL DEFAULT '',
+            expires_at REAL NOT NULL DEFAULT 0,
+            stale_at REAL NOT NULL DEFAULT 0,
+            stale_reason TEXT NOT NULL DEFAULT '',
+            metadata_json TEXT NOT NULL DEFAULT '{}',
+            CHECK(scope_type IN (
+                'session','conversation','workflow','workflow_goal',
+                'protocol_task','release','project_entity'
+            )),
+            CHECK(layer_kind IN (
+                'headline','brief','timeline','decisions','commitments',
+                'files','evidence','risks','next_action','semantic_tags',
+                'source_map'
+            )),
+            CHECK(status IN ('fresh','stale','expired','invalid')),
+            CHECK(quality_state IN (
+                'complete','partial','degraded','conflicted',
+                'source_missing','invalid'
+            )),
+            CHECK(privacy_level IN ('public','normal','private','sensitive','secret')),
+            CHECK(confidence >= 0.0 AND confidence <= 1.0),
+            CHECK(coverage >= 0.0 AND coverage <= 1.0),
+            CHECK(token_size >= 0),
+            UNIQUE(scope_type, scope_id, layer_kind, source_fingerprint, policy_version)
+        )
+        """
+    )
+    _migrate_add_index(conn, "idx_semantic_layers_scope_kind_status", "semantic_layers", "scope_type, scope_id, layer_kind, status, updated_at")
+    _migrate_add_index(conn, "idx_semantic_layers_scope_status", "semantic_layers", "scope_type, scope_id, status, updated_at")
+    _migrate_add_index(conn, "idx_semantic_layers_fingerprint", "semantic_layers", "source_fingerprint")
+    _migrate_add_index(conn, "idx_semantic_layers_stale", "semantic_layers", "status, stale_at")
+
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS semantic_layer_source_refs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            layer_uid TEXT NOT NULL,
+            source_ref TEXT NOT NULL,
+            source_kind TEXT NOT NULL,
+            source_version TEXT NOT NULL,
+            source_updated_at TEXT NOT NULL DEFAULT '',
+            privacy_level TEXT NOT NULL DEFAULT 'normal',
+            required_for_layer INTEGER NOT NULL DEFAULT 1,
+            validation_status TEXT NOT NULL DEFAULT 'ok',
+            validation_error TEXT NOT NULL DEFAULT '',
+            created_at REAL NOT NULL,
+            updated_at REAL NOT NULL,
+            metadata_json TEXT NOT NULL DEFAULT '{}',
+            FOREIGN KEY(layer_uid) REFERENCES semantic_layers(layer_uid) ON DELETE CASCADE,
+            CHECK(required_for_layer IN (0, 1)),
+            CHECK(validation_status IN ('ok','missing','changed','invalid','unsupported')),
+            CHECK(privacy_level IN ('public','normal','private','sensitive','secret')),
+            UNIQUE(layer_uid, source_ref, source_version)
+        )
+        """
+    )
+    _migrate_add_index(conn, "idx_semantic_layer_sources_layer", "semantic_layer_source_refs", "layer_uid")
+    _migrate_add_index(conn, "idx_semantic_layer_sources_ref", "semantic_layer_source_refs", "source_ref")
+    _migrate_add_index(conn, "idx_semantic_layer_sources_kind", "semantic_layer_source_refs", "source_kind, validation_status")
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -2270,6 +2828,13 @@ MIGRATIONS = [
     (67, "diary_quality_backfill_repair", _m67_diary_quality_backfill_repair),
     (68, "memory_fabric_index", _m68_memory_fabric_index),
     (69, "provider_runtime_metadata", _m69_provider_runtime_metadata),
+    (70, "commitments", _m70_commitments),
+    (71, "causal_edge_candidates", _m71_causal_edge_candidates),
+    (72, "memory_utility", _m72_memory_utility),
+    (73, "operational_state_snapshots", _m73_operational_state_snapshots),
+    (74, "entity_live_profiles", _m74_entity_live_profiles),
+    (75, "failure_prevention_ledger", _m75_failure_prevention_ledger),
+    (76, "semantic_layers", _m76_semantic_layers),
 ]
 
 

package/src/desktop_bridge.py

@@ -321,7 +321,7 @@ def _onboard_steps() -> list[dict]:
     return [
         {
             "id": "name",
-            "prompt": {"es": "¿Cómo te llamamos?", "en": "What should we call you?"},
+            "prompt": {"es": "¿Cómo te llamas?", "en": "What's your name?"},
             "hint": {
                 "es": "Tu nombre corto, el que usarás en el día a día.",
                 "en": "Your short name, the one we'll use day to day.",

package/src/doctor/providers/runtime.py

@@ -3842,12 +3842,16 @@ def check_local_index_hygiene(fix: bool = False) -> DoctorCheck:
     try:
         from local_context import api as local_context_api
 
-        result = local_context_api.local_index_hygiene(fix=fix)
+        try:
+            result = local_context_api.local_index_hygiene(fix=fix, quick=not fix)
+        except TypeError:
+            result = local_context_api.local_index_hygiene(fix=fix)
         residue = result.get("residue") or {}
         cleanup = result.get("cleanup") or {}
         privacy = result.get("privacy") or {}
         privacy_residue = privacy.get("residue") or {}
         privacy_cleanup = privacy.get("cleanup") or {}
+        privacy_truncated = bool(privacy.get("truncated") or privacy_residue.get("truncated"))
         suspect_roots = [str(path) for path in result.get("removed_roots") or []]
         residue_total = sum(int(residue.get(key, 0) or 0) for key in ("assets", "jobs", "errors", "dirs", "checkpoints"))
         cleanup_total = sum(int(cleanup.get(key, 0) or 0) for key in ("assets", "jobs", "errors", "dirs", "checkpoints"))
@@ -3859,9 +3863,11 @@ def check_local_index_hygiene(fix: bool = False) -> DoctorCheck:
             "cleanup=" + json.dumps(cleanup, sort_keys=True),
             "privacy_residue=" + json.dumps(privacy_residue, sort_keys=True),
             "privacy_cleanup=" + json.dumps(privacy_cleanup, sort_keys=True),
+            "quick_scan=" + str(bool(result.get("quick") or privacy.get("quick"))),
+            "privacy_truncated=" + str(privacy_truncated),
         ]
         evidence.extend(f"root={path}" for path in suspect_roots[:5])
-        if residue_total == 0 and privacy_residue_total == 0 and not suspect_roots:
+        if residue_total == 0 and privacy_residue_total == 0 and not suspect_roots and not privacy_truncated:
             return DoctorCheck(
                 id="runtime.local_index_hygiene",
                 tier="runtime",
@@ -3889,7 +3895,7 @@ def check_local_index_hygiene(fix: bool = False) -> DoctorCheck:
             severity="warn",
             summary="Local memory index has stale or private residue",
             evidence=evidence,
-            repair_plan=["Run `nexo doctor --tier runtime --fix` to purge stale local memory roots and private local-memory residue"],
+            repair_plan=["Run `nexo doctor --tier runtime --fix` to purge stale local memory roots/private residue, or run a full local_index_hygiene scan outside release readiness"],
             escalation_prompt="Local memory may contain stale or private index payloads that should be purged before indexing continues.",
         )
     except Exception as exc: