nexo-brain 2.3.0 → 2.3.1

package/src/scripts/check-context 2.py

@@ -1,264 +0,0 @@
-#!/usr/bin/env python3
-"""Context checker for NEXO operations - prevents duplicate actions.
-
-Mechanical checks (email sent, file exists, action done) run in Python.
-When the 'smart' command is used, passes context to Claude CLI for
-intelligent duplicate/conflict detection that goes beyond file checks.
-"""
-
-import os
-import sys
-import json
-import hashlib
-import subprocess
-from datetime import datetime
-from pathlib import Path
-
-NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
-
-CLAUDE_CLI = Path.home() / ".local" / "bin" / "claude"
-
-class ContextChecker:
-    def __init__(self):
-        self.state_dir = NEXO_HOME / 'state'
-        self.state_dir.mkdir(exist_ok=True)
-        
-    def check_email_sent(self, to_addr, subject, since_hours=72):
-        """Check if email was already sent to address with subject."""
-        sent_path = Path.home() / 'mail' / '.nexo-sent' / '.Sent'  # Configure for your mail setup
-        if not sent_path.exists():
-            return False
-
-        subject_lower = subject.lower()
-        to_lower = to_addr.lower()
-        cutoff = datetime.now().timestamp() - (since_hours * 3600)
-        cur_dir = sent_path / 'cur'
-        if not cur_dir.exists():
-            return False
-
-        for msg_file in cur_dir.iterdir():
-            try:
-                if msg_file.stat().st_mtime < cutoff:
-                    continue
-                content = msg_file.read_text(errors='ignore')
-            except (OSError, UnicodeDecodeError):
-                continue
-
-            content_lower = content.lower()
-            if f"to:{to_lower}" in content_lower or f"to: {to_lower}" in content_lower:
-                if subject_lower in content_lower:
-                    return True
-        return False
-        
-    def check_file_exists(self, pattern, search_dirs=None):
-        """Check if file matching pattern exists in common locations."""
-        if search_dirs is None:
-            search_dirs = [
-                '/var/www/vhosts',
-                str(NEXO_HOME),
-                '/opt'
-            ]
-            
-        for base_dir in search_dirs:
-            if not os.path.exists(base_dir):
-                continue
-            matches = []
-            try:
-                for root, _, files in os.walk(base_dir):
-                    for filename in files:
-                        if pattern in filename:
-                            matches.append(str(Path(root) / filename))
-                            if len(matches) >= 5:
-                                return matches
-            except OSError:
-                continue
-        return []
-        
-    def check_action_done(self, action_type, identifier, ttl_days=7):
-        """Check if action was already performed recently."""
-        action_file = self.state_dir / 'actions.json'
-        
-        # Load existing actions
-        actions = {}
-        if action_file.exists():
-            with open(action_file) as f:
-                actions = json.load(f)
-                
-        # Create action key
-        key = hashlib.md5(f"{action_type}:{identifier}".encode()).hexdigest()
-        
-        # Check if exists and not expired
-        if key in actions:
-            action_time = datetime.fromisoformat(actions[key]['timestamp'])
-            age_days = (datetime.now() - action_time).days
-            if age_days < ttl_days:
-                return True, actions[key]
-                
-        return False, None
-        
-    def mark_action_done(self, action_type, identifier, metadata=None):
-        """Mark action as completed."""
-        action_file = self.state_dir / 'actions.json'
-        
-        # Load existing actions
-        actions = {}
-        if action_file.exists():
-            with open(action_file) as f:
-                actions = json.load(f)
-                
-        # Add new action
-        key = hashlib.md5(f"{action_type}:{identifier}".encode()).hexdigest()
-        actions[key] = {
-            'type': action_type,
-            'identifier': identifier,
-            'timestamp': datetime.now().isoformat(),
-            'metadata': metadata or {}
-        }
-        
-        # Save
-        with open(action_file, 'w') as f:
-            json.dump(actions, f, indent=2)
-            
-        return key
-
-def smart_check(action_description: str, context: str = "") -> dict:
-    """Use Claude CLI to intelligently check if an action would be redundant.
-
-    Goes beyond simple file/hash checks — understands intent and context
-    to detect semantic duplicates (e.g., "send welcome email" vs
-    "email onboarding message" to same person).
-    """
-    checker = ContextChecker()
-
-    # Gather mechanical context first
-    state_file = checker.state_dir / 'actions.json'
-    recent_actions = {}
-    if state_file.exists():
-        try:
-            all_actions = json.loads(state_file.read_text())
-            cutoff = datetime.now().timestamp() - (7 * 86400)
-            for k, v in all_actions.items():
-                try:
-                    ts = datetime.fromisoformat(v['timestamp']).timestamp()
-                    if ts > cutoff:
-                        recent_actions[k] = v
-                except (ValueError, KeyError):
-                    pass
-        except Exception:
-            pass
-
-    if not CLAUDE_CLI.exists():
-        return {"redundant": False, "reason": "CLI unavailable, cannot smart-check"}
-
-    prompt = f"""You are a context deduplication engine for NEXO operations.
-
-PROPOSED ACTION:
-{action_description}
-
-ADDITIONAL CONTEXT:
-{context or "None"}
-
-RECENT ACTIONS (last 7 days):
-{json.dumps(list(recent_actions.values()), indent=1, default=str)}
-
-Respond with ONLY valid JSON (no markdown):
-{{
-  "redundant": true/false,
-  "confidence": 0.0-1.0,
-  "reason": "<one line explanation>",
-  "matching_action": "<identifier of matching action if redundant, else null>"
-}}
-
-Rules:
-- Same recipient + same intent within 72h = redundant
-- Same file modification with same content = redundant
-- Similar but different scope (e.g., different recipients) = NOT redundant
-- When in doubt, say not redundant (false negatives are cheaper than false positives)"""
-    )
-    if auth_check.returncode != 0:
-        # CLI not authenticated, skip gracefully
-        return {"redundant": False, "reason": "CLI not authenticated — skipped analysis", "suggestion": "N/A"}
-
-    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:
-            text = result.stdout.strip()
-            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 Exception:
-        pass
-
-    return {"redundant": False, "reason": "CLI check failed, defaulting to not redundant"}
-
-
-def main():
-    """CLI interface for context checking."""
-    if len(sys.argv) < 3:
-        print("Usage: check-context.py <command> <args>")
-        print("Commands:")
-        print("  email <to> <subject>       - Check if email was sent")
-        print("  file <pattern>             - Check if file exists")
-        print("  action <type> <id>         - Check if action was done")
-        print("  smart <description> [ctx]  - Intelligent duplicate check via CLI")
-        sys.exit(1)
-
-    checker = ContextChecker()
-    command = sys.argv[1]
-
-    if command == 'email':
-        if len(sys.argv) < 4:
-            print("Usage: check-context.py email <to> <subject>")
-            sys.exit(1)
-        exists = checker.check_email_sent(sys.argv[2], sys.argv[3])
-        print("EXISTS" if exists else "NOT_FOUND")
-        sys.exit(0 if not exists else 1)
-
-    elif command == 'file':
-        files = checker.check_file_exists(sys.argv[2])
-        if files:
-            print("\n".join(files))
-            sys.exit(1)
-        else:
-            print("NOT_FOUND")
-            sys.exit(0)
-
-    elif command == 'action':
-        if len(sys.argv) < 4:
-            print("Usage: check-context.py action <type> <id>")
-            sys.exit(1)
-        done, data = checker.check_action_done(sys.argv[2], sys.argv[3])
-        if done:
-            print(f"DONE: {data}")
-            sys.exit(1)
-        else:
-            print("NOT_DONE")
-            sys.exit(0)
-
-    elif command == 'smart':
-        if len(sys.argv) < 3:
-            print("Usage: check-context.py smart <description> [context]")
-            sys.exit(1)
-        description = sys.argv[2]
-        context = sys.argv[3] if len(sys.argv) > 3 else ""
-        result = smart_check(description, context)
-        print(json.dumps(result, indent=2))
-        sys.exit(1 if result.get("redundant") else 0)
-
-    else:
-        print(f"Unknown command: {command}")
-        sys.exit(1)
-
-if __name__ == '__main__':
-    main()

package/src/scripts/nexo-auto-update 2.py

@@ -1,6 +0,0 @@
-#!/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

@@ -1,25 +0,0 @@
-#!/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

@@ -1,140 +0,0 @@
-#!/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

@@ -1,242 +0,0 @@
-#!/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()