nexo-brain 2.4.0 → 2.5.1

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

@@ -34,22 +34,6 @@ SANDBOX_DIR = CLAUDE_DIR / "sandbox" / "workspace"
 MAX_CONSECUTIVE_FAILURES = 3
 MAX_SNAPSHOTS = 8
 
-# ── Safe zones for AUTO execution ────────────────────────────────────────
-# "review" mode (owner): broader zones, but nothing executes without approval
-# "auto" mode (public users): restricted to user scripts and plugins ONLY
-AUTO_SAFE_PREFIXES = [
-    str(CLAUDE_DIR / "scripts") + "/",
-    str(CLAUDE_DIR / "brain") + "/",
-    str(NEXO_CODE / "plugins") + "/",
-    str(CLAUDE_DIR / "logs") + "/",
-    str(CLAUDE_DIR / "coordination") + "/",
-]
-
-# Public mode: only user-created scripts — NEVER core, cortex, or plugins
-AUTO_SAFE_PREFIXES_PUBLIC = [
-    str(CLAUDE_DIR / "scripts") + "/",
-]
-
 # ── Immutable files — NEVER touch (applies to ALL modes) ────────────────
 IMMUTABLE_FILES = {
     "db.py", "server.py", "plugin_loader.py", "nexo-watchdog.sh",
@@ -63,6 +47,52 @@ IMMUTABLE_FILES = {
     "tools_task_history.py", "tools_menu.py",
 }
 
+
+def _repo_root() -> Path | None:
+    candidate = NEXO_CODE.parent
+    if (candidate / "package.json").exists():
+        return candidate
+    return None
+
+
+def _public_safe_prefixes() -> list[str]:
+    return [
+        str(CLAUDE_DIR / "scripts") + "/",
+        str(CLAUDE_DIR / "plugins") + "/",
+        str(CLAUDE_DIR / "skills") + "/",
+        str(CLAUDE_DIR / "skills-runtime") + "/",
+    ]
+
+
+def _managed_safe_prefixes() -> list[str]:
+    prefixes = [
+        str(CLAUDE_DIR / "scripts") + "/",
+        str(CLAUDE_DIR / "plugins") + "/",
+        str(CLAUDE_DIR / "brain") + "/",
+        str(CLAUDE_DIR / "coordination") + "/",
+        str(CLAUDE_DIR / "logs") + "/",
+        str(CLAUDE_DIR / "skills") + "/",
+        str(CLAUDE_DIR / "skills-core") + "/",
+        str(CLAUDE_DIR / "skills-runtime") + "/",
+        str(NEXO_CODE) + "/",
+    ]
+    repo_root = _repo_root()
+    if repo_root:
+        for rel in ("bin", "docs", "templates", "tests"):
+            prefixes.append(str(repo_root / rel) + "/")
+    return prefixes
+
+
+def _normalize_mode(mode: str) -> str:
+    value = str(mode or "auto").strip().lower()
+    aliases = {
+        "owner": "managed",
+        "core": "managed",
+        "hybrid": "managed",
+        "manual": "review",
+    }
+    return aliases.get(value, value if value in {"auto", "review", "managed"} else "auto")
+
 # ── Claude CLI path ──────────────────────────────────────────────────────
 def _resolve_claude_cli() -> Path:
     """Find claude CLI: saved path > PATH > common locations."""
@@ -161,16 +191,18 @@ def call_claude_cli(prompt: str) -> str:
 # ── File safety validation ───────────────────────────────────────────────
 def is_safe_path(filepath: str, mode: str = "auto") -> bool:
     """Check if a file path is within safe zones and not immutable.
-    mode='auto' (public): restricted to scripts/ and plugins/ only.
-    mode='review' (owner): broader zones but nothing executes without approval anyway.
+    mode='auto' (public): restricted to personal automation surfaces.
+    mode='managed' (owner): broader repo/core surfaces with rollback.
+    mode='review': broader zones for proposal validation, but no execution.
     """
     expanded = str(Path(filepath).expanduser().resolve())
     filename = Path(expanded).name
+    mode = _normalize_mode(mode)
 
     if filename in IMMUTABLE_FILES:
         return False
 
-    prefixes = AUTO_SAFE_PREFIXES if mode == "review" else AUTO_SAFE_PREFIXES_PUBLIC
+    prefixes = _managed_safe_prefixes() if mode in {"managed", "review"} else _public_safe_prefixes()
     for prefix in prefixes:
         resolved_prefix = str(Path(prefix).expanduser().resolve())
         if expanded.startswith(resolved_prefix):
@@ -217,13 +249,13 @@ def validate_syntax(filepath: str) -> tuple[bool, str]:
 
 
 # ── Apply a single change operation ──────────────────────────────────────
-def apply_change(change: dict) -> tuple[bool, str]:
+def apply_change(change: dict, mode: str = "auto") -> tuple[bool, str]:
     """Apply a single file change operation. Returns (success, message)."""
     filepath = str(Path(change["file"]).expanduser())
     operation = change.get("operation", "")
     content = change.get("content", "")
 
-    if not is_safe_path(filepath):
+    if not is_safe_path(filepath, mode=mode):
         return False, f"BLOCKED: {filepath} is outside safe zones or immutable"
 
     try:
@@ -268,7 +300,7 @@ def apply_change(change: dict) -> tuple[bool, str]:
 
 
 # ── Execute AUTO proposals ───────────────────────────────────────────────
-def execute_auto_proposal(proposal: dict, cycle_num: int, conn: sqlite3.Connection) -> dict:
+def execute_auto_proposal(proposal: dict, cycle_num: int, conn: sqlite3.Connection, mode: str = "auto") -> dict:
     """Execute an AUTO proposal with snapshot/apply/validate/rollback."""
     changes = proposal.get("changes", [])
     if not changes:
@@ -277,7 +309,7 @@ def execute_auto_proposal(proposal: dict, cycle_num: int, conn: sqlite3.Connecti
     # Validate all paths first
     for change in changes:
         filepath = str(Path(change["file"]).expanduser())
-        if not is_safe_path(filepath):
+        if not is_safe_path(filepath, mode=mode):
             return {"status": "blocked", "reason": f"Unsafe path: {filepath}"}
 
     # Collect files to snapshot (existing files only)
@@ -298,7 +330,7 @@ def execute_auto_proposal(proposal: dict, cycle_num: int, conn: sqlite3.Connecti
     all_results = []
     try:
         for change in changes:
-            success, msg = apply_change(change)
+            success, msg = apply_change(change, mode=mode)
             all_results.append(msg)
             log(f"    {msg}")
             if not success:
@@ -342,57 +374,102 @@ def execute_auto_proposal(proposal: dict, cycle_num: int, conn: sqlite3.Connecti
                     log(f"  Removed created file: {filepath}")
 
         return {
-            "status": "failed",
+            "status": "rolled_back",
             "snapshot_ref": snapshot_ref,
             "files_changed": [],
             "test_result": f"ROLLBACK: {e}; " + "; ".join(all_results),
         }
 
 
-# ── Review followup for owner mode ──────────────────────────────────────
-def _create_review_followup(conn: sqlite3.Connection, cycle_num: int,
-                            items: list[dict], analysis: str):
-    """Create a followup summarizing Evolution proposals for owner review."""
+# ── Followups for managed/review modes ──────────────────────────────────
+def _insert_followup(conn: sqlite3.Connection, followup_id: str, description: str,
+                     verification: str, due_date: str | None = None):
+    now_epoch = datetime.now().timestamp()
+    conn.execute(
+        "INSERT OR REPLACE INTO followups (id, description, date, status, verification, created_at, updated_at) "
+        "VALUES (?, ?, ?, 'PENDING', ?, ?, ?)",
+        (followup_id, description, due_date, verification, now_epoch, now_epoch)
+    )
+    conn.commit()
+
+
+def _create_cycle_followup(conn: sqlite3.Connection, cycle_num: int,
+                           items: list[dict], analysis: str, mode: str):
+    """Create a followup summarizing pending proposals or owner review items."""
     tomorrow = (date.today() + timedelta(days=1)).isoformat()
     followup_id = f"NF-EVO-C{cycle_num}"
 
     public_items = [i for i in items if i.get("scope") == "public"]
     local_items = [i for i in items if i.get("scope") != "public"]
 
-    lines = [f"Evolution Cycle #{cycle_num} — {len(items)} proposals to review."]
+    title = "proposals to review" if mode == "review" else "items needing attention"
+    lines = [f"Evolution Cycle #{cycle_num} — {len(items)} {title}."]
     lines.append(f"Analysis: {analysis[:200]}")
     lines.append("")
 
     if public_items:
         lines.append(f"FOR EVERYONE ({len(public_items)}):")
         for i, item in enumerate(public_items, 1):
-            lines.append(f"  {i}. [{item['dimension']}] {item['action'][:120]}")
+            status = item.get("status", "proposed").upper()
+            lines.append(f"  {i}. [{status}] [{item['dimension']}] {item['action'][:120]}")
             lines.append(f"     Why: {item['reasoning'][:100]}")
+            if item.get("detail"):
+                lines.append(f"     Detail: {item['detail'][:160]}")
         lines.append("")
 
     if local_items:
         lines.append(f"FOR YOU ONLY ({len(local_items)}):")
         for i, item in enumerate(local_items, 1):
-            lines.append(f"  {i}. [{item['dimension']}] {item['action'][:120]}")
+            status = item.get("status", "proposed").upper()
+            lines.append(f"  {i}. [{status}] [{item['dimension']}] {item['action'][:120]}")
             lines.append(f"     Why: {item['reasoning'][:100]}")
+            if item.get("detail"):
+                lines.append(f"     Detail: {item['detail'][:160]}")
 
     description = "\n".join(lines)
 
     try:
-        now_epoch = datetime.now().timestamp()
-        conn.execute(
-            "INSERT OR REPLACE INTO followups (id, description, date, status, verification, created_at, updated_at) "
-            "VALUES (?, ?, ?, 'pending', ?, ?, ?)",
-            (followup_id, description, tomorrow,
-             f"SELECT * FROM evolution_log WHERE cycle_number={cycle_num}",
-             now_epoch, now_epoch)
+        _insert_followup(
+            conn,
+            followup_id,
+            description,
+            f"SELECT * FROM evolution_log WHERE cycle_number={cycle_num}",
+            due_date=tomorrow,
         )
-        conn.commit()
         log(f"  Followup {followup_id} created for {tomorrow}")
     except Exception as e:
         log(f"  WARN: Failed to create followup: {e}")
 
 
+def _create_failure_followup(conn: sqlite3.Connection, cycle_num: int, log_id: int,
+                             proposal: dict, result: dict):
+    """Create an incident-style followup for a failed or blocked AUTO proposal."""
+    followup_id = f"NF-EVO-L{log_id}"
+    lines = [
+        f"Evolution AUTO proposal failed in cycle #{cycle_num}.",
+        f"Action: {proposal.get('action', '')[:200]}",
+        f"Dimension: {proposal.get('dimension', 'other')}",
+        f"Status: {result.get('status', 'failed')}",
+        f"Reason: {(result.get('reason') or result.get('test_result') or 'unknown')[:400]}",
+    ]
+    snapshot_ref = result.get("snapshot_ref")
+    if snapshot_ref:
+        lines.append(f"Snapshot: {snapshot_ref}")
+    description = "\n".join(lines)
+
+    try:
+        _insert_followup(
+            conn,
+            followup_id,
+            description,
+            f"SELECT * FROM evolution_log WHERE id={log_id}",
+            due_date=(date.today() + timedelta(days=1)).isoformat(),
+        )
+        log(f"  Failure followup {followup_id} created")
+    except Exception as e:
+        log(f"  WARN: Failed to create failure followup: {e}")
+
+
 # ── Main run ─────────────────────────────────────────────────────────────
 def run():
     log("=" * 60)
@@ -481,14 +558,12 @@ def run():
     max_auto = max_auto_changes(objective.get("total_evolutions", 0))
     auto_count = 0
     auto_applied = 0
-    evolution_mode = objective.get("evolution_mode", "auto")  # "auto" (public) or "review" (owner)
+    evolution_mode = _normalize_mode(objective.get("evolution_mode", "auto"))
 
     conn = sqlite3.connect(str(NEXO_DB), timeout=10)
     conn.execute("PRAGMA busy_timeout=5000")
 
-    # In "review" mode: log everything as pending_review, create followup
-    # In "auto" mode: execute AUTO proposals, log PROPOSE as proposed
-    review_items = []
+    followup_items = []
 
     for p in proposals:
         classification = p.get("classification", "propose")
@@ -498,30 +573,29 @@ def run():
         scope = p.get("scope", "local")  # "public" or "local"
 
         if evolution_mode == "review":
-            # Owner mode: nothing executes, everything queued for review
             log(f"  QUEUED [{scope}]: {action[:80]}")
             conn.execute(
                 "INSERT INTO evolution_log (cycle_number, dimension, proposal, classification, "
                 "reasoning, status) VALUES (?, ?, ?, ?, ?, ?)",
                 (cycle_num, dimension, action, classification, reasoning, "pending_review")
             )
-            review_items.append({
+            followup_items.append({
                 "dimension": dimension,
                 "action": action,
                 "reasoning": reasoning,
                 "scope": scope,
                 "classification": classification,
+                "status": "pending_review",
             })
 
         elif classification == "auto" and auto_count < max_auto:
-            # Public mode: execute AUTO proposals
             auto_count += 1
             log(f"  AUTO #{auto_count}/{max_auto}: {action[:80]}")
 
-            result = execute_auto_proposal(p, cycle_num, conn)
+            result = execute_auto_proposal(p, cycle_num, conn, mode=evolution_mode)
             status = result["status"]
 
-            conn.execute(
+            cur = conn.execute(
                 "INSERT INTO evolution_log (cycle_number, dimension, proposal, classification, "
                 "reasoning, status, files_changed, snapshot_ref, test_result) "
                 "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
@@ -530,16 +604,20 @@ def run():
                  result.get("snapshot_ref", ""),
                  result.get("test_result", ""))
             )
+            log_id = cur.lastrowid
 
             if status == "applied":
                 auto_applied += 1
                 log(f"    APPLIED successfully")
             elif status == "blocked":
-                log(f"    BLOCKED: {result.get('test_result', '')}")
+                detail = result.get("reason") or result.get("test_result", "")
+                log(f"    BLOCKED: {detail[:100]}")
+                _create_failure_followup(conn, cycle_num, log_id, p, result)
             elif status == "skipped":
                 log(f"    SKIPPED: {result.get('reason', '')}")
             else:
-                log(f"    FAILED: {result.get('test_result', '')[:100]}")
+                log(f"    ROLLED BACK: {result.get('test_result', '')[:100]}")
+                _create_failure_followup(conn, cycle_num, log_id, p, result)
 
         else:
             # PROPOSE or over auto limit
@@ -554,12 +632,20 @@ def run():
                 "reasoning, status) VALUES (?, ?, ?, ?, ?, ?)",
                 (cycle_num, dimension, action, classification, reasoning, "proposed")
             )
+            if evolution_mode in {"review", "managed"}:
+                followup_items.append({
+                    "dimension": dimension,
+                    "action": action,
+                    "reasoning": reasoning,
+                    "scope": scope,
+                    "classification": classification,
+                    "status": "proposed",
+                })
 
     conn.commit()
 
-    # In review mode: create followup for owner
-    if evolution_mode == "review" and review_items:
-        _create_review_followup(conn, cycle_num, review_items, response.get("analysis", ""))
+    if evolution_mode in {"review", "managed"} and followup_items:
+        _create_cycle_followup(conn, cycle_num, followup_items, response.get("analysis", ""), evolution_mode)
 
     # Update metrics
     scores = response.get("dimension_scores", {})
@@ -590,6 +676,7 @@ def run():
     objective.setdefault("history", []).insert(0, {
         "cycle": cycle_num,
         "date": str(date.today()),
+        "mode": evolution_mode,
         "proposals": len(proposals),
         "auto_count": auto_count,
         "auto_applied": auto_applied,

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
+}