nexo-brain 7.27.3 → 7.27.6

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.27.3",
+  "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.3` is the current packaged-runtime line. Patch release over v7.27.2 - OpenAI raw calls and Codex-managed bootstrap no longer send system-role messages, preventing account-model failures while preserving Anthropic/OpenAI provider parity.
+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.
 

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.3",
+  "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/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/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,

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.
 
@@ -2270,6 +2306,7 @@ 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),
 ]
 
 

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: