nexo-brain 5.3.9 → 5.3.11

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "5.3.9",
+  "version": "5.3.11",
   "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 `5.3.9` is the current packaged-runtime line: packaged updates now rebuild the core artifact manifest from the canonical npm package source instead of the live `~/.nexo/scripts` directory, so personal scripts stop being reclassified as core, portable user-data export keeps including them, and runtime doctor can recover personal LaunchAgent ownership cleanly after a bad `5.3.8` update.
+Version `5.3.11` is the current packaged-runtime line: protocol and Cortex now reject malformed `outcome`, `task_type`, and `impact_level` values explicitly instead of silently coercing them into other valid states, so task history, debt, hot context, and decision telemetry stay trustworthy even when a caller passes a bad contract payload.
 
 Start here:
 - [5-minute quickstart](docs/quickstart-5-minutes.md)
@@ -89,7 +89,7 @@ Versions `3.1.7` through `3.2.0` close the recent-memory gap:
 - when even that misses, NEXO now exposes raw transcript fallback tools for Claude Code and Codex session stores
 - NEXO can now inspect itself through a live system catalog derived from canonical sources instead of relying only on stale docs or operator memory
 
-Version `5.3.9` is the packaged core-artifact manifest heal for `5.3.8`: packaged updates now rebuild `runtime-core-artifacts.json` from the canonical npm package `src/` tree instead of scanning the live `~/.nexo/scripts` directory, script classification prefers that canonical packaged source when available, and runtime doctor syncs personal scripts before LaunchAgent inventory so personal automations recover cleanly instead of being mistaken for unknown core drift. Version `5.3.8` was the immediate packaged-migration hotfix for `5.3.7`: the installer/runtime migrator now discovers all top-level runtime Python modules from `src/` dynamically instead of relying on a manual allowlist, so new product surfaces like `nexo export` / `nexo import` actually arrive in `~/.nexo` after update instead of being present only in the published npm tarball. Version `5.3.7` closed the remaining packaged-runtime happy-path gap and finally exposed portable user-data migration commands: packaged `nexo update` now self-heals cron definitions and LaunchAgents after a successful npm bump, new `nexo export` / `nexo import` commands move operator data as a safe bundle instead of leaving that flow implicit, and runtime doctor now distinguishes tracked historical Codex drift from an actually broken runtime so cleaned installs stop staying red for stale transcript debt alone. Version `5.3.6` hardened the Claude Code bootstrap path and related runtime hygiene: managed client sync now writes the NEXO MCP server where current Claude Code actually reads it (`~/.claude.json`), script classification is stricter about core-vs-personal runtime artifacts, schedule status distinguishes genuinely running jobs from broken ones, and retroactive learnings stop opening keyword-only false positives outside their declared `applies_to` scope. Version `5.3.5` already keeps CLI version visibility honest right after `nexo update`: if the cached npm version lags behind the runtime you just installed, `nexo` / `nexo chat` now clamp `Latest` to the installed version and refresh the cache instead of showing a stale older release. Version `5.3.4` already cleaned up legacy core alias leakage and added the version-status banner. Version `5.3.3` closed the remaining packaged-runtime doctor mismatch: the built-in hourly backup helper is now inventoried as a core LaunchAgent, so clean installs no longer get a false unknown-LaunchAgent warning. Version `5.3.2` already hardened the runtime boundary by persisting which runtime scripts/hooks are core product artifacts, keeping `nexo scripts` from mixing those into the personal bucket, and migrating the legacy Claude Code heartbeat wrappers into managed core hooks.
+Version `5.3.11` hardens protocol and Cortex contracts: malformed `outcome`, `task_type`, and `impact_level` values now fail explicitly instead of being coerced into other valid states, so persisted task history, debt, hot context, and decision telemetry stay faithful to what the caller actually asked for. Version `5.3.10` tightened the packaged-runtime truth layer again: installs and updates now keep `~/.nexo/package.json` aligned with the published npm package so runtime metadata and doctor evidence no longer drift to an old version, `nexo doctor --tier deep` treats a missing `self-audit-summary.json` as a pending bootstrap artifact when the runtime was just installed or updated instead of reporting a false degradation, weekly Evolution now asks for explicit `dimension_scores` / `score_evidence` so telemetry can persist instead of staying blank, and daily synthesis only ingests `update-last-summary.json` when it carries actionable runtime signals. Version `5.3.9` is the packaged core-artifact manifest heal for `5.3.8`: packaged updates now rebuild `runtime-core-artifacts.json` from the canonical npm package `src/` tree instead of scanning the live `~/.nexo/scripts` directory, script classification prefers that canonical packaged source when available, and runtime doctor syncs personal scripts before LaunchAgent inventory so personal automations recover cleanly instead of being mistaken for unknown core drift. Version `5.3.8` was the immediate packaged-migration hotfix for `5.3.7`: the installer/runtime migrator now discovers all top-level runtime Python modules from `src/` dynamically instead of relying on a manual allowlist, so new product surfaces like `nexo export` / `nexo import` actually arrive in `~/.nexo` after update instead of being present only in the published npm tarball. Version `5.3.7` closed the remaining packaged-runtime happy-path gap and finally exposed portable user-data migration commands: packaged `nexo update` now self-heals cron definitions and LaunchAgents after a successful npm bump, new `nexo export` / `nexo import` commands move operator data as a safe bundle instead of leaving that flow implicit, and runtime doctor now distinguishes tracked historical Codex drift from an actually broken runtime so cleaned installs stop staying red for stale transcript debt alone. Version `5.3.6` hardened the Claude Code bootstrap path and related runtime hygiene: managed client sync now writes the NEXO MCP server where current Claude Code actually reads it (`~/.claude.json`), script classification is stricter about core-vs-personal runtime artifacts, schedule status distinguishes genuinely running jobs from broken ones, and retroactive learnings stop opening keyword-only false positives outside their declared `applies_to` scope. Version `5.3.5` already keeps CLI version visibility honest right after `nexo update`: if the cached npm version lags behind the runtime you just installed, `nexo` / `nexo chat` now clamp `Latest` to the installed version and refresh the cache instead of showing a stale older release. Version `5.3.4` already cleaned up legacy core alias leakage and added the version-status banner. Version `5.3.3` closed the remaining packaged-runtime doctor mismatch: the built-in hourly backup helper is now inventoried as a core LaunchAgent, so clean installs no longer get a false unknown-LaunchAgent warning. Version `5.3.2` already hardened the runtime boundary by persisting which runtime scripts/hooks are core product artifacts, keeping `nexo scripts` from mixing those into the personal bucket, and migrating the legacy Claude Code heartbeat wrappers into managed core hooks.
 
 Version `5.3.1` normalizes packaged npm installs so they behave like packaged npm installs: `nexo update` now keeps the runtime anchored to `~/.nexo`, refreshes packaged bootstrap/client artifacts after upgrade, avoids repo-only release-artifact drift in installed runtimes, and keeps personal scripts on the canonical packaged path.
 

package/bin/nexo-brain.js

@@ -120,6 +120,17 @@ function writeRuntimeCoreArtifactsManifest(nexoHome, srcDir) {
   }
 }
 
+function syncRuntimePackageMetadata(repoRoot = path.join(__dirname, ".."), runtimeHome = NEXO_HOME) {
+  try {
+    const pkgSrc = path.join(repoRoot, "package.json");
+    if (fs.existsSync(pkgSrc)) {
+      fs.copyFileSync(pkgSrc, path.join(runtimeHome, "package.json"));
+    }
+  } catch (err) {
+    log(`WARN: could not sync runtime package metadata: ${err.message}`);
+  }
+}
+
 function getCoreRuntimeFlatFiles(srcDir = path.join(__dirname, "..", "src")) {
   const staticFiles = [
     "server.py",
@@ -1606,6 +1617,7 @@ async function main() {
           updated_at: new Date().toISOString(),
           migrated_from: installedVersion,
         }, null, 2));
+        syncRuntimePackageMetadata(path.join(__dirname, ".."), NEXO_HOME);
 
         // Save updated CLAUDE.md template as reference (don't overwrite user's)
         const templateSrc = path.join(__dirname, "..", "templates", "CLAUDE.md.template");
@@ -1699,6 +1711,7 @@ async function main() {
           fs.copyFileSync(srcFile, destFile);
         }
       });
+      syncRuntimePackageMetadata(path.join(__dirname, ".."), NEXO_HOME);
 
       const templatesSrc = path.join(__dirname, "..", "templates");
       const templatesDest = path.join(NEXO_HOME, "templates");
@@ -2205,6 +2218,7 @@ async function main() {
       files_updated: 0,
     }, null, 2)
   );
+  syncRuntimePackageMetadata(path.join(__dirname, ".."), NEXO_HOME);
 
   // Copy source files
   log("Copying core runtime files...");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "5.3.9",
+  "version": "5.3.11",
   "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/db/__init__.py

@@ -147,13 +147,16 @@ from db._cron_runs import (
 
 # Protocol discipline runtime
 from db._protocol import (
+    VALID_IMPACT_LEVELS,
+    VALID_TASK_TYPES,
+    VALID_CLOSE_OUTCOMES,
     create_protocol_task, get_protocol_task, close_protocol_task,
     create_protocol_debt, resolve_protocol_debts, list_protocol_debts,
     protocol_compliance_summary,
     create_cortex_evaluation, get_cortex_evaluation, list_cortex_evaluations,
     cortex_evaluation_summary,
     latest_cortex_evaluation_for_task, task_has_cortex_evaluation,
-    override_cortex_evaluation,
+    override_cortex_evaluation, validate_close_outcome, validate_impact_level, validate_task_type,
 )
 
 # Durable workflow runtime

package/src/db/_protocol.py

@@ -9,6 +9,7 @@ from db._core import get_db
 
 VALID_TASK_TYPES = {"answer", "analyze", "edit", "execute", "delegate"}
 VALID_OUTCOMES = {"open", "done", "partial", "blocked", "failed", "cancelled"}
+VALID_CLOSE_OUTCOMES = VALID_OUTCOMES - {"open"}
 VALID_DEBT_STATUS = {"open", "forgiven", "resolved"}
 VALID_IMPACT_LEVELS = {"medium", "high", "critical"}
 
@@ -33,6 +34,30 @@ def _row_to_dict(row):
     return dict(row) if row else None
 
 
+def validate_task_type(task_type: str) -> str:
+    clean_type = (task_type or "").strip()
+    if clean_type not in VALID_TASK_TYPES:
+        expected = ", ".join(sorted(VALID_TASK_TYPES))
+        raise ValueError(f"Invalid task_type '{clean_type or '<empty>'}'. Expected one of: {expected}.")
+    return clean_type
+
+
+def validate_impact_level(impact_level: str) -> str:
+    clean_level = (impact_level or "").strip()
+    if clean_level not in VALID_IMPACT_LEVELS:
+        expected = ", ".join(sorted(VALID_IMPACT_LEVELS))
+        raise ValueError(f"Invalid impact_level '{clean_level or '<empty>'}'. Expected one of: {expected}.")
+    return clean_level
+
+
+def validate_close_outcome(outcome: str) -> str:
+    clean_outcome = (outcome or "").strip()
+    if clean_outcome not in VALID_CLOSE_OUTCOMES:
+        expected = ", ".join(sorted(VALID_CLOSE_OUTCOMES))
+        raise ValueError(f"Invalid close outcome '{clean_outcome or '<empty>'}'. Expected one of: {expected}.")
+    return clean_outcome
+
+
 def create_protocol_task(
     session_id: str,
     goal: str,
@@ -68,7 +93,7 @@ def create_protocol_task(
 ) -> dict:
     conn = get_db()
     task_id = _task_id()
-    clean_type = task_type if task_type in VALID_TASK_TYPES else "answer"
+    clean_type = validate_task_type(task_type)
     conn.execute(
         """INSERT INTO protocol_tasks (
                task_id, session_id, goal, task_type, area, project_hint, context_hint,
@@ -144,7 +169,7 @@ def create_cortex_evaluation(
     selection_source: str = "recommended",
 ) -> dict:
     conn = get_db()
-    clean_level = impact_level if impact_level in VALID_IMPACT_LEVELS else "high"
+    clean_level = validate_impact_level(impact_level)
     cursor = conn.execute(
         """INSERT INTO cortex_evaluations (
                session_id, task_id, goal, task_type, area, impact_level, context_hint,
@@ -335,7 +360,7 @@ def close_protocol_task(
     outcome_notes: str = "",
 ) -> dict:
     conn = get_db()
-    clean_outcome = outcome if outcome in VALID_OUTCOMES else "failed"
+    clean_outcome = validate_close_outcome(outcome)
     conn.execute(
         """UPDATE protocol_tasks
            SET status = ?,

package/src/doctor/providers/deep.py

@@ -1,17 +1,20 @@
 """Deep tier checks — read existing artifacts for richer validation. Target <60s."""
 from __future__ import annotations
 
+import datetime as dt
 import json
 import os
 import time
 from pathlib import Path
 
+from cron_recovery import load_enabled_crons
 from doctor.models import DoctorCheck, safe_check
 
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 
 # Freshness thresholds
 SELF_AUDIT_FRESHNESS = 86400 * 2  # 2 days (runs daily)
+SELF_AUDIT_BOOTSTRAP_GRACE = 86400  # 1 day grace after install/update before the first summary exists
 PREFLIGHT_FRESHNESS = 86400  # 1 day
 WATCHDOG_SMOKE_FRESHNESS = 86400  # 1 day
 
@@ -29,12 +32,70 @@ def _load_json(path: Path) -> dict:
     return json.loads(path.read_text())
 
 
+def _timestamp_age_seconds(value: str) -> float | None:
+    raw = str(value or "").strip()
+    if not raw:
+        return None
+    try:
+        parsed = dt.datetime.fromisoformat(raw.replace("Z", "+00:00"))
+    except Exception:
+        return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=dt.timezone.utc)
+    return max(0.0, time.time() - parsed.timestamp())
+
+
+def _runtime_bootstrap_age_seconds() -> float | None:
+    version_file = NEXO_HOME / "version.json"
+    try:
+        payload = _load_json(version_file)
+    except Exception:
+        payload = {}
+    for key in ("updated_at", "installed_at"):
+        age = _timestamp_age_seconds(str(payload.get(key, "") or ""))
+        if age is not None:
+            return age
+    return _file_age_seconds(version_file)
+
+
+def _self_audit_enabled() -> bool | None:
+    try:
+        return any(str(cron.get("id") or "").strip() == "self-audit" for cron in load_enabled_crons())
+    except Exception:
+        return None
+
+
 def check_self_audit_summary() -> DoctorCheck:
     """Check latest self-audit summary exists and is recent."""
     summary_file = NEXO_HOME / "logs" / "self-audit-summary.json"
     age = _file_age_seconds(summary_file)
 
     if age is None:
+        enabled = _self_audit_enabled()
+        if enabled is False:
+            return DoctorCheck(
+                id="deep.self_audit",
+                tier="deep",
+                status="healthy",
+                severity="info",
+                summary="Self-audit automation disabled or not installed",
+            )
+
+        bootstrap_age = _runtime_bootstrap_age_seconds()
+        if enabled and bootstrap_age is not None and bootstrap_age <= SELF_AUDIT_BOOTSTRAP_GRACE:
+            bootstrap_hours = bootstrap_age / 3600
+            return DoctorCheck(
+                id="deep.self_audit",
+                tier="deep",
+                status="healthy",
+                severity="info",
+                summary="Self-audit scheduled but no summary yet",
+                evidence=[
+                    f"Runtime install/update {bootstrap_hours:.0f} hours ago",
+                    f"Expected later at: {summary_file}",
+                ],
+            )
+
         return DoctorCheck(
             id="deep.self_audit",
             tier="deep",

package/src/evolution_cycle.py

@@ -261,6 +261,19 @@ def dry_run_restore_test() -> bool:
 def build_evolution_prompt(week_data: dict, objective: dict) -> str:
     """Build a SHORT prompt — CLI investigates on its own using tools."""
 
+    objective_dims = normalize_objective(objective).get("dimensions", {})
+    current_scores = {
+        dim: int(m["score"])
+        for dim, m in week_data.get("current_metrics", {}).items()
+        if isinstance(m, dict) and isinstance(m.get("score"), (int, float))
+    }
+    if not current_scores:
+        current_scores = {
+            dim: int((payload or {}).get("current", 0) or 0)
+            for dim, payload in objective_dims.items()
+            if isinstance(payload, dict)
+        }
+
     # Summary stats only — CLI will dig deeper with tools
     stats = {
         "learnings_this_week": len(week_data.get("learnings", [])),
@@ -268,7 +281,7 @@ def build_evolution_prompt(week_data: dict, objective: dict) -> str:
         "changes_this_week": len(week_data.get("changes", [])),
         "diaries_this_week": len(week_data.get("diaries", [])),
         "evolution_history": len(week_data.get("evolution_history", [])),
-        "current_scores": {dim: m["score"] for dim, m in week_data.get("current_metrics", {}).items()},
+        "current_scores": current_scores,
     }
 
     mode = normalize_objective(objective).get("evolution_mode", "auto")
@@ -332,6 +345,20 @@ SAFETY:
 OUTPUT FORMAT (JSON):
 {{
   "analysis": "one paragraph summary of what you found",
+  "dimension_scores": {{
+    "episodic_memory": 0,
+    "autonomy": 0,
+    "proactivity": 0,
+    "self_improvement": 0,
+    "agi": 0
+  }},
+  "score_evidence": {{
+    "episodic_memory": "why this score changed or stayed flat",
+    "autonomy": "why this score changed or stayed flat",
+    "proactivity": "why this score changed or stayed flat",
+    "self_improvement": "why this score changed or stayed flat",
+    "agi": "why this score changed or stayed flat"
+  }},
   "patterns": [{{"type": "...", "description": "...", "frequency": "..."}}],
   "proposals": [
     {{
@@ -345,6 +372,8 @@ OUTPUT FORMAT (JSON):
   ]
 }}
 
+Always include all five canonical keys in `dimension_scores` and `score_evidence`.
+Scores must be integers in the 0-100 range and reflect the current week, not targets.
 Max 3 proposals. Quality over quantity. If nothing needs improving, say so."""
 
     return prompt

package/src/plugins/cortex.py

@@ -22,6 +22,8 @@ import time
 from datetime import datetime, timedelta
 from pathlib import Path
 
+from db import VALID_IMPACT_LEVELS, VALID_TASK_TYPES, validate_impact_level, validate_task_type
+
 
 def _get_db():
     from db import get_db
@@ -734,9 +736,19 @@ def handle_cortex_check(
     Returns:
         Mode (ask/propose/act), available tools, warnings, and relevant Core Rules
     """
+    try:
+        clean_type = validate_task_type(task_type)
+    except ValueError as exc:
+        return "\n".join(
+            [
+                f"ERROR: {exc}",
+                f"Valid task types: {', '.join(sorted(VALID_TASK_TYPES))}",
+            ]
+        )
+
     state = {
         "goal": goal.strip() if goal else "",
-        "task_type": task_type if task_type in ("answer", "analyze", "edit", "execute", "delegate") else "answer",
+        "task_type": clean_type,
         "plan": _parse_json_list(plan),
         "known_facts": _parse_json_list(known_facts),
         "unknowns": _parse_json_list(unknowns),
@@ -860,8 +872,30 @@ def handle_cortex_decide(
             indent=2,
         )
 
-    clean_type = task_type if task_type in {"answer", "analyze", "edit", "execute", "delegate"} else "execute"
-    clean_level = impact_level if impact_level in {"medium", "high", "critical"} else "high"
+    try:
+        clean_type = validate_task_type(task_type)
+    except ValueError as exc:
+        return json.dumps(
+            {
+                "ok": False,
+                "error": str(exc),
+                "valid_task_types": sorted(VALID_TASK_TYPES),
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
+    try:
+        clean_level = validate_impact_level(impact_level)
+    except ValueError as exc:
+        return json.dumps(
+            {
+                "ok": False,
+                "error": str(exc),
+                "valid_impact_levels": sorted(VALID_IMPACT_LEVELS),
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
     parsed_constraints = _parse_json_list(constraints)
     parsed_evidence = _parse_json_list(evidence_refs)
     try:

package/src/plugins/evolution.py

@@ -1,33 +1,77 @@
 """Evolution plugin — NEXO self-improvement tools for interactive sessions."""
 
+import json
 import os
+from pathlib import Path
 from db import get_latest_metrics, get_evolution_history, update_evolution_log_status, get_db
 
 
+CANONICAL_DIMENSIONS = {
+    "episodic_memory": "Episodic Memory",
+    "autonomy": "Autonomy",
+    "proactivity": "Proactivity",
+    "self_improvement": "Self-improvement",
+    "agi": "AGI",
+}
+
+
+def _resolve_objective_file() -> Path:
+    nexo_home = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+    for candidate in (
+        nexo_home / "brain" / "evolution-objective.json",
+        nexo_home / "cortex" / "evolution-objective.json",
+    ):
+        if candidate.exists():
+            return candidate
+    return nexo_home / "brain" / "evolution-objective.json"
+
+
+def _load_objective() -> dict:
+    try:
+        raw = json.loads(_resolve_objective_file().read_text())
+    except Exception:
+        return {}
+    return raw if isinstance(raw, dict) else {}
+
+
 def handle_evolution_status() -> str:
     """Show current NEXO dimension scores and recent trend."""
     metrics = get_latest_metrics()
-    if not metrics:
-        return "No evolution metrics recorded."
-
-    BARS = {
-        "episodic_memory": "Episodic Memory",
-        "autonomy": "Autonomy",
-        "proactivity": "Proactivity",
-        "self_improvement": "Self-improvement",
-        "agi": "AGI",
-    }
+    objective = _load_objective()
+    objective_dims = objective.get("dimensions", {}) if isinstance(objective.get("dimensions"), dict) else {}
 
     from user_context import get_context
     lines = [f"{get_context().assistant_name} EVOLUTION STATUS:"]
-    for key, label in BARS.items():
+    has_output = False
+    for key, label in CANONICAL_DIMENSIONS.items():
         m = metrics.get(key)
         if m:
             score = m["score"]
             delta = m["delta"]
             bar = "█" * (score // 5) + "░" * (20 - score // 5)
             delta_str = f" (+{delta})" if delta > 0 else f" ({delta})" if delta < 0 else " (=)"
-            lines.append(f"  {label:<20} {bar} {score}%{delta_str}")
+            target = ""
+            if isinstance(objective_dims.get(key), dict) and objective_dims[key].get("target") is not None:
+                target = f" / target {int(objective_dims[key].get('target', 0) or 0)}%"
+            lines.append(f"  {label:<20} {bar} {score}%{delta_str}{target}")
+            has_output = True
+            continue
+
+        objective_entry = objective_dims.get(key)
+        if isinstance(objective_entry, dict):
+            score = int(objective_entry.get("current", 0) or 0)
+            target = int(objective_entry.get("target", 0) or 0)
+            bar = "█" * (score // 5) + "░" * (20 - score // 5)
+            lines.append(f"  {label:<20} {bar} {score}% (objective fallback, target {target}%)")
+            has_output = True
+
+    if not has_output:
+        return "No evolution metrics recorded."
+
+    if not metrics:
+        lines.append("  Note: no persisted evolution_metrics rows yet; showing objective fallback.")
+    if objective.get("last_evolution"):
+        lines.append(f"  Last evolution: {objective['last_evolution']}")
     return "\n".join(lines)
 
 

package/src/plugins/protocol.py

@@ -10,6 +10,8 @@ import secrets
 import time
 
 from db import (
+    VALID_TASK_TYPES,
+    VALID_CLOSE_OUTCOMES,
     close_protocol_task,
     create_followup,
     latest_cortex_evaluation_for_task,
@@ -28,6 +30,8 @@ from db import (
     resolve_protocol_debts,
     search_learnings,
     task_has_cortex_evaluation,
+    validate_close_outcome,
+    validate_task_type,
 )
 from plugins.cortex import evaluate_cortex_state
 from plugins.guard import handle_guard_check
@@ -651,7 +655,18 @@ def handle_confidence_check(
     clean_goal = (goal or "").strip()
     if not clean_goal:
         return json.dumps({"ok": False, "error": "goal is required"}, ensure_ascii=False, indent=2)
-    clean_type = task_type if task_type in {"answer", "analyze", "edit", "execute", "delegate"} else "answer"
+    try:
+        clean_type = validate_task_type(task_type)
+    except ValueError as exc:
+        return json.dumps(
+            {
+                "ok": False,
+                "error": str(exc),
+                "valid_task_types": sorted(VALID_TASK_TYPES),
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
     result = evaluate_response_confidence(
         goal=clean_goal,
         task_type=clean_type,
@@ -693,7 +708,18 @@ def handle_task_open(
     if not clean_goal:
         return json.dumps({"ok": False, "error": "goal is required"}, ensure_ascii=False, indent=2)
 
-    clean_type = task_type if task_type in {"answer", "analyze", "edit", "execute", "delegate"} else "answer"
+    try:
+        clean_type = validate_task_type(task_type)
+    except ValueError as exc:
+        return json.dumps(
+            {
+                "ok": False,
+                "error": str(exc),
+                "valid_task_types": sorted(VALID_TASK_TYPES),
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
     files_list = _parse_list(files)
     protocol_strictness = get_protocol_strictness()
     if protocol_strictness in {"strict", "learning"} and clean_type == "edit" and not files_list:
@@ -949,7 +975,19 @@ def handle_task_close(
             indent=2,
         )
 
-    clean_outcome = outcome if outcome in {"done", "partial", "blocked", "failed", "cancelled"} else "failed"
+    try:
+        clean_outcome = validate_close_outcome(outcome)
+    except ValueError as exc:
+        return json.dumps(
+            {
+                "ok": False,
+                "error": str(exc),
+                "task_id": task_id,
+                "valid_outcomes": sorted(VALID_CLOSE_OUTCOMES),
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
     clean_evidence = (evidence or "").strip()
     files_changed_list = _parse_list(files_changed)
     planned_files = _parse_list(task.get("files") or "[]")

package/src/scripts/nexo-synthesis.py

@@ -135,6 +135,36 @@ def _impact_reasoning(row: dict) -> str:
     return str(factors.get("reasoning") or "").strip()
 
 
+def _load_json_summary(path: Path, *, actionable) -> tuple[dict | None, str | None]:
+    if not path.exists():
+        return None, None
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except Exception as exc:
+        return None, str(exc)
+    if not isinstance(payload, dict):
+        return None, "summary payload is not a JSON object"
+    if not actionable(payload):
+        return None, None
+    return payload, None
+
+
+def _load_coordination_summary(filename: str, *, actionable) -> tuple[dict | None, str | None]:
+    return _load_json_summary(COORD_DIR / filename, actionable=actionable)
+
+
+def _update_summary_actionable(payload: dict) -> bool:
+    if any(payload.get(key) for key in ("error", "updated", "deferred_reason", "git_update", "npm_notice")):
+        return True
+    for action in payload.get("actions") or []:
+        if str(action).startswith("personal-schedules-"):
+            return True
+    for message in payload.get("client_bootstrap_updates") or []:
+        if "already current" not in str(message).lower():
+            return True
+    return False
+
+
 def collect_data() -> dict:
     """Collect all raw data for synthesis."""
     data = {"date": TODAY_STR}
@@ -207,6 +237,43 @@ def collect_data() -> dict:
         except Exception as exc:
             data["impact_queue_summary_error"] = str(exc)
 
+    followup_hygiene_summary, followup_hygiene_error = _load_coordination_summary(
+        "followup-hygiene-summary.json",
+        actionable=lambda payload: any(
+            int(payload.get(key, 0) or 0) > 0
+            for key in ("dirty_normalized", "stale_count", "orphan_count")
+        ),
+    )
+    if followup_hygiene_summary is not None:
+        data["followup_hygiene_summary"] = followup_hygiene_summary
+    elif followup_hygiene_error:
+        data["followup_hygiene_summary_error"] = followup_hygiene_error
+
+    outcome_checker_summary, outcome_checker_error = _load_coordination_summary(
+        "outcome-checker-summary.json",
+        actionable=lambda payload: (
+            any(
+                int(payload.get(key, 0) or 0) > 0
+                for key in ("checked", "met", "missed", "pending", "errors")
+            )
+            or bool(payload.get("ids"))
+            or bool(((payload.get("auto_promoted_patterns") or {}).get("promoted") or []))
+        ),
+    )
+    if outcome_checker_summary is not None:
+        data["outcome_checker_summary"] = outcome_checker_summary
+    elif outcome_checker_error:
+        data["outcome_checker_summary_error"] = outcome_checker_error
+
+    update_summary, update_summary_error = _load_json_summary(
+        NEXO_HOME / "logs" / "update-last-summary.json",
+        actionable=_update_summary_actionable,
+    )
+    if update_summary is not None:
+        data["update_summary"] = update_summary
+    elif update_summary_error:
+        data["update_summary_error"] = update_summary_error
+
     # Guard stats
     data["guard_stats"] = safe_query(
         "SELECT category, COUNT(*) as cnt FROM learnings WHERE status='active' "