nexo-brain 7.27.2 → 7.27.6

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

@@ -2228,6 +2228,11 @@ def check_client_bootstrap_parity(fix: bool = False) -> DoctorCheck:
                 severity = "warn"
                 evidence.append(f"codex config missing managed `mcp_servers.nexo` at {codex_config.get('path')}")
                 repair_plan.append("Re-sync Codex so manual sessions keep the shared brain even if `codex mcp add` state drifts")
+            elif codex_config.get("exists") and codex_config.get("has_initial_messages"):
+                status = "degraded"
+                severity = "warn"
+                evidence.append(f"codex config still has legacy `initial_messages` at {codex_config.get('path')}")
+                repair_plan.append("Run `nexo clients sync --client codex` so Codex uses the AGENTS.md bootstrap without legacy system-role startup messages")
             elif codex_config.get("exists"):
                 evidence.append(
                     "codex config bootstrap managed"
@@ -3837,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"))
@@ -3854,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",
@@ -3884,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:

package/src/enforcement_engine.py

@@ -14,6 +14,7 @@ import queue
 import subprocess
 import threading
 import time
+import hashlib
 from pathlib import Path
 import re
 import paths
@@ -408,10 +409,10 @@ class HeadlessEnforcer:
         self._guardian_mode_cache: dict[str, str] = {}
         # R14 state — opened on a detected correction, counts down by one each
         # tool call. When it reaches zero without a nexo_learning_add we
-        # enqueue the R14 reminder. The window guard is "3 tool calls" per
-        # plan doc 1; make it overridable via the env for field tuning.
+        # enqueue the R14 reminder and persist a correction-learning debt.
         self._r14_window_remaining = 0
         self._r14_correction_seen_for_turn = False
+        self._r14_correction_text = ""
         # R25 — last user message is inspected for an explicit permit token
         # ("force OK", "si borra", etc). Populated by on_user_message.
         self._r25_last_user_text = ""
@@ -420,6 +421,7 @@ class HeadlessEnforcer:
         self._r17_window_remaining = 0
         self._r17_promise_seen_for_turn = False
         self._r17_first_tool_call_in_window = True
+        self._r17_commitment_ids: list[str] = []
         # R24 stale-memory state — incremented externally via notify_
         # stale_memory_cited (e.g. from R07 when age_days >= threshold).
         # Counts down on each tool call; fires when it reaches zero
@@ -706,6 +708,7 @@ class HeadlessEnforcer:
             return
         self._r14_window_remaining = _R14_WINDOW
         self._r14_correction_seen_for_turn = True
+        self._r14_correction_text = text or ""
         _logger.info("[R14 %s] correction detected; window opened for %d tool calls",
                      mode.upper(), self._r14_window_remaining)
         # v7.7 Gap 7.2 — wire on_event so the map's
@@ -856,6 +859,7 @@ class HeadlessEnforcer:
             _logger.info("[R14] satisfied by learning_add; closing window")
             self._r14_window_remaining = 0
             self._r14_correction_seen_for_turn = False
+            self._r14_correction_text = ""
             return
         self._r14_window_remaining -= 1
         if self._r14_window_remaining > 0:
@@ -867,7 +871,35 @@ class HeadlessEnforcer:
         else:
             self._enqueue(_R14_PROMPT, "r14:correction-window-exhausted", rule_id="R14_correction_learning")
             _logger.info("[R14 %s] enqueued correction reminder", mode.upper())
+        if self._session_id:
+            try:
+                from db import create_protocol_debt, list_protocol_debts, record_session_correction_requirement  # type: ignore
+
+                record_session_correction_requirement(
+                    self._session_id,
+                    self._r14_correction_text,
+                    source="r14_window_exhausted",
+                )
+                existing = list_protocol_debts(
+                    status="open",
+                    session_id=self._session_id,
+                    debt_type="missing_learning_after_correction",
+                    limit=1,
+                )
+                if not existing:
+                    create_protocol_debt(
+                        self._session_id,
+                        "missing_learning_after_correction",
+                        severity="error",
+                        evidence=(
+                            "R14 detected a user correction and the 2-tool-call "
+                            "learning window expired without nexo_learning_add."
+                        ),
+                    )
+            except Exception:
+                pass
         self._r14_correction_seen_for_turn = False
+        self._r14_correction_text = ""
 
     def on_assistant_text(self, text: str, *, declared_detector=None, has_open_task=None):
         """R16 — scan assistant message for done-claim with open protocol_task.
@@ -1018,13 +1050,106 @@ class HeadlessEnforcer:
         self._r17_window_remaining = _R17_WINDOW
         self._r17_promise_seen_for_turn = True
         self._r17_first_tool_call_in_window = True
+        self._record_r17_commitment(text or "")
         _logger.info("[R17 %s] promise detected; window open %d", mode.upper(), _R17_WINDOW)
 
+    def _record_r17_commitment(self, text: str) -> None:
+        statement = (text or "").strip()
+        if not statement:
+            return
+        try:
+            from db import create_commitment, record_memory_event
+        except Exception:
+            return
+        source_id = hashlib.sha1(
+            f"{self._session_id or ''}|{statement[:800]}".encode("utf-8", errors="ignore"),
+            usedforsecurity=False,
+        ).hexdigest()[:24]
+        memory_event_uid = ""
+        try:
+            event = record_memory_event(
+                event_type="assistant_promise_detected",
+                source_type="commitment",
+                source_id=source_id,
+                session_id=self._session_id or "",
+                actor=self._session_id or "nexo",
+                metadata={"statement": statement[:800], "rule_id": "R17_promise_debt"},
+                raw_ref=f"commitment:{source_id}",
+                confidence=0.72,
+                idempotency_key=f"r17-commitment:{source_id}",
+            )
+            memory_event_uid = str(event.get("event_uid") or "") if isinstance(event, dict) else ""
+        except Exception as exc:  # noqa: BLE001
+            _logger.debug("R17 commitment memory event skipped: %s", exc)
+        try:
+            result = create_commitment(
+                statement=statement,
+                source_type="assistant_text",
+                source_id=source_id,
+                memory_event_uid=memory_event_uid,
+                session_id=self._session_id or "",
+                owner="agent",
+                status="active",
+                confidence=0.72,
+                evidence_ref=f"memory_event:{memory_event_uid}" if memory_event_uid else "",
+                metadata={"rule_id": "R17_promise_debt"},
+            )
+            commitment_id = str(result.get("id") or "")
+            if commitment_id and commitment_id not in self._r17_commitment_ids:
+                self._r17_commitment_ids.append(commitment_id)
+        except Exception as exc:  # noqa: BLE001
+            _logger.debug("R17 commitment create skipped: %s", exc)
+
+    def _mark_r17_commitments_in_progress(self, tool_name: str) -> None:
+        if not self._r17_commitment_ids:
+            return
+        try:
+            from db import update_commitment_status
+        except Exception:
+            return
+        for commitment_id in list(self._r17_commitment_ids)[-5:]:
+            try:
+                update_commitment_status(
+                    commitment_id,
+                    status="in_progress",
+                    evidence_ref=f"tool:{tool_name}",
+                    metadata={"last_tool_seen": tool_name},
+                )
+            except Exception as exc:  # noqa: BLE001
+                _logger.debug("R17 commitment progress update skipped: %s", exc)
+
+    def _resolve_r17_commitments_from_task_close(self, tool_input) -> None:
+        payload = tool_input if isinstance(tool_input, dict) else {}
+        sid = str(payload.get("sid") or self._session_id or "")
+        task_id = str(payload.get("task_id") or "")
+        evidence_text = " ".join(
+            str(payload.get(field) or "")
+            for field in ("evidence", "summary", "change_summary", "outcome_notes", "result", "verification")
+        ).strip()
+        if not sid or not evidence_text:
+            return
+        try:
+            from db import resolve_matching_commitments
+        except Exception:
+            return
+        try:
+            resolve_matching_commitments(
+                session_id=sid,
+                evidence_text=evidence_text,
+                action_ref_type="protocol_task" if task_id else "",
+                action_ref_id=task_id,
+                evidence_ref=f"protocol_task:{task_id}" if task_id else "nexo_task_close",
+                status="fulfilled",
+            )
+        except Exception as exc:  # noqa: BLE001
+            _logger.debug("R17 commitment resolution skipped: %s", exc)
+
     def _advance_r17_window(self, tool_name: str):
         if not self._r17_promise_seen_for_turn:
             return
         if self._r17_first_tool_call_in_window:
             self._r17_first_tool_call_in_window = False
+            self._mark_r17_commitments_in_progress(tool_name)
             return
         self._r17_window_remaining -= 1
         if self._r17_window_remaining > 0:
@@ -2160,6 +2285,7 @@ class HeadlessEnforcer:
         if name == "nexo_task_close":
             self.reset_task_cycle("nexo_task_open")
             self._start_post_close_cooldown()
+            self._resolve_r17_commitments_from_task_close(tool_input)
 
         # v7.7 Gap 1 — autonomous detector for multi_step_task_detected.
         # The event was dispatched by the map but nothing ever raised it.

package/src/hook_guardrails.py

@@ -19,6 +19,11 @@ from plugins.guard import _load_conditioned_learnings, _normalize_path_token
 from protocol_settings import get_protocol_strictness
 from product_mode import core_writes_allowed, is_protected_runtime_core_path
 
+try:
+    from guardrails.minimal_delta import evaluate as _minimal_delta_evaluate
+except Exception:  # pragma: no cover - guardrail must never break the hook import
+    _minimal_delta_evaluate = None
+
 READ_LIKE_TOOLS = {"Read"}
 WRITE_LIKE_TOOLS = {"Edit", "MultiEdit", "Write"}
 DELETE_LIKE_TOOLS = {"Delete"}
@@ -639,6 +644,72 @@ def _extract_touched_files(tool_input) -> list[str]:
     return unique
 
 
+def _minimal_delta_prompt_text(payload: dict, tool_input: dict) -> str:
+    parts: list[str] = []
+    for key in ("prompt", "user_prompt", "context_hint", "user_text"):
+        value = payload.get(key)
+        if isinstance(value, str) and value.strip():
+            parts.append(value.strip())
+    for key in ("prompt", "user_prompt", "context_hint", "user_text"):
+        value = tool_input.get(key)
+        if isinstance(value, str) and value.strip():
+            parts.append(value.strip())
+    tail = payload.get("transcript_tail")
+    if isinstance(tail, list):
+        for item in tail[-6:]:
+            if isinstance(item, str) and item.strip():
+                parts.append(item.strip())
+            elif isinstance(item, dict):
+                text = item.get("text") or item.get("content")
+                if isinstance(text, str) and text.strip():
+                    parts.append(text.strip())
+    return "\n".join(parts)
+
+
+def _read_existing_text(filepath: str) -> str:
+    try:
+        return Path(filepath).read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return ""
+
+
+def _collect_minimal_delta_warning_or_block(payload: dict, *, tool_name: str, files: list[str]) -> dict | None:
+    if _minimal_delta_evaluate is None or tool_name not in {"Edit", "MultiEdit", "Write"}:
+        return None
+    tool_input = payload.get("tool_input")
+    if not isinstance(tool_input, dict):
+        return None
+    prompt_text = _minimal_delta_prompt_text(payload, tool_input)
+    if not prompt_text:
+        return None
+    target_path = str(tool_input.get("file_path") or tool_input.get("path") or (files[0] if files else "")).strip()
+    if not target_path:
+        return None
+
+    if tool_name == "Write":
+        old_text = _read_existing_text(target_path)
+        new_text = str(tool_input.get("content") or "")
+    elif tool_name == "MultiEdit":
+        edits = tool_input.get("edits")
+        if not isinstance(edits, list):
+            return None
+        old_text = "\n".join(str(edit.get("old_string") or "") for edit in edits if isinstance(edit, dict))
+        new_text = "\n".join(str(edit.get("new_string") or "") for edit in edits if isinstance(edit, dict))
+    else:
+        old_text = str(tool_input.get("old_string") or "")
+        new_text = str(tool_input.get("new_string") or "")
+    if not new_text or old_text == new_text:
+        return None
+
+    try:
+        decision = _minimal_delta_evaluate(prompt_text, target_path, old_text, new_text)
+    except Exception:
+        return None
+    if decision.get("decision") not in {"warn", "block"}:
+        return None
+    return decision
+
+
 def _extract_bash_command(tool_input) -> str:
     if not isinstance(tool_input, dict):
         return ""
@@ -1575,6 +1646,39 @@ def process_pre_tool_event(payload: dict) -> dict:
     sid = _resolve_nexo_sid(conn, claude_sid)
     open_task = _find_any_open_task(conn, sid) if sid else None
     warnings: list[dict] = []
+    minimal_delta = _collect_minimal_delta_warning_or_block(
+        payload,
+        tool_name=tool_name,
+        files=files,
+    )
+    if minimal_delta and minimal_delta.get("decision") == "block":
+        return {
+            "ok": True,
+            "session_id": sid,
+            "tool_name": tool_name,
+            "operation": op,
+            "strictness": strictness,
+            "blocks": [
+                {
+                    "file": minimal_delta.get("target_path", ""),
+                    "reason_code": "minimal_delta_scope_creep",
+                    "severity": "error",
+                    "debt_type": "minimal_delta_scope_creep",
+                    "minimal_delta": minimal_delta,
+                }
+            ],
+            "warnings": warnings,
+            "status": "blocked",
+        }
+    if minimal_delta and minimal_delta.get("decision") == "warn":
+        warnings.append(
+            {
+                "file": minimal_delta.get("target_path", ""),
+                "reason_code": "minimal_delta_soft_envelope",
+                "severity": "warn",
+                "minimal_delta": minimal_delta,
+            }
+        )
     legacy_memory_blocks = _collect_legacy_memory_write_blocks(
         conn,
         sid=sid,

package/src/local_context/api.py

@@ -42,6 +42,7 @@ DEFAULT_ROUTER_MAX_CHARS = int(os.environ.get("NEXO_LOCAL_CONTEXT_ROUTER_MAX_CHA
 DEFAULT_MAX_JOB_ATTEMPTS = int(os.environ.get("NEXO_LOCAL_INDEX_MAX_JOB_ATTEMPTS", "3") or "3")
 DEFAULT_SQLITE_BUSY_RETRY_ATTEMPTS = int(os.environ.get("NEXO_LOCAL_CONTEXT_BUSY_RETRY_ATTEMPTS", "5") or "5")
 DEFAULT_SQLITE_BUSY_RETRY_DELAY_SECONDS = float(os.environ.get("NEXO_LOCAL_CONTEXT_BUSY_RETRY_DELAY_SECONDS", "0.35") or "0.35")
+DEFAULT_HYGIENE_QUICK_SCAN_LIMIT = int(os.environ.get("NEXO_LOCAL_INDEX_HYGIENE_QUICK_SCAN_LIMIT", "5000") or "5000")
 INITIAL_INDEX_COMPLETE_KEY = "initial_index_complete"
 INITIAL_INDEX_STARTED_AT_KEY = "initial_index_started_at"
 PERFORMANCE_PROFILE_KEY = "performance_profile"
@@ -1329,8 +1330,20 @@ def _purge_asset_ids(conn, asset_ids: list[str]) -> dict:
     return counts
 
 
-def _privacy_unsafe_asset_ids(conn) -> list[str]:
-    rows = conn.execute("SELECT asset_id, path, privacy_class FROM local_assets").fetchall()
+def _bounded_fetchall(conn, sql: str, params: tuple[Any, ...] = (), *, max_rows: int | None = None) -> tuple[list[Any], bool]:
+    if max_rows is None or max_rows <= 0:
+        return conn.execute(sql, params).fetchall(), False
+    rows = conn.execute(f"{sql} LIMIT ?", (*params, max_rows + 1)).fetchall()
+    truncated = len(rows) > max_rows
+    return rows[:max_rows], truncated
+
+
+def _privacy_unsafe_asset_ids(conn, *, max_rows: int | None = None) -> tuple[list[str], bool]:
+    rows, truncated = _bounded_fetchall(
+        conn,
+        "SELECT asset_id, path, privacy_class FROM local_assets",
+        max_rows=max_rows,
+    )
     override_prefixes = _active_user_override_prefixes_conn(conn)
     unsafe: list[str] = []
     for row in rows:
@@ -1340,30 +1353,40 @@ def _privacy_unsafe_asset_ids(conn) -> list[str]:
             continue
         if should_skip_file(path) or privacy_class in {"private_profile_blocked", "system_blocked", "sensitive_inventory_only"}:
             unsafe.append(str(row["asset_id"]))
-    return unsafe
+    return unsafe, truncated
 
 
-def _privacy_unsafe_dir_ids(conn) -> list[str]:
-    rows = conn.execute("SELECT dir_id, path FROM local_index_dirs").fetchall()
+def _privacy_unsafe_dir_ids(conn, *, max_rows: int | None = None) -> tuple[list[str], bool]:
+    rows, truncated = _bounded_fetchall(
+        conn,
+        "SELECT dir_id, path FROM local_index_dirs",
+        max_rows=max_rows,
+    )
     override_prefixes = _active_user_override_prefixes_conn(conn)
-    return [
+    unsafe = [
         str(row["dir_id"])
         for row in rows
         if should_skip_tree(str(row["path"] or "")) and not _path_under_any_prefix(str(row["path"] or ""), override_prefixes)
     ]
+    return unsafe, truncated
 
 
-def _content_secret_asset_ids(conn) -> list[str]:
-    rows = conn.execute(
-        """
+def _content_secret_asset_ids(conn, *, max_rows: int | None = None) -> tuple[list[str], bool]:
+    sql = """
         SELECT c.asset_id, c.text
         FROM local_chunks c
         JOIN local_assets a ON a.asset_id=c.asset_id
         WHERE a.status='active'
           AND COALESCE(a.privacy_class, 'normal')='normal'
-        ORDER BY c.asset_id, c.chunk_index
-        """
-    ).fetchall()
+    """
+    params: tuple[Any, ...] = ()
+    if max_rows is None or max_rows <= 0:
+        rows = conn.execute(sql + " ORDER BY c.asset_id, c.chunk_index", params).fetchall()
+        truncated = False
+    else:
+        rows = conn.execute(sql + " LIMIT ?", (max_rows + 1,)).fetchall()
+        truncated = len(rows) > max_rows
+        rows = rows[:max_rows]
     secret_ids: set[str] = set()
     for row in rows:
         asset_id = str(row["asset_id"])
@@ -1371,7 +1394,7 @@ def _content_secret_asset_ids(conn) -> list[str]:
             continue
         if contains_secret(str(row["text"] or "")):
             secret_ids.add(asset_id)
-    return sorted(secret_ids)
+    return sorted(secret_ids), truncated
 
 
 def _mark_content_secret_assets(conn, asset_ids: list[str]) -> int:
@@ -1419,12 +1442,21 @@ def _mark_content_secret_assets(conn, asset_ids: list[str]) -> int:
     return len(unique_ids)
 
 
-def local_index_privacy_hygiene(*, fix: bool = False) -> dict:
+def local_index_privacy_hygiene(*, fix: bool = False, quick: bool = False) -> dict:
     conn = _conn()
-    asset_ids = _privacy_unsafe_asset_ids(conn)
-    dir_ids = _privacy_unsafe_dir_ids(conn)
-    content_secret_ids = _content_secret_asset_ids(conn)
-    residue = {"assets": len(asset_ids), "dirs": len(dir_ids), "content_secret_assets": len(content_secret_ids)}
+    max_rows = None if fix or not quick else DEFAULT_HYGIENE_QUICK_SCAN_LIMIT
+    asset_ids, assets_truncated = _privacy_unsafe_asset_ids(conn, max_rows=max_rows)
+    dir_ids, dirs_truncated = _privacy_unsafe_dir_ids(conn, max_rows=max_rows)
+    content_secret_ids, chunks_truncated = _content_secret_asset_ids(conn, max_rows=max_rows)
+    truncated = bool(assets_truncated or dirs_truncated or chunks_truncated)
+    residue = {
+        "assets": len(asset_ids),
+        "dirs": len(dir_ids),
+        "content_secret_assets": len(content_secret_ids),
+        "truncated": truncated,
+        "quick": bool(quick and not fix),
+        "scan_limit": int(max_rows or 0),
+    }
     cleanup = {"assets": 0, "jobs": 0, "errors": 0, "chunks": 0, "embeddings": 0, "entities": 0, "relations": 0, "versions": 0, "dirs": 0, "content_secret_assets": 0}
     if fix:
         cleanup.update(_purge_asset_ids(conn, asset_ids))
@@ -1437,10 +1469,10 @@ def local_index_privacy_hygiene(*, fix: bool = False) -> dict:
         conn.commit()
         if asset_ids or dir_ids or content_secret_ids:
             log_event("warn", "privacy_hygiene_repaired", "Local memory privacy hygiene repaired", cleanup=cleanup)
-    return {"ok": True, "fix": fix, "residue": residue, "cleanup": cleanup}
+    return {"ok": True, "fix": fix, "quick": bool(quick and not fix), "truncated": truncated, "residue": residue, "cleanup": cleanup}
 
 
-def local_index_hygiene(*, fix: bool = False) -> dict:
+def local_index_hygiene(*, fix: bool = False, quick: bool = False) -> dict:
     conn = _conn()
     removed_paths: list[str] = []
     for row in conn.execute("SELECT id, root_path, source, status FROM local_index_roots").fetchall():
@@ -1455,10 +1487,10 @@ def local_index_hygiene(*, fix: bool = False) -> dict:
     if fix:
         cleanup = _purge_removed_root_payloads(conn)
     conn.commit()
-    privacy = local_index_privacy_hygiene(fix=fix)
+    privacy = local_index_privacy_hygiene(fix=fix, quick=quick and not fix)
     if fix and (removed_paths or any(int(cleanup.get(key, 0) or 0) for key in ("assets", "jobs", "errors", "dirs", "checkpoints"))):
         log_event("info", "index_hygiene_repaired", "Local memory index hygiene repaired", roots=[redact_path(path) for path in removed_paths], cleanup=cleanup)
-    return {"ok": True, "fix": fix, "removed_roots": removed_paths, "residue": before, "cleanup": cleanup, "privacy": privacy}
+    return {"ok": True, "fix": fix, "quick": bool(quick and not fix), "removed_roots": removed_paths, "residue": before, "cleanup": cleanup, "privacy": privacy}
 
 
 def repair_index_hygiene() -> dict: