nexo-brain 7.12.15 → 7.13.5

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.12.15",
+  "version": "7.13.5",
   "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,11 @@
 
 [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.12.15` is the current packaged-runtime line. Patch release — same-version packaged updates now still run the safe maintenance path, Deep Sleep clears process locks on shutdown, sent replies are recorded in durable continuity, and personal script schedule-marker drift is surfaced during reconcile. Result: coordinated Desktop bundles can refresh Brain safely without breaking install/update parity on macOS, Windows via WSL, or Linux.
+Version `7.13.5` is the current packaged-runtime line. Corrective release — D.5 correction-learning enforcement is durable, doctor `--fix` explicitly repairs orphan personal schedule metadata, G5 now warns on protected `com.nexo.*.plist` unload/remove flows with the three-layer recovery path, and Codex now gets a managed `PreToolUse` guard for shell/exec_command calls plus `installation_live.codex_protocol_compliance` drift checks. Result: coordinated Desktop bundles can ship the fixed Brain without changing the Mac/Windows installation contract.
+
+Previously in `7.13.3`: unified release — doctor now repairs orphan personal script metadata and ignores historical `versions/**` snapshots, `nexo update` prunes runtime snapshots older than two back, protocol compliance self-heals missing task-open/change-log/stale-session gaps, headless automation uses bounded timeouts, Guardian false positives are tightened, and Codex CLI config/default checks are release-gated. Result: coordinated Desktop bundles can ship the new Brain without changing the Mac/Windows installation contract.
+
+Previously in `7.12.15`: patch release — same-version packaged updates now still run the safe maintenance path, Deep Sleep clears process locks on shutdown, sent replies are recorded in durable continuity, and personal script schedule-marker drift is surfaced during reconcile. Result: coordinated Desktop bundles can refresh Brain safely without breaking install/update parity on macOS, Windows via WSL, or Linux.
 
 Previously in `7.12.0`: minor release — adds `nexo support-snapshot` for generic local runtime diagnostics and completes the silent-reminder hardening on the live Protocol Enforcer path. The support collector emits one JSON bundle with version/platform metadata, runtime path presence, health-check output, and recent event/operation tails, while map-driven reminders (`nexo_startup`, `nexo_smart_startup`, `nexo_heartbeat`, `nexo_reminders`, `nexo_session_diary_*`, `nexo_stop`, `nexo_task_close`, compaction checkpoint prompts) now say explicitly that silence owns the entire reminder turn.
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "nexo-brain",
-  "version": "7.12.15",
+  "version": "7.13.5",
   "mcpName": "io.github.wazionapps/nexo",
-  "description": "NEXO Brain \u2014 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.",
+  "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",
   "bin": {
     "nexo-brain": "bin/nexo-brain.js",

package/src/auto_close_sessions.py

@@ -152,6 +152,36 @@ def promote_draft_to_diary(sid: str, draft: dict, task: str = ""):
     delete_diary_draft(sid)
 
 
+def auto_close_open_protocol_tasks(conn, sid: str, task: str = "") -> list[str]:
+    """Close stale open protocol tasks as partial when their session is reaped."""
+    rows = conn.execute(
+        """SELECT task_id, goal
+           FROM protocol_tasks
+           WHERE session_id = ? AND status = 'open'
+           ORDER BY opened_at ASC""",
+        (sid,),
+    ).fetchall()
+    closed: list[str] = []
+    for row in rows:
+        task_id = row["task_id"]
+        goal = str(row["goal"] or "")
+        evidence = (
+            f"Auto-closed as partial because session {sid} became stale before an explicit nexo_task_close. "
+            f"Session task: {task or 'unknown'}. Open goal: {goal[:240]}"
+        )
+        conn.execute(
+            """UPDATE protocol_tasks
+               SET status = 'partial',
+                   close_evidence = ?,
+                   outcome_notes = 'auto-close: stale session ended without explicit task_close',
+                   closed_at = datetime('now')
+               WHERE task_id = ? AND status = 'open'""",
+            (evidence[:4000], task_id),
+        )
+        closed.append(task_id)
+    return closed
+
+
 def main():
     init_db()
     conn = get_db()
@@ -161,9 +191,12 @@ def main():
         print(f"[{datetime.datetime.now().isoformat(timespec='seconds')}] No stale sessions")
         return
 
+    closed_task_ids: list[str] = []
     for session in orphans:
         sid = session["sid"]
         draft = get_diary_draft(sid)
+        closed_tasks = auto_close_open_protocol_tasks(conn, sid, task=session.get("task", ""))
+        closed_task_ids.extend(closed_tasks)
 
         if draft:
             promote_draft_to_diary(sid, draft, task=session.get("task", ""))
@@ -196,7 +229,10 @@ def main():
     os.makedirs(os.path.dirname(AUTO_CLOSE_LOG), exist_ok=True)
     with open(AUTO_CLOSE_LOG, "a") as f:
         ts = datetime.datetime.now().isoformat(timespec="seconds")
-        f.write(f"{ts} — auto-closed {len(orphans)} session(s): {[s['sid'] for s in orphans]}\n")
+        f.write(
+            f"{ts} — auto-closed {len(orphans)} session(s): {[s['sid'] for s in orphans]} "
+            f"and {len(closed_task_ids)} protocol task(s): {closed_task_ids}\n"
+        )
 
 
 if __name__ == "__main__":

package/src/client_sync.py

@@ -527,6 +527,11 @@ def _codex_config_path(home: Path | None = None) -> Path:
     return base / ".codex" / "config.toml"
 
 
+def _codex_hooks_path(home: Path | None = None) -> Path:
+    base = home or _user_home()
+    return base / ".codex" / "hooks.json"
+
+
 def _toml_key(key: str) -> str:
     if key.replace("_", "").replace("-", "").isalnum():
         return key
@@ -632,6 +637,12 @@ def _sync_codex_managed_config(
     if "reasoning_effort" in runtime_profile:
         payload["model_reasoning_effort"] = runtime_profile.get("reasoning_effort") or ""
 
+    features = payload.setdefault("features", {})
+    if isinstance(features, dict):
+        features["codex_hooks"] = True
+    else:
+        payload["features"] = {"codex_hooks": True}
+
     payload["initial_messages"] = [
         {
             "role": "system",
@@ -643,6 +654,7 @@ def _sync_codex_managed_config(
     codex_table = nexo_table.setdefault("codex", {})
     codex_table["bootstrap_managed"] = True
     codex_table["mcp_managed"] = True
+    codex_table["hooks_managed"] = True
     codex_table["bootstrap_bytes"] = len(bootstrap_prompt.encode("utf-8")) if bootstrap_prompt else 0
     if runtime_profile.get("model"):
         # Record the healed/actual model in use, not the raw (possibly Claude) profile.
@@ -670,11 +682,127 @@ def _sync_codex_managed_config(
         "path": str(path),
         "bootstrap_managed": True,
         "mcp_managed": True,
+        "hooks_enabled": True,
         "model": runtime_profile.get("model", ""),
         "reasoning_effort": runtime_profile.get("reasoning_effort", "") or "",
     }
 
 
+CODEX_SUPPORTED_HOOK_EVENTS = {"PreToolUse"}
+CODEX_PRETOOL_MATCHER = r"^(Bash|shell_command|exec_command)$"
+
+
+def _codex_core_hook_specs(runtime_root: Path) -> list[dict]:
+    specs: list[dict] = []
+    for spec in _core_hook_specs(runtime_root):
+        if spec.get("event") not in CODEX_SUPPORTED_HOOK_EVENTS:
+            continue
+        item = dict(spec)
+        if item.get("event") == "PreToolUse":
+            item["matcher"] = CODEX_PRETOOL_MATCHER
+            item["statusMessage"] = "NEXO guard"
+        specs.append(item)
+    return specs
+
+
+def _merge_codex_hooks(existing_hooks, *, runtime_root: Path, nexo_home: Path) -> tuple[dict, int]:
+    hooks_payload = dict(existing_hooks) if isinstance(existing_hooks, dict) else {}
+    hooks_dir = _resolve_hook_source_dir(runtime_root)
+    managed_count = 0
+    core_hook_specs = _codex_core_hook_specs(runtime_root)
+    current_identities_by_event = _current_core_hook_identities_by_event(core_hook_specs)
+    managed_identities_by_event = _managed_core_hook_identities_by_event(current_identities_by_event)
+
+    for event, managed_identities in managed_identities_by_event.items():
+        sections = _normalize_hook_sections(hooks_payload.get(event))
+        desired_identities = current_identities_by_event.get(event, set())
+        cleaned_sections: list[dict] = []
+        for section in sections:
+            cleaned_hooks = []
+            for hook in section["hooks"]:
+                identity = _hook_identity(hook.get("command", ""))
+                if identity in managed_identities and identity not in desired_identities:
+                    continue
+                cleaned_hooks.append(hook)
+            if cleaned_hooks:
+                cleaned_sections.append(
+                    {
+                        "matcher": section.get("matcher", "*") or "*",
+                        "hooks": cleaned_hooks,
+                    }
+                )
+        if cleaned_sections:
+            hooks_payload[event] = cleaned_sections
+        elif event in hooks_payload and event in current_identities_by_event:
+            hooks_payload.pop(event, None)
+
+    for spec in core_hook_specs:
+        event = spec["event"]
+        sections = _normalize_hook_sections(hooks_payload.get(event))
+        hooks_payload[event] = sections
+        command = _render_hook_command(spec, nexo_home=nexo_home, runtime_root=runtime_root, hooks_dir=hooks_dir)
+        identity = spec["identity"]
+        matcher = spec.get("matcher") or "*"
+
+        found = False
+        for section in sections:
+            for hook in section["hooks"]:
+                if _hook_identity(hook.get("command", "")) != identity:
+                    continue
+                section["matcher"] = matcher
+                hook["type"] = "command"
+                hook["command"] = command
+                if spec.get("timeout"):
+                    hook["timeout"] = spec["timeout"]
+                if spec.get("statusMessage"):
+                    hook["statusMessage"] = spec["statusMessage"]
+                found = True
+                managed_count += 1
+                break
+            if found:
+                break
+
+        if found:
+            continue
+
+        target = None
+        for section in sections:
+            if section.get("matcher", "*") == matcher:
+                target = section
+                break
+        if target is None:
+            target = {"matcher": matcher, "hooks": []}
+            sections.append(target)
+
+        new_hook = {"type": "command", "command": command}
+        if spec.get("timeout"):
+            new_hook["timeout"] = spec["timeout"]
+        if spec.get("statusMessage"):
+            new_hook["statusMessage"] = spec["statusMessage"]
+        target["hooks"].append(new_hook)
+        managed_count += 1
+
+    return hooks_payload, managed_count
+
+
+def _sync_codex_hooks(path: Path, *, runtime_root: Path, nexo_home: Path) -> dict:
+    payload = _load_json_object(path)
+    action = "updated" if payload else "created"
+    payload["hooks"], managed_count = _merge_codex_hooks(
+        payload.get("hooks", {}),
+        runtime_root=runtime_root,
+        nexo_home=nexo_home,
+    )
+    _write_json_object(path, payload)
+    return {
+        "ok": True,
+        "action": action,
+        "path": str(path),
+        "managed_hook_count": managed_count,
+        "pretool_matcher": CODEX_PRETOOL_MATCHER,
+    }
+
+
 def _load_json_object(path: Path) -> dict:
     if not path.is_file():
         return {}
@@ -1187,6 +1315,7 @@ def sync_codex(
     )
     codex_bin = shutil.which("codex")
     config_path = _codex_config_path(home_path)
+    hooks_path = _codex_hooks_path(home_path)
     if not codex_bin:
         result = {
             "ok": True,
@@ -1210,6 +1339,11 @@ def sync_codex(
                 runtime_profile=runtime_profile,
                 server_config=server_config,
             )
+            result["hooks"] = _sync_codex_hooks(
+                hooks_path,
+                runtime_root=Path(runtime_root).expanduser() if runtime_root else _resolve_runtime_root(nexo_home_path),
+                nexo_home=nexo_home_path,
+            )
         return result
 
     cmd = [codex_bin, "mcp", "add", "nexo"]
@@ -1248,6 +1382,11 @@ def sync_codex(
         runtime_profile=runtime_profile,
         server_config=server_config,
     )
+    sync_result["hooks"] = _sync_codex_hooks(
+        hooks_path,
+        runtime_root=Path(runtime_root).expanduser() if runtime_root else _resolve_runtime_root(nexo_home_path),
+        nexo_home=nexo_home_path,
+    )
     if result.returncode != 0:
         sync_result["warning"] = (result.stderr or result.stdout or "codex mcp add failed").strip()
     return sync_result

package/src/db/__init__.py

@@ -169,6 +169,9 @@ from db._protocol import (
     create_protocol_task, get_protocol_task, close_protocol_task,
     set_protocol_task_guard_acknowledged,
     create_protocol_debt, resolve_protocol_debts, list_protocol_debts,
+    record_session_correction_requirement, list_session_correction_requirements,
+    session_has_open_correction_requirement, resolve_session_correction_requirements,
+    correction_requirement_summary,
     protocol_compliance_summary,
     create_cortex_evaluation, get_cortex_evaluation, list_cortex_evaluations,
     cortex_evaluation_summary,

package/src/db/_protocol.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 """NEXO DB — Protocol discipline runtime."""
 
 import json
+import hashlib
 import secrets
 import time
 
@@ -34,6 +35,12 @@ def _row_to_dict(row):
     return dict(row) if row else None
 
 
+def _correction_context_hash(session_id: str, text: str) -> str:
+    clean = " ".join(str(text or "").strip().split())[:1200]
+    digest = hashlib.sha1(f"{session_id.strip()}\0{clean}".encode("utf-8"), usedforsecurity=False)
+    return digest.hexdigest()[:20]
+
+
 def validate_task_type(task_type: str) -> str:
     clean_type = (task_type or "").strip()
     if clean_type not in VALID_TASK_TYPES:
@@ -529,6 +536,155 @@ def list_protocol_debts(
     return [dict(row) for row in rows]
 
 
+def record_session_correction_requirement(
+    session_id: str,
+    correction_text: str,
+    *,
+    source: str = "heartbeat",
+) -> dict:
+    """Persist that a detected user correction requires a learning_add."""
+    conn = get_db()
+    clean_sid = str(session_id or "").strip()
+    if not clean_sid:
+        return {"ok": False, "error": "session_id is required"}
+    clean_text = " ".join(str(correction_text or "").strip().split())
+    context_hash = _correction_context_hash(clean_sid, clean_text)
+    conn.execute(
+        """INSERT OR IGNORE INTO session_correction_requirements
+           (session_id, context_hash, correction_text, source)
+           VALUES (?, ?, ?, ?)""",
+        (clean_sid, context_hash, clean_text[:4000], str(source or "heartbeat").strip()[:80]),
+    )
+    conn.commit()
+    row = conn.execute(
+        """SELECT *
+           FROM session_correction_requirements
+           WHERE session_id = ? AND context_hash = ?
+           LIMIT 1""",
+        (clean_sid, context_hash),
+    ).fetchone()
+    out = _row_to_dict(row) or {}
+    out["ok"] = True
+    return out
+
+
+def list_session_correction_requirements(
+    *,
+    session_id: str = "",
+    status: str = "open",
+    limit: int = 50,
+) -> list[dict]:
+    conn = get_db()
+    clauses: list[str] = []
+    params: list[object] = []
+    if session_id:
+        clauses.append("session_id = ?")
+        params.append(str(session_id).strip())
+    if status:
+        clauses.append("status = ?")
+        params.append(str(status).strip())
+    where = f"WHERE {' AND '.join(clauses)}" if clauses else ""
+    rows = conn.execute(
+        f"""SELECT *
+            FROM session_correction_requirements
+            {where}
+            ORDER BY detected_at DESC, id DESC
+            LIMIT ?""",
+        params + [max(1, int(limit or 50))],
+    ).fetchall()
+    return [dict(row) for row in rows]
+
+
+def session_has_open_correction_requirement(session_id: str) -> bool:
+    if not str(session_id or "").strip():
+        return False
+    conn = get_db()
+    row = conn.execute(
+        """SELECT 1
+           FROM session_correction_requirements
+           WHERE session_id = ? AND status = 'open'
+           LIMIT 1""",
+        (str(session_id).strip(),),
+    ).fetchone()
+    return bool(row)
+
+
+def resolve_session_correction_requirements(
+    *,
+    session_id: str = "",
+    learning_id: int | None = None,
+) -> int:
+    """Resolve open correction requirements after a real learning_add."""
+    conn = get_db()
+    clean_sid = str(session_id or "").strip()
+    if not clean_sid:
+        rows = conn.execute(
+            """SELECT session_id, COUNT(*) AS total
+               FROM session_correction_requirements
+               WHERE status = 'open'
+               GROUP BY session_id
+               ORDER BY MAX(detected_at) DESC"""
+        ).fetchall()
+        if len(rows) == 1:
+            clean_sid = str(rows[0]["session_id"] or "").strip()
+        else:
+            try:
+                row = conn.execute(
+                    """SELECT r.session_id
+                       FROM session_correction_requirements r
+                       LEFT JOIN sessions s ON s.sid = r.session_id
+                       WHERE r.status = 'open'
+                       ORDER BY COALESCE(s.last_heartbeat_ts, s.last_update_epoch, s.started_epoch, 0) DESC,
+                                r.detected_at DESC
+                       LIMIT 1"""
+                ).fetchone()
+            except Exception:
+                row = None
+            clean_sid = str(row["session_id"] or "").strip() if row else ""
+        if not clean_sid:
+            return 0
+    cursor = conn.execute(
+        """UPDATE session_correction_requirements
+           SET status = 'resolved',
+               resolved_at = datetime('now'),
+               resolved_learning_id = ?
+           WHERE session_id = ? AND status = 'open'""",
+        (int(learning_id) if learning_id else None, clean_sid),
+    )
+    conn.commit()
+    if cursor.rowcount:
+        resolve_protocol_debts(
+            session_id=clean_sid,
+            debt_types=["missing_learning_after_correction"],
+            resolution=f"Learning #{learning_id} persisted after user correction.",
+        )
+    return int(cursor.rowcount or 0)
+
+
+def correction_requirement_summary(session_id: str = "") -> dict:
+    conn = get_db()
+    clauses: list[str] = []
+    params: list[object] = []
+    if session_id:
+        clauses.append("session_id = ?")
+        params.append(str(session_id).strip())
+    where = f"WHERE {' AND '.join(clauses)}" if clauses else ""
+    rows = conn.execute(
+        f"""SELECT status, COUNT(*) AS total
+            FROM session_correction_requirements
+            {where}
+            GROUP BY status"""
+    ).fetchall()
+    counts = {str(row["status"]): int(row["total"] or 0) for row in rows}
+    return {
+        "session_id": str(session_id or "").strip(),
+        "corrections_detected": sum(counts.values()),
+        "learnings_persisted": counts.get("resolved", 0),
+        "open_requirements": counts.get("open", 0),
+        "by_status": counts,
+    }
+
+
 def protocol_compliance_summary(days: int = 7) -> dict:
     conn = get_db()
     window = f"-{max(1, int(days))} days"

package/src/db/_schema.py

@@ -923,6 +923,28 @@ def _m55_cortex_critique_trace(conn):
     _migrate_add_column(conn, "cortex_evaluations", "decision_mode", "TEXT DEFAULT 'heuristic'")
 
 
+def _m56_session_correction_requirements(conn):
+    """Track user corrections that must be turned into durable learnings."""
+    conn.execute(
+        """CREATE TABLE IF NOT EXISTS session_correction_requirements (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT NOT NULL,
+            context_hash TEXT NOT NULL,
+            correction_text TEXT DEFAULT '',
+            source TEXT DEFAULT 'heartbeat',
+            status TEXT NOT NULL DEFAULT 'open',
+            detected_at TEXT DEFAULT (datetime('now')),
+            resolved_at TEXT DEFAULT NULL,
+            resolved_learning_id INTEGER DEFAULT NULL,
+            followup_id TEXT DEFAULT '',
+            UNIQUE(session_id, context_hash)
+        )"""
+    )
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_session_correction_requirements_session ON session_correction_requirements(session_id)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_session_correction_requirements_status ON session_correction_requirements(status)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_session_correction_requirements_detected ON session_correction_requirements(detected_at)")
+
+
 def _m39_hook_runs(conn):
     """Persist hook lifecycle observability — closes Fase 3 item 7.
 
@@ -1494,6 +1516,7 @@ MIGRATIONS = [
     (53, "session_conversation_identity", _m53_session_conversation_identity),
     (54, "continuity_snapshots", _m54_continuity_snapshots),
     (55, "cortex_critique_trace", _m55_cortex_critique_trace),
+    (56, "session_correction_requirements", _m56_session_correction_requirements),
 ]