nexo-brain 7.31.12 → 7.32.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.31.12",
+  "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.12` is the current packaged-runtime line. Patch release over v7.31.11 - Local Memory core hardening (Release A: defensive cosine, stable chunk ids, iCloud dataless handling, performance PRAGMAs) plus an offline-first dependency installer. 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.12",
+  "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/hooks/post_tool_use.py

@@ -415,6 +415,73 @@ def check_production_change_log_closeout(payload: dict, sid: str) -> str | None:
     return append_operator_language_contract(message)
 
 
+_SHARED_MUTATION_TOOLS = {
+    "Edit",
+    "Write",
+    "MultiEdit",
+    "NotebookEdit",
+    "apply_patch",
+    "functions.apply_patch",
+}
+_SHARED_PATH_RE = re.compile(
+    r"("
+    r"/Users/[^ \n\r\t'\"]+/Documents/_PhpstormProjects/|"
+    r"/Users/[^ \n\r\t'\"]+/.nexo/core/|"
+    r"/home/nexodesk/|"
+    r"/var/www/|"
+    r"/public_html/|"
+    r"/httpdocs/"
+    r")",
+    re.IGNORECASE,
+)
+_SCOPE_REQUIRED_MARKERS = {
+    "conversation": re.compile(r"\b(conversation|conversaci[oó]n|hilo|thread|email|ticket|mensaje|message|n/a)\b", re.IGNORECASE),
+    "tenant": re.compile(r"\b(tenant|tienda|shop|cuenta|account|cliente|client|n/a)\b", re.IGNORECASE),
+    "language": re.compile(r"\b(idioma|language|lang|locale|es|en|de|fr|pt|it|ca|n/a)\b", re.IGNORECASE),
+    "environment": re.compile(r"\b(entorno|environment|local|runtime|producto|producci[oó]n|production|prod|staging)\b", re.IGNORECASE),
+    "surface": re.compile(r"\b(superficie|surface|api|ui|dominio|domain|web|public)\b", re.IGNORECASE),
+    "deploy": re.compile(r"\b(deploy|despliegue|publicado|published|release|rama|branch|n/a)\b", re.IGNORECASE),
+}
+
+
+def _payload_scope_text(payload: dict) -> str:
+    try:
+        return json.dumps(_tool_input(payload), ensure_ascii=False)
+    except Exception:
+        return str(_tool_input(payload) or "")
+
+
+def _is_shared_mutation_payload(payload: dict) -> bool:
+    tool_name = _tool_name(payload)
+    cmd = _extract_command(payload)
+    input_text = _payload_scope_text(payload)
+    combined = "\n".join(part for part in (tool_name, cmd, input_text) if part)
+    if tool_name in _SHARED_MUTATION_TOOLS and _SHARED_PATH_RE.search(combined):
+        return True
+    if cmd and (_is_production_mutation_command(cmd) or _SHARED_PATH_RE.search(cmd)):
+        return True
+    return False
+
+
+def check_shared_scope_closeout(payload: dict) -> str | None:
+    if not _is_shared_mutation_payload(payload):
+        return None
+    scope_text = _payload_scope_text(payload)
+    missing = [
+        label
+        for label, pattern in _SCOPE_REQUIRED_MARKERS.items()
+        if not pattern.search(scope_text)
+    ]
+    if not missing:
+        return None
+    message = (
+        "Antes de seguir con este cambio compartido, deja fijado el alcance operativo: "
+        "conversación afectada, tenant/tienda, idiomas, entorno, superficie pública y estado de deploy. "
+        "Si algún campo no aplica, márcalo como N/A y continúa con evidencia."
+    )
+    return append_operator_language_contract(message)
+
+
 def _run_auto_capture(payload: dict) -> int:
     """Pipe the tool result into auto_capture for post-output classification."""
     text = _extract_tool_text(payload)
@@ -484,13 +551,20 @@ def main() -> int:
         sid = _resolve_sid_from_payload(payload)
         reminder = check_inbox_and_emit_reminder(sid)
         change_log_message = check_production_change_log_closeout(payload, sid)
+        shared_scope_message = check_shared_scope_closeout(payload)
         g1_message: str | None = None
         try:
             from g1_enforcer import check_response_contract_gate  # type: ignore
             g1_message = check_response_contract_gate(sid)
         except Exception:
             g1_message = None
-        combined = _combine_system_messages(protocol_message, reminder, change_log_message, g1_message)
+        combined = _combine_system_messages(
+            protocol_message,
+            reminder,
+            change_log_message,
+            shared_scope_message,
+            g1_message,
+        )
         if combined:
             print(json.dumps({"systemMessage": combined}))
     except Exception:

package/src/plugins/protocol.py

@@ -1307,6 +1307,58 @@ PUBLIC_RELEASE_WORK_RE = re.compile(
     re.IGNORECASE,
 )
 HIGH_STAKES_WORK_TYPES = {"release", "deploy", "deployment", "publish", "publicar", "desplegar"}
+VISIBLE_RELEASE_SURFACE_PATTERNS = {
+    "api": (
+        re.compile(r"\bapi\b\s*[:=-]", re.IGNORECASE),
+        re.compile(r"\bendpoint(?:s)?\b\s*[:=-]", re.IGNORECASE),
+        re.compile(r"\bruta(?:s)?\b\s*[:=-]", re.IGNORECASE),
+    ),
+    "ui": (
+        re.compile(r"\bui\b\s*[:=-]", re.IGNORECASE),
+        re.compile(r"\bux\b\s*[:=-]", re.IGNORECASE),
+        re.compile(r"\binterfaz\b\s*[:=-]", re.IGNORECASE),
+        re.compile(r"\bnavegador\b\s*[:=-]", re.IGNORECASE),
+        re.compile(r"\bbrowser\b\s*[:=-]", re.IGNORECASE),
+    ),
+    "dominio_publico": (
+        re.compile(r"\bdominio\s+p[uú]blico\b\s*[:=-]", re.IGNORECASE),
+        re.compile(r"\bpublic\s+domain\b\s*[:=-]", re.IGNORECASE),
+        re.compile(r"\burl\s+p[uú]blica\b\s*[:=-]", re.IGNORECASE),
+        re.compile(r"\bpublic\s+url\b\s*[:=-]", re.IGNORECASE),
+        re.compile(r"https?://[^\s]+", re.IGNORECASE),
+    ),
+    "rama_publicacion": (
+        re.compile(r"\brama\b\s*[:=-]", re.IGNORECASE),
+        re.compile(r"\bbranch\b\s*[:=-]", re.IGNORECASE),
+        re.compile(r"\borigin/(?:main|master|stable|release|gh-pages)\b", re.IGNORECASE),
+        re.compile(r"\bgh-pages\b", re.IGNORECASE),
+    ),
+    "artefactos": (
+        re.compile(r"\bartefacto(?:s)?\b\s*[:=-]", re.IGNORECASE),
+        re.compile(r"\bartifact(?:s)?\b\s*[:=-]", re.IGNORECASE),
+        re.compile(r"\b(?:dmg|exe|zip|image|imagen|cloud\s+build|github\s+release)\b", re.IGNORECASE),
+    ),
+    "manifiestos": (
+        re.compile(r"\bmanifiesto(?:s)?\b\s*[:=-]", re.IGNORECASE),
+        re.compile(r"\bmanifest(?:s)?\b\s*[:=-]", re.IGNORECASE),
+        re.compile(r"\b(?:manifest\.json|update\.json|package\.json|composer\.json)\b", re.IGNORECASE),
+    ),
+    "prueba_viva": (
+        re.compile(r"\bprueba\s+viva\b\s*[:=-]", re.IGNORECASE),
+        re.compile(r"\blive\s+test\b\s*[:=-]", re.IGNORECASE),
+        re.compile(r"\bsmoke\b\s*[:=-]", re.IGNORECASE),
+        re.compile(r"\b(?:curl|playwright|logs?\s+vivos?|gcloud\s+logs|http\s*200|200\s+ok)\b", re.IGNORECASE),
+    ),
+}
+VISIBLE_RELEASE_SURFACE_LABELS = {
+    "api": "API",
+    "ui": "UI",
+    "dominio_publico": "dominio público",
+    "rama_publicacion": "rama de publicación",
+    "artefactos": "artefactos",
+    "manifiestos": "manifiestos",
+    "prueba_viva": "prueba viva",
+}
 
 
 def _normalize_artifact_hash(value: str) -> str:
@@ -1344,6 +1396,15 @@ def _has_public_release_evidence(evidence: str) -> bool:
     return bool(PUBLIC_RELEASE_EVIDENCE_RE.search(evidence or ""))
 
 
+def _missing_visible_release_surfaces(evidence: str) -> list[str]:
+    text = evidence or ""
+    missing: list[str] = []
+    for key, patterns in VISIBLE_RELEASE_SURFACE_PATTERNS.items():
+        if not any(pattern.search(text) for pattern in patterns):
+            missing.append(VISIBLE_RELEASE_SURFACE_LABELS[key])
+    return missing
+
+
 def _active_followup_snapshot(limit: int = 5) -> list[dict]:
     try:
         followups = get_followups("active")
@@ -1376,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()
@@ -1404,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)
 
 
@@ -2289,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"],
@@ -2476,6 +2585,40 @@ def handle_task_close(
             indent=2,
         )
 
+    if clean_outcome == "done" and _is_high_stakes_public_work(task, work_type, stakes, closure_text):
+        missing_surfaces = _missing_visible_release_surfaces(live_surface_evidence)
+        if missing_surfaces:
+            debt = _ensure_open_debt(
+                task["session_id"],
+                task_id,
+                "visible_release_surface_matrix_incomplete",
+                severity="error",
+                evidence=(
+                    "Visible release/deploy/fix close lacked the full evidence matrix. "
+                    f"Missing surfaces: {', '.join(missing_surfaces)}. "
+                    f"Evidence provided: {live_surface_evidence[:240]!r}"
+                ),
+                debts=debts_created,
+            )
+            return json.dumps(
+                {
+                    "ok": False,
+                    "error": "Cannot close visible release/deploy/fix as done without the full surface evidence matrix.",
+                    "hint": (
+                        "Enumerate API, UI, public domain, publication branch, artifacts, manifests, "
+                        "and live test evidence. Use N/A only for a surface that truly does not exist."
+                    ),
+                    "task_id": task_id,
+                    "blocked_by": "visible_release_surface_matrix",
+                    "debt_id": debt.get("id"),
+                    "debt_type": "visible_release_surface_matrix_incomplete",
+                    "missing_surfaces": missing_surfaces,
+                    "response_mode": "verify",
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+
     if task.get("guard_has_blocking") and not files_changed_list:
         open_task_debts = list_protocol_debts(status="open", task_id=task_id, limit=200)
         has_guard_touch_violation = any(

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/requirements.txt

@@ -17,15 +17,19 @@ anthropic>=0.80.0
 openai>=2.20.0
 
 # Embedding model (optional but recommended for cognitive features).
-# Hard-pinned (==) so the offline wheel bundle (fetch-python-wheels.sh) is
-# reproducible across Win+Mac. onnxruntime is fastembed's transitive native
-# wheel — the fragile, platform-specific one — so it is pinned explicitly too;
-# floating it lets pip resolve an unbundled build and break offline installs.
-# >=0.8.0 was the floor (older releases need Python <3.12 and pip iterates each
-# obsolete version for ~10 min on Ubuntu 24.04 before finding a compatible one,
-# verified during Win11 clean install bootstrap); 0.8.0 is the bundled version.
+# fastembed is hard-pinned (==) so the offline wheel bundle is reproducible; it is
+# pure-python (py3-none-any) so the pin holds on every platform. >=0.8.0 was the
+# floor (older releases need Python <3.12 and pip iterates each obsolete version for
+# ~10 min on Ubuntu 24.04 before finding a compatible one, verified during Win11
+# clean install bootstrap); 0.8.0 is the bundled version.
+#
+# onnxruntime (fastembed's native transitive dep) is deliberately NOT hard-pinned:
+# its wheels are platform/glibc-specific — e.g. 1.26 only ships for manylinux_2_28,
+# while the offline bundle also targets manylinux_2_17/2014 (which cap at 1.19.2).
+# A `==` pin can't be satisfied for every target and breaks BOTH the cross-platform
+# wheel bundle and installs on older Linux. Let fastembed/pip resolve the best
+# onnxruntime wheel per platform.
 fastembed==0.8.0
-onnxruntime==1.26.0
 
 # Local Context Layer — document parsers (REQUIRED for the local memory index).
 # extractors.py imports these lazily; without them a clean bundle silently indexes

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,),