nexo-brain 7.27.2 → 7.27.6

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.27.2",
+  "version": "7.27.6",
   "description": "Local cognitive runtime for Claude Code \u2014 persistent memory, overnight learning, doctor diagnostics, personal scripts, recovery-aware jobs, startup preflight, and optional dashboard/power helper.",
   "author": {
     "name": "NEXO Brain",

package/README.md

@@ -18,7 +18,9 @@
 
 [Watch the overview video](https://nexo-brain.com/watch/) · [Watch on YouTube](https://www.youtube.com/watch?v=i2lkGhKyVqI) · [Open the infographic](https://nexo-brain.com/assets/nexo-brain-infographic-v5.png)
 
-Version `7.27.2` is the current packaged-runtime line. Patch release over v7.27.1 - legacy Codex preferences now migrate to OpenAI correctly, and the F0.6 config-folder transition keeps reading existing `config/schedule.json` before it is moved.
+Version `7.27.6` is the current packaged-runtime line. Patch release over v7.27.5 - operational memory continuity now persists promises as commitments, routes pre-answer questions through evidence-backed memory, and exposes observation-queue convergence in health checks.
+
+Previously in `7.27.5`: patch release over v7.27.4 - Desktop onboarding asks for the user's name directly in Spanish with `¿Cómo te llamas?`, matching Desktop fallback copy.
 
 Previously in `7.27.1`: patch release over v7.27.0 - lifecycle stop calls skip external provider session UUIDs safely, and provider runtime selection keeps chat plus automation aligned to the same Anthropic/OpenAI account.
 
@@ -413,7 +415,7 @@ Version `5.0.0` closes the loop between memory, decisions, outcomes, and reusabl
 |------------|-------------|-------|----------------|
 | Shared brain / MCP runtime | Yes | Yes | Yes |
 | Managed bootstrap document | `~/.claude/CLAUDE.md` | `~/.codex/AGENTS.md` | Not applicable |
-| Global startup bootstrap sync | Native via hooks + bootstrap | Managed via bootstrap + Codex config `initial_messages` + `mcp_servers.nexo` | Managed MCP-only shared-brain metadata |
+| Global startup bootstrap sync | Native via hooks + bootstrap | Managed via bootstrap + Codex config `mcp_servers.nexo` | Managed MCP-only shared-brain metadata |
 | `nexo chat` terminal client | Yes | Yes | No |
 | Background automation backend | Recommended | Supported | No |
 | Raw transcript source for Deep Sleep | Yes | Yes | No |

package/bin/windows-wsl-bridge.js

@@ -18,6 +18,15 @@ const PRESERVED_FLAG_ENV_KEYS = [
   "NEXO_SKIP_MODEL_WARMUP",
   "NEXO_NO_LAUNCHD",
   "NEXO_INSTALL_NO_LAUNCHD",
+  // v0.41.23 — forward the bundled-node hints so client_sync.py
+  // _bundled_npm_runtime() can resolve a real Linux node + npm-cli.js inside
+  // WSL and actually install claude/codex under NEXO_DESKTOP_MANAGED=1.
+  // Without these surviving the `env -i` reset below, the managed install
+  // hard-returns managed_install_failed and installs NOTHING → claude/codex
+  // absent → `claude --version` exit 127 → the Connect buttons open no
+  // browser on a fresh Windows install. (Learning #638.)
+  "NEXO_DESKTOP_NODE",
+  "NEXO_DESKTOP_NPM_CLI",
 ];
 
 function isWindowsHost(platform = process.platform) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.27.2",
+  "version": "7.27.6",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain — Shared brain for AI agents. Persistent memory, semantic RAG, natural forgetting, metacognitive guard, trust scoring, 150+ MCP tools. Works with Claude Code, Codex, Claude Desktop & any MCP client. 100% local, free.",
   "homepage": "https://nexo-brain.com",

package/src/agent_runner.py

@@ -625,10 +625,6 @@ def _codex_managed_initial_messages_enabled() -> bool:
     )
 
 
-def _codex_initial_messages_config(prompt_text: str) -> str:
-    return f'initial_messages=[{{role="system",content={json.dumps(prompt_text, ensure_ascii=False)}}}]'
-
-
 def _codex_interactive_launch_flags() -> list[str]:
     return ["--sandbox", "danger-full-access", "--ask-for-approval", "never"]
 
@@ -752,9 +748,6 @@ def build_interactive_client_command(
                 "Codex launcher not found in PATH. Install `codex` first or reconfigure NEXO."
             )
         cmd = [codex_bin, *_codex_interactive_launch_flags()]
-        bootstrap_prompt = _load_client_bootstrap_prompt(CLIENT_CODEX)
-        if bootstrap_prompt and not _codex_managed_initial_messages_enabled():
-            cmd.extend(["-c", _codex_initial_messages_config(bootstrap_prompt)])
         if resolved_model:
             cmd.extend(["-m", resolved_model])
         if resolved_effort:
@@ -915,9 +908,6 @@ def build_followup_terminal_shell_command(
             )
         target_cwd = str(Path(cwd).expanduser()) if cwd else str(Path.home())
         cmd = [codex_bin, *_codex_interactive_launch_flags()]
-        bootstrap_prompt = _load_client_bootstrap_prompt(CLIENT_CODEX)
-        if bootstrap_prompt and not _codex_managed_initial_messages_enabled():
-            cmd.extend(["-c", _codex_initial_messages_config(bootstrap_prompt)])
         if resolved_model:
             cmd.extend(["-m", resolved_model])
         if resolved_effort:
@@ -1451,9 +1441,6 @@ def run_automation_prompt(
                 "-o",
                 str(output_path),
             ]
-            bootstrap_prompt = _load_client_bootstrap_prompt(CLIENT_CODEX)
-            if bootstrap_prompt and not _codex_managed_initial_messages_enabled():
-                cmd.extend(["-c", _codex_initial_messages_config(bootstrap_prompt)])
             if resolved_model:
                 cmd.extend(["-m", resolved_model])
             if resolved_effort:

package/src/call_model_raw.py

@@ -138,6 +138,22 @@ def _extract_openai_text(response) -> str:
         return ""
 
 
+def _openai_messages(prompt: str, system: str | None) -> list[dict]:
+    if system:
+        return [
+            {
+                "role": "user",
+                "content": (
+                    "Instructions:\n"
+                    f"{system}\n\n"
+                    "Task:\n"
+                    f"{prompt}"
+                ),
+            }
+        ]
+    return [{"role": "user", "content": prompt}]
+
+
 def _call_anthropic_raw(
     *,
     prompt: str,
@@ -214,10 +230,7 @@ def _call_openai_raw(
         raise ClassifierUnavailableError("openai: no OPENAI_API_KEY found")
 
     client = openai.OpenAI(api_key=api_key, timeout=timeout)
-    messages: list[dict] = []
-    if system:
-        messages.append({"role": "system", "content": system})
-    messages.append({"role": "user", "content": prompt})
+    messages = _openai_messages(prompt, system)
 
     try:
         response = client.chat.completions.create(

package/src/classifier_local.py

@@ -213,11 +213,55 @@ class LocalZeroShotClassifier:
         )
 
 
+_SHARED_CLASSIFIER_LOCK = threading.Lock()
+_SHARED_CLASSIFIERS: dict[tuple[str, str], LocalZeroShotClassifier] = {}
+
+
+def get_shared_zero_shot_classifier(
+    *,
+    model_id: str = MODEL_ID,
+    revision: str = MODEL_REVISION,
+    confidence_floor: float = DEFAULT_CONFIDENCE_FLOOR,
+) -> LocalZeroShotClassifier:
+    """Return the process-wide classifier wrapper for this pinned model.
+
+    The underlying transformer pipeline is still lazy-loaded, but once it is
+    warm all semantic callers share it instead of creating fresh wrappers.
+    """
+    key = (model_id, revision)
+    with _SHARED_CLASSIFIER_LOCK:
+        classifier = _SHARED_CLASSIFIERS.get(key)
+        if classifier is None:
+            classifier = LocalZeroShotClassifier(
+                model_id=model_id,
+                revision=revision,
+                confidence_floor=confidence_floor,
+            )
+            _SHARED_CLASSIFIERS[key] = classifier
+        else:
+            classifier.confidence_floor = confidence_floor
+        return classifier
+
+
+def is_local_classifier_warm(
+    *,
+    model_id: str = MODEL_ID,
+    revision: str = MODEL_REVISION,
+) -> bool:
+    """Return True only when this process already has a loaded pipeline."""
+    key = (model_id, revision)
+    with _SHARED_CLASSIFIER_LOCK:
+        classifier = _SHARED_CLASSIFIERS.get(key)
+        return bool(classifier is not None and classifier._pipe is not None)
+
+
 __all__ = [
     "LocalZeroShotClassifier",
     "ClassificationResult",
     "MODEL_ID",
     "MODEL_REVISION",
     "DEFAULT_CONFIDENCE_FLOOR",
+    "get_shared_zero_shot_classifier",
+    "is_local_classifier_warm",
     "is_local_classifier_available_with_install_state",
 ]

package/src/client_sync.py

@@ -978,12 +978,10 @@ def _sync_codex_managed_config(
     else:
         payload["features"] = {"hooks": True}
 
-    payload["initial_messages"] = [
-        {
-            "role": "system",
-            "content": bootstrap_prompt,
-        }
-    ] if bootstrap_prompt else []
+    # Codex model APIs used by some accounts reject system-role bootstrap
+    # messages. Keep the durable bootstrap in AGENTS.md and remove any legacy
+    # initial_messages block written by older NEXO versions.
+    payload.pop("initial_messages", None)
 
     nexo_table = payload.setdefault("nexo", {})
     codex_table = nexo_table.setdefault("codex", {})

package/src/db/__init__.py

@@ -56,6 +56,7 @@ _outcomes = _load_submodule("db._outcomes")
 _goal_profiles = _load_submodule("db._goal_profiles")
 _continuity = _load_submodule("db._continuity")
 _memory_v2 = _load_submodule("db._memory_v2")
+_commitments = _load_submodule("db._commitments")
 
 # Core: connection, constants, init, utils
 from db._core import (
@@ -110,6 +111,13 @@ from db._memory_v2 import (
     memory_observation_stats,
 )
 
+from db._commitments import (
+    create_commitment,
+    list_commitments,
+    update_commitment_status,
+    resolve_matching_commitments,
+)
+
 # PostToolUse inbox-reminder rate limit (v6.0.1)
 _hook_inbox_reminders = _load_submodule("db._hook_inbox_reminders")
 from db._hook_inbox_reminders import (

package/src/db/_commitments.py

@@ -0,0 +1,344 @@
+"""Durable commitment ledger for future-action promises.
+
+The ledger is an index over promises and their linked action artifacts. It is
+not a scheduler: followups, workflows, outcomes, and protocol tasks remain the
+systems that execute work.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import re
+from typing import Any
+
+from db._core import get_db, now_epoch
+
+
+ACTIVE_STATUSES = {"active", "in_progress", "pending"}
+CLOSED_STATUSES = {"fulfilled", "missed", "cancelled", "superseded"}
+VALID_OWNERS = {"agent", "user", "shared", "waiting"}
+VALID_STATUSES = ACTIVE_STATUSES | CLOSED_STATUSES
+_WORD_RE = re.compile(r"[a-z0-9_]+")
+
+
+def _clean_text(value: Any, *, max_chars: int = 1200) -> str:
+    text = str(value or "").strip()
+    if len(text) > max_chars:
+        return text[: max(0, max_chars - 3)].rstrip() + "..."
+    return text
+
+
+def _status(value: str) -> str:
+    clean = str(value or "active").strip().lower()
+    return clean if clean in VALID_STATUSES else "active"
+
+
+def _owner(value: str) -> str:
+    clean = str(value or "agent").strip().lower()
+    return clean if clean in VALID_OWNERS else "agent"
+
+
+def _json(value: dict[str, Any] | None) -> str:
+    try:
+        return json.dumps(value or {}, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+    except Exception:
+        return "{}"
+
+
+def _tokens(value: str) -> set[str]:
+    return {item for item in _WORD_RE.findall(str(value or "").lower()) if len(item) >= 3}
+
+
+def _dedupe_key(*, source_type: str, source_id: str, session_id: str, statement: str) -> str:
+    seed = "|".join(
+        [
+            _clean_text(source_type, max_chars=80).lower(),
+            _clean_text(source_id, max_chars=160).lower(),
+            _clean_text(session_id, max_chars=160).lower(),
+            _clean_text(statement, max_chars=600).lower(),
+        ]
+    )
+    return hashlib.sha1(seed.encode("utf-8", errors="ignore"), usedforsecurity=False).hexdigest()
+
+
+def _commitment_id(dedupe_key: str) -> str:
+    return f"CM-{dedupe_key[:16].upper()}"
+
+
+def _row_dict(row: Any) -> dict[str, Any]:
+    if not row:
+        return {}
+    data = dict(row)
+    try:
+        data["metadata"] = json.loads(data.get("metadata_json") or "{}")
+    except Exception:
+        data["metadata"] = {}
+    return data
+
+
+def create_commitment(
+    *,
+    statement: str,
+    source_type: str = "",
+    source_id: str = "",
+    memory_event_uid: str = "",
+    session_id: str = "",
+    conversation_id: str = "",
+    project_key: str = "",
+    owner: str = "agent",
+    deadline: str = "",
+    status: str = "active",
+    confidence: float = 0.5,
+    action_ref_type: str = "",
+    action_ref_id: str = "",
+    outcome_id: int | None = None,
+    evidence_ref: str = "",
+    dedupe_key: str = "",
+    metadata: dict[str, Any] | None = None,
+    created_at: float | None = None,
+) -> dict[str, Any]:
+    clean_statement = _clean_text(statement)
+    if not clean_statement:
+        return {"ok": False, "error": "statement_required"}
+    stamp = float(created_at if created_at is not None else now_epoch())
+    clean_source_type = _clean_text(source_type, max_chars=80)
+    clean_source_id = _clean_text(source_id, max_chars=180)
+    clean_session_id = _clean_text(session_id, max_chars=180)
+    key = _clean_text(dedupe_key, max_chars=80) or _dedupe_key(
+        source_type=clean_source_type,
+        source_id=clean_source_id,
+        session_id=clean_session_id,
+        statement=clean_statement,
+    )
+    commitment_id = _commitment_id(key)
+    conn = get_db()
+    existing = conn.execute("SELECT * FROM commitments WHERE dedupe_key = ? LIMIT 1", (key,)).fetchone()
+    if existing:
+        result = _row_dict(existing)
+        result.update({"ok": True, "created": False})
+        return result
+    conn.execute(
+        """
+        INSERT INTO commitments (
+            id, created_at, updated_at, closed_at, source_type, source_id,
+            memory_event_uid, session_id, conversation_id, project_key,
+            statement, owner, deadline, status, confidence, action_ref_type,
+            action_ref_id, outcome_id, evidence_ref, dedupe_key, metadata_json
+        )
+        VALUES (?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            commitment_id,
+            stamp,
+            stamp,
+            clean_source_type,
+            clean_source_id,
+            _clean_text(memory_event_uid, max_chars=180),
+            clean_session_id,
+            _clean_text(conversation_id, max_chars=180),
+            _clean_text(project_key, max_chars=120),
+            clean_statement,
+            _owner(owner),
+            _clean_text(deadline, max_chars=80),
+            _status(status),
+            max(0.0, min(1.0, float(confidence or 0.5))),
+            _clean_text(action_ref_type, max_chars=80),
+            _clean_text(action_ref_id, max_chars=180),
+            int(outcome_id) if outcome_id is not None else None,
+            _clean_text(evidence_ref, max_chars=240),
+            key,
+            _json(metadata),
+        ),
+    )
+    conn.commit()
+    row = conn.execute("SELECT * FROM commitments WHERE id = ?", (commitment_id,)).fetchone()
+    result = _row_dict(row)
+    result.update({"ok": True, "created": True})
+    return result
+
+
+def list_commitments(
+    *,
+    query: str = "",
+    status: str = "",
+    session_id: str = "",
+    project_key: str = "",
+    owner: str = "",
+    limit: int = 20,
+) -> list[dict[str, Any]]:
+    clauses = ["1=1"]
+    params: list[Any] = []
+    if status:
+        clean_status = status.strip().lower()
+        if clean_status in {"open", "active"}:
+            clauses.append("status IN ('active','in_progress','pending')")
+        elif clean_status in {"closed", "resolved"}:
+            clauses.append("status IN ('fulfilled','missed','cancelled','superseded')")
+        else:
+            clauses.append("status = ?")
+            params.append(_status(clean_status))
+    if session_id.strip():
+        clauses.append("session_id = ?")
+        params.append(session_id.strip())
+    if project_key.strip():
+        clauses.append("project_key = ?")
+        params.append(project_key.strip())
+    if owner.strip():
+        clauses.append("owner = ?")
+        params.append(_owner(owner))
+    max_items = max(1, min(int(limit or 20), 100))
+    terms = _tokens(query)
+    # Query filtering is semantic-ish and happens in Python over multiple
+    # fields. Fetch a larger bounded window first so older relevant open
+    # commitments do not disappear merely because the caller requested a
+    # small result limit.
+    query_window = 500 if terms else max_items * 3
+    rows = get_db().execute(
+        f"""
+        SELECT * FROM commitments
+         WHERE {' AND '.join(clauses)}
+         ORDER BY
+            CASE status WHEN 'active' THEN 0 WHEN 'in_progress' THEN 1 WHEN 'pending' THEN 2 ELSE 3 END,
+            COALESCE(deadline, '') ASC,
+            updated_at DESC
+         LIMIT ?
+        """,
+        [*params, query_window],
+    ).fetchall()
+    items = [_row_dict(row) for row in rows]
+    if terms:
+        filtered = []
+        for item in items:
+            haystack = _tokens(
+                " ".join(
+                    str(item.get(field) or "")
+                    for field in (
+                        "id",
+                        "statement",
+                        "source_type",
+                        "source_id",
+                        "session_id",
+                        "project_key",
+                        "action_ref_type",
+                        "action_ref_id",
+                        "evidence_ref",
+                    )
+                )
+            )
+            if terms & haystack:
+                filtered.append(item)
+        items = filtered
+    return items[:max_items]
+
+
+def update_commitment_status(
+    commitment_id: str,
+    *,
+    status: str,
+    evidence_ref: str = "",
+    action_ref_type: str = "",
+    action_ref_id: str = "",
+    outcome_id: int | None = None,
+    metadata: dict[str, Any] | None = None,
+    now: float | None = None,
+) -> dict[str, Any]:
+    clean_status = _status(status)
+    stamp = float(now if now is not None else now_epoch())
+    closed_at = stamp if clean_status in CLOSED_STATUSES else None
+    conn = get_db()
+    row = conn.execute("SELECT * FROM commitments WHERE id = ?", (commitment_id.strip(),)).fetchone()
+    if not row:
+        return {"ok": False, "error": f"commitment_not_found:{commitment_id}"}
+    merged_metadata = _row_dict(row).get("metadata") or {}
+    merged_metadata.update(metadata or {})
+    conn.execute(
+        """
+        UPDATE commitments
+           SET status = ?,
+               updated_at = ?,
+               closed_at = ?,
+               evidence_ref = COALESCE(NULLIF(?, ''), evidence_ref),
+               action_ref_type = COALESCE(NULLIF(?, ''), action_ref_type),
+               action_ref_id = COALESCE(NULLIF(?, ''), action_ref_id),
+               outcome_id = COALESCE(?, outcome_id),
+               metadata_json = ?
+         WHERE id = ?
+        """,
+        (
+            clean_status,
+            stamp,
+            closed_at,
+            _clean_text(evidence_ref, max_chars=240),
+            _clean_text(action_ref_type, max_chars=80),
+            _clean_text(action_ref_id, max_chars=180),
+            int(outcome_id) if outcome_id is not None else None,
+            _json(merged_metadata),
+            commitment_id.strip(),
+        ),
+    )
+    conn.commit()
+    updated = conn.execute("SELECT * FROM commitments WHERE id = ?", (commitment_id.strip(),)).fetchone()
+    result = _row_dict(updated)
+    result["ok"] = True
+    return result
+
+
+def resolve_matching_commitments(
+    *,
+    session_id: str = "",
+    evidence_text: str = "",
+    action_ref_type: str = "",
+    action_ref_id: str = "",
+    evidence_ref: str = "",
+    status: str = "fulfilled",
+    limit: int = 5,
+) -> dict[str, Any]:
+    """Close active commitments when completion evidence overlaps enough."""
+    terms = _tokens(evidence_text)
+    if not terms and not (action_ref_type and action_ref_id):
+        return {"ok": True, "resolved": 0, "items": [], "reason": "no_matching_signal"}
+    candidates = list_commitments(session_id=session_id, status="open", limit=max(1, min(limit, 20)))
+    resolved: list[dict[str, Any]] = []
+    for item in candidates:
+        action_match = (
+            bool(action_ref_type and action_ref_id)
+            and item.get("action_ref_type") == action_ref_type
+            and item.get("action_ref_id") == action_ref_id
+        )
+        statement_terms = _tokens(str(item.get("statement") or ""))
+        matched_terms = terms & statement_terms
+        overlap = len(matched_terms) / max(1, len(statement_terms))
+        required_matches = max(4, math.ceil(len(statement_terms) * 0.55))
+        strong_text_match = bool(
+            len(matched_terms) >= required_matches
+            and overlap >= 0.65
+        )
+        if not action_match and not strong_text_match:
+            continue
+        resolved.append(
+            update_commitment_status(
+                str(item.get("id")),
+                status=status,
+                evidence_ref=evidence_ref,
+                action_ref_type=action_ref_type,
+                action_ref_id=action_ref_id,
+                metadata={
+                    "resolved_by": "action_ref" if action_match else "strong_matching_evidence",
+                    "overlap": round(overlap, 4),
+                    "matched_terms": sorted(matched_terms)[:12],
+                },
+            )
+        )
+        if len(resolved) >= limit:
+            break
+    return {"ok": True, "resolved": len(resolved), "items": resolved}
+
+
+__all__ = [
+    "create_commitment",
+    "list_commitments",
+    "update_commitment_status",
+    "resolve_matching_commitments",
+]

package/src/db/_memory_v2.py

@@ -1028,7 +1028,7 @@ def backfill_memory_observations(
     return {"ok": True, "sources": sorted(requested), "seen": seen, "created_or_updated": created}
 
 
-def memory_observation_health() -> dict:
+def memory_observation_health(*, pending_sla_seconds: int = 3600, now: float | None = None) -> dict:
     conn = _core().get_db()
     tables = {
         "memory_events": _table_exists(conn, "memory_events"),
@@ -1044,11 +1044,40 @@ def memory_observation_health() -> dict:
     if tables["memory_observations"]:
         counts["observations"] = int(conn.execute("SELECT COUNT(*) FROM memory_observations").fetchone()[0])
         latest["observation_created_at"] = conn.execute("SELECT MAX(created_at) FROM memory_observations").fetchone()[0]
+    pending_sla = max(1, int(pending_sla_seconds or 3600))
+    pending_older_than_sla = 0
+    oldest_pending = None
+    max_pending_age_seconds = 0.0
     if tables["memory_observation_queue"]:
         rows = conn.execute(
             "SELECT status, COUNT(*) AS cnt FROM memory_observation_queue GROUP BY status"
         ).fetchall()
         counts["queue"] = {row["status"]: int(row["cnt"]) for row in rows}
+        stamp = float(now if now is not None else _core().now_epoch())
+        stale_cutoff = stamp - pending_sla
+        pending_older_than_sla = int(
+            conn.execute(
+                """
+                SELECT COUNT(*)
+                  FROM memory_observation_queue
+                 WHERE status IN ('pending', 'failed')
+                   AND created_at <= ?
+                """,
+                (stale_cutoff,),
+            ).fetchone()[0]
+        )
+        oldest = conn.execute(
+            """
+            SELECT event_uid, status, created_at, updated_at, last_error
+              FROM memory_observation_queue
+             WHERE status IN ('pending', 'failed')
+             ORDER BY created_at ASC, id ASC
+             LIMIT 1
+            """
+        ).fetchone()
+        if oldest:
+            oldest_pending = dict(oldest)
+            max_pending_age_seconds = max(0.0, stamp - float(oldest["created_at"] or stamp))
 
     fts_enabled = _is_virtual_fts_table(conn, "memory_observations_fts")
     fts_queryable = False
@@ -1061,12 +1090,33 @@ def memory_observation_health() -> dict:
 
     missing_required = [name for name in ("memory_events", "memory_observations", "memory_observation_queue") if not tables[name]]
     failed_queue = int(counts["queue"].get("failed", 0))
+    warnings = []
+    if pending_older_than_sla:
+        warnings.append(
+            {
+                "code": "pending_sla_breached",
+                "pending_older_than_sla": pending_older_than_sla,
+                "pending_sla_seconds": pending_sla,
+                "max_pending_age_seconds": max_pending_age_seconds,
+                "oldest_pending": oldest_pending,
+            }
+        )
+    if failed_queue:
+        warnings.append({"code": "queue_failed", "failed": failed_queue})
     return {
-        "ok": not missing_required and failed_queue == 0,
+        "ok": not missing_required and failed_queue == 0 and pending_older_than_sla == 0,
         "tables": tables,
         "missing_required": missing_required,
         "counts": counts,
         "latest": latest,
+        "queue_sla": {
+            "pending_sla_seconds": pending_sla,
+            "pending_sla_ok": pending_older_than_sla == 0,
+            "pending_older_than_sla": pending_older_than_sla,
+            "oldest_pending": oldest_pending,
+            "max_pending_age_seconds": max_pending_age_seconds,
+        },
+        "warnings": warnings,
         "fts_enabled": fts_enabled,
         "fts_degraded": tables["memory_observations_fts"] and not fts_enabled,
         "fts_queryable": fts_queryable,