nexo-brain 7.23.13 → 7.25.0

package/src/db/__init__.py

@@ -100,6 +100,7 @@ from db._memory_v2 import (
     list_memory_events,
     memory_event_stats,
     upsert_memory_observation,
+    publish_intraday_fact,
     process_memory_observation_queue,
     list_memory_observations,
     search_memory_observations_fts,
@@ -124,6 +125,7 @@ from db._reminders import (
     find_similar_followups,
     compute_followup_impact, score_followup, score_active_followups,
     add_item_history, get_item_history, validate_item_read_token,
+    normalize_followup_status, followup_due_state, followup_lifecycle_lane, followup_lifecycle_snapshot,
 )
 
 # Learnings

package/src/db/_fts.py

@@ -1,5 +1,5 @@
 """NEXO DB — Fts module."""
-import os, pathlib, sqlite3, threading, datetime
+import os, pathlib, re, sqlite3, threading, datetime
 import paths
 from db._core import get_db, now_epoch, DB_PATH
 
@@ -328,22 +328,26 @@ def fts_search(query: str, source_filter: str = None, limit: int = 20) -> list[d
         limit: Max results (default 20)
     """
     conn = get_db()
-    words = query.strip().split()
+    raw_query = query.strip()
+    words = raw_query.split()
     if not words:
         return []
 
     # Expand with synonyms for cross-language matching
     all_words = _expand_synonyms(words)
 
-    # Build FTS5 query: each word as quoted term with OR for broad matching
+    # Build FTS5 query: each word as quoted term with OR for broad matching.
+    # Symbol-heavy identifiers (emails, paths, refs) need deterministic token
+    # boundaries so FTS5 never treats punctuation as query syntax.
     fts_terms = []
     for w in all_words:
         # Strip FTS5 special chars to avoid syntax errors
-        safe = w.replace('"', '').replace("'", '').replace('*', '').replace('^', '').replace('-', ' ').strip()
+        safe = w.replace('"', '').replace("'", '').replace('*', '').replace('^', '').strip()
+        safe = re.sub(r"[-@/\\:]+", " ", safe)
         if not safe:
             continue
-        # Split on dots (e.g., "capabilities.json" → "capabilities" + "json")
-        parts = [p.strip() for p in safe.split('.') if p.strip()]
+        # Split on dots and punctuation boundaries (e.g., emails, paths, files).
+        parts = [p.strip() for p in re.split(r"[.\s]+", safe) if p.strip()]
         for part in parts:
             fts_terms.append(f'"{part}"')
             # Add prefix search for camelCase/code identifiers (contains uppercase mid-word)
@@ -361,6 +365,24 @@ def fts_search(query: str, source_filter: str = None, limit: int = 20) -> list[d
     params.append(limit)
 
     try:
+        exact_rows = []
+        if re.search(r"[@/\\:.-]", raw_query):
+            exact_where = ""
+            exact_params = [f"%{raw_query}%", f"%{raw_query}%", f"%{raw_query}%"]
+            if source_filter:
+                exact_where = "AND source = ?"
+                exact_params.append(source_filter)
+            exact_params.append(limit)
+            exact_rows = conn.execute(f"""
+                SELECT source, source_id, title,
+                       substr(body, 1, 240) AS snippet,
+                       category, updated_at, -100.0 AS rank
+                FROM unified_search
+                WHERE (title LIKE ? OR body LIKE ? OR source_id LIKE ?) {exact_where}
+                ORDER BY updated_at DESC
+                LIMIT ?
+            """, exact_params).fetchall()
+
         rows = conn.execute(f"""
             SELECT source, source_id, title,
                    snippet(unified_search, 3, '»', '«', '...', 40) AS snippet,
@@ -370,7 +392,16 @@ def fts_search(query: str, source_filter: str = None, limit: int = 20) -> list[d
             ORDER BY rank
             LIMIT ?
         """, params).fetchall()
-        return [dict(r) for r in rows]
+        merged = []
+        seen = set()
+        for row in list(exact_rows) + list(rows):
+            item = dict(row)
+            key = (item.get("source"), item.get("source_id"))
+            if key in seen:
+                continue
+            seen.add(key)
+            merged.append(item)
+        return merged[:limit]
     except Exception:
         return []
 
@@ -403,4 +434,3 @@ def _migrate_add_index(conn, index_name: str, table: str, column: str):
     """Create index if it doesn't exist (idempotent)."""
     conn.execute(f"CREATE INDEX IF NOT EXISTS {index_name} ON {table}({column})")
     conn.commit()
-

package/src/db/_learnings.py

@@ -205,7 +205,7 @@ def find_similar_learnings(new_id: int, title: str, content: str, category: str)
         return []
     conn = _core().get_db()
     rows = conn.execute(
-        "SELECT id, title, content FROM learnings WHERE category = ? AND id != ?",
+        "SELECT id, title, content FROM learnings WHERE category = ? AND id != ? AND COALESCE(status, 'active') = 'active'",
         (category, new_id)
     ).fetchall()
     results = []

package/src/db/_memory_v2.py

@@ -9,6 +9,7 @@ stable substrate without changing hook behaviour again.
 import hashlib
 import importlib
 import json
+import os
 import re
 import sqlite3
 import sys
@@ -429,6 +430,101 @@ def _derive_observation(event: dict) -> dict:
     }
 
 
+def _intraday_facts_enabled() -> bool:
+    value = os.environ.get("NEXO_INTRADAY_FACTS_ENABLED", "1").strip().lower()
+    return value not in {"0", "false", "no", "off", "disabled"}
+
+
+def _intraday_fact_candidate(observation: dict) -> bool:
+    if str(observation.get("status") or "active").lower() != "active":
+        return False
+    if float(observation.get("salience") or 0.0) < 0.62:
+        return False
+    if str(observation.get("observation_type") or "") not in {
+        "code_change",
+        "correction",
+        "decision",
+        "task_result",
+    }:
+        return False
+    if not str(observation.get("summary") or "").strip():
+        return False
+
+    facts = observation.get("facts") if isinstance(observation.get("facts"), dict) else {}
+    metadata = facts.get("metadata") if isinstance(facts.get("metadata"), dict) else {}
+    event_type = str(facts.get("event_type") or "")
+    source_type = str(facts.get("source_type") or "")
+    refs = [str(ref) for ref in observation.get("evidence_refs") or []]
+    observation_type = str(observation.get("observation_type") or "")
+
+    if observation_type == "task_result":
+        outcome = str(metadata.get("outcome") or event_type.removeprefix("protocol_task_") or "").lower()
+        return outcome in {"done", "closed", "completed", "success", "partial"}
+    if observation_type == "code_change":
+        verification_keys = {
+            "verified",
+            "verification",
+            "change_verify",
+            "test_output",
+            "tests_passed",
+            "evidence",
+        }
+        if source_type in {"change_log", "evidence_ledger", "protocol_task"}:
+            return True
+        if any(key in metadata and str(metadata.get(key) or "").strip() for key in verification_keys):
+            return True
+        return any(ref.startswith(("change_log:", "evidence:", "protocol_task:")) for ref in refs)
+    return observation_type in {"correction", "decision"}
+
+
+def publish_intraday_fact(observation: dict, *, ttl_hours: int = 36) -> dict:
+    """Expose high-salience observations as temporary hot context.
+
+    This is deliberately not long-term promotion. Deep Sleep can later promote,
+    merge, or discard the observation; the intraday fact only keeps today's
+    important work visible while the operator keeps working.
+    """
+    if not _intraday_facts_enabled():
+        return {"ok": True, "skipped": True, "reason": "intraday facts disabled"}
+    if not _intraday_fact_candidate(observation):
+        return {"ok": True, "skipped": True, "reason": "not an intraday fact candidate"}
+
+    uid = str(observation.get("observation_uid") or "").strip()
+    if not uid:
+        return {"ok": False, "error": "observation_uid is required"}
+
+    try:
+        from db._hot_context import capture_context_event
+
+        result = capture_context_event(
+            event_type="intraday_fact",
+            title=_truncate(observation.get("subject") or uid, 160),
+            summary=_truncate(observation.get("summary") or "", 600),
+            body=_truncate(observation.get("summary") or "", 1600),
+            context_key=f"intraday_fact:{uid}",
+            context_title=_truncate(observation.get("subject") or uid, 160),
+            context_summary=_truncate(observation.get("summary") or "", 600),
+            context_type="intraday_fact",
+            state="active",
+            owner="nexo",
+            actor="memory-observation-processor",
+            source_type="memory_observation",
+            source_id=uid,
+            session_id=str(observation.get("session_id") or ""),
+            metadata={
+                "observation_type": observation.get("observation_type") or "",
+                "project_key": observation.get("project_key") or "",
+                "promotion_state": observation.get("promotion_state") or "observation",
+                "evidence_refs": observation.get("evidence_refs") or [],
+            },
+            ttl_hours=ttl_hours,
+            created_at=float(observation.get("updated_at") or _core().now_epoch()),
+        )
+        return {"ok": True, "context_key": result.get("context_key"), "result": result}
+    except Exception as exc:
+        return {"ok": False, "error": _truncate(str(exc), 500)}
+
+
 def upsert_memory_observation(observation: dict) -> dict:
     conn = _core().get_db()
     if not _table_exists(conn, "memory_observations"):
@@ -520,6 +616,7 @@ def process_memory_observation_queue(limit: int = 25) -> dict:
     ).fetchall()
     processed = 0
     failed = 0
+    intraday_facts = 0
     now = _core().now_epoch()
     for row in rows:
         event = _row_to_event(row)
@@ -527,6 +624,9 @@ def process_memory_observation_queue(limit: int = 25) -> dict:
         try:
             observation = _derive_observation(event)
             upsert_memory_observation(observation)
+            intraday_result = publish_intraday_fact(observation)
+            if intraday_result.get("ok") and not intraday_result.get("skipped"):
+                intraday_facts += 1
             conn.execute(
                 """
                 UPDATE memory_observation_queue
@@ -554,7 +654,13 @@ def process_memory_observation_queue(limit: int = 25) -> dict:
             )
             failed += 1
     conn.commit()
-    return {"ok": failed == 0, "processed": processed, "failed": failed, "total_seen": len(rows)}
+    return {
+        "ok": failed == 0,
+        "processed": processed,
+        "failed": failed,
+        "intraday_facts": intraday_facts,
+        "total_seen": len(rows),
+    }
 
 
 def list_memory_events(

package/src/db/_protocol.py

@@ -365,9 +365,9 @@ def cortex_evaluation_summary(days: int = 30) -> dict:
 
     gaps: list[str] = []
     if total < 3:
-        gaps.append("Muy pocas evaluaciones del cortex para inferir mejora estable.")
+        gaps.append("Too few Cortex evaluations to infer stable improvement.")
     if len(linked) < 2:
-        gaps.append("Muy pocas decisiones enlazadas a outcomes para medir calidad real de recomendación.")
+        gaps.append("Too few decisions linked to outcomes to measure real recommendation quality.")
 
     return {
         "days": max(1, int(days)),

package/src/db/_reminders.py

@@ -14,7 +14,53 @@ from db._hot_context import capture_context_event
 from db._learnings import extract_keywords
 from db._semantic_similarity import hybrid_similarity_score
 
-ACTIVE_EXCLUDED_STATUSES = {"DELETED", "archived", "blocked", "waiting"}
+ACTIVE_EXCLUDED_STATUSES = {
+    "ARCHIVED",
+    "BLOCKED",
+    "DELETED",
+    "DONE",
+    "EXPIRED",
+    "NEEDS_DECISION",
+    "PARKED",
+    "STALE_REVIEW",
+    "WAITING",
+    "WAITING_EXTERNAL",
+    "WAITING_USER",
+}
+FOLLOWUP_TERMINAL_STATUSES = {"COMPLETED", "DELETED", "DONE", "EXPIRED", "ARCHIVED"}
+FOLLOWUP_WAITING_USER_STATUSES = {"NEEDS_DECISION", "WAITING_USER"}
+FOLLOWUP_WAITING_EXTERNAL_STATUSES = {"WAITING", "WAITING_EXTERNAL"}
+FOLLOWUP_BLOCKED_STATUSES = {"BLOCKED"}
+FOLLOWUP_STATUS_ALIASES = {
+    "": "PENDING",
+    "PENDIENTE": "PENDING",
+    "PENDING": "PENDING",
+    "ACTIVE": "PENDING",
+    "ACTIVO": "PENDING",
+    "COMPLETADO": "COMPLETED",
+    "COMPLETED": "COMPLETED",
+    "DONE": "DONE",
+    "HECHO": "DONE",
+    "ELIMINADO": "DELETED",
+    "DELETED": "DELETED",
+    "ARCHIVED": "ARCHIVED",
+    "ARCHIVADO": "ARCHIVED",
+    "BLOCKED": "BLOCKED",
+    "BLOQUEADO": "BLOCKED",
+    "WAITING": "WAITING",
+    "WAITING_EXTERNAL": "WAITING_EXTERNAL",
+    "ESPERANDO": "WAITING_EXTERNAL",
+    "WAITING_USER": "WAITING_USER",
+    "NEEDS_DECISION": "NEEDS_DECISION",
+    "NEEDS-DECISION": "NEEDS_DECISION",
+    "NEEDS DECISION": "NEEDS_DECISION",
+    "DECISION": "NEEDS_DECISION",
+    "NECESITA_DECISION": "NEEDS_DECISION",
+    "PARKED": "PARKED",
+    "APARCADO": "PARKED",
+    "STALE_REVIEW": "STALE_REVIEW",
+    "EXPIRED": "EXPIRED",
+}
 READ_TOKEN_TTL_SECONDS = 30 * 60
 
 # Opportunistic cleanup of expired item_read_tokens: runs at most once every
@@ -71,6 +117,49 @@ def _truncate(text: str | None, limit: int = 240) -> str:
     return text if len(text) <= limit else text[: limit - 3] + "..."
 
 
+def normalize_followup_status(status: str | None) -> str:
+    """Return the canonical followup status used by lifecycle tools."""
+    clean = str(status or "").strip()
+    if not clean:
+        return "PENDING"
+    upper = clean.upper().replace("-", "_")
+    if upper.startswith("COMPLETED"):
+        return "COMPLETED"
+    return FOLLOWUP_STATUS_ALIASES.get(upper, upper)
+
+
+def followup_lifecycle_lane(followup: dict) -> str:
+    """Classify one followup into an operational lane without mutating it."""
+    status = normalize_followup_status(followup.get("status"))
+    owner = str(followup.get("owner") or "").strip().lower()
+    if status in FOLLOWUP_TERMINAL_STATUSES:
+        return "completed" if status in {"COMPLETED", "DONE"} else status.lower()
+    if status in FOLLOWUP_BLOCKED_STATUSES:
+        return "blocked"
+    if status in FOLLOWUP_WAITING_USER_STATUSES or owner == "user":
+        return "waiting_user"
+    if status in FOLLOWUP_WAITING_EXTERNAL_STATUSES or owner == "waiting":
+        return "waiting_external"
+    if status == "PARKED":
+        return "parked"
+    if status == "STALE_REVIEW":
+        return "stale_review"
+    return "active"
+
+
+def followup_due_state(followup: dict) -> str:
+    """Return due/backlog/future/completed without changing the lifecycle lane."""
+    lane = followup_lifecycle_lane(followup)
+    if lane != "active":
+        return lane
+    due = _parse_date(followup.get("date"))
+    if due is None:
+        return "backlog"
+    if due > datetime.date.today():
+        return "future"
+    return "due"
+
+
 def _format_changes(before: sqlite3.Row | dict | None, after: sqlite3.Row | dict | None, fields: list[str]) -> str:
     if before is None or after is None:
         return ""
@@ -226,18 +315,20 @@ def _active_status_where(column_name: str = "status") -> str:
     excluded = ", ".join(f"'{value}'" for value in sorted(ACTIVE_EXCLUDED_STATUSES))
     return (
         f"{column_name} NOT LIKE 'COMPLETED%' "
-        f"AND {column_name} NOT IN ({excluded})"
+        f"AND UPPER(COALESCE({column_name}, '')) NOT IN ({excluded})"
     )
 
 
 def _context_state_from_status(status: str | None) -> str:
-    normalized = str(status or "PENDING").strip().upper()
+    normalized = normalize_followup_status(status)
     if normalized.startswith("COMPLETED"):
         return "resolved"
     if normalized == "DELETED":
         return "abandoned"
-    if normalized == "WAITING":
+    if normalized in {"WAITING_USER", "NEEDS_DECISION"}:
         return "waiting_user"
+    if normalized in {"WAITING", "WAITING_EXTERNAL"}:
+        return "waiting_third_party"
     if normalized == "BLOCKED":
         return "blocked"
     return "active"
@@ -632,6 +723,7 @@ def create_followup(
     """
     conn = get_db()
     now = now_epoch()
+    status = normalize_followup_status(status)
     similar = find_similar_followups(description)
     warning = ""
     if similar:
@@ -742,6 +834,8 @@ def update_followup(
             updates.pop("owner")
         else:
             updates["owner"] = coerced
+    if "status" in updates:
+        updates["status"] = normalize_followup_status(updates["status"])
     if not updates:
         return {"error": "No valid fields to update"}
 
@@ -1102,6 +1196,40 @@ def get_followup_history(id: str, limit: int = 20) -> list[dict]:
     return get_item_history("followup", id, limit=limit)
 
 
+def followup_lifecycle_snapshot(limit: int = 500) -> dict:
+    """Return followups grouped by lifecycle lane for dashboards and runners."""
+    conn = get_db()
+    rows = conn.execute(
+        "SELECT * FROM followups ORDER BY updated_at DESC LIMIT ?",
+        (max(1, min(int(limit or 500), 5000)),),
+    ).fetchall()
+    lanes = {
+        "active": [],
+        "waiting_user": [],
+        "waiting_external": [],
+        "blocked": [],
+        "parked": [],
+        "stale_review": [],
+        "expired": [],
+        "completed": [],
+        "deleted": [],
+        "archived": [],
+    }
+    for row in rows:
+        item = dict(row)
+        item["status"] = normalize_followup_status(item.get("status"))
+        lane = followup_lifecycle_lane(item)
+        item["lifecycle_lane"] = lane
+        item["due_state"] = followup_due_state(item)
+        lanes.setdefault(lane, []).append(item)
+    return {
+        "ok": True,
+        "total": len(rows),
+        "lanes": lanes,
+        "counts": {lane: len(items) for lane, items in lanes.items()},
+    }
+
+
 def _parse_date(date_str: str | None) -> datetime.date | None:
     text = str(date_str or "").strip()
     if not text:

package/src/db/_schema.py

@@ -1341,7 +1341,7 @@ def _m49_protocol_guard_ack_backfill(conn):
 
 def _m50_dedupe_nexo_product_learning_pair(conn):
     """Block D.2 / G7-adjacent: dedupe the two learnings that encode the
-    "NEXO Brain producto público vs instancia personal de Francisco"
+    "NEXO Brain public product vs Francisco's personal instance"
     invariant as a physically separate pair.
 
     Francisco's runtime has this concept stored twice (historical IDs 212
@@ -1368,7 +1368,7 @@ def _m50_dedupe_nexo_product_learning_pair(conn):
 
     def _norm(text: str) -> str:
         # Collapse whitespace and strip punctuation/case so "NEXO Brain
-        # producto público vs instancia personal" matches its twin no
+        # public product vs personal instance" matches its twin no
         # matter how the operator rephrased it.
         import re as _re
         stripped = _re.sub(r"[\W_]+", " ", str(text or "")).strip().lower()
@@ -2080,6 +2080,51 @@ def _m67_diary_quality_backfill_repair(conn):
     _migrate_add_index(conn, "idx_diary_archive_quality", "diary_archive", "quality_tier, quality_score, created_at")
 
 
+def _m68_memory_fabric_index(conn):
+    """Memory Fabric v1 index tables for historical backup memory."""
+    conn.executescript(
+        """
+        CREATE TABLE IF NOT EXISTS memory_fabric_sources (
+            source_id TEXT PRIMARY KEY,
+            source_type TEXT NOT NULL,
+            source_ref TEXT NOT NULL,
+            status TEXT NOT NULL DEFAULT 'active',
+            item_count INTEGER NOT NULL DEFAULT 0,
+            last_indexed_at TEXT DEFAULT '',
+            metadata_json TEXT NOT NULL DEFAULT '{}'
+        );
+
+        CREATE TABLE IF NOT EXISTS historical_diary_index (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            source_backup_path TEXT NOT NULL,
+            source_table TEXT NOT NULL DEFAULT 'session_diary',
+            source_row_id INTEGER NOT NULL,
+            session_id TEXT NOT NULL DEFAULT '',
+            created_at TEXT NOT NULL DEFAULT '',
+            domain TEXT NOT NULL DEFAULT '',
+            summary TEXT NOT NULL DEFAULT '',
+            decisions TEXT NOT NULL DEFAULT '',
+            pending TEXT NOT NULL DEFAULT '',
+            context_next TEXT NOT NULL DEFAULT '',
+            mental_state TEXT NOT NULL DEFAULT '',
+            self_critique TEXT NOT NULL DEFAULT '',
+            source TEXT NOT NULL DEFAULT '',
+            content_hash TEXT NOT NULL UNIQUE,
+            indexed_at TEXT DEFAULT (datetime('now')),
+            metadata_json TEXT NOT NULL DEFAULT '{}',
+            UNIQUE(source_backup_path, source_table, source_row_id)
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_historical_diary_session
+            ON historical_diary_index(session_id);
+        CREATE INDEX IF NOT EXISTS idx_historical_diary_created
+            ON historical_diary_index(created_at);
+        CREATE INDEX IF NOT EXISTS idx_historical_diary_domain
+            ON historical_diary_index(domain);
+        """
+    )
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -2148,6 +2193,7 @@ MIGRATIONS = [
     (65, "diary_quality", _m65_diary_quality),
     (66, "transcript_index", _m66_transcript_index),
     (67, "diary_quality_backfill_repair", _m67_diary_quality_backfill_repair),
+    (68, "memory_fabric_index", _m68_memory_fabric_index),
 ]
 
 

package/src/doctor/providers/runtime.py

@@ -3900,6 +3900,74 @@ def check_local_index_hygiene(fix: bool = False) -> DoctorCheck:
         )
 
 
+def check_memory_fabric_health(fix: bool = False) -> DoctorCheck:
+    try:
+        import memory_fabric
+
+        repair = None
+        if fix:
+            repair = memory_fabric.repair_memory_fabric(
+                transcript_hours=720,
+                transcript_limit=1000,
+                backup_limit=5000,
+            )
+        report = memory_fabric.memory_fabric_health(include_backup_scan=True)
+        issues = report.get("issues") or []
+        evidence = [
+            "transcripts=" + json.dumps(report.get("transcripts") or {}, sort_keys=True),
+            "historical_diaries=" + json.dumps(report.get("historical_diaries") or {}, sort_keys=True),
+            "local_context=" + json.dumps(report.get("local_context") or {}, sort_keys=True),
+            "knowledge_graph=" + json.dumps(report.get("knowledge_graph") or {}, sort_keys=True),
+        ]
+        evidence.extend(
+            f"issue={item.get('severity')}:{item.get('code')}:{item.get('message')}"
+            for item in issues[:6]
+            if isinstance(item, dict)
+        )
+        if repair:
+            evidence.append("repair=" + json.dumps({
+                "transcripts_indexed": (repair.get("transcripts") or {}).get("indexed"),
+                "historical_diaries_inserted": (repair.get("backups") or {}).get("inserted"),
+            }, sort_keys=True))
+        blocking = [
+            item for item in issues
+            if isinstance(item, dict) and item.get("code") in {"transcript_index_empty", "backup_diaries_not_reconciled"}
+        ]
+        if not blocking:
+            return DoctorCheck(
+                id="runtime.memory_fabric",
+                tier="runtime",
+                status="healthy",
+                severity="info",
+                summary="Memory Fabric coverage is queryable",
+                evidence=evidence,
+                repair_plan=[],
+                fixed=bool(repair),
+            )
+        return DoctorCheck(
+            id="runtime.memory_fabric",
+            tier="runtime",
+            status="degraded",
+            severity="warn",
+            summary="Memory Fabric coverage needs repair",
+            evidence=evidence,
+            repair_plan=["Run `nexo doctor --tier runtime --fix` or `nexo update` to warm transcript and historical backup indexes"],
+            escalation_prompt="Some memory sources exist outside the active query indexes, so exact historical lookup may fall back to slow raw scans.",
+            fixed=bool(repair),
+        )
+    except Exception as exc:
+        return DoctorCheck(
+            id="runtime.memory_fabric",
+            tier="runtime",
+            status="degraded",
+            severity="warn",
+            summary="Memory Fabric health could not be checked",
+            evidence=[str(exc)],
+            repair_plan=["Inspect memory_fabric.py and DB migrations"],
+            escalation_prompt="Support cannot verify unified memory coverage.",
+        )
+
+
 def run_runtime_checks(fix: bool = False) -> list[DoctorCheck]:
     """Run all runtime-tier checks. Read-only by default."""
     return [
@@ -3922,6 +3990,7 @@ def run_runtime_checks(fix: bool = False) -> list[DoctorCheck]:
         safe_check(check_automation_caller_coverage),
         safe_check(check_state_watchers),
         safe_check(check_local_index_hygiene, fix=fix),
+        safe_check(check_memory_fabric_health, fix=fix),
         safe_check(check_release_artifact_sync),
         safe_check(check_release_trace_hygiene),
         safe_check(check_launchagent_inventory),

package/src/events_bus.py

@@ -101,11 +101,10 @@ def emit(
     path.parent.mkdir(parents=True, exist_ok=True)
     _rotate_if_needed(path)
 
-    # v0.32.5 — antes `_next_id(path)` se calculaba ANTES de adquirir el
-    # flock → dos emitters concurrentes leían el mismo tail, computaban
-    # el mismo id, y escribían dos eventos con el mismo id. El renderer
-    # dedup descartaba el segundo silently → eventos perdidos. Ahora
-    # `_next_id` se llama DENTRO del lock, garantizando monotonía.
+    # v0.32.5 — `_next_id(path)` used to run BEFORE taking the flock. Two
+    # concurrent emitters could read the same tail, compute the same id, and
+    # write two events with that id. Renderer dedup then dropped the second
+    # event silently. Calling `_next_id` INSIDE the lock guarantees monotonicity.
     line = None
     event = None
     with path.open("a", encoding="utf-8") as fh: