nexo-brain 0.2.1 → 0.3.1

package/README.md

@@ -162,7 +162,7 @@ That's it. No need to run `claude` manually. Atlas will greet you immediately
 | Component | What | Where |
 |-----------|------|-------|
 | Cognitive engine | Python: fastembed, numpy, vector search | pip packages |
-| MCP server | 76 tools for memory, learning, guard | ~/.nexo/ |
+| MCP server | 77 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/ |
@@ -173,19 +173,19 @@ That's it. No need to run `claude` manually. Atlas will greet you immediately
 
 - **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.
+- **Claude Opus (latest version) strongly recommended.** NEXO provides 77 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 77 tools without hesitation.
 - Python 3, Homebrew, and Claude Code are installed automatically if missing.
 
 ## Architecture
 
-### 76 MCP Tools across 16 Categories
+### 77 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 |
+| Sessions | 4 | startup, heartbeat, stop, 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 |
@@ -270,7 +270,7 @@ openclaw mcp set nexo-brain '{"command":"python3","args":["~/.nexo/src/server.py
 openclaw gateway restart
 ```
 
-All 76 NEXO tools become available to your OpenClaw agent immediately.
+All 77 NEXO tools become available to your OpenClaw agent immediately.
 
 > **First time?** Run `npx nexo-brain` first to install the cognitive engine and dependencies.
 
@@ -298,7 +298,19 @@ Configure in `~/.openclaw/openclaw.json`:
 }
 ```
 
-This replaces OpenClaw's default memory system with NEXO's full cognitive architecture — Atkinson-Shiffrin memory, semantic RAG, trust scoring, guard system, and all 76 tools.
+This replaces OpenClaw's default memory system with NEXO's full cognitive architecture — Atkinson-Shiffrin memory, semantic RAG, trust scoring, guard system, and all 77 tools.
+
+## Listed On
+
+| Directory | Type | Link |
+|-----------|------|------|
+| npm | Package | [nexo-brain](https://www.npmjs.com/package/nexo-brain) |
+| Glama | MCP Directory | [glama.ai](https://glama.ai/mcp/servers/@wazionapps/nexo) |
+| mcp.so | MCP Directory | [mcp.so](https://mcp.so/server/nexo/wazionapps) |
+| mcpservers.org | MCP Directory | [mcpservers.org](https://mcpservers.org) |
+| OpenClaw | Native Plugin | [openclaw.com](https://openclaw.ai) |
+| dev.to | Technical Article | [How I Applied Cognitive Psychology to AI Agents](https://dev.to/wazionapps/how-i-applied-cognitive-psychology-to-give-ai-agents-real-memory-2oce) |
+| nexo-brain.com | Official Website | [nexo-brain.com](https://nexo-brain.com) |
 
 ## Contributing
 
@@ -310,4 +322,4 @@ MIT — see [LICENSE](LICENSE)
 
 ---
 
-Built by [WAzion](https://wazion.com) | Created by Francisco Garcia
+Built by [WAzion](https://www.wazion.com)

package/bin/nexo-brain 2.js

@@ -0,0 +1,610 @@
+#!/usr/bin/env node
+/**
+ * create-nexo — Interactive installer for NEXO cognitive co-operator.
+ *
+ * Usage: npx create-nexo
+ *
+ * What it does:
+ * 1. Asks for the co-operator's name
+ * 2. Asks permission to scan the workspace
+ * 3. Installs Python dependencies (fastembed, numpy, mcp)
+ * 4. Creates ~/.nexo/ with DB, personality, and config
+ * 5. Configures Claude Code MCP settings
+ * 6. Creates LaunchAgents for macOS automated processes
+ * 7. Generates CLAUDE.md with the operator's instructions
+ */
+
+const { execSync, spawnSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+
+const NEXO_HOME = path.join(require("os").homedir(), ".nexo");
+const CLAUDE_SETTINGS = path.join(
+  require("os").homedir(),
+  ".claude",
+  "settings.json"
+);
+const LAUNCH_AGENTS = path.join(
+  require("os").homedir(),
+  "Library",
+  "LaunchAgents"
+);
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+function ask(question) {
+  return new Promise((resolve) => rl.question(question, resolve));
+}
+
+function run(cmd, opts = {}) {
+  try {
+    return execSync(cmd, { encoding: "utf8", stdio: "pipe", ...opts }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function log(msg) {
+  console.log(`  ${msg}`);
+}
+
+async function main() {
+  console.log("");
+  console.log(
+    "  ╔══════════════════════════════════════════════════════════╗"
+  );
+  console.log(
+    "  ║  NEXO — Cognitive Co-Operator for Claude Code          ║"
+  );
+  console.log(
+    "  ║  Atkinson-Shiffrin Memory | RAG | Trust Score           ║"
+  );
+  console.log(
+    "  ╚══════════════════════════════════════════════════════════╝"
+  );
+  console.log("");
+
+  // Check prerequisites
+  const platform = process.platform;
+  if (platform !== "darwin") {
+    log("NEXO currently supports macOS only. Linux support coming soon.");
+    process.exit(1);
+  }
+
+  // Find or install Homebrew (needed for Python)
+  let hasBrew = run("which brew");
+  if (!hasBrew) {
+    log("Homebrew not found. Installing...");
+    spawnSync("/bin/bash", ["-c", '$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)'], {
+      stdio: "inherit",
+    });
+    hasBrew = run("which brew") || run("eval $(/opt/homebrew/bin/brew shellenv) && which brew");
+  }
+
+  // Find or install Python
+  let python = run("which python3");
+  if (!python) {
+    if (hasBrew) {
+      log("Python 3 not found. Installing via Homebrew...");
+      spawnSync("brew", ["install", "python3"], { stdio: "inherit" });
+      python = run("which python3");
+    }
+    if (!python) {
+      log("Python 3 not found and couldn't install automatically.");
+      log("Install it manually: brew install python3");
+      process.exit(1);
+    }
+  }
+  const pyVersion = run(`${python} --version`);
+  log(`Found ${pyVersion} at ${python}`);
+
+  // Find or install Claude Code
+  let claudeInstalled = run("which claude");
+  if (!claudeInstalled) {
+    log("Claude Code not found. Installing...");
+    const npmInstall = spawnSync("npm", ["install", "-g", "@anthropic-ai/claude-code"], {
+      stdio: "inherit",
+    });
+    claudeInstalled = run("which claude");
+    if (!claudeInstalled) {
+      log("Could not install Claude Code automatically.");
+      log("Install it manually: npm install -g @anthropic-ai/claude-code");
+      process.exit(1);
+    }
+    log("Claude Code installed successfully.");
+  } else {
+    log("Claude Code detected.");
+  }
+  console.log("");
+
+  // Step 1: Name
+  const name = await ask("  How should I call myself? (default: NEXO) > ");
+  const operatorName = name.trim() || "NEXO";
+  log(`Got it. I'm ${operatorName}.`);
+  console.log("");
+
+  // Step 2: Permission to scan
+  const scanAnswer = await ask(
+    "  Can I explore your workspace to learn about your projects? (y/n) > "
+  );
+  const doScan = scanAnswer.trim().toLowerCase().startsWith("y");
+  console.log("");
+
+  // Step 2b: Keep Mac awake for nocturnal processes?
+  const caffeinateAnswer = await ask(
+    "  Keep Mac awake so my cognitive processes run on schedule? (y/n) > "
+  );
+  const doCaffeinate = caffeinateAnswer.trim().toLowerCase().startsWith("y");
+  console.log("");
+
+  // Step 3: Install Python dependencies
+  log("Installing cognitive engine dependencies...");
+  const pipInstall = spawnSync(
+    python,
+    [
+      "-m",
+      "pip",
+      "install",
+      "--quiet",
+      "fastembed",
+      "numpy",
+      "mcp[cli]",
+    ],
+    { stdio: "inherit" }
+  );
+  if (pipInstall.status !== 0) {
+    log("Failed to install Python dependencies. Check pip.");
+    process.exit(1);
+  }
+  log("Dependencies installed.");
+
+  // Step 4: Create ~/.nexo/
+  log("Setting up NEXO home...");
+  const dirs = [
+    NEXO_HOME,
+    path.join(NEXO_HOME, "plugins"),
+    path.join(NEXO_HOME, "scripts"),
+    path.join(NEXO_HOME, "logs"),
+    path.join(NEXO_HOME, "backups"),
+    path.join(NEXO_HOME, "coordination"),
+    path.join(NEXO_HOME, "brain"),
+  ];
+  dirs.forEach((d) => fs.mkdirSync(d, { recursive: true }));
+
+  // Write version file for auto-update tracking
+  const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8"));
+  fs.writeFileSync(
+    path.join(NEXO_HOME, "version.json"),
+    JSON.stringify({
+      version: pkg.version,
+      installed_at: new Date().toISOString(),
+      files_updated: 0,
+    }, null, 2)
+  );
+
+  // Copy source files
+  const srcDir = path.join(__dirname, "..", "src");
+  const scriptsSrcDir = path.join(__dirname, "..", "src", "scripts");
+  const pluginsSrcDir = path.join(__dirname, "..", "src", "plugins");
+  const templateDir = path.join(__dirname, "..", "templates");
+
+  // Core files
+  const coreFiles = [
+    "server.py",
+    "db.py",
+    "plugin_loader.py",
+    "cognitive.py",
+    "tools_sessions.py",
+    "tools_coordination.py",
+    "tools_reminders.py",
+    "tools_reminders_crud.py",
+    "tools_learnings.py",
+    "tools_credentials.py",
+    "tools_task_history.py",
+    "tools_menu.py",
+  ];
+  coreFiles.forEach((f) => {
+    const src = path.join(srcDir, f);
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, path.join(NEXO_HOME, f));
+    }
+  });
+
+  // Plugins
+  const pluginFiles = [
+    "__init__.py",
+    "guard.py",
+    "episodic_memory.py",
+    "cognitive_memory.py",
+    "entities.py",
+    "preferences.py",
+    "agents.py",
+    "backup.py",
+    "evolution.py",
+  ];
+  pluginFiles.forEach((f) => {
+    const src = path.join(pluginsSrcDir, f);
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, path.join(NEXO_HOME, "plugins", f));
+    }
+  });
+
+  // Scripts
+  const scriptFiles = fs
+    .readdirSync(scriptsSrcDir || ".")
+    .filter((f) => f.endsWith(".py"));
+  scriptFiles.forEach((f) => {
+    const src = path.join(scriptsSrcDir, f);
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, path.join(NEXO_HOME, "scripts", f));
+    }
+  });
+
+  // Generate personality
+  const personality = `# ${operatorName} — Personality
+
+I am ${operatorName}, a cognitive co-operator. Not an assistant — an operational partner.
+
+## Core traits
+- Direct: I say what I think, not what sounds nice
+- Action-oriented: I do things, I don't suggest things
+- Self-critical: I track my mistakes and learn from them
+- Proactive: If I can detect or fix something without being asked, I do it
+
+## What I never do
+- Ask the user to do something I can do myself
+- Say "I can't" without trying alternatives first
+- Give long explanations when a short answer suffices
+- Repeat mistakes I've already logged
+`;
+  fs.writeFileSync(path.join(NEXO_HOME, "brain", "personality.md"), personality);
+
+  // Generate user profile
+  const profile = `# User Profile
+
+Created: ${new Date().toISOString().split("T")[0]}
+Operator name: ${operatorName}
+
+## Observed preferences
+(${operatorName} will learn these over time)
+
+## Work patterns
+(${operatorName} will observe and record these)
+`;
+  fs.writeFileSync(path.join(NEXO_HOME, "brain", "user-profile.md"), profile);
+
+  // Step 5: Scan workspace
+  if (doScan) {
+    log("Scanning workspace...");
+    const cwd = process.cwd();
+    const findings = [];
+
+    // Git repos
+    const gitDirs = run(
+      `find "${cwd}" -maxdepth 3 -name ".git" -type d 2>/dev/null`
+    );
+    if (gitDirs) {
+      const repos = gitDirs.split("\n").filter(Boolean);
+      findings.push(`${repos.length} git repositories`);
+    }
+
+    // Package managers
+    if (fs.existsSync(path.join(cwd, "package.json")))
+      findings.push("Node.js project detected");
+    if (fs.existsSync(path.join(cwd, "requirements.txt")))
+      findings.push("Python project detected");
+    if (fs.existsSync(path.join(cwd, "Cargo.toml")))
+      findings.push("Rust project detected");
+    if (fs.existsSync(path.join(cwd, "go.mod")))
+      findings.push("Go project detected");
+
+    // Config files
+    if (fs.existsSync(path.join(cwd, ".env")))
+      findings.push(".env file found (will NOT read contents)");
+
+    if (findings.length > 0) {
+      log("Found:");
+      findings.forEach((f) => log(`  - ${f}`));
+    } else {
+      log("No projects detected in current directory.");
+    }
+
+    // Save scan results
+    fs.writeFileSync(
+      path.join(NEXO_HOME, "brain", "workspace-scan.json"),
+      JSON.stringify(
+        { scanned_at: new Date().toISOString(), cwd, findings },
+        null,
+        2
+      )
+    );
+  }
+
+  console.log("");
+
+  // Step 6: Configure Claude Code MCP
+  log("Configuring Claude Code MCP server...");
+  let settings = {};
+  if (fs.existsSync(CLAUDE_SETTINGS)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(CLAUDE_SETTINGS, "utf8"));
+    } catch {
+      settings = {};
+    }
+  }
+
+  if (!settings.mcpServers) settings.mcpServers = {};
+  settings.mcpServers.nexo = {
+    command: python,
+    args: [path.join(NEXO_HOME, "server.py")],
+    env: {
+      NEXO_HOME: NEXO_HOME,
+      NEXO_NAME: operatorName,
+    },
+  };
+
+  // Configure hooks for session capture (Sensory Register)
+  if (!settings.hooks) settings.hooks = {};
+
+  // Copy hook scripts to NEXO_HOME
+  const hooksSrcDir = path.join(__dirname, "..", "src", "hooks");
+  const hooksDestDir = path.join(NEXO_HOME, "hooks");
+  fs.mkdirSync(hooksDestDir, { recursive: true });
+  ["session-start.sh", "capture-session.sh", "session-stop.sh"].forEach((h) => {
+    const src = path.join(hooksSrcDir, h);
+    const dest = path.join(hooksDestDir, h);
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, dest);
+      fs.chmodSync(dest, "755");
+    }
+  });
+
+  // SessionStart hook
+  if (!settings.hooks.SessionStart) settings.hooks.SessionStart = [];
+  const startHook = {
+    type: "command",
+    command: `bash ${path.join(hooksDestDir, "session-start.sh")}`,
+  };
+  if (!settings.hooks.SessionStart.some((h) => h.command && h.command.includes("session-start.sh"))) {
+    settings.hooks.SessionStart.push(startHook);
+  }
+
+  // PostToolUse hook (captures tool usage to session_buffer)
+  if (!settings.hooks.PostToolUse) settings.hooks.PostToolUse = [];
+  const captureHook = {
+    type: "command",
+    command: `bash ${path.join(hooksDestDir, "capture-session.sh")}`,
+  };
+  if (!settings.hooks.PostToolUse.some((h) => h.command && h.command.includes("capture-session.sh"))) {
+    settings.hooks.PostToolUse.push(captureHook);
+  }
+
+  // Stop hook (session end)
+  if (!settings.hooks.Stop) settings.hooks.Stop = [];
+  const stopHook = {
+    type: "command",
+    command: `bash ${path.join(hooksDestDir, "session-stop.sh")}`,
+  };
+  if (!settings.hooks.Stop.some((h) => h.command && h.command.includes("session-stop.sh"))) {
+    settings.hooks.Stop.push(stopHook);
+  }
+
+  const settingsDir = path.dirname(CLAUDE_SETTINGS);
+  fs.mkdirSync(settingsDir, { recursive: true });
+  fs.writeFileSync(CLAUDE_SETTINGS, JSON.stringify(settings, null, 2));
+  log("MCP server + hooks configured in Claude Code settings.");
+
+  // Step 7: Install LaunchAgents
+  log("Setting up automated processes...");
+  fs.mkdirSync(LAUNCH_AGENTS, { recursive: true });
+
+  const agents = [
+    {
+      name: "cognitive-decay",
+      script: "nexo-cognitive-decay.py",
+      hour: 3,
+      minute: 0,
+    },
+    {
+      name: "postmortem",
+      script: "nexo-postmortem-consolidator.py",
+      hour: 23,
+      minute: 30,
+    },
+    {
+      name: "sleep",
+      script: "nexo-sleep.py",
+      hour: 4,
+      minute: 0,
+    },
+    {
+      name: "self-audit",
+      script: "nexo-daily-self-audit.py",
+      hour: 7,
+      minute: 0,
+    },
+    { name: "catchup", script: "nexo-catchup.py", runAtLoad: true },
+  ];
+
+  agents.forEach((agent) => {
+    const plistName = `com.nexo.${agent.name}.plist`;
+    const plistPath = path.join(LAUNCH_AGENTS, plistName);
+
+    let scheduleBlock = "";
+    if (agent.runAtLoad) {
+      scheduleBlock = `    <key>RunAtLoad</key>
+    <true/>`;
+    } else {
+      scheduleBlock = `    <key>StartCalendarInterval</key>
+    <dict>
+        <key>Hour</key>
+        <integer>${agent.hour}</integer>
+        <key>Minute</key>
+        <integer>${agent.minute}</integer>
+    </dict>
+    <key>RunAtLoad</key>
+    <false/>`;
+    }
+
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.nexo.${agent.name}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${python}</string>
+        <string>${path.join(NEXO_HOME, "scripts", agent.script)}</string>
+    </array>
+    ${scheduleBlock}
+    <key>StandardOutPath</key>
+    <string>${path.join(NEXO_HOME, "logs", `${agent.name}-stdout.log`)}</string>
+    <key>StandardErrorPath</key>
+    <string>${path.join(NEXO_HOME, "logs", `${agent.name}-stderr.log`)}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>HOME</key>
+        <string>${require("os").homedir()}</string>
+        <key>NEXO_HOME</key>
+        <string>${NEXO_HOME}</string>
+        <key>PATH</key>
+        <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+    </dict>
+</dict>
+</plist>`;
+
+    fs.writeFileSync(plistPath, plist);
+    // Register the agent
+    try {
+      execSync(
+        `launchctl bootout gui/$(id -u) "${plistPath}" 2>/dev/null; launchctl bootstrap gui/$(id -u) "${plistPath}"`,
+        { stdio: "pipe" }
+      );
+    } catch {
+      // May fail if not previously loaded, that's OK
+    }
+  });
+  log(`${agents.length} automated processes configured.`);
+
+  // Caffeinate: keep Mac awake for nocturnal processes
+  if (doCaffeinate) {
+    const caffHookSrc = path.join(__dirname, "..", "src", "hooks", "caffeinate-guard.sh");
+    const caffHookDest = path.join(NEXO_HOME, "hooks", "caffeinate-guard.sh");
+    if (fs.existsSync(caffHookSrc)) {
+      fs.copyFileSync(caffHookSrc, caffHookDest);
+      fs.chmodSync(caffHookDest, "755");
+    }
+
+    const caffPlist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.nexo.caffeinate</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>/bin/bash</string>
+        <string>${caffHookDest}</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>${path.join(NEXO_HOME, "logs", "caffeinate-stdout.log")}</string>
+    <key>StandardErrorPath</key>
+    <string>${path.join(NEXO_HOME, "logs", "caffeinate-stderr.log")}</string>
+</dict>
+</plist>`;
+
+    const caffPlistPath = path.join(LAUNCH_AGENTS, "com.nexo.caffeinate.plist");
+    fs.writeFileSync(caffPlistPath, caffPlist);
+    try {
+      execSync(
+        `launchctl bootout gui/$(id -u) "${caffPlistPath}" 2>/dev/null; launchctl bootstrap gui/$(id -u) "${caffPlistPath}"`,
+        { stdio: "pipe" }
+      );
+    } catch {}
+    log("Caffeinate enabled — Mac will stay awake for cognitive processes.");
+  }
+
+  // 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 = "";
+  if (fs.existsSync(templateSrc)) {
+    claudeMd = fs
+      .readFileSync(templateSrc, "utf8")
+      .replace(/\{\{NAME\}\}/g, operatorName)
+      .replace(/\{\{NEXO_HOME\}\}/g, NEXO_HOME);
+  } else {
+    claudeMd = `# ${operatorName} — Cognitive Co-Operator
+
+Instructions for ${operatorName} are generated during setup.
+See ~/.nexo/ for configuration.
+`;
+  }
+
+  // Write to user's global CLAUDE.md if it doesn't exist
+  const userClaudeMd = path.join(require("os").homedir(), ".claude", "CLAUDE.md");
+  if (!fs.existsSync(userClaudeMd)) {
+    fs.writeFileSync(userClaudeMd, claudeMd);
+    log("Created ~/.claude/CLAUDE.md with operator instructions.");
+  } else {
+    // Save as reference
+    fs.writeFileSync(path.join(NEXO_HOME, "CLAUDE.md.generated"), claudeMd);
+    log(
+      "~/.claude/CLAUDE.md already exists. Generated template saved to ~/.nexo/CLAUDE.md.generated"
+    );
+  }
+
+  console.log("");
+  console.log(
+    "  ╔══════════════════════════════════════════════════════════╗"
+  );
+  console.log(
+    `  ║  ${operatorName} is ready. Type '${aliasName}' to start.${" ".repeat(Math.max(0, 30 - operatorName.length - aliasName.length))}║`
+  );
+  console.log(
+    "  ╚══════════════════════════════════════════════════════════╝"
+  );
+  console.log("");
+
+  rl.close();
+}
+
+main().catch((err) => {
+  console.error("Setup failed:", err.message);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "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": {
@@ -17,7 +17,7 @@
     "openclaw",
     "openclaw-plugin"
   ],
-  "author": "Francisco Garcia <hello@wazion.com>",
+  "author": "WAzion Apps <hello@wazion.com>",
   "license": "MIT",
   "repository": {
     "type": "git",