nexo-brain 7.27.3 → 7.27.6

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:

package/src/plugins/protocol.py

@@ -61,6 +61,13 @@ R03_TRIVIAL_EVIDENCE_PATTERN = re.compile(
     r"terminado|arreglado|cerrado|solved|resuelto)\s*[\.!]*\s*$",
     re.IGNORECASE,
 )
+P0_P1_FINDING_PATTERN = re.compile(
+    r"^\s*(?:#{1,6}\s+|[-*+]\s+|\d+[.)]\s+)?(?:\*\*)?"
+    r"(P[01])(?:\*\*)?\s*(?:[:\-–—\])\)]|\b)",
+    re.IGNORECASE,
+)
+FOLLOWUP_REF_PATTERN = re.compile(r"\bNF-[A-Z0-9][A-Z0-9-]*\b", re.IGNORECASE)
+ANALYZE_ARTIFACT_SUFFIXES = {".md", ".markdown", ".txt"}
 
 
 def _is_trivial_evidence(text: str) -> tuple[bool, str]:
@@ -85,6 +92,54 @@ def _is_trivial_evidence(text: str) -> tuple[bool, str]:
     return False, ""
 
 
+def _existing_analyze_artifact_paths(refs: list[str]) -> list[Path]:
+    paths_found: list[Path] = []
+    seen: set[str] = set()
+    for ref in refs:
+        clean = str(ref or "").strip()
+        if not clean or clean.lower().startswith("followup_id"):
+            continue
+        if ":" in clean and not clean.startswith("/"):
+            prefix, value = clean.split(":", 1)
+            if prefix.strip().lower() in {"file", "path", "artifact", "report"}:
+                clean = value.strip()
+        candidate = Path(os.path.expanduser(clean))
+        if not candidate.is_file() or candidate.suffix.lower() not in ANALYZE_ARTIFACT_SUFFIXES:
+            continue
+        resolved = str(candidate.resolve())
+        if resolved in seen:
+            continue
+        seen.add(resolved)
+        paths_found.append(candidate)
+    return paths_found
+
+
+def _count_p0_p1_findings(paths_found: list[Path]) -> tuple[int, list[dict]]:
+    total = 0
+    artifacts: list[dict] = []
+    for path in paths_found:
+        findings = 0
+        try:
+            with path.open("r", encoding="utf-8", errors="replace") as fh:
+                for line in fh:
+                    if P0_P1_FINDING_PATTERN.search(line):
+                        findings += 1
+        except OSError:
+            continue
+        if findings:
+            total += findings
+            artifacts.append({"path": str(path), "findings": findings})
+    return total, artifacts
+
+
+def _count_followup_refs(refs: list[str]) -> int:
+    seen: set[str] = set()
+    for ref in refs:
+        for match in FOLLOWUP_REF_PATTERN.findall(str(ref or "")):
+            seen.add(match.upper())
+    return len(seen)
+
+
 def _external_real_world_text(task: dict, *parts: str) -> str:
     fields = [
         task.get("goal", ""),
@@ -1493,6 +1548,7 @@ def handle_task_close(
     if extra_refs:
         refs_line = "Evidence refs: " + ", ".join(extra_refs)
         clean_evidence = f"{clean_evidence}\n{refs_line}".strip() if clean_evidence else refs_line
+    all_evidence_refs = [*_parse_list(task.get("evidence_refs") or "[]"), *extra_refs]
     files_changed_list = _parse_list(files_changed)
     planned_files = _parse_list(task.get("files") or "[]")
     effective_files = files_changed_list or planned_files
@@ -1508,6 +1564,46 @@ def handle_task_close(
         high_stakes=bool(task.get("response_high_stakes")),
     )
 
+    if (task.get("task_type") or "").strip() == "analyze" and clean_outcome == "done":
+        artifact_paths = _existing_analyze_artifact_paths(all_evidence_refs)
+        finding_count, finding_artifacts = _count_p0_p1_findings(artifact_paths)
+        followup_ref_count = _count_followup_refs(all_evidence_refs)
+        if finding_count > followup_ref_count:
+            missing = finding_count - followup_ref_count
+            debt = _ensure_open_debt(
+                task["session_id"],
+                task_id,
+                "analyze_p0_p1_followups_missing",
+                severity="error",
+                evidence=(
+                    f"Analyze task produced {finding_count} P0/P1 finding(s) in report artifact(s) "
+                    f"but evidence_refs only contained {followup_ref_count} followup id(s); "
+                    f"{missing} actionable finding(s) would be left without durable followup. "
+                    f"Artifacts: {json.dumps(finding_artifacts, ensure_ascii=False)}"
+                ),
+                debts=debts_created,
+            )
+            return json.dumps(
+                {
+                    "ok": False,
+                    "error": "Cannot close analyze task as 'done' while P0/P1 report findings lack followup refs.",
+                    "hint": (
+                        "Create one followup for each P0/P1 finding and pass those followup IDs in evidence_refs, "
+                        "then retry nexo_task_close."
+                    ),
+                    "task_id": task_id,
+                    "blocked_by": "analyze_p0_p1_followup_gate",
+                    "debt_id": debt.get("id"),
+                    "debt_type": "analyze_p0_p1_followups_missing",
+                    "findings": finding_count,
+                    "followup_refs": followup_ref_count,
+                    "missing_followups": missing,
+                    "artifacts": finding_artifacts,
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+
     pending_corrections = list_session_correction_requirements(
         session_id=task["session_id"],
         status="open",