nexo-brain 2.1.0 → 2.2.0

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-cognitive-decay 2.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""NEXO Cognitive Decay — Daily Ebbinghaus sweep + STM→LTM promotion."""
+
+import json
+import os
+import sys
+from pathlib import Path
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+# Auto-detect: if running from repo (src/scripts/), use src/ as NEXO_CODE
+_script_dir = Path(__file__).resolve().parent
+_repo_src = _script_dir.parent  # src/scripts/ -> src/
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(_repo_src) if (_repo_src / "server.py").exists() else str(NEXO_HOME)))
+from datetime import datetime, timedelta
+
+sys.path.insert(0, str(NEXO_CODE))
+import cognitive
+
+STATE_FILE = NEXO_HOME / "operations" / ".catchup-state.json"
+
+
+def update_catchup_state():
+    """Register successful run so catch-up script knows we ran."""
+    try:
+        state = json.loads(STATE_FILE.read_text()) if STATE_FILE.exists() else {}
+    except Exception:
+        state = {}
+    state["cognitive-decay"] = datetime.now().isoformat()
+    STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    STATE_FILE.write_text(json.dumps(state, indent=2))
+
+
+def main():
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    print(f"[{ts}] Cognitive decay starting...")
+
+    # 0. Process quarantine FIRST — promote/reject/expire pending items
+    #    BUG FIX 26-Mar-2026: quarantine was NEVER processed automatically.
+    #    78 items were stuck as pending indefinitely.
+    try:
+        q_result = cognitive.process_quarantine()
+        print(f"[{ts}] Quarantine: {q_result['promoted']} promoted, {q_result['rejected']} rejected, "
+              f"{q_result['expired']} expired, {q_result['still_pending']} still pending.")
+    except Exception as e:
+        print(f"[{ts}] Quarantine processing error: {e}")
+
+    # 0b. Purge test/dev memories from STM
+    try:
+        test_purged = cognitive.gc_test_memories()
+        if test_purged > 0:
+            print(f"[{ts}] Purged {test_purged} test/dev memories from STM.")
+    except Exception as e:
+        print(f"[{ts}] Test memory purge error: {e}")
+
+    # 1. Apply decay
+    cognitive.apply_decay()
+    print(f"[{ts}] Decay applied.")
+
+    # 2. Promote eligible STM → LTM
+    promoted = cognitive.promote_stm_to_ltm()
+    print(f"[{ts}] Promoted {promoted} STM memories to LTM.")
+
+    # 3. Garbage collect expired STM + sensory
+    gc_count = cognitive.gc_stm()
+    try:
+        gc_sensory = cognitive.gc_sensory(max_age_hours=48)
+        print(f"[{ts}] GC: removed {gc_count} expired STM, {gc_sensory} expired sensory.")
+    except Exception as e:
+        print(f"[{ts}] GC: removed {gc_count} expired STM. Sensory GC error: {e}")
+
+    # 4. Semantic consolidation — merge near-duplicate LTM (cosine > 0.9)
+    #    With discriminative fusion: siblings (different environments) are linked, not merged
+    try:
+        result = cognitive.consolidate_semantic(threshold=0.9, dry_run=False)
+        merged = result.get("merged", [])
+        siblings = result.get("siblings", [])
+        if merged:
+            print(f"[{ts}] Consolidated {len(merged)} duplicate LTM pairs:")
+            for m in merged[:10]:
+                print(f"[{ts}]   [{m['score']}] kept #{m['keep_id']} ({m['keep_access']} accesses), merged #{m['drop_id']}")
+        if siblings:
+            print(f"[{ts}] Linked {len(siblings)} sibling pairs (similar-but-incompatible):")
+            for s in siblings[:10]:
+                print(f"[{ts}]   [{s['score']}] #{s['memory_a_id']} <> #{s['memory_b_id']} differ in: {', '.join(s['discriminators'])}")
+        if not merged and not siblings:
+            print(f"[{ts}] No semantic duplicates or siblings found (threshold=0.9)")
+    except Exception as e:
+        print(f"[{ts}] Consolidation error: {e}")
+
+    # 5. Correction fatigue — mark memories corrected 3+ times as unreliable
+    try:
+        fatigued = cognitive.check_correction_fatigue()
+        if fatigued:
+            print(f"[{ts}] CORRECTION FATIGUE: {len(fatigued)} memories corrected 3+ times in 7d:")
+            for f in fatigued:
+                print(f"[{ts}]   LTM #{f['memory_id']} ({f['corrections_7d']}x): {f['content'][:80]}...")
+        else:
+            print(f"[{ts}] No correction fatigue detected.")
+    except Exception as e:
+        print(f"[{ts}] Correction fatigue check error: {e}")
+
+    # 6. Memory Dreaming — discover hidden connections between recent memories
+    try:
+        dream_result = cognitive.dream_cycle(max_insights=15)
+        scanned = dream_result["memories_scanned"]
+        created = dream_result["insights_created"]
+        candidates = dream_result["candidates_found"]
+        print(f"[{ts}] Dream cycle: scanned {scanned} recent memories, {candidates} candidates, {created} insights created.")
+        for insight in dream_result["insights"][:10]:
+            print(f"[{ts}]   [{insight['similarity']}] {insight['title_a'][:40]} <-> {insight['title_b'][:40]}")
+    except Exception as e:
+        print(f"[{ts}] Dream cycle error: {e}")
+
+    # 7. Auto-merge duplicates (runs AFTER dream_cycle, higher threshold than consolidation)
+    try:
+        merge_result = cognitive.auto_merge_duplicates(threshold=0.92)
+        if merge_result["merged"] > 0:
+            print(f"[{ts}] Auto-merge: scanned {merge_result['scanned']}, merged {merge_result['merged']} duplicates, {merge_result['kept']} kept.")
+            for m in merge_result["merge_log"][:10]:
+                print(f"[{ts}]   [{m['similarity']}] kept #{m['kept_id']}, dropped #{m['dropped_id']}")
+        else:
+            print(f"[{ts}] Auto-merge: scanned {merge_result['scanned']}, no duplicates above 0.92 threshold.")
+    except Exception as e:
+        print(f"[{ts}] Auto-merge error: {e}")
+
+    # 9. Adaptive weight learning — Ridge regression from feedback-annotated entries
+    try:
+        sys.path.insert(0, str(NEXO_CODE / "plugins"))
+        from adaptive_mode import learn_weights, prune_adaptive_log, check_weight_rollback
+
+        rollback = check_weight_rollback()
+        if rollback["status"] == "rolled_back":
+            print(f"[{ts}] WEIGHT ROLLBACK: {rollback['reason']}")
+        elif rollback["status"] == "ok":
+            print(f"[{ts}] Weight health: pre={rollback['pre_rate']}/day, post={rollback['post_rate']}/day")
+        elif rollback["status"] != "no_learned_weights":
+            print(f"[{ts}] Weight rollback: {rollback['status']}")
+
+        result = learn_weights()
+        if result["status"] in ("shadow", "active"):
+            mode_label = "SHADOW" if result["status"] == "shadow" else "ACTIVE"
+            print(f"[{ts}] Learned weights ({mode_label}) from {result['samples']} samples. Max drift: {result['max_drift']:.4f}")
+            for signal, weight in result["weights"].items():
+                drift = result["drift"][signal]
+                arrow = "+" if drift > 0 else "" if drift < 0 else "="
+                print(f"[{ts}]   {signal}: {weight:.4f} ({arrow}{drift:.4f} from static)")
+        elif result["status"] == "insufficient_data":
+            print(f"[{ts}] Weight learning: {result['samples']}/{result['min_required']} samples (waiting)")
+        else:
+            print(f"[{ts}] Weight learning: {result['status']}")
+
+        pruned = prune_adaptive_log(max_age_days=90)
+        if pruned > 0:
+            print(f"[{ts}] Pruned {pruned} adaptive_log entries >90 days")
+    except Exception as e:
+        print(f"[{ts}] Adaptive weight learning error: {e}")
+
+    # 10. Project somatic events from nexo.db -> cognitive.db
+    try:
+        projected = cognitive.somatic_project_events()
+        if projected > 0:
+            print(f"[{ts}] Somatic projection: {projected} events projected to cognitive.db")
+    except Exception as e:
+        print(f"[{ts}] Somatic projection error: {e}")
+
+    # 11. Somatic marker nightly decay
+    try:
+        decayed = cognitive.somatic_nightly_decay(gamma=0.95)
+        print(f"[{ts}] Somatic decay: {decayed} markers processed (x0.95)")
+    except Exception as e:
+        print(f"[{ts}] Somatic decay error: {e}")
+
+    # 8. Stats
+    stats = cognitive.get_stats()
+    print(f"[{ts}] STM: {stats['stm_active']} active (+{stats.get('stm_promoted', 0)} promoted, {stats.get('stm_total', 0)} total) | LTM: {stats['ltm_active']} active, {stats['ltm_dormant']} dormant")
+    print(f"[{ts}] Done.")
+
+    update_catchup_state()
+
+
+if __name__ == "__main__":
+    main()