nexo-brain 2.0.0 → 2.1.0

package/src/crons/sync.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+"""
+NEXO Cron Sync — Synchronize crons/manifest.json with system LaunchAgents (macOS).
+
+Called by nexo_update after pulling new code. Ensures:
+- New crons in manifest → installed
+- Removed crons from manifest → unloaded + deleted
+- Changed schedule/interval → plist updated + reloaded
+- Personal (non-core) crons → left untouched
+
+Usage:
+  python3 crons/sync.py [--dry-run]
+
+Environment:
+  NEXO_HOME — root of NEXO installation
+  NEXO_CODE — path to NEXO source (defaults to script parent's parent)
+"""
+
+import json
+import os
+import platform
+import plistlib
+import subprocess
+import sys
+from pathlib import Path
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent.parent)))
+MANIFEST = Path(__file__).resolve().parent / "manifest.json"
+LAUNCH_AGENTS_DIR = Path.home() / "Library" / "LaunchAgents"
+LABEL_PREFIX = "com.nexo."
+LOG_DIR = NEXO_HOME / "logs"
+
+
+def log(msg: str):
+    print(f"[cron-sync] {msg}", flush=True)
+
+
+def load_manifest() -> list[dict]:
+    with open(MANIFEST) as f:
+        data = json.load(f)
+    return data.get("crons", [])
+
+
+def build_plist(cron: dict) -> dict:
+    """Build a macOS LaunchAgent plist dict from a manifest entry."""
+    cron_id = cron["id"]
+    label = f"{LABEL_PREFIX}{cron_id}"
+    script_path = str(NEXO_CODE / cron["script"])
+    script_type = cron.get("type", "python")
+
+    if script_type == "shell":
+        program_args = ["/bin/bash", script_path]
+    else:
+        # Find python3
+        python_candidates = [
+            "/opt/homebrew/bin/python3",
+            "/usr/local/bin/python3",
+            "/Library/Frameworks/Python.framework/Versions/3.12/bin/python3",
+            "/usr/bin/python3",
+        ]
+        python_bin = "python3"
+        for p in python_candidates:
+            if Path(p).exists():
+                python_bin = p
+                break
+        program_args = [python_bin, script_path]
+
+    plist = {
+        "Label": label,
+        "ProgramArguments": program_args,
+        "StandardOutPath": str(LOG_DIR / f"{cron_id}-stdout.log"),
+        "StandardErrorPath": str(LOG_DIR / f"{cron_id}-stderr.log"),
+        "EnvironmentVariables": {
+            "PATH": "/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin:"
+                    + str(Path.home() / ".local" / "bin") + ":"
+                    + str(Path.home() / ".nvm/versions/node/v22.14.0/bin") + ":"
+                    + "/Library/Frameworks/Python.framework/Versions/3.12/bin",
+            "HOME": str(Path.home()),
+            "NEXO_HOME": str(NEXO_HOME),
+            "NEXO_CODE": str(NEXO_CODE),
+            "PYTHONUNBUFFERED": "1",
+        },
+    }
+
+    # Schedule
+    if "interval_seconds" in cron:
+        plist["StartInterval"] = cron["interval_seconds"]
+    elif "schedule" in cron:
+        cal = {}
+        s = cron["schedule"]
+        if "hour" in s:
+            cal["Hour"] = s["hour"]
+        if "minute" in s:
+            cal["Minute"] = s["minute"]
+        if "weekday" in s:
+            cal["Weekday"] = s["weekday"]
+        plist["StartCalendarInterval"] = cal
+
+    return plist
+
+
+def get_installed_nexo_crons() -> dict[str, Path]:
+    """Return dict of cron_id → plist_path for installed NEXO crons."""
+    installed = {}
+    if not LAUNCH_AGENTS_DIR.exists():
+        return installed
+    for f in LAUNCH_AGENTS_DIR.glob(f"{LABEL_PREFIX}*.plist"):
+        cron_id = f.stem.replace(LABEL_PREFIX, "")
+        installed[cron_id] = f
+    return installed
+
+
+def plist_needs_update(existing_path: Path, new_plist: dict) -> bool:
+    """Check if the installed plist differs from what we'd generate."""
+    try:
+        with open(existing_path, "rb") as f:
+            existing = plistlib.load(f)
+    except Exception:
+        return True
+
+    # Compare key fields
+    if existing.get("ProgramArguments") != new_plist.get("ProgramArguments"):
+        return True
+    if existing.get("StartInterval") != new_plist.get("StartInterval"):
+        return True
+    if existing.get("StartCalendarInterval") != new_plist.get("StartCalendarInterval"):
+        return True
+    return False
+
+
+def install_plist(label: str, plist: dict, plist_path: Path, dry_run: bool):
+    """Write plist and load it."""
+    if dry_run:
+        log(f"  DRY-RUN: would install {plist_path.name}")
+        return
+
+    # Unload if already loaded
+    subprocess.run(["launchctl", "unload", str(plist_path)], capture_output=True)
+
+    with open(plist_path, "wb") as f:
+        plistlib.dump(plist, f)
+
+    subprocess.run(["launchctl", "load", str(plist_path)], capture_output=True)
+    log(f"  Installed + loaded: {plist_path.name}")
+
+
+def unload_plist(plist_path: Path, dry_run: bool):
+    """Unload and remove a plist."""
+    if dry_run:
+        log(f"  DRY-RUN: would remove {plist_path.name}")
+        return
+
+    subprocess.run(["launchctl", "unload", str(plist_path)], capture_output=True)
+    plist_path.unlink(missing_ok=True)
+    log(f"  Removed: {plist_path.name}")
+
+
+def sync(dry_run: bool = False):
+    if platform.system() != "Darwin":
+        log("Not macOS — cron sync only supports LaunchAgents. Skipping.")
+        return
+
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+    LAUNCH_AGENTS_DIR.mkdir(parents=True, exist_ok=True)
+
+    manifest_crons = load_manifest()
+    manifest_ids = {c["id"] for c in manifest_crons}
+    installed = get_installed_nexo_crons()
+
+    log(f"Manifest: {len(manifest_crons)} core crons")
+    log(f"Installed: {len(installed)} NEXO crons")
+
+    # 1. Install or update crons from manifest
+    for cron in manifest_crons:
+        cron_id = cron["id"]
+        label = f"{LABEL_PREFIX}{cron_id}"
+        plist_path = LAUNCH_AGENTS_DIR / f"{label}.plist"
+        new_plist = build_plist(cron)
+
+        if cron_id not in installed:
+            log(f"  NEW: {cron_id}")
+            install_plist(label, new_plist, plist_path, dry_run)
+        elif plist_needs_update(installed[cron_id], new_plist):
+            log(f"  UPDATE: {cron_id}")
+            install_plist(label, new_plist, plist_path, dry_run)
+        else:
+            log(f"  OK: {cron_id}")
+
+    # 2. Remove crons that are in installed but NOT in manifest and ARE core
+    #    (personal crons like shopify-backup, email-monitor are left alone)
+    for cron_id, plist_path in installed.items():
+        if cron_id not in manifest_ids:
+            # Check if this was previously a core cron by reading the plist
+            # If it points to NEXO_CODE scripts → it's core, safe to remove
+            try:
+                with open(plist_path, "rb") as f:
+                    existing = plistlib.load(f)
+                args = existing.get("ProgramArguments", [])
+                is_core = any(str(NEXO_CODE) in str(a) for a in args)
+            except Exception:
+                is_core = False
+
+            if is_core:
+                log(f"  REMOVE (no longer in manifest): {cron_id}")
+                unload_plist(plist_path, dry_run)
+            else:
+                log(f"  SKIP (personal): {cron_id}")
+
+    log("Sync complete.")
+
+
+if __name__ == "__main__":
+    dry_run = "--dry-run" in sys.argv
+    if dry_run:
+        log("DRY RUN MODE — no changes will be made")
+    sync(dry_run=dry_run)

package/src/dashboard/app.py

@@ -308,15 +308,29 @@ async def api_adaptive():
 
 @app.get("/api/sessions")
 async def api_sessions(limit: int = Query(10, ge=1, le=50)):
-    """Recent session diaries."""
+    """Recent session diaries + active sessions from sessions table."""
     db = _db()
     conn = db.get_db()
+    # Active sessions (from sessions table, not diaries)
+    active_rows = conn.execute(
+        "SELECT sid as session_id, task, last_update_epoch, claude_session_id "
+        "FROM sessions WHERE last_update_epoch > (strftime('%s','now') - 900) "
+        "ORDER BY last_update_epoch DESC"
+    ).fetchall()
+    active = [dict(r) for r in active_rows]
+    # Add last_heartbeat as ISO string for frontend
+    for a in active:
+        epoch = a.get("last_update_epoch", 0)
+        if epoch:
+            import datetime
+            a["last_heartbeat"] = datetime.datetime.fromtimestamp(epoch).isoformat()
+    # Recent diaries
     rows = conn.execute(
         "SELECT * FROM session_diary ORDER BY created_at DESC LIMIT ?",
         (limit,),
     ).fetchall()
     diaries = [dict(r) for r in rows]
-    return {"count": len(diaries), "sessions": diaries}
+    return {"count": len(diaries), "sessions": active, "diaries": diaries}
 
 
 @app.get("/api/kg/nodes")

package/src/dashboard/templates/dashboard.html

@@ -446,11 +446,12 @@
 
     // --- Overdue Items ---
     if (remindersData || followupsData) {
+      const excludeStatus = ['completed', 'COMPLETED', 'archived', 'deleted', 'DELETED', 'blocked', 'waiting'];
       const reminders = (remindersData?.reminders || []).filter(r =>
-        r.status === 'PENDING' && r.date && r.date < today
+        !excludeStatus.includes(r.status) && r.date && r.date <= today
       );
       const followups = (followupsData?.followups || []).filter(f =>
-        f.status === 'PENDING' && f.date && f.date < today
+        !excludeStatus.includes(f.status) && f.date && f.date <= today
       );
       const total = reminders.length + followups.length;
       const el = document.getElementById('overdue-count');

package/src/db/_episodic.py

@@ -82,7 +82,7 @@ def auto_resolve_followups(change: dict) -> list[str]:
     conn = get_db()
     open_followups = conn.execute(
         "SELECT * FROM followups WHERE status NOT LIKE 'COMPLETED%' "
-        "AND status != 'DELETED'"
+        "AND status NOT IN ('DELETED','archived','blocked','waiting')"
     ).fetchall()
 
     if not open_followups:

package/src/db/_reminders.py

@@ -69,14 +69,16 @@ def get_reminders(filter_type: str = 'all') -> list[dict]:
     elif filter_type == 'due':
         rows = conn.execute(
             "SELECT * FROM reminders WHERE status NOT LIKE 'COMPLETED%' "
-            "AND status != 'DELETED' AND date IS NOT NULL AND date <= ? "
+            "AND status NOT IN ('DELETED','archived','blocked','waiting') "
+            "AND date IS NOT NULL AND date <= ? "
             "ORDER BY date ASC",
             (today,)
         ).fetchall()
     else:  # 'all' — active only
         rows = conn.execute(
             "SELECT * FROM reminders WHERE status NOT LIKE 'COMPLETED%' "
-            "AND status != 'DELETED' ORDER BY date ASC NULLS LAST"
+            "AND status NOT IN ('DELETED','archived','blocked','waiting') "
+            "ORDER BY date ASC NULLS LAST"
         ).fetchall()
     return [dict(r) for r in rows]
 
@@ -100,7 +102,7 @@ def find_similar_followups(description: str, threshold: float = 0.3) -> list[dic
     conn = get_db()
     rows = conn.execute(
         "SELECT * FROM followups WHERE status NOT LIKE 'COMPLETED%' "
-        "AND status != 'DELETED'"
+        "AND status NOT IN ('DELETED','archived','blocked','waiting')"
     ).fetchall()
 
     def tokenize(text: str) -> set:
@@ -313,14 +315,16 @@ def get_followups(filter_type: str = 'all') -> list[dict]:
     elif filter_type == 'due':
         rows = conn.execute(
             "SELECT * FROM followups WHERE status NOT LIKE 'COMPLETED%' "
-            "AND status != 'DELETED' AND date IS NOT NULL AND date <= ? "
+            "AND status NOT IN ('DELETED','archived','blocked','waiting') "
+            "AND date IS NOT NULL AND date <= ? "
             "ORDER BY date ASC",
             (today,)
         ).fetchall()
     else:  # 'all' — active only
         rows = conn.execute(
             "SELECT * FROM followups WHERE status NOT LIKE 'COMPLETED%' "
-            "AND status != 'DELETED' ORDER BY date ASC NULLS LAST"
+            "AND status NOT IN ('DELETED','archived','blocked','waiting') "
+            "ORDER BY date ASC NULLS LAST"
         ).fetchall()
     return [dict(r) for r in rows]
 

package/src/hooks/session-stop.sh

@@ -58,7 +58,8 @@ SESSION_START_TS="$NEXO_HOME/operations/.session-start-ts"
 # 0.5. Detect non-interactive (claude -p) sessions — skip post-mortem entirely
 #      SessionStart hook writes .session-start-ts. If missing or stale (>30 min),
 #      this is likely a -p script session — approve immediately.
-if [ ! -f "$SESSION_START_TS" ] || [ "$(($(date +%s) - $(cat "$SESSION_START_TS" 2>/dev/null || echo 0)))" -gt 1800 ]; then
+#      Also skip if NEXO_HEADLESS=1 is set (explicit headless mode for scripts).
+if [ "${NEXO_HEADLESS:-}" = "1" ] || [ ! -f "$SESSION_START_TS" ] || [ "$(($(date +%s) - $(cat "$SESSION_START_TS" 2>/dev/null || echo 0)))" -gt 1800 ]; then
     cat << 'HOOKEOF'
 {
   "decision": "approve"

package/src/plugins/core_rules.py

@@ -11,35 +11,52 @@ def _get_db():
 
 def _seed_if_empty():
     """Seed rules from JSON if table is empty (first run after migration)."""
+    import sys
     conn = _get_db()
     try:
         count = conn.execute("SELECT COUNT(*) FROM core_rules WHERE is_active = 1").fetchone()[0]
     except Exception:
-        # Table doesn't exist yet — migrations haven't run. Bail gracefully.
-        return
+        # Table doesn't exist yet — create it
+        conn.execute("""CREATE TABLE IF NOT EXISTS core_rules (
+            id TEXT PRIMARY KEY, category TEXT NOT NULL, rule TEXT NOT NULL,
+            why TEXT NOT NULL, importance INTEGER NOT NULL DEFAULT 3,
+            type TEXT NOT NULL DEFAULT 'advisory', added_in TEXT DEFAULT '',
+            removed_in TEXT DEFAULT NULL, is_active INTEGER NOT NULL DEFAULT 1)""")
+        conn.execute("""CREATE TABLE IF NOT EXISTS core_rules_version (
+            id INTEGER PRIMARY KEY, version TEXT NOT NULL, updated_at TEXT NOT NULL)""")
+        conn.execute("INSERT OR IGNORE INTO core_rules_version (id, version, updated_at) VALUES (1, '0.0.0', datetime('now'))")
+        conn.commit()
+        count = 0
     if count > 0:
         return
 
     rules_file = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
                               "rules", "core-rules.json")
     if not os.path.exists(rules_file):
+        print(f"[core_rules] WARNING: {rules_file} not found, skipping seed", file=sys.stderr)
         return
 
-    with open(rules_file) as f:
-        data = json.load(f)
-
-    version = data["_meta"]["version"]
-    for cat_key, cat in data["categories"].items():
-        for rule in cat["rules"]:
-            conn.execute(
-                """INSERT OR REPLACE INTO core_rules (id, category, rule, why, importance, type, added_in)
-                   VALUES (?, ?, ?, ?, ?, ?, ?)""",
-                (rule["id"], cat_key, rule["rule"], rule["why"],
-                 rule["importance"], rule["type"], rule.get("added_in", version))
-            )
-
-    conn.execute("UPDATE core_rules_version SET version = ?, updated_at = datetime('now') WHERE id = 1", (version,))
-    conn.commit()
+    try:
+        with open(rules_file) as f:
+            data = json.load(f)
+
+        version = data["_meta"]["version"]
+        loaded = 0
+        for cat_key, cat in data["categories"].items():
+            for rule in cat["rules"]:
+                conn.execute(
+                    """INSERT OR REPLACE INTO core_rules (id, category, rule, why, importance, type, added_in)
+                       VALUES (?, ?, ?, ?, ?, ?, ?)""",
+                    (rule["id"], cat_key, rule["rule"], rule["why"],
+                     rule["importance"], rule["type"], rule.get("added_in", version))
+                )
+                loaded += 1
+
+        conn.execute("UPDATE core_rules_version SET version = ?, updated_at = datetime('now') WHERE id = 1", (version,))
+        conn.commit()
+        print(f"[core_rules] Seeded {loaded} rules (v{version})", file=sys.stderr)
+    except Exception as e:
+        print(f"[core_rules] ERROR seeding rules: {e}", file=sys.stderr)
 
 
 def handle_rules_check(area: str = "", importance_min: int = 0) -> str:

package/src/plugins/update.py

@@ -196,6 +196,22 @@ def handle_update(remote: str = "origin", branch: str = "main") -> str:
             raise RuntimeError(f"Verification failed: {verify_err}")
         steps_done.append("verify")
 
+        # Step 7: Sync crons with manifest
+        cron_sync_result = ""
+        try:
+            cron_sync_path = NEXO_CODE / "crons" / "sync.py"
+            if cron_sync_path.exists():
+                import subprocess as _sp
+                r = _sp.run(
+                    [sys.executable, str(cron_sync_path)],
+                    capture_output=True, text=True, timeout=30,
+                    env={**os.environ, "NEXO_HOME": str(NEXO_HOME), "NEXO_CODE": str(NEXO_CODE)},
+                )
+                cron_sync_result = r.stdout.strip()
+                steps_done.append("cron-sync")
+        except Exception as e:
+            cron_sync_result = f"Cron sync warning: {e}"
+
         # Build result
         if pull_out == "Already up to date.":
             return f"Already up to date (v{old_version}). No changes pulled."
@@ -209,6 +225,8 @@ def handle_update(remote: str = "origin", branch: str = "main") -> str:
         lines.append(f"  Backup: {backup_dir}")
         if version_changed:
             lines.append("  Migrations: applied")
+        if "cron-sync" in steps_done:
+            lines.append("  Crons: synced with manifest")
         lines.append("")
         lines.append("MCP server restart needed to load new code.")
         return "\n".join(lines)

package/src/scripts/check-context.py

@@ -174,24 +174,21 @@ Rules:
 - 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)"""
-
-    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 {"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", "--bare",
-             "--allowedTools", "Read,Write,Edit,Glob,Grep"],
-            capture_output=True, text=True, timeout=60, 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:
             text = result.stdout.strip()