nexo-brain 0.1.0 → 0.1.2

package/README.md

@@ -143,19 +143,26 @@ The installer handles everything:
   Generating operator instructions...
 
   ╔══════════════════════════════════════════════════════════╗
-  ║  Atlas is ready.                                       ║
-  ║  Open Claude Code and start a conversation.            ║
+  ║  Atlas is ready. Type 'atlas' to start.                ║
   ╚══════════════════════════════════════════════════════════╝
 ```
 
-Open Claude Code and start working. Atlas will introduce itself on the first message.
+### Starting a Session
+
+The installer creates a shell alias with your chosen name. Just type it:
+
+```bash
+atlas
+```
+
+That's it. No need to run `claude` manually. Atlas will greet you immediately — adapted to the time of day, resuming from where you left off if there's a previous session. No cold starts, no waiting for your input.
 
 ### What Gets Installed
 
 | Component | What | Where |
 |-----------|------|-------|
 | Cognitive engine | Python: fastembed, numpy, vector search | pip packages |
-| MCP server | 50+ tools for memory, learning, guard | ~/.nexo/ |
+| MCP server | 76 tools for memory, learning, guard | ~/.nexo/ |
 | Plugins | Guard, episodic memory, cognitive memory, entities, preferences | ~/.nexo/plugins/ |
 | Hooks | Session capture, briefing, stop detection | ~/.nexo/hooks/ |
 | LaunchAgents | Decay, sleep, audit, postmortem, catch-up | ~/Library/LaunchAgents/ |
@@ -166,27 +173,31 @@ Open Claude Code and start working. Atlas will introduce itself on the first mes
 
 - **macOS** (Linux support planned)
 - **Node.js 18+** (for the installer)
+- **Claude Opus (latest version) strongly recommended.** NEXO provides 76 MCP tools across 16 categories. This cognitive load requires a top-tier model with large context window. Smaller models (Haiku, Sonnet) may struggle with tool selection and produce inconsistent results. Opus handles all 76 tools without hesitation.
 - Python 3, Homebrew, and Claude Code are installed automatically if missing.
 
 ## Architecture
 
-### 50+ MCP Tools
-
-| Category | Tools | Purpose |
-|----------|-------|---------|
-| Cognitive (8) | retrieve, stats, inspect, metrics, dissonance, resolve, sentiment, trust | The brain |
-| Guard (3) | check, stats, log_repetition | Error prevention |
-| Episodic (10) | changes, decisions, session diary, recall | What happened and why |
-| Sessions (3) | startup, heartbeat, status | Session lifecycle |
-| Reminders (4) | create, update, complete, delete | User's tasks |
-| Followups (4) | create, update, complete, delete | System's tasks |
-| Learnings (5) | add, search, update, delete, list | Error patterns |
-| Entities (5) | search, create, update, delete, list | People, services, URLs |
-| Preferences (4) | get, set, list, delete | Observed preferences |
-| Credentials (5) | create, get, update, delete, list | Secure storage |
-| Agents (5) | get, create, update, delete, list | Agent delegation |
-| Backup (3) | now, list, restore | Data safety |
-| Evolution (5) | propose, approve, reject, status, history | Self-improvement |
+### 76 MCP Tools across 16 Categories
+
+| Category | Count | Tools | Purpose |
+|----------|-------|-------|---------|
+| Cognitive | 8 | retrieve, stats, inspect, metrics, dissonance, resolve, sentiment, trust | The brain — memory, RAG, trust, mood |
+| Guard | 3 | check, stats, log_repetition | Metacognitive error prevention |
+| Episodic | 10 | change_log/search/commit, decision_log/outcome/search, review_queue, diary_write/read, recall | What happened and why |
+| Sessions | 3 | startup, heartbeat, status | Session lifecycle + context shift detection |
+| Coordination | 7 | track, untrack, files, send, ask, answer, check_answer | Multi-session file coordination + messaging |
+| Reminders | 5 | list, create, update, complete, delete | User's tasks and deadlines |
+| Followups | 4 | create, update, complete, delete | System's autonomous verification tasks |
+| Learnings | 5 | add, search, update, delete, list | Error patterns and prevention rules |
+| Credentials | 5 | create, get, update, delete, list | Secure local credential storage |
+| Task History | 3 | log, list, frequency | Execution tracking and overdue alerts |
+| Menu | 1 | menu | Operations center with box-drawing UI |
+| Entities | 5 | search, create, update, delete, list | People, services, URLs |
+| Preferences | 4 | get, set, list, delete | Observed user preferences |
+| Agents | 5 | get, create, update, delete, list | Agent delegation registry |
+| Backup | 3 | now, list, restore | SQLite data safety |
+| Evolution | 5 | propose, approve, reject, status, history | Self-improvement proposals |
 
 ### Plugin System
 

package/bin/{create-nexo.js → nexo-brain.js}

@@ -127,7 +127,74 @@ async function main() {
   log(`Got it. I'm ${operatorName}.`);
   console.log("");
 
-  // Step 2: Permission to scan
+  // Step 2: Personality Calibration
+  log("Let's calibrate my personality to work best with you.");
+  log("(These can be changed anytime via nexo_preference_set)");
+  console.log("");
+
+  const autonomyAnswer = await ask(
+    "  How autonomous should I be?\n" +
+    "    1. Ask before most actions (conservative)\n" +
+    "    2. Act on routine tasks, ask on important ones (balanced)\n" +
+    "    3. Act first, inform after — only ask when truly uncertain (full autonomy)\n" +
+    "  > "
+  );
+  const autonomyLevel = ["conservative", "balanced", "full"][parseInt(autonomyAnswer.trim()) - 1] || "balanced";
+
+  const communicationAnswer = await ask(
+    "\n  How should I communicate?\n" +
+    "    1. Concise — just results, no filler (expert user)\n" +
+    "    2. Balanced — brief explanations when useful\n" +
+    "    3. Detailed — explain reasoning and trade-offs\n" +
+    "  > "
+  );
+  const communicationStyle = ["concise", "balanced", "detailed"][parseInt(communicationAnswer.trim()) - 1] || "balanced";
+
+  const honestyAnswer = await ask(
+    "\n  When I disagree with your approach, should I:\n" +
+    "    1. Push back firmly and explain why\n" +
+    "    2. Mention it briefly but follow your lead\n" +
+    "    3. Just do what you ask\n" +
+    "  > "
+  );
+  const honestyLevel = ["firm-pushback", "mention-and-follow", "just-execute"][parseInt(honestyAnswer.trim()) - 1] || "firm-pushback";
+
+  const proactivityAnswer = await ask(
+    "\n  How proactive should I be?\n" +
+    "    1. Only do what's asked\n" +
+    "    2. Suggest improvements when I spot them\n" +
+    "    3. Fix things I notice without asking, and propose optimizations\n" +
+    "  > "
+  );
+  const proactivityLevel = ["reactive", "suggestive", "proactive"][parseInt(proactivityAnswer.trim()) - 1] || "proactive";
+
+  const errorAnswer = await ask(
+    "\n  When I make a mistake, how should I handle it?\n" +
+    "    1. Brief acknowledgment, fix it, move on\n" +
+    "    2. Explain what went wrong and what I learned\n" +
+    "  > "
+  );
+  const errorHandling = ["brief-fix", "explain-and-learn"][parseInt(errorAnswer.trim()) - 1] || "brief-fix";
+
+  console.log("");
+  log(`Calibrated: autonomy=${autonomyLevel}, communication=${communicationStyle}, honesty=${honestyLevel}, proactivity=${proactivityLevel}, errors=${errorHandling}`);
+  console.log("");
+
+  // Save calibration
+  const calibration = {
+    autonomy: autonomyLevel,
+    communication: communicationStyle,
+    honesty: honestyLevel,
+    proactivity: proactivityLevel,
+    error_handling: errorHandling,
+    calibrated_at: new Date().toISOString(),
+  };
+  fs.writeFileSync(
+    path.join(NEXO_HOME, "brain", "calibration.json"),
+    JSON.stringify(calibration, null, 2)
+  );
+
+  // Step 3: Permission to scan
   const scanAnswer = await ask(
     "  Can I explore your workspace to learn about your projects? (y/n) > "
   );
@@ -533,7 +600,33 @@ Operator name: ${operatorName}
     log("Caffeinate enabled — Mac will stay awake for cognitive processes.");
   }
 
-  // Step 8: Generate CLAUDE.md template
+  // Step 8: Create shell alias so user can just type the operator's name
+  log("Creating shell alias...");
+  const aliasName = operatorName.toLowerCase();
+  const aliasLine = `alias ${aliasName}='claude --dangerously-skip-permissions "."'`;
+  const aliasComment = `# ${operatorName} — start Claude Code with ${operatorName} speaking first`;
+
+  // Detect shell and add alias
+  const userShell = process.env.SHELL || "/bin/bash";
+  const rcFile = userShell.includes("zsh")
+    ? path.join(require("os").homedir(), ".zshrc")
+    : path.join(require("os").homedir(), ".bash_profile");
+
+  let rcContent = "";
+  if (fs.existsSync(rcFile)) {
+    rcContent = fs.readFileSync(rcFile, "utf8");
+  }
+
+  if (!rcContent.includes(`alias ${aliasName}=`)) {
+    fs.appendFileSync(rcFile, `\n${aliasComment}\n${aliasLine}\n`);
+    log(`Added '${aliasName}' alias to ${path.basename(rcFile)}`);
+    log(`After setup, open a new terminal and type: ${aliasName}`);
+  } else {
+    log(`Alias '${aliasName}' already exists in ${path.basename(rcFile)}`);
+  }
+  console.log("");
+
+  // Step 9: Generate CLAUDE.md template
   log("Generating operator instructions...");
   const templateSrc = path.join(templateDir, "CLAUDE.md.template");
   let claudeMd = "";
@@ -568,16 +661,7 @@ See ~/.nexo/ for configuration.
     "  ╔══════════════════════════════════════════════════════════╗"
   );
   console.log(
-    `  ║  ${operatorName} is ready.${" ".repeat(Math.max(0, 39 - operatorName.length))}║`
-  );
-  console.log(
-    "  ║                                                        ║"
-  );
-  console.log(
-    "  ║  Open Claude Code and start a conversation.            ║"
-  );
-  console.log(
-    `  ║  ${operatorName} will introduce ${operatorName.length > 4 ? "itself" : "itself"} on first message.${" ".repeat(Math.max(0, 27 - operatorName.length))}║`
+    `  ║  ${operatorName} is ready. Type '${aliasName}' to start.${" ".repeat(Math.max(0, 30 - operatorName.length - aliasName.length))}║`
   );
   console.log(
     "  ╚══════════════════════════════════════════════════════════╝"

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "nexo-brain",
-  "version": "0.1.0",
+  "version": "0.1.2",
+  "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO — Cognitive co-operator for Claude Code. Atkinson-Shiffrin memory, semantic RAG, trust scoring, and metacognitive error prevention.",
   "bin": {
-    "nexo-brain": "./bin/create-nexo.js"
+    "nexo-brain": "./bin/nexo-brain.js"
   },
   "keywords": [
     "claude-code",

package/src/scripts/nexo-catchup.py

@@ -8,7 +8,6 @@ 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)
@@ -24,15 +23,14 @@ import sys
 from datetime import datetime, timedelta
 from pathlib import Path
 
-HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
-LOG_DIR = HOME / "claude" / "logs"
+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 = HOME / "claude" / "operations" / ".catchup-state.json"
+STATE_FILE = NEXO_HOME / "operations" / ".catchup-state.json"
+SCRIPTS = NEXO_HOME / "src" / "scripts"
 
-PYTHON_BREW = "/opt/homebrew/bin/python3"
-PYTHON_SYS = "/Library/Frameworks/Python.framework/Versions/3.12/bin/python3"
-SCRIPTS = HOME / "claude" / "scripts"
+PYTHON = sys.executable
 
 
 def log(msg: str):
@@ -95,7 +93,7 @@ def should_run(task_name: str, hour: int, minute: int, state: dict, weekday: int
     return last_run < last_scheduled
 
 
-def run_task(name: str, python: str, script: str, state: dict) -> bool:
+def run_task(name: str, script: str, state: dict) -> bool:
     """Execute a task and update state."""
     script_path = str(SCRIPTS / script)
     if not Path(script_path).exists():
@@ -105,9 +103,9 @@ def run_task(name: str, python: str, script: str, state: dict) -> bool:
     log(f"  RUNNING {name}: {script}")
     try:
         result = subprocess.run(
-            [python, script_path],
+            [PYTHON, script_path],
             capture_output=True, text=True, timeout=300,
-            env={**os.environ, "HOME": str(HOME), "NEXO_CATCHUP": "1"}
+            env={**os.environ, "HOME": str(Path.home()), "NEXO_HOME": str(NEXO_HOME), "NEXO_CATCHUP": "1"}
         )
         if result.returncode == 0:
             log(f"  OK {name} (exit 0)")
@@ -128,41 +126,23 @@ def run_task(name: str, python: str, script: str, state: dict) -> bool:
 
 def main():
     log("=== NEXO Catch-Up starting (boot/wake) ===")
-
-    # Auto-update check FIRST (before running any other tasks)
-    update_script = SCRIPTS / "nexo-auto-update.py"
-    if update_script.exists():
-        log("Checking for updates...")
-        try:
-            python_for_update = PYTHON_BREW if os.path.exists(PYTHON_BREW) else PYTHON_SYS
-            subprocess.run(
-                [python_for_update, str(update_script)],
-                capture_output=True, text=True, timeout=60,
-                env={**os.environ, "NEXO_HOME": str(HOME)}
-            )
-        except Exception as e:
-            log(f"  Update check failed: {e}")
-
     state = load_state()
 
     # Define tasks in execution order (matching their intended schedule order)
-    # Find Python — prefer homebrew, fallback to system
-    python_path = PYTHON_BREW if os.path.exists(PYTHON_BREW) else PYTHON_SYS
-
     tasks = [
-        # (name, hour, minute, python, script, weekday)
-        ("cognitive-decay", 3, 0, python_path, "nexo-cognitive-decay.py", None),
-        ("sleep", 4, 0, python_path, "nexo-sleep.py", None),
-        ("self-audit", 7, 0, python_path, "nexo-daily-self-audit.py", None),
-        ("postmortem", 23, 30, python_path, "nexo-postmortem-consolidator.py", None),
+        # (name, hour, minute, script, weekday)
+        ("cognitive-decay", 3, 0, "nexo-cognitive-decay.py", None),
+        ("sleep", 4, 0, "nexo-sleep.py", None),
+        ("self-audit", 7, 0, "nexo-daily-self-audit.py", None),
+        ("postmortem", 23, 30, "nexo-postmortem-consolidator.py", None),
     ]
 
     ran = 0
     skipped = 0
-    for name, hour, minute, python, script, weekday in tasks:
+    for name, hour, minute, 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):
+            if run_task(name, script, state):
                 ran += 1
         else:
             skipped += 1

package/src/scripts/nexo-cognitive-decay.py

@@ -5,11 +5,13 @@ import json
 import sys
 from pathlib import Path
 from datetime import datetime
+import os
 
-sys.path.insert(0, str(Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))))
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+sys.path.insert(0, str(NEXO_HOME / "src"))
 import cognitive
 
-STATE_FILE = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))) / "operations" / ".catchup-state.json"
+STATE_FILE = NEXO_HOME / "operations" / ".catchup-state.json"
 
 
 def update_catchup_state():

package/src/scripts/nexo-daily-self-audit.py

@@ -2,7 +2,7 @@
 """
 NEXO Daily Self-Audit
 Proactively scans for common issues before they become problems.
-Runs via launchd at 7:00 AM daily. Results saved to ~/claude/logs/self-audit.log
+Runs via launchd at 7:00 AM daily. Results saved to NEXO_HOME/logs/self-audit.log
 """
 import json
 import os
@@ -14,17 +14,17 @@ import hashlib
 from datetime import datetime, timedelta
 from pathlib import Path
 
-LOG_DIR = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))) / "logs"
+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 / "self-audit.log"
-NEXO_DB = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))) / "nexo.db"
-# Project directory for git checks (user configurable)
-HASH_REGISTRY = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))) / "scripts" / ".watchdog-hashes"
-SNAPSHOT_GOLDEN = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))) / "snapshots" / "golden" / "files" / "claude"
-RUNTIME_PREFLIGHT_SUMMARY = LOG_DIR / "runtime-preflight-summary.json"
-WATCHDOG_SMOKE_SUMMARY = LOG_DIR / "watchdog-smoke-summary.json"
-RESTORE_LOG = LOG_DIR / "snapshot-restores.log"
-CORTEX_LOG_DIR = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))) / "cortex" / "logs"
+NEXO_DB = NEXO_HOME / "nexo.db"
+# Optional: project directory for git checks — set via env var
+PROJECT_DIR_STR = os.environ.get("NEXO_PROJECT_DIR", "")
+PROJECT_DIR = Path(PROJECT_DIR_STR) if PROJECT_DIR_STR else None
+HASH_REGISTRY = NEXO_HOME / "scripts" / ".watchdog-hashes"
+CORTEX_LOG_DIR = NEXO_HOME / "cortex" / "logs"
 
 findings = []
 
@@ -72,12 +72,13 @@ def check_overdue_followups():
         finding("WARN", "followups", f"{len(rows)} overdue: {', '.join(r[0][:40] for r in rows[:5])}")
 
 
+# ── Check 3: Git uncommitted changes in project dir ─────────────────────────
 def check_uncommitted_changes():
-    if not WAZION_DIR.exists():
+    if not PROJECT_DIR or not PROJECT_DIR.exists():
         return
     result = subprocess.run(
         ["git", "status", "--porcelain"],
-        cwd=str(WAZION_DIR), capture_output=True, text=True
+        cwd=str(PROJECT_DIR), capture_output=True, text=True
     )
     lines = [l for l in result.stdout.strip().split("\n") if l.strip()]
     if len(lines) > 10:
@@ -101,7 +102,7 @@ def check_cron_errors():
 
 # ── Check 5: Evolution failures ─────────────────────────────────────────
 def check_evolution_health():
-    obj_file = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))) / "cortex" / "evolution-objective.json"
+    obj_file = NEXO_HOME / "cortex" / "evolution-objective.json"
     if not obj_file.exists():
         return
     obj = json.loads(obj_file.read_text())
@@ -224,122 +225,10 @@ def check_memory_reviews():
         finding("INFO", "memory", f"{total_due} memory reviews due ({due_decisions} decisions, {due_learnings} learnings)")
 
 
-def _sha256(path: Path) -> str:
-    return hashlib.sha256(path.read_bytes()).hexdigest()
-
-
-# ── Check 12: Watchdog registry sanity ──────────────────────────────────
-def check_watchdog_registry():
-    if not HASH_REGISTRY.exists():
-        finding("WARN", "watchdog", "hash registry missing")
-        return
-    text = HASH_REGISTRY.read_text(errors="ignore")
-    forbidden = ["CLAUDE.md", "db.py", "server.py", "plugin_loader.py", "cortex-wrapper.py"]
-    bad = [name for name in forbidden if name in text]
-    if bad:
-        finding("ERROR", "watchdog", f"mutable files still protected by watchdog: {', '.join(bad)}")
-
-
-# ── Check 13: Snapshot drift on protected recovery files ────────────────
-def check_snapshot_sync():
-    pairs = [
-        (Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))) / "db.py", SNAPSHOT_GOLDEN / "nexo-mcp" / "db.py"),
-        (Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))) / "cortex" / "cortex-wrapper.py", SNAPSHOT_GOLDEN / "cortex" / "cortex-wrapper.py"),
-        (Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))) / "cortex" / "evolution_cycle.py", SNAPSHOT_GOLDEN / "cortex" / "evolution_cycle.py"),
-    ]
-    drift = []
-    for live, snap in pairs:
-        if not live.exists() or not snap.exists():
-            drift.append(live.name)
-            continue
-        if _sha256(live) != _sha256(snap):
-            drift.append(live.name)
-    if drift:
-        finding("WARN", "snapshots", f"golden snapshot drift: {', '.join(drift)}")
-
-
-# ── Check 14: Recent restore activity ───────────────────────────────────
-def check_restore_activity():
-    if not RESTORE_LOG.exists():
-        return
-    cutoff_day = datetime.now() - timedelta(days=1)
-    current_hour_prefix = datetime.now().strftime("%Y-%m-%d %H")
-    recent_day = 0
-    recent_hour = 0
-    for line in RESTORE_LOG.read_text(errors="ignore").splitlines():
-        if not line.startswith("["):
-            continue
-        if "/.codex/memories/nexo-" in line:
-            continue
-        try:
-            ts = datetime.strptime(line[1:20], "%Y-%m-%d %H:%M:%S")
-        except ValueError:
-            continue
-        if ts >= cutoff_day:
-            recent_day += 1
-        if line[1:14] == current_hour_prefix:
-            recent_hour += 1
-    if recent_hour > 2:
-        finding("ERROR", "restore", f"{recent_hour} snapshot restores in last hour")
-    elif recent_day > 5:
-        finding("WARN", "restore", f"{recent_day} snapshot restores in last 24h")
-    elif recent_day > 0:
-        finding("INFO", "restore", f"{recent_day} snapshot restores in last 24h (historical activity)")
-
-
-# ── Check 15: Bad model responses ───────────────────────────────────────
-def check_bad_responses():
-    if not CORTEX_LOG_DIR.exists():
-        return
-    cutoff = datetime.now() - timedelta(days=1)
-    bad = [
-        p for p in CORTEX_LOG_DIR.glob("bad-response-*.json")
-        if datetime.fromtimestamp(p.stat().st_mtime) >= cutoff
-    ]
-    if bad:
-        finding("WARN", "cortex", f"{len(bad)} bad model responses in last 24h")
-
-
-# ── Check 16: Runtime preflight freshness ───────────────────────────────
-def check_runtime_preflight():
-    if not RUNTIME_PREFLIGHT_SUMMARY.exists():
-        finding("WARN", "preflight", "runtime preflight summary missing")
-        return
-    data = json.loads(RUNTIME_PREFLIGHT_SUMMARY.read_text())
-    ts = data.get("timestamp")
-    try:
-        when = datetime.fromisoformat(ts)
-    except Exception:
-        finding("WARN", "preflight", "runtime preflight timestamp invalid")
-        return
-    if when < datetime.now() - timedelta(days=1):
-        finding("WARN", "preflight", "runtime preflight older than 24h")
-    if not data.get("ok", False):
-        finding("ERROR", "preflight", "runtime preflight failing")
-
-
-# ── Check 17: Watchdog smoke freshness ──────────────────────────────────
-def check_watchdog_smoke():
-    if not WATCHDOG_SMOKE_SUMMARY.exists():
-        finding("WARN", "watchdog", "watchdog smoke summary missing")
-        return
-    data = json.loads(WATCHDOG_SMOKE_SUMMARY.read_text())
-    ts = data.get("timestamp")
-    try:
-        when = datetime.fromisoformat(ts)
-    except Exception:
-        finding("WARN", "watchdog", "watchdog smoke timestamp invalid")
-        return
-    if when < datetime.now() - timedelta(days=1):
-        finding("WARN", "watchdog", "watchdog smoke older than 24h")
-    if not data.get("ok", False):
-        finding("ERROR", "watchdog", "watchdog smoke failing")
-
-
-# ── Check 18: Cognitive memory health ────────────────────────────────
+# ── Check 12: Cognitive memory health ────────────────────────────────
 def check_cognitive_health():
     """Check cognitive.db health and run weekly GC on Sundays."""
-    cognitive_db = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))) / "cognitive.db"
+    cognitive_db = NEXO_HOME / "cognitive.db"
     if not cognitive_db.exists():
         finding("WARN", "cognitive", "cognitive.db not found")
         return
@@ -360,7 +249,6 @@ def check_cognitive_health():
 
     # Metrics report (spec section 9)
     try:
-        sys.path.insert(0, str(Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))))
         import cognitive as cog
 
         metrics = cog.get_metrics(days=7)
@@ -373,7 +261,7 @@ def check_cognitive_health():
 
             if metrics["needs_multilingual"]:
                 finding("WARN", "cognitive-metrics",
-                        f"Retrieval relevance {metrics['retrieval_relevance_pct']}% < 70% — consider switching to multilingual model (spec 13.3)")
+                        f"Retrieval relevance {metrics['retrieval_relevance_pct']}% < 70% — consider switching to multilingual model")
 
             if metrics["retrieval_relevance_pct"] < 50 and metrics["total_retrievals"] >= 5:
                 finding("ERROR", "cognitive-metrics",
@@ -399,21 +287,20 @@ def check_cognitive_health():
     except Exception as e:
         finding("WARN", "cognitive-metrics", f"Metrics collection failed: {e}")
 
-    # Phase triggers monitoring (spec section 10)
+    # Phase triggers monitoring
     try:
-        sys.path.insert(0, str(Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))))
         import cognitive as cog
 
         db_cog = cog._get_db()
 
         # v2.0: Procedural memory — trigger: >50 procedural change_logs
-        procedural_markers = ['1.', '2.', '3.', 'step ', 'Step ', 'then ', 'first ', 'First ', '→', '->', 'SSH', 'scp', 'git commit', 'deploy']
+        procedural_markers = ['1.', '2.', '3.', 'step ', 'Step ', 'then ', 'first ', 'First ', '→', '->', 'git commit', 'deploy']
         changes = db_cog.execute('SELECT content FROM ltm_memories WHERE source_type = "change"').fetchall()
         procedural_count = sum(1 for r in changes if sum(1 for m in procedural_markers if m in r[0]) >= 2)
         if procedural_count >= 50:
-            finding("WARN", "cognitive-phase", f"v2.0 TRIGGER MET: {procedural_count} procedural memories (>50). Implement Store 4 (memoria procedimental).")
+            finding("WARN", "cognitive-phase", f"v2.0 TRIGGER MET: {procedural_count} procedural memories (>50). Implement Store 4 (procedural memory).")
 
-        # v2.1: MEMORY.md reduction — trigger: RAG relevance >80% for 30 days
+        # v2.1: MEMORY reduction — trigger: RAG relevance >80% for 30 days
         metrics_file = LOG_DIR / "cognitive-metrics-history.json"
         try:
             history = json.loads(metrics_file.read_text()) if metrics_file.exists() else []
@@ -437,7 +324,7 @@ def check_cognitive_health():
             last_30 = history[-30:]
             all_above_80 = all(h["relevance"] >= 80.0 for h in last_30)
             if all_above_80:
-                finding("WARN", "cognitive-phase", "v2.1 TRIGGER MET: RAG relevance >80% for 30 consecutive days. Reduce MEMORY.md to ~20 lines.")
+                finding("WARN", "cognitive-phase", "v2.1 TRIGGER MET: RAG relevance >80% for 30 consecutive days. Consider reducing static memory files.")
 
         # v2.2: Dashboard — trigger: 30 days of metrics
         if len(history) >= 30:
@@ -448,8 +335,6 @@ def check_cognitive_health():
         if ltm_count >= 1000:
             finding("WARN", "cognitive-phase", f"v3.0 TRIGGER MET: {ltm_count} LTM vectors (>1000). Implement K-means clustering.")
 
-        # v1.4: Multilingual — already checked in metrics section above
-
     except Exception as e:
         finding("WARN", "cognitive-phase", f"Phase trigger check failed: {e}")
 
@@ -457,7 +342,6 @@ def check_cognitive_health():
     if datetime.now().weekday() == 6:
         log("  Running weekly cognitive GC (Sunday)...")
         try:
-            sys.path.insert(0, str(Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))))
             import cognitive as cog
 
             # 1. Delete STM with strength < 0.1 and > 30 days
@@ -478,6 +362,11 @@ def check_cognitive_health():
 
 # ── Main ────────────────────────────────────────────────────────────────
 def main():
+    # Ensure cognitive module is importable
+    src_dir = NEXO_HOME / "src"
+    if src_dir.exists() and str(src_dir) not in sys.path:
+        sys.path.insert(0, str(src_dir))
+
     log("=" * 60)
     log("NEXO Daily Self-Audit starting")
 
@@ -492,12 +381,6 @@ def main():
     check_repetition_rate()
     check_unused_learnings()
     check_memory_reviews()
-    check_watchdog_registry()
-    check_snapshot_sync()
-    check_restore_activity()
-    check_bad_responses()
-    check_runtime_preflight()
-    check_watchdog_smoke()
     check_cognitive_health()
 
     errors = sum(1 for f in findings if f["severity"] == "ERROR")
@@ -517,7 +400,7 @@ def main():
     # Register successful run for catch-up
     try:
         import json as _json
-        _state_file = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))) / "operations" / ".catchup-state.json"
+        _state_file = NEXO_HOME / "operations" / ".catchup-state.json"
         _state = _json.loads(_state_file.read_text()) if _state_file.exists() else {}
         _state["self-audit"] = datetime.now().isoformat()
         _state_file.write_text(_json.dumps(_state, indent=2))