nexo-brain 7.31.13 → 7.32.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.31.13",
+  "version": "7.32.0",
   "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,7 @@
 
 [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.31.13` is the current packaged-runtime line. Patch release over v7.31.12 - the offline wheel bundle no longer hard-pins onnxruntime, so cross-platform/offline installs (including older Linux) resolve a compatible native wheel instead of failing. Version `7.31.11` was a patch release over v7.31.10 - MCP lifecycle robustness + guardrail precision.
+Version `7.32.0` is the current packaged-runtime line. Minor release - Cognitive OS Ola 1: the causal/provenance graph now populates from every evidence-backed task close (the connect-the-dots substrate that was previously empty), and abandoned durable workflows are reaped so the cross-session resume surface stays clean. Bundles the 7.31.14 critical fixes (cron-fleet drift guard, deterministic spreading-activation id, real guard_context evidence, auto error->learning capture, fulfillable confidence-check gate, approval-paused workflow resume).
 
 Previously in `7.31.9`: patch release over v7.31.8 - UI release closeout now has to prove the original reported symptom was reopened with observable evidence before claiming the release is ready.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.31.13",
+  "version": "7.32.0",
   "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/auto_close_sessions.py

@@ -182,6 +182,43 @@ def auto_close_open_protocol_tasks(conn, sid: str, task: str = "") -> list[str]:
     return closed
 
 
+def auto_close_abandoned_workflow_runs(conn, sid: str) -> dict:
+    """Reap durable workflow_runs / workflow_goals abandoned by a stale session.
+
+    auto_close only reaped protocol_tasks; a session that opened a durable
+    workflow_run / workflow_goal and never closed it left a zombie 'running'
+    row forever, polluting the resume surface (M10 gap). Move non-terminal ones
+    to a terminal state when their owning session is reaped. closed_at/updated_at
+    use datetime('now') to match the workflow tables' timestamp format.
+    """
+    note = "auto-close: stale session ended without explicit workflow close"
+    runs = conn.execute(
+        "SELECT run_id FROM workflow_runs "
+        "WHERE session_id = ? AND status IN ('open','running','blocked','waiting_approval')",
+        (sid,),
+    ).fetchall()
+    for row in runs:
+        conn.execute(
+            "UPDATE workflow_runs SET status='cancelled', next_action=?, "
+            "closed_at=datetime('now'), updated_at=datetime('now') "
+            "WHERE run_id=? AND status IN ('open','running','blocked','waiting_approval')",
+            (note, row["run_id"]),
+        )
+    goals = conn.execute(
+        "SELECT goal_id FROM workflow_goals "
+        "WHERE session_id = ? AND status IN ('active','blocked')",
+        (sid,),
+    ).fetchall()
+    for row in goals:
+        conn.execute(
+            "UPDATE workflow_goals SET status='abandoned', blocker_reason=?, "
+            "closed_at=datetime('now'), updated_at=datetime('now') "
+            "WHERE goal_id=? AND status IN ('active','blocked')",
+            (note, row["goal_id"]),
+        )
+    return {"runs": len(runs), "goals": len(goals)}
+
+
 def main():
     init_db()
     conn = get_db()
@@ -197,6 +234,7 @@ def main():
         draft = get_diary_draft(sid)
         closed_tasks = auto_close_open_protocol_tasks(conn, sid, task=session.get("task", ""))
         closed_task_ids.extend(closed_tasks)
+        auto_close_abandoned_workflow_runs(conn, sid)
 
         if draft:
             promote_draft_to_diary(sid, draft, task=session.get("task", ""))

package/src/cognitive/_search.py

@@ -784,8 +784,19 @@ CO_ACTIVATION_MIN_STRENGTH = 0.1
 
 
 def _canonical_co_id(store: str, mid: int) -> int:
-    """Create a canonical hash ID for co-activation tracking."""
-    return hash(f"{store}:{mid}") % (2**31)
+    """Create a canonical, PROCESS-STABLE hash ID for co-activation tracking.
+
+    MUST be deterministic across processes. Python's builtin hash() is salted
+    per process (PYTHONHASHSEED), so co-activation links written in one MCP
+    process never matched the same memory's id in the next — fragmenting the
+    associative graph (observed ~6x distinct ids per memory) and silently
+    degrading spreading activation to within-a-single-process-lifetime. blake2b
+    is stable across processes and runs.
+    """
+    import hashlib
+
+    digest = hashlib.blake2b(f"{store}:{mid}".encode("utf-8"), digest_size=8).digest()
+    return int.from_bytes(digest, "big") % (2**31)
 
 
 def record_co_activation(memory_ids: list[tuple[str, int]]):

package/src/crons/sync.py

@@ -727,13 +727,18 @@ def install_plist(label: str, plist: dict, plist_path: Path, dry_run: bool):
         log(f"  DRY-RUN: would install {plist_path.name}")
         return
 
-    with open(plist_path, "wb") as f:
-        plistlib.dump(plist, f)
-
+    # Ephemeral/test runtimes (temp NEXO_HOME or HOME, e.g. a pytest run) must
+    # NOT touch the operator's real ~/Library/LaunchAgents. The guard is checked
+    # BEFORE writing the plist file: otherwise a test run rewrites the real
+    # plists with temp-dir ProgramArguments, and one reboot/reload silently
+    # kills the whole consolidation cron fleet (cron-fleet-drift incident).
     if not launchctl_side_effects_allowed():
-        log(f"  Installed but skipped launchctl in ephemeral runtime: {plist_path.name}")
+        log(f"  Skipped plist write in ephemeral runtime: {plist_path.name}")
         return
 
+    with open(plist_path, "wb") as f:
+        plistlib.dump(plist, f)
+
     result = reload_launchagent_plist(plist_path, label=label)
     if result.get("action") == "skipped-ephemeral-runtime":
         log(f"  Installed but skipped launchctl in ephemeral runtime: {plist_path.name}")
@@ -751,8 +756,8 @@ def unload_plist(plist_path: Path, dry_run: bool):
         return
 
     if not launchctl_side_effects_allowed():
-        plist_path.unlink(missing_ok=True)
-        log(f"  Removed without launchctl in ephemeral runtime: {plist_path.name}")
+        # Ephemeral/test runtime: never delete the operator's real plists.
+        log(f"  Skipped plist removal in ephemeral runtime: {plist_path.name}")
         return
 
     result = unload_launchagent_plist(plist_path)
@@ -830,7 +835,9 @@ def sync(dry_run: bool = False):
         return
 
     LOG_DIR.mkdir(parents=True, exist_ok=True)
-    LAUNCH_AGENTS_DIR.mkdir(parents=True, exist_ok=True)
+    # In an ephemeral/test runtime, do not even create the real LaunchAgents dir.
+    if launchctl_side_effects_allowed():
+        LAUNCH_AGENTS_DIR.mkdir(parents=True, exist_ok=True)
 
     manifest_crons = load_manifest()
     manifest_ids = {c["id"] for c in manifest_crons}

package/src/db/_schema.py

@@ -3081,6 +3081,37 @@ def _m81_core_rules_product_metadata(conn):
     conn.execute("CREATE INDEX IF NOT EXISTS idx_core_rules_protected ON core_rules(protected, is_active)")
 
 
+def _m82_confidence_checks(conn):
+    """Persist nexo_confidence_check calls so the answer-contract gate works.
+
+    The G1 enforcer (hooks/g1_enforcer.py) treats a verify/ask/defer contract as
+    fulfilled when a confidence_checks row exists for the session created after
+    the task opened. No code ever created or wrote this table, so verify
+    contracts were structurally unfulfillable. handle_confidence_check now writes
+    a row per call; created_at uses datetime('now') to match opened_at format.
+    """
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS confidence_checks (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT,
+            task_id TEXT,
+            goal_hash TEXT,
+            task_type TEXT,
+            area TEXT,
+            response_mode TEXT,
+            confidence INTEGER,
+            high_stakes INTEGER NOT NULL DEFAULT 0,
+            created_at TEXT
+        )
+        """
+    )
+    conn.execute(
+        "CREATE INDEX IF NOT EXISTS idx_confidence_checks_session "
+        "ON confidence_checks(session_id, created_at)"
+    )
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -3163,6 +3194,7 @@ MIGRATIONS = [
     (79, "operational_closure_links_readiness", _m79_operational_closure_links_readiness),
     (80, "opportunity_orchestrator", _m80_opportunity_orchestrator),
     (81, "core_rules_product_metadata", _m81_core_rules_product_metadata),
+    (82, "confidence_checks", _m82_confidence_checks),
 ]
 
 

package/src/hooks/auto_capture.py

@@ -289,7 +289,7 @@ def _content_hash(fact_type: str, content: str) -> str:
 
 
 def _auto_learning_add(title: str, content: str) -> bool:
-    """Best-effort call to tools_learnings.add_learning.
+    """Best-effort call to tools_learnings.handle_learning_add.
 
     Returns True when the learning was stored, False otherwise. Failures
     are silent so the hook itself never breaks the user's prompt flow.
@@ -300,13 +300,19 @@ def _auto_learning_add(title: str, content: str) -> bool:
         return False
 
     try:
-        result = tools_learnings.add_learning(
+        # The public symbol is handle_learning_add. A prior call to a
+        # non-existent tools_learnings.add_learning raised AttributeError that
+        # was swallowed below, so EVERY auto-captured correction silently
+        # failed to persist a learning (error-capture / never-repeat broken).
+        result = tools_learnings.handle_learning_add(
             category="auto",
             title=title,
             content=content,
             priority="medium",
             reasoning="auto-captured from correction pattern in UserPromptSubmit/PostToolUse hook",
         )
+        if isinstance(result, str):
+            return not result.strip().upper().startswith("ERROR")
         if isinstance(result, dict):
             return bool(result.get("ok") or result.get("id") or result.get("learning_id"))
         return bool(result)

package/src/plugins/protocol.py

@@ -1437,6 +1437,7 @@ def handle_confidence_check(
     unknowns: str = "[]",
     verification_step: str = "",
     stakes: str = "",
+    sid: str = "",
 ) -> str:
     """Return the metacognitive response mode: answer, verify, ask, or defer."""
     clean_goal = (goal or "").strip()
@@ -1465,6 +1466,37 @@ def handle_confidence_check(
         verification_step=(verification_step or "").strip(),
         stakes=(stakes or "").strip(),
     )
+    # Persist the check so the G1 answer-contract gate can detect fulfillment of
+    # verify/ask/defer contracts (this table was previously never written, so
+    # verify contracts were structurally unfulfillable). Best-effort: a failure
+    # here must never break the metacognitive answer — g1 simply re-nudges, a
+    # visible signal rather than a silent corruption.
+    try:
+        import hashlib
+        from db import get_db
+        from plugins.guard import _resolve_active_sid
+        conn = get_db()
+        resolved_sid = (sid or "").strip() or _resolve_active_sid(conn)
+        if resolved_sid:
+            conn.execute(
+                """INSERT INTO confidence_checks
+                   (session_id, task_id, goal_hash, task_type, area,
+                    response_mode, confidence, high_stakes, created_at)
+                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))""",
+                (
+                    resolved_sid,
+                    "",
+                    hashlib.sha256(clean_goal.encode("utf-8")).hexdigest()[:16],
+                    clean_type,
+                    (area or "").strip(),
+                    str(result.get("mode") or ""),
+                    int(result.get("confidence") or 0),
+                    1 if result.get("high_stakes") else 0,
+                ),
+            )
+            conn.commit()
+    except Exception:
+        pass
     return json.dumps({"ok": True, **result}, ensure_ascii=False, indent=2)
 
 
@@ -2350,6 +2382,22 @@ def handle_task_close(
                     debt_types=["missing_change_log"],
                     resolution="Change log created by nexo_task_close",
                 )
+                # Cognitive OS Ola 1 — materialize causal/provenance edges from the
+                # closed task (task→change_log "ops:produced" + change_log→task
+                # "causal:motivated_by"). record_task_close_edges had NO caller, so
+                # the causal graph stayed empty (0 candidates) and could never feed
+                # connect-the-dots at answer time. Best-effort: graph wiring must
+                # never break a task close.
+                try:
+                    import causal_graph
+                    causal_graph.record_task_close_edges(
+                        task_id=task_id,
+                        change_log_id=change_log_id,
+                        project_key=str(task.get("project_hint") or task.get("area") or ""),
+                        reason_public=(clean_change_summary or task.get("goal") or "")[:200],
+                    )
+                except Exception:
+                    pass
         else:
             debt = _ensure_open_debt(
                 task["session_id"],

package/src/pre_answer_router.py

@@ -1987,15 +1987,48 @@ def _source_filesystem(request: SourceRequest) -> SourceResult:
 
 
 def _source_guard_context(request: SourceRequest) -> SourceResult:
-    # G01 cannot call the MCP guard from this pure core. Return the file scope
-    # so G15 can wire real guard context without changing the source plan.
-    if not request.files:
+    # Real guard verification: surface the file-conditioned blocking learnings
+    # for the requested files. Previously this returned fake evidence
+    # (evidence_refs=["guard_context:requested"], result_count=1) WITHOUT any
+    # check, which silently satisfied the critical-tier required-source / gap
+    # gate for release/server/billing/legal areas. Never fake evidence again.
+    files = [f.strip() for f in (request.files or "").split(",") if f.strip()]
+    if not files:
         return SourceResult(source="guard_context")
+    try:
+        from db import get_db
+        from plugins.guard import _load_conditioned_learnings
+        conn = get_db()
+        conditioned = _load_conditioned_learnings(conn, files)
+    except Exception:
+        # Fail-closed: do NOT fake evidence; report that verification could not run.
+        return SourceResult(
+            source="guard_context",
+            rendered="Guard verification could not run for: " + ", ".join(files),
+            result_count=0,
+        )
+    refs: list[str] = []
+    lines: list[str] = []
+    for filepath, entries in conditioned.items():
+        for entry in entries:
+            refs.append(f"learning:{entry.get('id')}")
+            lines.append(
+                f"- [{entry.get('priority', 'medium')}] {entry.get('title', '')} (applies_to {filepath})"
+            )
+    if lines:
+        return SourceResult(
+            source="guard_context",
+            rendered="Blocking/file-conditioned learnings:\n" + "\n".join(lines),
+            evidence_refs=refs,
+            result_count=len(refs),
+        )
+    # Guard ran and found nothing blocking — a real verified-clean result.
     return SourceResult(
         source="guard_context",
-        rendered=f"Guard context requested for files: {request.files}",
-        evidence_refs=["guard_context:requested"],
-        result_count=1,
+        rendered="Guard verified: no blocking file-conditioned learnings for "
+        + ", ".join(files),
+        evidence_refs=["guard_context:verified_clean"],
+        result_count=0,
     )
 
 

package/src/tools_sessions.py

@@ -317,7 +317,7 @@ def _session_portability_bundle(sid: str = "") -> dict:
         dict(row) for row in conn.execute(
             """SELECT run_id, goal_id, goal, workflow_kind, status, priority, next_action, current_step_key, updated_at
                FROM workflow_runs
-               WHERE session_id = ? AND status IN ('open', 'running', 'blocked', 'needs_approval')
+               WHERE session_id = ? AND status IN ('open', 'running', 'blocked', 'waiting_approval')
                ORDER BY updated_at DESC
                LIMIT 10""",
             (session_id,),