nexo-brain 2.0.0 → 2.1.0

package/src/scripts/deep-sleep/synthesize.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""
+Deep Sleep v2 -- Phase 3: Synthesize extractions into actionable findings.
+
+One Claude call that reads all per-session extractions and produces a
+unified synthesis with cross-session patterns, morning agenda, context
+packets, and deduplicated actions.
+
+Environment variables:
+  NEXO_HOME  -- root of the NEXO installation (default: ~/.nexo)
+"""
+import json
+import os
+import shutil
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+DEEP_SLEEP_DIR = NEXO_HOME / "operations" / "deep-sleep"
+PROMPT_FILE = Path(__file__).parent / "synthesize-prompt.md"
+
+CLAUDE_TIMEOUT = 21600  # 3h safety net (prevents zombie processes)
+
+
+def find_claude_cli() -> str:
+    """Find the Claude CLI binary."""
+    candidates = [
+        Path.home() / ".local" / "bin" / "claude",
+        Path("/usr/local/bin/claude"),
+    ]
+    for c in candidates:
+        if c.exists():
+            return str(c)
+    which = shutil.which("claude")
+    if which:
+        return which
+    return "claude"
+
+
+def extract_json_from_response(text: str) -> dict | None:
+    """Parse JSON from Claude's response, handling markdown fences."""
+    text = text.strip()
+
+    if text.startswith("```"):
+        lines = text.split("\n")
+        end = len(lines)
+        for i in range(len(lines) - 1, 0, -1):
+            if lines[i].strip() == "```":
+                end = i
+                break
+        text = "\n".join(lines[1:end]).strip()
+
+    brace_start = text.find("{")
+    if brace_start < 0:
+        return None
+
+    depth = 0
+    for i in range(brace_start, len(text)):
+        if text[i] == "{":
+            depth += 1
+        elif text[i] == "}":
+            depth -= 1
+            if depth == 0:
+                try:
+                    return json.loads(text[brace_start:i + 1])
+                except json.JSONDecodeError:
+                    break
+    return None
+
+
+def main():
+    target_date = sys.argv[1] if len(sys.argv) > 1 else datetime.now().strftime("%Y-%m-%d")
+
+    extractions_file = DEEP_SLEEP_DIR / f"{target_date}-extractions.json"
+    context_file = DEEP_SLEEP_DIR / f"{target_date}-context.txt"
+
+    if not extractions_file.exists():
+        print(f"[synthesize] No extractions file for {target_date}. Run extract.py first.")
+        sys.exit(1)
+
+    # Check if there are any findings worth synthesizing
+    with open(extractions_file) as f:
+        extractions = json.load(f)
+
+    total_findings = extractions.get("total_findings", 0)
+    if total_findings == 0:
+        print(f"[synthesize] No findings to synthesize for {target_date}.")
+        # Write minimal synthesis
+        output = {
+            "date": target_date,
+            "sessions_analyzed": extractions.get("sessions_analyzed", 0),
+            "cross_session_patterns": [],
+            "morning_agenda": [],
+            "context_packets": [],
+            "actions": [],
+            "summary": f"No significant findings for {target_date}."
+        }
+        output_file = DEEP_SLEEP_DIR / f"{target_date}-synthesis.json"
+        with open(output_file, "w") as f:
+            json.dump(output, f, indent=2, ensure_ascii=False)
+        print(f"[synthesize] Output: {output_file}")
+        return
+
+    # Build prompt
+    prompt_template = PROMPT_FILE.read_text()
+    prompt = prompt_template.replace("{{EXTRACTIONS_FILE}}", str(extractions_file))
+    prompt = prompt.replace("{{CONTEXT_FILE}}", str(context_file))
+
+    claude_bin = find_claude_cli()
+    print(f"[synthesize] Phase 3: Synthesizing {total_findings} findings from {target_date}")
+    print(f"[synthesize] Claude CLI: {claude_bin}")
+
+    try:
+        env = os.environ.copy()
+        env["NEXO_HEADLESS"] = "1"  # Skip stop hook post-mortem
+
+        result = subprocess.run(
+            [
+                claude_bin,
+                "-p", prompt,
+                "--model", "opus",
+                "--output-format", "text",
+                "--allowedTools",
+                "Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__nexo_startup,mcp__nexo__nexo_learning_search,mcp__nexo__nexo_recall,mcp__nexo__nexo_reminders"
+            ],
+            capture_output=True,
+            text=True,
+            timeout=CLAUDE_TIMEOUT,
+            env=env
+        )
+
+        if result.returncode != 0:
+            print(f"[synthesize] Claude CLI error (exit {result.returncode}): {result.stderr[:300]}", file=sys.stderr)
+            sys.exit(1)
+
+        # Filter hook contamination
+        output_text = "\n".join(
+            l for l in result.stdout.strip().splitlines()
+            if not l.strip().startswith("Post-mortem")
+        )
+        parsed = extract_json_from_response(output_text)
+
+        # Fallback: Opus might have written the file directly via Write tool
+        if not parsed:
+            for candidate in [
+                DEEP_SLEEP_DIR / f"{target_date}-analysis.json",
+                DEEP_SLEEP_DIR / f"{target_date}-synthesis.json",
+            ]:
+                if candidate.exists() and candidate.stat().st_size > 100:
+                    try:
+                        parsed = json.load(open(candidate))
+                        print(f"[synthesize] Opus wrote file directly: {candidate}")
+                        break
+                    except Exception:
+                        continue
+
+        if not parsed:
+            debug_file = DEEP_SLEEP_DIR / f"debug-synthesize-{target_date}.txt"
+            debug_file.write_text(result.stdout[:10000])
+            print(f"[synthesize] Failed to parse JSON. Raw output saved to {debug_file}", file=sys.stderr)
+            sys.exit(1)
+
+        # Write synthesis output
+        output_file = DEEP_SLEEP_DIR / f"{target_date}-synthesis.json"
+        with open(output_file, "w") as f:
+            json.dump(parsed, f, indent=2, ensure_ascii=False)
+
+        n_actions = len(parsed.get("actions", []))
+        n_patterns = len(parsed.get("cross_session_patterns", []))
+        n_agenda = len(parsed.get("morning_agenda", []))
+        n_packets = len(parsed.get("context_packets", []))
+
+        print(f"[synthesize] Done.")
+        print(f"  Actions: {n_actions}")
+        print(f"  Cross-session patterns: {n_patterns}")
+        print(f"  Morning agenda items: {n_agenda}")
+        print(f"  Context packets: {n_packets}")
+        print(f"[synthesize] Output: {output_file}")
+
+    except subprocess.TimeoutExpired:
+        print(f"[synthesize] Claude CLI timeout ({CLAUDE_TIMEOUT}s)", file=sys.stderr)
+        sys.exit(1)
+    except FileNotFoundError:
+        print(f"[synthesize] Claude CLI not found at: {claude_bin}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/src/scripts/nexo-catchup.py

@@ -125,7 +125,7 @@ def run_task(name: str, python: str, script: str, state: dict) -> bool:
     try:
         result = subprocess.run(
             [python, script_path],
-            capture_output=True, text=True, timeout=300,
+            capture_output=True, text=True, timeout=21600,
             env={**os.environ, "HOME": str(HOME), "NEXO_CATCHUP": "1"}
         )
         if result.returncode == 0:
@@ -187,10 +187,6 @@ def _cli_post_catchup_assessment(ran: int, skipped: int, state: dict):
     if not CLAUDE_CLI.exists():
         log(f"Caught up {ran} tasks, {skipped} already current. (CLI unavailable for assessment)")
         return
-
-    auth_check = subprocess.run(
-        [str(CLAUDE_CLI), "-p", "Reply with exactly: ok", "--bare", "--output-format", "text", "--model", "haiku"],
-        capture_output=True, text=True, timeout=15
     )
     if auth_check.returncode != 0:
         # CLI not authenticated, skip gracefully
@@ -222,14 +218,15 @@ Format:
 
     log(f"Caught up {ran} tasks — running CLI assessment...")
     env = os.environ.copy()
+    env["NEXO_HEADLESS"] = "1"  # Skip stop hook post-mortem
     env.pop("CLAUDECODE", None)
     env.pop("CLAUDE_CODE", None)
 
     try:
         result = subprocess.run(
-            [str(CLAUDE_CLI), "-p", prompt, "--model", "opus", "--output-format", "text", "--bare",
-             "--allowedTools", "Read,Write,Edit,Glob,Grep"],
-            capture_output=True, text=True, timeout=90, env=env
+            [str(CLAUDE_CLI), "-p", prompt, "--model", "opus", "--output-format", "text",
+             "--allowedTools", "Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*"],
+            capture_output=True, text=True, timeout=21600, env=env
         )
         if result.returncode == 0:
             log(f"Assessment written to {assessment_file}")

package/src/scripts/nexo-daily-self-audit.py

@@ -303,6 +303,25 @@ def check_runtime_preflight():
         finding("ERROR", "preflight", "runtime preflight failing")
 
 
+def run_watchdog_smoke():
+    """Run the watchdog smoke test so its summary is fresh before we check it."""
+    smoke_script = Path(__file__).resolve().parent / "nexo-watchdog-smoke.py"
+    if not smoke_script.exists():
+        finding("WARN", "watchdog", f"smoke script not found at {smoke_script}")
+        return
+    try:
+        result = subprocess.run(
+            [sys.executable, str(smoke_script)],
+            capture_output=True, text=True, timeout=60
+        )
+        if result.returncode != 0:
+            finding("WARN", "watchdog", f"smoke test exited {result.returncode}")
+    except subprocess.TimeoutExpired:
+        finding("ERROR", "watchdog", "smoke test timed out (60s)")
+    except Exception as e:
+        finding("WARN", "watchdog", f"smoke test failed: {e}")
+
+
 def check_watchdog_smoke():
     if not WATCHDOG_SMOKE_SUMMARY.exists():
         return
@@ -409,9 +428,11 @@ def interpret_findings(raw_findings: list) -> bool:
 
     findings_json = json.dumps(raw_findings, ensure_ascii=False, indent=1)
 
-    prompt = f"""You are NEXO's morning self-audit interpreter. The mechanical checks found
+    prompt = f"""FIRST: Call nexo_startup(task='daily self-audit') to register this session.
+
+You are NEXO's morning self-audit interpreter. The mechanical checks found
 {len(errors)} errors and {len(warns)} warnings. Your job is to UNDERSTAND what's
-actually wrong, not just list findings.
+actually wrong, not just list findings. Use nexo_learning_add for new findings and nexo_followup_create for action items.
 
 RAW FINDINGS:
 {findings_json}
@@ -441,30 +462,17 @@ Also write the machine-readable summary to {LOG_DIR}/self-audit-summary.json.
 Execute without asking."""
 
     log("Stage B: Invoking Claude CLI (opus) for interpretation...")
-
-    # Verify Claude CLI is authenticated before calling
-    try:
-        auth_check = subprocess.run(
-            [str(CLAUDE_CLI), "-p", "Reply with exactly: ok", "--bare", "--output-format", "text", "--model", "haiku"],
-            capture_output=True, text=True, timeout=15
-        )
-        if auth_check.returncode != 0:
-            log("Stage B: Claude CLI not available or not authenticated. Skipping Stage B.")
-            return False
-    except Exception:
-        log("Stage B: Claude CLI check failed. Skipping Stage B.")
-        return False
-
     env = os.environ.copy()
+    env["NEXO_HEADLESS"] = "1"  # Skip stop hook post-mortem
     env.pop("CLAUDECODE", None)
     env.pop("CLAUDE_CODE", None)
 
     try:
         result = subprocess.run(
             [str(CLAUDE_CLI), "-p", prompt, "--model", "opus",
-             "--output-format", "text", "--bare",
-             "--allowedTools", "Read,Write,Edit,Glob,Grep"],
-            capture_output=True, text=True, timeout=180, env=env
+             "--output-format", "text",
+             "--allowedTools", "Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*"],
+            capture_output=True, text=True, timeout=21600, env=env
         )
 
         if result.returncode != 0:
@@ -507,6 +515,7 @@ def main():
     check_restore_activity()
     check_bad_responses()
     check_runtime_preflight()
+    run_watchdog_smoke()
     check_watchdog_smoke()
     check_cognitive_health()
 

package/src/scripts/nexo-deep-sleep.sh

@@ -24,38 +24,53 @@ log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_DIR/deep-sleep.l
 
 run_analysis() {
     local DATE="$1"
-    log "=== Deep Sleep starting for $DATE ==="
+    log "=== Deep Sleep v2 starting for $DATE ==="
 
-    # Step 1: Collect transcripts
-    log "Step 1: Collecting transcripts for $DATE..."
-    python3 "$SCRIPT_DIR/deep-sleep/collect_transcripts.py" "$DATE" 2>&1 | tee -a "$LOG_DIR/deep-sleep.log"
+    # Phase 1: Collect all context (Python, no LLM)
+    log "Phase 1: Collecting context for $DATE..."
+    python3 "$SCRIPT_DIR/deep-sleep/collect.py" "$DATE" 2>&1 | tee -a "$LOG_DIR/deep-sleep.log"
 
-    # Check if transcripts were found
-    if [ ! -f "$DEEP_SLEEP_DIR/$DATE-transcripts.json" ]; then
-        log "No transcripts file generated for $DATE. Skipping."
+    if [ ! -f "$DEEP_SLEEP_DIR/$DATE-context.txt" ]; then
+        log "No context file generated for $DATE. Skipping."
         return 0
     fi
 
-    SESSIONS=$(python3 -c "import json; print(json.load(open('$DEEP_SLEEP_DIR/$DATE-transcripts.json'))['sessions_found'])")
+    # Check meta for session count
+    SESSIONS=0
+    if [ -f "$DEEP_SLEEP_DIR/$DATE-meta.json" ]; then
+        SESSIONS=$(python3 -c "import json; print(json.load(open('$DEEP_SLEEP_DIR/$DATE-meta.json'))['sessions_found'])")
+    elif [ -f "$DEEP_SLEEP_DIR/$DATE-index.json" ]; then
+        SESSIONS=$(python3 -c "import json; print(json.load(open('$DEEP_SLEEP_DIR/$DATE-index.json'))['sessions_found'])")
+    fi
     if [ "$SESSIONS" -eq 0 ]; then
         log "No sessions found for $DATE. Skipping."
         return 0
     fi
 
-    # Step 2: Analyze with Claude CLI
-    log "Step 2: Analyzing $SESSIONS sessions with Claude CLI..."
-    python3 "$SCRIPT_DIR/deep-sleep/analyze_session.py" "$DATE" 2>&1 | tee -a "$LOG_DIR/deep-sleep.log"
+    # Phase 2: Extract findings per session (Claude Opus)
+    log "Phase 2: Extracting findings from $SESSIONS sessions..."
+    python3 "$SCRIPT_DIR/deep-sleep/extract.py" "$DATE" 2>&1 | tee -a "$LOG_DIR/deep-sleep.log"
 
-    if [ ! -f "$DEEP_SLEEP_DIR/$DATE-analysis.json" ]; then
-        log "Analysis failed for $DATE. No output generated."
+    if [ ! -f "$DEEP_SLEEP_DIR/$DATE-extractions.json" ]; then
+        log "Extraction failed for $DATE. No output."
         return 1
     fi
 
-    # Step 3: Apply findings
-    log "Step 3: Applying findings for $DATE..."
+    # Phase 3: Cross-session synthesis (Claude Opus, one call)
+    log "Phase 3: Synthesizing cross-session findings..."
+    python3 "$SCRIPT_DIR/deep-sleep/synthesize.py" "$DATE" 2>&1 | tee -a "$LOG_DIR/deep-sleep.log"
+
+    if [ ! -f "$DEEP_SLEEP_DIR/$DATE-synthesis.json" ]; then
+        log "Synthesis failed for $DATE. Falling back to extractions only."
+        # Fall back: apply extractions directly
+        cp "$DEEP_SLEEP_DIR/$DATE-extractions.json" "$DEEP_SLEEP_DIR/$DATE-synthesis.json"
+    fi
+
+    # Phase 4: Apply findings
+    log "Phase 4: Applying findings..."
     python3 "$SCRIPT_DIR/deep-sleep/apply_findings.py" "$DATE" 2>&1 | tee -a "$LOG_DIR/deep-sleep.log"
 
-    log "=== Deep Sleep complete for $DATE ==="
+    log "=== Deep Sleep v2 complete for $DATE ==="
     return 0
 }
 

package/src/scripts/nexo-evolution-run.py

@@ -100,36 +100,21 @@ def set_consecutive_failures(count: int):
 
 
 # ── Claude CLI call ──────────────────────────────────────────────────────
-CLI_TIMEOUT = 600  # 10 minutes — Opus needs time for large prompts
+CLI_TIMEOUT = 21600  # 3h safety net (prevents zombie processes)
 
 
 def verify_claude_cli() -> bool:
-    """Verify Claude CLI is available and authenticated with a real prompt test."""
-    try:
-        auth_check = subprocess.run(
-            [str(CLAUDE_CLI), "-p", "Reply with exactly: ok", "--bare", "--output-format", "text", "--model", "haiku"],
-            capture_output=True, text=True, timeout=15
-        )
-        if auth_check.returncode != 0:
-            stderr = auth_check.stderr[:200] if auth_check.stderr else ""
-            log(f"Claude CLI not authenticated or unavailable: {stderr}")
-            return False
-        return True
-    except Exception as e:
-        log(f"Claude CLI check failed: {e}")
-        return False
-
-
 def call_claude_cli(prompt: str) -> str:
     """Call claude -p prompt --model opus via subprocess. Returns stdout text."""
     env = os.environ.copy()
+    env["NEXO_HEADLESS"] = "1"  # Skip stop hook post-mortem
     env.pop("CLAUDECODE", None)
     env.pop("CLAUDE_CODE", None)
 
     result = subprocess.run(
         [str(CLAUDE_CLI), "-p", prompt, "--model", "opus",
-         "--output-format", "text", "--bare",
-         "--allowedTools", "Read,Write,Edit,Glob,Grep,Bash"],
+         "--output-format", "text",
+         "--allowedTools", "Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*"],
         capture_output=True,
         text=True,
         timeout=CLI_TIMEOUT,
@@ -424,7 +409,7 @@ def run():
         return
 
     # Call Opus via claude -p
-    log("Calling claude -p --model opus --bare...")
+    log("Calling claude -p --model opus...")
     try:
         raw_response = call_claude_cli(prompt)
     except Exception as e:

package/src/scripts/nexo-followup-hygiene.py

@@ -61,7 +61,8 @@ def main():
     cutoff = (date.today() - timedelta(days=14)).isoformat()
     stale = conn.execute(
         "SELECT id, description, date, updated_at FROM followups "
-        "WHERE status NOT LIKE 'COMPLETED%' AND status NOT LIKE 'COMPLETED%' "
+        "WHERE status NOT LIKE 'COMPLETED%' "
+        "AND status NOT IN ('DELETED','archived','blocked','waiting') "
         "AND date != '' AND date < ? "
         "ORDER BY date",
         (cutoff,)
@@ -75,7 +76,8 @@ def main():
     # 3. Orphaned followups (no date, no recent update)
     orphans = conn.execute(
         "SELECT id, description FROM followups "
-        "WHERE status NOT LIKE 'COMPLETED%' AND status NOT LIKE 'COMPLETED%' "
+        "WHERE status NOT LIKE 'COMPLETED%' "
+        "AND status NOT IN ('DELETED','archived','blocked','waiting') "
         "AND (date IS NULL OR date = '') "
         "ORDER BY id"
     ).fetchall()

package/src/scripts/nexo-github-monitor.py

@@ -36,7 +36,7 @@ def gh_api(endpoint: str) -> dict | list | None:
     try:
         result = subprocess.run(
             ["gh", "api", endpoint],
-            capture_output=True, text=True, timeout=30
+            capture_output=True, text=True, timeout=21600
         )
         if result.returncode == 0:
             return json.loads(result.stdout)
@@ -109,7 +109,7 @@ def collect_data():
             try:
                 result = subprocess.run(
                     ["gh", "api", f"repos/{REPO}/compare/{tag}...main"],
-                    capture_output=True, text=True, timeout=30
+                    capture_output=True, text=True, timeout=21600
                 )
                 if result.returncode == 0:
                     compare = json.loads(result.stdout)
@@ -157,24 +157,21 @@ Return as JSON:
   "alerts": ["alert1", ...],
   "release_recommendation": "text or null"
 }}"""
-
-    auth_check = subprocess.run(
-        [str(CLAUDE_CLI), "-p", "Reply with exactly: ok", "--bare", "--output-format", "text", "--model", "haiku"],
-        capture_output=True, text=True, timeout=15
     )
     if auth_check.returncode != 0:
         # CLI not authenticated, skip gracefully
         return ""
 
     env = os.environ.copy()
+    env["NEXO_HEADLESS"] = "1"  # Skip stop hook post-mortem
     env.pop("CLAUDECODE", None)
     env.pop("CLAUDE_CODE", None)
 
     result = subprocess.run(
         [str(CLAUDE_CLI), "-p", prompt,
-         "--model", "opus", "--output-format", "text", "--bare",
-         "--allowedTools", "Read,Write,Edit,Glob,Grep"],
-        capture_output=True, text=True, timeout=180, env=env
+         "--model", "opus", "--output-format", "text",
+         "--allowedTools", "Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*"],
+        capture_output=True, text=True, timeout=21600, env=env
     )
 
     if result.returncode != 0:

package/src/scripts/nexo-immune.py

@@ -901,30 +901,17 @@ Raw findings:
 Write the report. Be concise — max 40 lines."""
 
     print("\n[TRIAGE] Running CLI interpretation...")
-
-    # Verify Claude CLI is authenticated before calling
-    try:
-        auth_check = subprocess.run(
-            [str(CLAUDE_CLI), "-p", "Reply with exactly: ok", "--bare", "--output-format", "text", "--model", "haiku"],
-            capture_output=True, text=True, timeout=15
-        )
-        if auth_check.returncode != 0:
-            print("[TRIAGE] Claude CLI not available or not authenticated. Skipping triage.")
-            return
-    except Exception:
-        print("[TRIAGE] Claude CLI check failed. Skipping triage.")
-        return
-
     env = os.environ.copy()
+    env["NEXO_HEADLESS"] = "1"  # Skip stop hook post-mortem
     env.pop("CLAUDECODE", None)
     env.pop("CLAUDE_CODE", None)
 
     try:
         result = subprocess.run(
             [str(CLAUDE_CLI), "-p", prompt, "--model", "opus",
-             "--output-format", "text", "--bare",
-             "--allowedTools", "Read,Write,Edit,Glob,Grep"],
-            capture_output=True, text=True, timeout=120, env=env
+             "--output-format", "text",
+             "--allowedTools", "Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*"],
+            capture_output=True, text=True, timeout=21600, env=env
         )
         if result.returncode == 0:
             print(f"[TRIAGE] Report written to {triage_file}")

package/src/scripts/nexo-learning-validator.py

@@ -111,35 +111,6 @@ Rules:
 
     # Try CLI first, fall back to mechanical similarity
     if CLAUDE_CLI.exists():
-        auth_check = subprocess.run(
-            [str(CLAUDE_CLI), "-p", "Reply with exactly: ok", "--bare", "--output-format", "text", "--model", "haiku"],
-            capture_output=True, text=True, timeout=15
-        )
-        if auth_check.returncode != 0:
-            # CLI not authenticated, skip gracefully
-            return {"known": False, "confidence": 0, "recommendation": "CLI not authenticated — skipped validation", "matching_learnings": []}
-
-        env = os.environ.copy()
-        env.pop("CLAUDECODE", None)
-        env.pop("CLAUDE_CODE", None)
-
-        try:
-            result = subprocess.run(
-                [str(CLAUDE_CLI), "-p", prompt, "--model", "opus", "--output-format", "text", "--bare",
-                 "--allowedTools", "Read,Write,Edit,Glob,Grep"],
-                capture_output=True, text=True, timeout=60, env=env
-            )
-            if result.returncode == 0:
-                text = result.stdout.strip()
-                # Strip markdown fences if present
-                if "```json" in text:
-                    text = text.split("```json")[1].split("```")[0]
-                elif "```" in text:
-                    text = text.split("```")[1].split("```")[0]
-                return json.loads(text.strip())
-        except (subprocess.TimeoutExpired, json.JSONDecodeError, Exception):
-            pass  # Fall through to mechanical fallback
-
     # Fallback: mechanical SequenceMatcher (original logic)
     return _mechanical_validate(finding, learnings)
 

package/src/scripts/nexo-postmortem-consolidator.py

@@ -113,7 +113,7 @@ def consolidate_with_cli(data: dict) -> bool:
 
     diaries_with_critique = [
         d for d in data["diaries"]
-        if d.get("self_critique") and not (d["self_critique"] or "").strip().lower().startswith("no self-critique")
+        if d.get("self_critique") and not str(d["self_critique"]).strip().lower().startswith("no self-critique")
     ]
 
     if not diaries_with_critique:
@@ -125,8 +125,10 @@ def consolidate_with_cli(data: dict) -> bool:
     if len(diaries_json) > 12000:
         diaries_json = diaries_json[:12000] + "\n... (truncated)"
 
-    prompt = f"""You are NEXO's nightly consolidator. Your job is to review the self-critiques
-from today and decide which deserve to become permanent rules (feedback_postmortem_*.md).
+    prompt = f"""FIRST: Call nexo_startup(task='nightly postmortem consolidation') to register this session.
+
+You are NEXO's nightly consolidator. Your job is to review the self-critiques
+from today and decide which deserve to become permanent rules. Use nexo_learning_add for permanent rules and nexo_followup_create for action items.
 
 DATE: {data['date']}
 SESSIONS TODAY: {len(data['diaries'])} total, {len(diaries_with_critique)} with self-critique
@@ -185,30 +187,17 @@ INSTRUCTIONS:
 Execute without asking."""
 
     log(f"Stage 2: Invoking Claude CLI (opus) with {len(diaries_with_critique)} critiques...")
-
-    # Verify Claude CLI is authenticated before calling
-    try:
-        auth_check = subprocess.run(
-            [str(CLAUDE_CLI), "-p", "Reply with exactly: ok", "--bare", "--output-format", "text", "--model", "haiku"],
-            capture_output=True, text=True, timeout=15
-        )
-        if auth_check.returncode != 0:
-            log("Stage 2: Claude CLI not available or not authenticated. Skipping Stage 2.")
-            return False
-    except Exception:
-        log("Stage 2: Claude CLI check failed. Skipping Stage 2.")
-        return False
-
     env = os.environ.copy()
+    env["NEXO_HEADLESS"] = "1"  # Skip stop hook post-mortem
     env.pop("CLAUDECODE", None)
     env.pop("CLAUDE_CODE", None)
 
     try:
         result = subprocess.run(
             [str(CLAUDE_CLI), "-p", prompt, "--model", "opus",
-             "--output-format", "text", "--bare",
-             "--allowedTools", "Read,Write,Edit,Glob,Grep"],
-            capture_output=True, text=True, timeout=300, env=env
+             "--output-format", "text",
+             "--allowedTools", "Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*"],
+            capture_output=True, text=True, timeout=21600, env=env
         )
 
         if result.returncode != 0:

package/src/scripts/nexo-proactive-dashboard.py

@@ -38,6 +38,7 @@ def check_overdue_followups() -> list[dict]:
         SELECT id, description, date, created_at, reasoning
         FROM followups
         WHERE status NOT LIKE 'COMPLETED%'
+        AND status NOT IN ('DELETED','archived','blocked','waiting')
         AND date IS NOT NULL AND date != ''
         ORDER BY date ASC
     """).fetchall()