nexo-brain 2.3.2 → 2.5.0

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

@@ -19,9 +19,13 @@ from datetime import datetime
 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().parents[2])))
 DEEP_SLEEP_DIR = NEXO_HOME / "operations" / "deep-sleep"
 PROMPT_FILE = Path(__file__).parent / "synthesize-prompt.md"
 
+if str(NEXO_CODE) not in sys.path:
+    sys.path.insert(0, str(NEXO_CODE))
+
 CLAUDE_TIMEOUT = 21600  # 3h safety net (prevents zombie processes)
 
 
@@ -71,6 +75,31 @@ def extract_json_from_response(text: str) -> dict | None:
     return None
 
 
+def collect_skill_runtime_candidates(target_date: str) -> tuple[Path, dict]:
+    """Collect mature skill candidates from DB usage so Deep Sleep can evolve them."""
+    output_file = DEEP_SLEEP_DIR / f"{target_date}-skill-runtime-candidates.json"
+    payload = {
+        "scriptable": [],
+        "improvements": [],
+    }
+    try:
+        from db import (
+            collect_scriptable_skill_candidates,
+            collect_skill_improvement_candidates,
+            init_db,
+        )
+
+        init_db()
+        payload["scriptable"] = collect_scriptable_skill_candidates()
+        payload["improvements"] = collect_skill_improvement_candidates()
+    except Exception as e:
+        payload["error"] = str(e)
+
+    with open(output_file, "w") as f:
+        json.dump(payload, f, indent=2, ensure_ascii=False)
+    return output_file, payload
+
+
 def main():
     target_date = sys.argv[1] if len(sys.argv) > 1 else datetime.now().strftime("%Y-%m-%d")
 
@@ -86,7 +115,10 @@ def main():
         extractions = json.load(f)
 
     total_findings = extractions.get("total_findings", 0)
-    if total_findings == 0:
+    runtime_candidates_file, runtime_candidates = collect_skill_runtime_candidates(target_date)
+    runtime_candidate_count = len(runtime_candidates.get("scriptable", [])) + len(runtime_candidates.get("improvements", []))
+
+    if total_findings == 0 and runtime_candidate_count == 0:
         print(f"[synthesize] No findings to synthesize for {target_date}.")
         # Write minimal synthesis
         output = {
@@ -95,6 +127,8 @@ def main():
             "cross_session_patterns": [],
             "morning_agenda": [],
             "context_packets": [],
+            "skills": [],
+            "skill_evolution_candidates": [],
             "actions": [],
             "summary": f"No significant findings for {target_date}."
         }
@@ -108,9 +142,11 @@ def main():
     prompt_template = PROMPT_FILE.read_text()
     prompt = prompt_template.replace("{{EXTRACTIONS_FILE}}", str(extractions_file))
     prompt = prompt.replace("{{CONTEXT_FILE}}", str(context_file))
+    prompt = prompt.replace("{{SKILL_RUNTIME_FILE}}", str(runtime_candidates_file))
 
     claude_bin = find_claude_cli()
     print(f"[synthesize] Phase 3: Synthesizing {total_findings} findings from {target_date}")
+    print(f"[synthesize] Skill runtime candidates: {runtime_candidate_count}")
     print(f"[synthesize] Claude CLI: {claude_bin}")
 
     try:

package/src/scripts/nexo-dashboard.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+# ============================================================================
+# NEXO Dashboard — Web UI at localhost:6174
+# Schedule: keepAlive (persistent daemon, auto-restart on crash)
+# ============================================================================
+set -uo pipefail
+
+NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
+NEXO_CODE="${NEXO_CODE:-$NEXO_HOME}"
+
+# Find Python
+if [ -x "$NEXO_HOME/.venv/bin/python3" ]; then
+    PYTHON="$NEXO_HOME/.venv/bin/python3"
+else
+    PYTHON="python3"
+fi
+
+# Dashboard module location: prefer NEXO_CODE (repo), fallback NEXO_HOME (installed)
+if [ -f "$NEXO_CODE/dashboard/app.py" ]; then
+    DASH_DIR="$NEXO_CODE"
+elif [ -f "$NEXO_HOME/dashboard/app.py" ]; then
+    DASH_DIR="$NEXO_HOME"
+else
+    echo "Dashboard not found" >&2
+    exit 1
+fi
+
+cd "$DASH_DIR"
+exec "$PYTHON" -m dashboard.app --no-browser --port 6174

package/src/scripts/nexo-day-orchestrator.sh

@@ -0,0 +1,139 @@
+#!/bin/bash
+# ============================================================================
+# NEXO Day Orchestrator — autonomous NEXO cycle every 15 min
+# Schedule: keepAlive, self-enforced operating hours (default 8:00-23:00)
+#
+# This is NOT a Python script that simulates intelligence.
+# This launches Claude Code as NEXO with full MCP access.
+# NEXO thinks, acts, and reports — like any interactive session.
+# ============================================================================
+set -euo pipefail
+
+NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
+LOG_DIR="$NEXO_HOME/logs"
+mkdir -p "$LOG_DIR" "$NEXO_HOME/operations"
+
+# --- Configuration ---
+CYCLE_INTERVAL=900  # 15 minutes between cycles
+CYCLE_TIMEOUT=600   # 10 min max per cycle
+MAX_TURNS=30        # Claude max turns per cycle
+HOUR_START=8
+HOUR_END=23
+
+# --- Find Claude CLI ---
+find_claude() {
+    for candidate in \
+        "$(command -v claude 2>/dev/null)" \
+        "$HOME/.claude/local/claude" \
+        "/opt/homebrew/bin/claude" \
+        "/usr/local/bin/claude"; do
+        if [ -n "$candidate" ] && [ -x "$candidate" ]; then
+            echo "$candidate"
+            return 0
+        fi
+    done
+    return 1
+}
+
+CLAUDE=$(find_claude) || {
+    echo "$(date '+%Y-%m-%d %H:%M') ERROR: claude CLI not found" >&2
+    exit 1
+}
+
+# --- Prevent overlapping cycles ---
+LOCKFILE="$NEXO_HOME/operations/.orchestrator.lock"
+acquire_lock() {
+    if [ -f "$LOCKFILE" ]; then
+        local pid
+        pid=$(cat "$LOCKFILE" 2>/dev/null || echo "")
+        if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+            return 1  # Still running
+        fi
+    fi
+    echo $$ > "$LOCKFILE"
+    return 0
+}
+release_lock() { rm -f "$LOCKFILE"; }
+
+# --- The orchestrator prompt ---
+PROMPT='You are NEXO in autonomous orchestrator mode. The user is NOT present. You have 5 minutes max.
+
+ABSOLUTE PRIORITY: act, do not list. If you can do something, do it. If you need the user, send email.
+
+CHECKLIST (in this order):
+
+1. OVERDUE FOLLOWUPS: nexo_reminders(filter="due") + nexo_reminders(filter="followups")
+   - NEXO tasks (verify, check, monitor) → DO THEM NOW
+   - Tasks needing user decision → accumulate for email
+   - Completed ones → nexo_followup_complete
+
+2. EMAIL: nexo_email_inbox(unread_only=true, limit=10)
+   - Emails you can process → process them
+   - Important emails for user → accumulate for email
+
+3. INFRASTRUCTURE: nexo_doctor(tier="runtime")
+   - If degraded/critical → try to fix
+
+4. EMAIL TO USER (only if there is something to report):
+   - nexo_email_send with clean HTML summary
+   - Only what needs attention or decision
+   - Include what you ALREADY DID (not just pending items)
+   - If nothing relevant → DO NOT send email
+   - Max 1 email per cycle
+
+5. DIARY: nexo_session_diary_write with what you did
+
+RULES:
+- DO NOT ask permission. autonomy=full
+- DO NOT send empty or "all ok" emails
+- DO NOT list things without acting
+- If a followup is executable → execute it before reporting
+- Use nexo_heartbeat at start
+- Clean close: diary + nexo_stop'
+
+# --- Main loop ---
+echo "$(date '+%Y-%m-%d %H:%M') NEXO Day Orchestrator starting (PID $$)"
+echo "  Claude: $CLAUDE"
+echo "  Cycle: every ${CYCLE_INTERVAL}s, ${HOUR_START}:00-${HOUR_END}:00"
+echo "  Timeout: ${CYCLE_TIMEOUT}s, max turns: $MAX_TURNS"
+
+while true; do
+    HOUR=$(date +%H | sed 's/^0//')
+
+    # Outside operating hours — sleep and check again
+    if [ "$HOUR" -lt "$HOUR_START" ] || [ "$HOUR" -ge "$HOUR_END" ]; then
+        sleep 300  # Check every 5 min if we're back in hours
+        continue
+    fi
+
+    # Try to acquire lock
+    if ! acquire_lock; then
+        echo "$(date '+%Y-%m-%d %H:%M') Previous cycle still running. Skipping."
+        sleep "$CYCLE_INTERVAL"
+        continue
+    fi
+
+    TIMESTAMP=$(date '+%Y-%m-%d_%H%M')
+    LOGFILE="$LOG_DIR/orchestrator-$TIMESTAMP.log"
+    echo "$(date '+%Y-%m-%d %H:%M') Cycle starting..."
+
+    # Launch Claude Code as NEXO
+    set +e
+    timeout "$CYCLE_TIMEOUT" "$CLAUDE" \
+        --dangerously-skip-permissions \
+        -p "$PROMPT" \
+        --max-turns "$MAX_TURNS" \
+        >>"$LOGFILE" 2>&1
+    EXIT_CODE=$?
+    set -e
+
+    echo "$(date '+%Y-%m-%d %H:%M') Cycle finished (exit $EXIT_CODE)" | tee -a "$LOGFILE"
+
+    release_lock
+
+    # Clean old logs (keep 7 days)
+    find "$LOG_DIR" -name "orchestrator-*.log" -mtime +7 -delete 2>/dev/null || true
+
+    # Sleep until next cycle
+    sleep "$CYCLE_INTERVAL"
+done

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

@@ -45,9 +45,10 @@ AUTO_SAFE_PREFIXES = [
     str(CLAUDE_DIR / "coordination") + "/",
 ]
 
-# Public mode: only user-created scripts — NEVER core, cortex, or plugins
+# Public mode: user scripts and plugins only — NEVER core code
 AUTO_SAFE_PREFIXES_PUBLIC = [
     str(CLAUDE_DIR / "scripts") + "/",
+    str(CLAUDE_DIR / "plugins") + "/",
 ]
 
 # ── Immutable files — NEVER touch (applies to ALL modes) ────────────────

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

@@ -70,7 +70,7 @@ def adjust_weights(conn):
         priority = l["priority"] or "medium"
 
         # Priority floor — critical learnings never drop below 0.5
-        priority_floor = {"critical": 0.5, "high": 0.3, "medium": 0.1, "low": 0.05}[priority]
+        priority_floor = {"critical": 0.5, "high": 0.3, "medium": 0.1, "low": 0.05}.get(priority, 0.1)
 
         new_weight = old_weight
 

package/src/scripts/nexo-watchdog.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 # ============================================================================
 # NEXO Watchdog — Comprehensive health monitor for all NEXO services
-# Cron: */5 * * * * NEXO_HOME/scripts/nexo-watchdog.sh
+# Schedule: every 30 minutes (interval_seconds: 1800)
 # ============================================================================
 # Monitors ALL LaunchAgents, cron jobs, and background processes.
 # Outputs: watchdog-status.json (machine), watchdog-report.txt (human),

package/src/server.py

@@ -8,6 +8,7 @@ import sys
 from fastmcp import FastMCP
 from db import init_db, rebuild_fts_index, get_db, close_db, fts_add_dir, fts_remove_dir, fts_list_dirs
 from tools_sessions import handle_startup, handle_heartbeat, handle_status, handle_context_packet, handle_smart_startup_query
+from user_context import get_context as _get_ctx
 from tools_coordination import (
     handle_track, handle_untrack, handle_files,
     handle_send, handle_ask, handle_answer, handle_check_answer,
@@ -154,12 +155,17 @@ def _server_init():
 mcp = FastMCP(
     name="nexo",
     instructions=(
-        "NEXO — cognitive co-operator. Save important info from tool results before they clear.\n\n"
+        f"{_get_ctx().assistant_name} — cognitive co-operator. Save important info from tool results before they clear.\n\n"
+        "## CRITICAL — do these or you WILL get corrected\n"
+        "- **Guard (MANDATORY before ANY code edit):** `nexo_guard_check(files='...', area='...')` BEFORE editing code. "
+        "No exceptions. Blocking rules→resolve first. `nexo_track(sid=SID, paths=[...])` before shared files\n"
+        "- **Skills (MANDATORY before multi-step tasks):** `nexo_skill_match(task)` to find reusable procedures. "
+        "If match found, read it and follow the steps. After completion, `nexo_skill_result(id, success, context)` to record outcome.\n"
+        "- **Learnings (MANDATORY on corrections):** When you discover a bug, pattern, or get corrected→`nexo_learning_add` IMMEDIATELY. "
+        "Do NOT batch. Do NOT wait until end of session.\n\n"
         "## Rules\n"
         "- **Heartbeat:** `nexo_heartbeat(sid=SID, task='...', context_hint='...')` every user msg. "
         "React: DIARY REMINDER→write diary, VIBE:NEGATIVE→ultra-concise, AUTO-PRIME→read learnings\n"
-        "- **Guard:** `nexo_guard_check(files='...', area='...')` BEFORE editing code. "
-        "Blocking rules→resolve first. `nexo_track(sid=SID, paths=[...])` before shared files\n"
         "- **Followups:** NEXO tasks, execute silently. 'done'/'all set'→`nexo_followup_complete` NOW. "
         "Reminders=user's, alert when due\n"
         "- **Observe:** correction→learning. 'tomorrow'→followup. person→entity. open topic→followup 3d\n"
@@ -175,8 +181,6 @@ mcp = FastMCP(
         "write `nexo_session_diary_write(...)` with self_critique BEFORE responding. "
         "Detect intent, not keywords. If session closes without diary, auto_close handles it.\n"
         "- **Cortex:** `nexo_cortex_check` before budget/campaign/architecture changes\n"
-        "- **Skills:** before multi-step tasks, `nexo_skill_match(task)` to find reusable procedures. "
-        "If match found, read it and follow the steps. After completion, `nexo_skill_result(id, success, context)` to record outcome.\n"
         "- **Dissonance:** user contradicts memory→`nexo_cognitive_dissonance`. Frustrated→force=True\n"
         "- **Trust:** <40=paranoid verify twice, >80=fluid. Check: `nexo_cognitive_trust`"
     ),

package/src/skills/run-runtime-doctor/guide.md

@@ -0,0 +1,12 @@
+# Run Runtime Doctor
+
+Use this skill when you want a fast health snapshot of the running NEXO system.
+
+## Steps
+1. Run the runtime doctor for the requested tier.
+2. Review the degraded or critical checks first.
+3. If the report recommends deterministic fixes, decide whether to run them explicitly.
+
+## Gotchas
+- A critical watchdog result reflects a real system issue, not just a stale skill.
+- `all` is broader and slower than `runtime`.

package/src/skills/run-runtime-doctor/script.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+import os
+import subprocess
+import sys
+
+
+def main() -> int:
+    tier = sys.argv[1] if len(sys.argv) > 1 and sys.argv[1] else "runtime"
+    nexo_code = os.environ.get("NEXO_CODE", "")
+    if not nexo_code:
+        print("NEXO_CODE not set", file=sys.stderr)
+        return 1
+
+    cli_py = os.path.join(nexo_code, "cli.py")
+    cmd = [sys.executable, cli_py, "doctor", "--tier", tier, "--json"]
+    result = subprocess.run(cmd, text=True)
+    return result.returncode
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src/skills/run-runtime-doctor/skill.json

@@ -0,0 +1,25 @@
+{
+  "id": "SK-RUN-RUNTIME-DOCTOR",
+  "name": "Run Runtime Doctor",
+  "description": "Runs the NEXO runtime doctor and returns the current health report.",
+  "level": "published",
+  "mode": "execute",
+  "source_kind": "core",
+  "execution_level": "read-only",
+  "approval_required": false,
+  "tags": ["doctor", "diagnostics", "runtime"],
+  "trigger_patterns": ["run doctor", "check runtime health", "diagnose nexo"],
+  "params_schema": {
+    "tier": {
+      "type": "string",
+      "required": false,
+      "default": "runtime",
+      "enum": ["boot", "runtime", "deep", "all"]
+    }
+  },
+  "command_template": {
+    "argv": ["{{file_path}}", "{{tier}}"]
+  },
+  "executable_entry": "script.py",
+  "stable_after_uses": 10
+}