nexo-brain 2.0.0 → 2.2.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-auto-update 2.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python3
+"""DEPRECATED: Updates are handled automatically by NEXO on startup."""
+import sys
+print("This script is deprecated. NEXO auto-updates on startup.")
+print("To update manually, use the nexo_update MCP tool.")
+sys.exit(0)

package/src/scripts/nexo-backup 2.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+# NEXO DB hourly backup — crontab: 0 * * * * $NEXO_HOME/scripts/nexo-backup.sh
+NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
+NEXO_DIR="$NEXO_HOME"
+BACKUP_DIR="$NEXO_HOME/backups"
+WEEKLY_DIR="$BACKUP_DIR/weekly"
+DB="$NEXO_HOME/data/nexo.db"
+RETENTION_HOURS=48
+
+mkdir -p "$BACKUP_DIR" "$WEEKLY_DIR"
+
+# Hourly backup
+TIMESTAMP=$(date +%Y-%m-%d-%H%M)
+sqlite3 "$DB" ".backup '$BACKUP_DIR/nexo-$TIMESTAMP.db'"
+
+# Weekly backup — save one per week (Sundays)
+WEEK=$(date +%Y-W%V)
+WEEKLY_FILE="$WEEKLY_DIR/weekly-$WEEK.db"
+if [ ! -f "$WEEKLY_FILE" ] && [ "$(date +%u)" = "7" ]; then
+    cp "$BACKUP_DIR/nexo-$TIMESTAMP.db" "$WEEKLY_FILE"
+fi
+
+# Cleanup: hourly >48h, weekly >90 days
+find "$BACKUP_DIR" -maxdepth 1 -name "nexo-*.db" -mmin +$((RETENTION_HOURS * 60)) -delete
+find "$WEEKLY_DIR" -name "weekly-*.db" -mtime +90 -delete

package/src/scripts/nexo-brain-activation 2.sh

@@ -0,0 +1,140 @@
+#!/usr/bin/env bash
+# nexo-brain-activation.sh — NF24: Spontaneous Activation
+# Reads user_model.json, detects significant shifts, and generates insights
+# for NEXO startup. If nothing relevant: exit 0 with no output.
+
+set -euo pipefail
+
+BRAIN_DIR="~/.nexo/brain"
+MODEL_FILE="$BRAIN_DIR/user_model.json"
+SUMMARIES_DIR="$BRAIN_DIR/daily_summaries"
+
+# --- Guard: required file ---
+if [[ ! -f "$MODEL_FILE" ]]; then
+    exit 0
+fi
+
+# --- Inline Python to parse JSON and analyze ---
+python3 - <<'PYEOF'
+import json
+import sys
+import os
+import glob
+from datetime import datetime, timedelta
+
+BRAIN_DIR = os.path.expanduser("~/.nexo/brain")
+MODEL_FILE = os.path.join(BRAIN_DIR, "user_model.json")
+SUMMARIES_DIR = os.path.join(BRAIN_DIR, "daily_summaries")
+
+# ── Load model ──────────────────────────────────────────────────────────
+try:
+    with open(MODEL_FILE) as f:
+        model = json.load(f)
+except Exception:
+    sys.exit(0)
+
+insights = []
+
+# ── 1. Analyze evolution_log — last 3-5 entries ─────────────────────
+evolution = model.get("evolution_log", [])
+recent = evolution[-5:] if len(evolution) >= 5 else evolution
+
+# Detect entries from the last 3 days
+today = datetime.now().date()
+cutoff = today - timedelta(days=3)
+
+recent_obs = []
+for entry in recent:
+    try:
+        entry_date = datetime.strptime(entry["date"], "%Y-%m-%d").date()
+        if entry_date >= cutoff:
+            recent_obs.append(entry)
+    except Exception:
+        pass
+
+if recent_obs:
+    for obs in recent_obs[-2:]:  # max 2 most recent
+        insights.append(obs["observation"].strip())
+
+# ── 2. Detect trait changes >0.1 between entries (if history exists) ──
+# The current model only has a snapshot; if in the future there is history
+# in evolution_log with trait deltas, this can be expanded here.
+# Detect the most extreme trait as the dominant identity signal.
+traits = model.get("traits", {})
+if traits:
+    dominant = max(traits, key=lambda k: traits[k])
+    dominant_val = traits[dominant]
+    weakest = min(traits, key=lambda k: traits[k])
+    weakest_val = traits[weakest]
+    # Only report if extreme (>0.9 or <0.2) to avoid noise
+    if dominant_val >= 0.9:
+        insights.append(f"Dominant trait: {dominant}={dominant_val} (highest recorded)")
+    if weakest_val <= 0.2:
+        insights.append(f"Lowest trait: {weakest}={weakest_val} (low tolerance active)")
+
+# ── 3. Recent contradictions (last 3 days) ─────────────────────────
+contradictions = model.get("contradictions", [])
+recent_contradictions = []
+for c in contradictions:
+    try:
+        c_date = datetime.strptime(c["date"], "%Y-%m-%d").date()
+        if c_date >= cutoff:
+            recent_contradictions.append(c)
+    except Exception:
+        pass
+
+for c in recent_contradictions:
+    insights.append(f"Contradiction detected: {c['description'].strip()}")
+
+# ── 4. Current active focus ─────────────────────────────────────────────────
+current_focus = model.get("current_focus", [])
+# Only include if there are focus items (and it's not initial startup)
+if len(current_focus) > 0 and len(insights) == 0:
+    # If no other insights, report focus as minimum context
+    focus_str = ", ".join(current_focus)
+    insights.append(f"Current focus: {focus_str}")
+
+# ── 5. Goals: active/dormant changes ─────────────────────────────────────
+goals_active = model.get("goals_active", [])
+goals_dormant = model.get("goals_dormant", [])
+# If there are dormant goals, mention them (may need reactivation)
+if goals_dormant:
+    insights.append(f"Goal dormant: {goals_dormant[0]}")
+
+# ── Read last daily summary ─────────────────────────────────────────────
+summary_text = ""
+try:
+    files = sorted(glob.glob(os.path.join(SUMMARIES_DIR, "*.md")))
+    if files:
+        with open(files[-1]) as f:
+            lines = [l.rstrip() for l in f.readlines() if l.strip()]
+        # Take up to 3 lines of content (exclude header)
+        content_lines = [l for l in lines if not l.startswith("# Resumen") and not l.startswith("# Summary")]
+        summary_text = " | ".join(content_lines[:3])
+except Exception:
+    pass
+
+# ── Output ────────────────────────────────────────────────────────────────
+# If no real insights, exit without output
+if not insights and not summary_text:
+    sys.exit(0)
+
+# Deduplicate and limit
+seen = set()
+unique_insights = []
+for ins in insights:
+    key = ins[:60]
+    if key not in seen:
+        seen.add(key)
+        unique_insights.append(ins)
+
+if unique_insights:
+    print("BRAIN_INSIGHTS:")
+    for ins in unique_insights[:5]:
+        print(f"- {ins}")
+
+if summary_text:
+    print("RECENT_SUMMARY:")
+    print(summary_text[:400])
+
+PYEOF

package/src/scripts/nexo-catchup 2.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+"""
+NEXO Catch-Up — Runs at Mac boot to execute any missed scheduled tasks.
+
+When the Mac was asleep/off during scheduled times, launchd does NOT retry
+missed StartCalendarInterval jobs. This script detects what was missed and
+runs them in the correct order.
+
+Scheduled tasks (ordered by intended run time):
+  03:00 — cognitive-decay (Ebbinghaus decay + STM→LTM promotion)
+  03:00 — evolution (weekly, Sundays only)
+  04:00 — sleep (session cleanup)
+  07:00 — self-audit (health checks + weekly cognitive GC on Sundays)
+  23:30 — postmortem (consolidation + sensory register)
+
+Logic: For each task, check if its last successful run was before the
+most recent scheduled time. If so, run it now.
+"""
+
+import json
+import os
+import subprocess
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+
+CLAUDE_CLI = Path.home() / ".local" / "bin" / "claude"
+
+HOME = Path.home()
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+LOG_DIR = NEXO_HOME / "logs"
+LOG_DIR.mkdir(parents=True, exist_ok=True)
+LOG_FILE = LOG_DIR / "catchup.log"
+STATE_FILE = NEXO_HOME / "operations" / ".catchup-state.json"
+
+SCRIPTS = NEXO_HOME / "scripts"
+
+# Resolve Python: prefer NEXO's venv, then the same Python running this script
+def _resolve_python() -> str:
+    """Find the best Python to use for subprocess calls."""
+    # Check for NEXO_CODE env var pointing to the repo's src/
+    nexo_code = os.environ.get("NEXO_CODE", "")
+    if nexo_code:
+        venv_python = Path(nexo_code).parent / ".venv" / "bin" / "python"
+        if venv_python.exists():
+            return str(venv_python)
+    # Check for venv relative to NEXO_HOME
+    venv_python = NEXO_HOME / ".venv" / "bin" / "python"
+    if venv_python.exists():
+        return str(venv_python)
+    # Fall back to the same Python running this script
+    return sys.executable
+
+NEXO_PYTHON = _resolve_python()
+
+
+def log(msg: str):
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    line = f"[{ts}] {msg}"
+    print(line, flush=True)
+    with open(LOG_FILE, "a") as f:
+        f.write(line + "\n")
+
+
+def load_state() -> dict:
+    if STATE_FILE.exists():
+        try:
+            return json.loads(STATE_FILE.read_text())
+        except Exception:
+            pass
+    return {}
+
+
+def save_state(state: dict):
+    STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    STATE_FILE.write_text(json.dumps(state, indent=2))
+
+
+def last_scheduled_time(hour: int, minute: int, weekday: int = None) -> datetime:
+    """Calculate the most recent time this task should have run."""
+    now = datetime.now()
+    today_at = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
+
+    if weekday is not None:
+        # Weekly task — find the most recent matching weekday
+        days_since = (now.weekday() - weekday) % 7
+        target = now - timedelta(days=days_since)
+        target = target.replace(hour=hour, minute=minute, second=0, microsecond=0)
+        if target > now:
+            target -= timedelta(weeks=1)
+        return target
+
+    # Daily task
+    if today_at <= now:
+        return today_at
+    else:
+        return today_at - timedelta(days=1)
+
+
+def should_run(task_name: str, hour: int, minute: int, state: dict, weekday: int = None) -> bool:
+    """Check if task needs catch-up: last run was before last scheduled time."""
+    last_run_str = state.get(task_name)
+    last_scheduled = last_scheduled_time(hour, minute, weekday)
+
+    if not last_run_str:
+        # Never ran — should run
+        return True
+
+    try:
+        last_run = datetime.fromisoformat(last_run_str)
+    except ValueError:
+        return True
+
+    return last_run < last_scheduled
+
+
+def run_task(name: str, python: str, script: str, state: dict) -> bool:
+    """Execute a task and update state."""
+    script_path = str(SCRIPTS / script)
+    if not Path(script_path).exists():
+        log(f"  SKIP {name}: script not found ({script_path})")
+        return False
+
+    log(f"  RUNNING {name}: {script}")
+    try:
+        result = subprocess.run(
+            [python, script_path],
+            capture_output=True, text=True, timeout=21600,
+            env={**os.environ, "HOME": str(HOME), "NEXO_CATCHUP": "1"}
+        )
+        if result.returncode == 0:
+            log(f"  OK {name} (exit 0)")
+        else:
+            log(f"  WARN {name} (exit {result.returncode})")
+            if result.stderr:
+                log(f"    stderr: {result.stderr[:300]}")
+        state[name] = datetime.now().isoformat()
+        save_state(state)
+        return True
+    except subprocess.TimeoutExpired:
+        log(f"  TIMEOUT {name} (300s)")
+        return False
+    except Exception as e:
+        log(f"  ERROR {name}: {e}")
+        return False
+
+
+def main():
+    log("=== NEXO Catch-Up starting (boot/wake) ===")
+    state = load_state()
+
+    # Define tasks in execution order (matching their intended schedule order)
+    # Note: auto-update is handled by the MCP server on startup, not by catchup.
+    tasks = [
+        # (name, hour, minute, python, script, weekday)
+        ("cognitive-decay", 3, 0, NEXO_PYTHON, "nexo-cognitive-decay.py", None),
+        ("evolution", 3, 0, NEXO_PYTHON, "nexo-evolution-run.py", 6),  # Sunday = 6
+        ("sleep", 4, 0, NEXO_PYTHON, "nexo-sleep.py", None),
+        ("self-audit", 7, 0, NEXO_PYTHON, "nexo-daily-self-audit.py", None),
+        ("github-monitor", 8, 0, NEXO_PYTHON, "nexo-github-monitor.py", None),
+        ("postmortem", 23, 30, NEXO_PYTHON, "nexo-postmortem-consolidator.py", None),
+    ]
+
+    ran = 0
+    skipped = 0
+    for name, hour, minute, python, script, weekday in tasks:
+        if should_run(name, hour, minute, state, weekday):
+            log(f"  {name} — missed scheduled run, catching up...")
+            if run_task(name, python, script, state):
+                ran += 1
+        else:
+            skipped += 1
+
+    if ran == 0:
+        log("All tasks up to date, nothing to catch up.")
+    elif ran >= 3:
+        # Many tasks caught up — ask CLI to assess system state
+        _cli_post_catchup_assessment(ran, skipped, state)
+    else:
+        log(f"Caught up {ran} tasks, {skipped} already current.")
+
+    log("=== Catch-Up complete ===")
+
+
+def _cli_post_catchup_assessment(ran: int, skipped: int, state: dict):
+    """When 3+ tasks were missed, use CLI to assess if there are concerns."""
+    if not CLAUDE_CLI.exists():
+        log(f"Caught up {ran} tasks, {skipped} already current. (CLI unavailable for assessment)")
+        return
+    )
+    if auth_check.returncode != 0:
+        # CLI not authenticated, skip gracefully
+        print(f"[{datetime.now().strftime('%H:%M:%S')}] Claude CLI not authenticated. Skipping CLI analysis.")
+        return
+
+    assessment_file = LOG_DIR / "catchup-assessment.md"
+    state_summary = json.dumps(state, indent=2, default=str)
+
+    prompt = f"""You are the NEXO Catch-Up system. The Mac was off/asleep and {ran} scheduled tasks just ran as catch-up ({skipped} were already current).
+
+Task run state (timestamps of last successful runs):
+{state_summary}
+
+Assess:
+1. How long was the system likely offline? (compare timestamps to now)
+2. Are there any tasks that depend on each other where order matters?
+3. Any tasks that may have produced stale results because they ran late?
+4. Should any task be re-run at its normal time today?
+
+Write a brief assessment (max 20 lines) to: {assessment_file}
+
+Format:
+## Catch-Up Assessment — {datetime.now().strftime('%Y-%m-%d %H:%M')}
+- Offline duration: ~Xh
+- Tasks caught up: {ran}
+- Concerns: ...
+- Recommendation: ..."""
+
+    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",
+             "--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}")
+        else:
+            log(f"CLI assessment exited {result.returncode}")
+    except subprocess.TimeoutExpired:
+        log("CLI assessment timed out (90s)")
+    except Exception as e:
+        log(f"CLI assessment error: {e}")
+
+
+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}")