neohive 6.0.2 → 6.1.0

package/cli.js

@@ -4,12 +4,24 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
+const { upsertNeohiveMcpInToml } = require('./lib/codex-neohive-toml');
+
+// ─────────────────────────────────────────────────────────────────────────────
+// CLI_CONFIG — centralized constants for the Neohive CLI
+// ─────────────────────────────────────────────────────────────────────────────
+const CLI_CONFIG = {
+  MCP_TOOL_TIMEOUT_S:   300,    // MCP tool timeout written to IDE config files (seconds)
+  OLLAMA_DETECT_TIMEOUT_MS: 5000, // timeout for 'ollama --version' probe
+  OLLAMA_HEARTBEAT_MS:  10000,  // how often Ollama agent writes heartbeat
+  OLLAMA_POLL_MS:        2000,  // how often Ollama agent polls for messages
+  MSG_MAX_CHARS:        10000,  // max length of --msg text argument
+};
 
 const command = process.argv[2];
 
 function printUsage() {
   console.log(`
-  Neohive v6.0.0
+  Neohive v6.1.0
   The MCP collaboration layer for AI CLI tools.
 
   Usage:
@@ -17,9 +29,15 @@ function printUsage() {
     npx neohive init --claude       Configure for Claude Code only
     npx neohive init --gemini       Configure for Gemini CLI only
     npx neohive init --codex        Configure for Codex CLI only
-    npx neohive init --all          Configure for all detected CLIs
+    npx neohive init --cursor       Configure for Cursor IDE only (.cursor/mcp.json)
+    npx neohive init --vscode       Configure for VS Code GitHub Copilot
+    npx neohive init --antigravity  Configure for Antigravity IDE
+    npx neohive init --all          Configure for all supported CLIs
+    npx neohive mcp                 Start MCP stdio server (used internally by IDE configs)
     npx neohive init --ollama       Setup Ollama local LLM bridge
     npx neohive init --template T   Initialize with a team template
+    npx neohive serve               Run MCP server in HTTP mode (port 4321)
+    npx neohive serve --port 8080   Custom port for HTTP server
     npx neohive dashboard           Launch web dashboard (http://localhost:3000)
     npx neohive dashboard --lan     Dashboard accessible on LAN
     npx neohive status              Show active agents and tasks
@@ -55,13 +73,18 @@ function detectCLIs() {
     detected.push('codex');
   }
 
+  // Cursor IDE: ~/.cursor/ (app support) exists
+  if (fs.existsSync(path.join(home, '.cursor'))) {
+    detected.push('cursor');
+  }
+
   return detected;
 }
 
 // Detect Ollama installation
 function detectOllama() {
   try {
-    const version = execSync('ollama --version', { encoding: 'utf8', timeout: 5000 }).trim();
+    const version = execSync('ollama --version', { encoding: 'utf8', timeout: CLI_CONFIG.OLLAMA_DETECT_TIMEOUT_MS }).trim();
     return { installed: true, version };
   } catch {
     return { installed: false };
@@ -73,6 +96,16 @@ function dataDir(cwd) {
   return path.join(cwd, '.neohive');
 }
 
+// Absolute Node binary for MCP configs — CLIs often spawn without Volta/nvm PATH, so plain "node" fails.
+function mcpNodeCommand() {
+  return process.execPath;
+}
+
+// MCP stdio "command" for npx — do not use /usr/bin/env (not portable on Windows).
+function mcpNpxCommand() {
+  return process.platform === 'win32' ? 'npx.cmd' : 'npx';
+}
+
 // Configure for Claude Code (.mcp.json in project root)
 function setupClaude(serverPath, cwd) {
   const mcpConfigPath = path.join(cwd, '.mcp.json');
@@ -90,9 +123,9 @@ function setupClaude(serverPath, cwd) {
   }
 
   mcpConfig.mcpServers['neohive'] = {
-    command: 'node',
+    command: mcpNodeCommand(),
     args: [serverPath],
-    timeout: 300,
+    timeout: CLI_CONFIG.MCP_TOOL_TIMEOUT_S,
   };
 
   fs.writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2) + '\n');
@@ -122,14 +155,199 @@ function setupGemini(serverPath, cwd) {
   }
 
   settings.mcpServers['neohive'] = {
-    command: 'node',
+    command: mcpNodeCommand(),
     args: [serverPath],
-    timeout: 300,
+    timeout: CLI_CONFIG.MCP_TOOL_TIMEOUT_S,
     trust: true,
   };
 
+  if (!settings.context) settings.context = {};
+  if (!settings.context.files) settings.context.files = [];
+  if (!settings.context.files.includes('GEMINI.md')) {
+    settings.context.files.push('GEMINI.md');
+  }
+
   fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
   console.log('  [ok] Gemini CLI: .gemini/settings.json updated');
+
+  // Write GEMINI.md agent rules if not already present
+  const geminiMdPath = path.join(cwd, 'GEMINI.md');
+  if (!fs.existsSync(geminiMdPath)) {
+    fs.writeFileSync(geminiMdPath, geminiMdTemplate());
+    console.log('  [ok] Gemini CLI: GEMINI.md created with agent rules');
+  } else {
+    console.log('  [skip] GEMINI.md already exists — not overwriting');
+  }
+}
+
+function geminiMdTemplate() {
+  return `# Neohive Agent — Gemini CLI
+
+You are a Neohive team agent. Follow these rules exactly, every session, no exceptions.
+
+## First thing to do — always
+
+1. Call \`register\` with your assigned name (e.g. \`register(name="Gemini")\`)
+2. Call \`get_briefing\` to load project context and current work
+3. Call \`listen\` to wait for messages from the Coordinator
+
+Do NOT explore the codebase, ask questions, or take initiative before completing these 3 steps.
+
+## Core rules
+
+- **After every action** — call \`listen()\`. This is how you receive your next task.
+- **Before starting a task** — call \`update_task(id, status="in_progress")\`
+- **After finishing a task** — call \`update_task(id, status="done")\`, then report to Coordinator
+- **Before editing a file** — call \`lock_file(path)\`. Call \`unlock_file(path)\` when done.
+- **Check tasks first** — call \`list_tasks()\` before starting anything new. Never work on another agent's task.
+- **Keep messages short** — 2–3 paragraphs max. Lead with what changed, then files, then decisions.
+
+## Workflow
+
+\`\`\`
+register → get_briefing → listen → [receive task] → update_task(in_progress)
+→ do work → update_task(done) → send_message(Coordinator, summary) → listen
+\`\`\`
+
+Repeat the last 5 steps for every task. Never exit the listen loop.
+
+## Available MCP tools
+
+**Messaging:** \`register\`, \`send_message\`, \`broadcast\`, \`listen\`, \`check_messages\`, \`get_history\`, \`handoff\`
+**Tasks:** \`create_task\`, \`update_task\`, \`list_tasks\`
+**Workflows:** \`create_workflow\`, \`advance_workflow\`, \`workflow_status\`
+**Workspaces:** \`workspace_write\`, \`workspace_read\`, \`workspace_list\`
+**Branching:** \`fork_conversation\`, \`switch_branch\`, \`list_branches\`
+
+## What NOT to do
+
+- Do not self-assign tasks
+- Do not modify files without a task assigned to you
+- Do not skip \`listen()\` after responding
+- Do not send long messages — be concise
+- Do not ask the Coordinator for permission before starting an assigned task — just do it
+`;
+}
+
+// Configure for VS Code GitHub Copilot (.vscode/mcp.json + copilot instructions)
+function setupVSCode(cwd) {
+  const vscodeDir = path.join(cwd, '.vscode');
+  const mcpPath = path.join(vscodeDir, 'mcp.json');
+  if (!fs.existsSync(vscodeDir)) fs.mkdirSync(vscodeDir, { recursive: true });
+
+  let config = { servers: {} };
+  if (fs.existsSync(mcpPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(mcpPath, 'utf8'));
+      if (!config.servers) config.servers = {};
+    } catch {
+      fs.copyFileSync(mcpPath, mcpPath + '.backup');
+      console.log('  [warn] Existing .vscode/mcp.json was invalid — backed up');
+    }
+  }
+
+  config.servers['neohive'] = {
+    type: 'stdio',
+    command: mcpNpxCommand(),
+    args: ['-y', 'neohive', 'mcp'],
+    env: {
+      NEOHIVE_DATA_DIR: '${workspaceFolder}/.neohive',
+    },
+    cwd: '${workspaceFolder}',
+  };
+
+  fs.writeFileSync(mcpPath, JSON.stringify(config, null, 2) + '\n');
+  console.log('  [ok] VS Code: .vscode/mcp.json updated');
+
+  // Write copilot instructions
+  const githubDir = path.join(cwd, '.github');
+  const instructionsPath = path.join(githubDir, 'copilot-instructions.md');
+  if (!fs.existsSync(githubDir)) fs.mkdirSync(githubDir, { recursive: true });
+  if (!fs.existsSync(instructionsPath)) {
+    fs.writeFileSync(instructionsPath, neohiveAgentRules('Copilot'));
+    console.log('  [ok] VS Code: .github/copilot-instructions.md created');
+  }
+}
+
+// Configure for Antigravity (~/.gemini/antigravity/mcp_config.json + skill)
+function setupAntigravity(cwd) {
+  const antigravityDir = path.join(os.homedir(), '.gemini', 'antigravity');
+  const mcpPath = path.join(antigravityDir, 'mcp_config.json');
+  if (!fs.existsSync(antigravityDir)) fs.mkdirSync(antigravityDir, { recursive: true });
+
+  let config = { mcpServers: {} };
+  if (fs.existsSync(mcpPath)) {
+    try {
+      // Strip JS-style comments before parsing (Antigravity writes JSONC)
+      const raw = fs.readFileSync(mcpPath, 'utf8').replace(/\/\/[^\n]*/g, '');
+      config = JSON.parse(raw);
+      if (!config.mcpServers) config.mcpServers = {};
+    } catch {
+      fs.copyFileSync(mcpPath, mcpPath + '.backup');
+      console.log('  [warn] Existing mcp_config.json was invalid — backed up');
+    }
+  }
+
+  const abDataDir = path.join(path.resolve(cwd), '.neohive').replace(/\\/g, '/');
+
+  config.mcpServers['neohive'] = {
+    command: 'npx',
+    args: ['-y', 'neohive', 'mcp'],
+    cwd: cwd,
+    env: { NEOHIVE_DATA_DIR: abDataDir },
+  };
+
+  fs.writeFileSync(mcpPath, JSON.stringify(config, null, 2) + '\n');
+  console.log('  [ok] Antigravity: ~/.gemini/antigravity/mcp_config.json updated');
+
+  // Write skill
+  const skillDir = path.join(cwd, '.agent', 'skills', 'neohive');
+  if (!fs.existsSync(skillDir)) fs.mkdirSync(skillDir, { recursive: true });
+  const skillPath = path.join(skillDir, 'SKILL.md');
+  if (!fs.existsSync(skillPath)) {
+    fs.writeFileSync(skillPath, neohiveAgentRules('Gemini'));
+    console.log('  [ok] Antigravity: .agent/skills/neohive/SKILL.md created');
+  }
+}
+
+function neohiveAgentRules(defaultName) {
+  return `# Neohive Agent
+
+You are a Neohive team agent. Follow these rules every session.
+
+## On session start — always do this first
+
+1. Call \`register\` with your assigned name (e.g. \`register(name="${defaultName}")\`)
+2. Call \`get_briefing\` to load project context and active work
+3. Call \`listen\` to wait for messages from the Coordinator
+
+Do NOT explore the codebase or take initiative before completing these 3 steps.
+
+## Core rules
+
+- **After every action** — call \`listen()\`. This is how you receive your next task.
+- **Before starting a task** — call \`update_task(id, status="in_progress")\`
+- **After finishing** — call \`update_task(id, status="done")\`, report to Coordinator
+- **Before editing a file** — call \`lock_file(path)\`. Call \`unlock_file(path)\` when done.
+- **Check tasks first** — call \`list_tasks()\` before starting anything. Never take another agent's task.
+- **Keep messages short** — 2–3 paragraphs max. Lead with what changed, then files, then decisions.
+
+## Workflow loop
+
+\`\`\`
+register → get_briefing → listen → [receive task] → update_task(in_progress)
+→ do work → update_task(done) → send_message(Coordinator, summary) → listen
+\`\`\`
+
+Never exit the listen loop.
+
+## Available MCP tools (neohive server)
+
+**Messaging:** \`register\`, \`send_message\`, \`broadcast\`, \`listen\`, \`check_messages\`, \`get_history\`
+**Tasks:** \`create_task\`, \`update_task\`, \`list_tasks\`
+**Workflows:** \`create_workflow\`, \`advance_workflow\`, \`workflow_status\`
+**Workspaces:** \`workspace_write\`, \`workspace_read\`, \`workspace_list\`
+`;
 }
 
 // Configure for Codex CLI (uses .codex/config.toml)
@@ -152,21 +370,56 @@ function setupCodex(serverPath, cwd) {
     fs.copyFileSync(configPath, configPath + '.backup');
   }
 
-  // Only add if not already present
-  if (!config.includes('[mcp_servers.neohive]')) {
-    const tomlBlock = `
-[mcp_servers.neohive]
-command = "node"
-args = [${JSON.stringify(serverPath)}]
-timeout = 300
-`;
-    config += tomlBlock;
-    fs.writeFileSync(configPath, config);
-  }
+  const abDataDir = path.join(path.resolve(cwd), '.neohive').replace(/\\/g, '/');
+  const envSection =
+    `[mcp_servers.neohive.env]\nNEOHIVE_DATA_DIR = ${JSON.stringify(abDataDir)}\n`;
+  const hadNeohive = config.includes('[mcp_servers.neohive]');
+  config = upsertNeohiveMcpInToml(config, {
+    command: mcpNodeCommand(),
+    serverPath,
+    timeout: CLI_CONFIG.MCP_TOOL_TIMEOUT_S,
+    envSection: hadNeohive ? undefined : envSection,
+  });
+  fs.writeFileSync(configPath, config);
 
   console.log('  [ok] Codex CLI: .codex/config.toml updated');
 }
 
+// Configure for Cursor IDE — absolute NEOHIVE_DATA_DIR so Node never sees unexpanded ${workspaceFolder}.
+// If the IDE omits env on spawn, server startup still resolves the hive via lib/resolve-server-data-dir.js
+// (walks cwd ancestors for the same MCP files).
+function setupCursor(serverPath, cwd) {
+  const cursorDir = path.join(cwd, '.cursor');
+  const mcpConfigPath = path.join(cursorDir, 'mcp.json');
+  const abDataDir = path.join(path.resolve(cwd), '.neohive').replace(/\\/g, '/');
+
+  if (!fs.existsSync(cursorDir)) {
+    fs.mkdirSync(cursorDir, { recursive: true });
+  }
+
+  let mcpConfig = { mcpServers: {} };
+  if (fs.existsSync(mcpConfigPath)) {
+    try {
+      mcpConfig = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf8'));
+      if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+    } catch {
+      const backup = mcpConfigPath + '.backup';
+      fs.copyFileSync(mcpConfigPath, backup);
+      console.log('  [warn] Existing .cursor/mcp.json was invalid — backed up to mcp.json.backup');
+    }
+  }
+
+  mcpConfig.mcpServers['neohive'] = {
+    command: mcpNodeCommand(),
+    args: [serverPath],
+    env: { NEOHIVE_DATA_DIR: abDataDir },
+    timeout: CLI_CONFIG.MCP_TOOL_TIMEOUT_S,
+  };
+
+  fs.writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2) + '\n');
+  console.log('  [ok] Cursor IDE: .cursor/mcp.json updated');
+}
+
 // Setup Ollama agent bridge script
 function setupOllama(serverPath, cwd) {
   const dir = dataDir(cwd);
@@ -272,10 +525,10 @@ async function processMessages() {
 
 // Main loop
 register();
-const hb = setInterval(heartbeat, 10000);
+const hb = setInterval(heartbeat, CLI_CONFIG.OLLAMA_HEARTBEAT_MS);
 hb.unref();
 console.log('[' + name + '] Listening for messages... (Ctrl+C to stop)');
-setInterval(processMessages, 2000);
+setInterval(processMessages, CLI_CONFIG.OLLAMA_POLL_MS);
 
 // Cleanup on exit
 process.on('SIGINT', function() { console.log('\\n[' + name + '] Shutting down.'); process.exit(0); });
@@ -314,8 +567,14 @@ function init() {
     targets = ['gemini'];
   } else if (flag === '--codex') {
     targets = ['codex'];
+  } else if (flag === '--cursor') {
+    targets = ['cursor'];
+  } else if (flag === '--vscode') {
+    targets = ['vscode'];
+  } else if (flag === '--antigravity') {
+    targets = ['antigravity'];
   } else if (flag === '--all') {
-    targets = ['claude', 'gemini', 'codex'];
+    targets = ['claude', 'gemini', 'codex', 'cursor', 'vscode', 'antigravity'];
   } else if (flag === '--ollama') {
     const ollama = detectOllama();
     if (!ollama.installed) {
@@ -344,14 +603,17 @@ function init() {
 
   for (const target of targets) {
     switch (target) {
-      case 'claude': setupClaude(serverPath, cwd); break;
-      case 'gemini': setupGemini(serverPath, cwd); break;
-      case 'codex':  setupCodex(serverPath, cwd);  break;
+      case 'claude':      setupClaude(serverPath, cwd);   break;
+      case 'gemini':      setupGemini(serverPath, cwd);   break;
+      case 'codex':       setupCodex(serverPath, cwd);    break;
+      case 'cursor':      setupCursor(serverPath, cwd);   break;
+      case 'vscode':      setupVSCode(cwd);               break;
+      case 'antigravity': setupAntigravity(cwd);          break;
     }
   }
 
   // Add .neohive/ and MCP config files to .gitignore
-  const gitignoreEntries = ['.neohive/', '.mcp.json', '.codex/', '.gemini/'];
+  const gitignoreEntries = ['.neohive/', '.mcp.json', '.cursor/mcp.json', '.codex/', '.gemini/'];
   if (fs.existsSync(gitignorePath)) {
     let content = fs.readFileSync(gitignorePath, 'utf8');
     const missing = gitignoreEntries.filter(e => !content.includes(e));
@@ -367,8 +629,16 @@ function init() {
     console.log('  [ok] .gitignore created');
   }
 
+  const configuredCursor = targets.includes('cursor');
   console.log('');
-  console.log('  Neohive is ready! Restart your CLI to pick up the MCP tools.');
+  console.log(
+    configuredCursor
+      ? '  Neohive is ready! Restart Cursor (or reload MCP tools) and restart any terminal CLIs you use.'
+      : '  Neohive is ready! Restart your CLI to pick up the MCP tools.'
+  );
+  console.log('  MCP server command is your current Node binary (works when the IDE has no Volta/nvm in PATH):');
+  console.log('    ' + mcpNodeCommand());
+  console.log('  Re-run `npx neohive init` after switching machines or Node versions.');
   console.log('');
 
   // Show template if --template was provided
@@ -383,11 +653,15 @@ function init() {
   if (templateFlag) {
     showTemplate(templateFlag);
   } else {
-    console.log('  Open two terminals and start a conversation between agents.');
+    if (configuredCursor) {
+      console.log('  Cursor: use register + listen() from chat (neohive MCP). Terminal CLIs: one session per agent.');
+    } else {
+      console.log('  Open two terminals and start a conversation between agents.');
+    }
     console.log('  Tip: Use "npx neohive init --template pair" for ready-made prompts.');
     console.log('');
     console.log('  \x1b[1m  Monitor:\x1b[0m');
-    console.log('    npx neohive dashboard');
+    console.log('    npx neohive dashboard   → http://localhost:3000 (set NEOHIVE_PORT to change)');
     console.log('    npx neohive status');
     console.log('    npx neohive doctor');
     console.log('');
@@ -502,6 +776,17 @@ function showTemplate(templateName) {
   }
 }
 
+function serve() {
+  // Parse --port flag
+  const portIdx = process.argv.indexOf('--port');
+  if (portIdx !== -1 && process.argv[portIdx + 1]) {
+    process.env.NEOHIVE_SERVER_PORT = process.argv[portIdx + 1];
+  }
+  // Signal server.js to use HTTP transport
+  process.env.NEOHIVE_TRANSPORT = 'http';
+  require('./server.js');
+}
+
 function dashboard() {
   if (process.argv.includes('--lan')) {
     process.env.NEOHIVE_LAN = 'true';
@@ -544,6 +829,14 @@ function cliMsg() {
     process.exit(1);
   }
   const text = textParts.join(' ');
+  if (text.length > CLI_CONFIG.MSG_MAX_CHARS) {
+    console.error(`  Message text exceeds maximum length of ${CLI_CONFIG.MSG_MAX_CHARS} characters.`);
+    process.exit(1);
+  }
+  if (!text.trim().length) {
+    console.error('  Message text cannot be empty or whitespace only.');
+    process.exit(1);
+  }
   const dir = resolveDataDirCli();
   if (!fs.existsSync(dir)) {
     console.error('  No .neohive/ directory found. Run "npx neohive init" first.');
@@ -559,12 +852,16 @@ function cliMsg() {
     timestamp: new Date().toISOString(),
   };
 
-  const messagesFile = path.join(dir, 'messages.jsonl');
-  const historyFile = path.join(dir, 'history.jsonl');
-  fs.appendFileSync(messagesFile, JSON.stringify(msg) + '\n');
-  fs.appendFileSync(historyFile, JSON.stringify(msg) + '\n');
-
-  console.log('  Message sent to ' + recipient + ': ' + text);
+  try {
+    const messagesFile = path.join(dir, 'messages.jsonl');
+    const historyFile = path.join(dir, 'history.jsonl');
+    fs.appendFileSync(messagesFile, JSON.stringify(msg) + '\n');
+    fs.appendFileSync(historyFile, JSON.stringify(msg) + '\n');
+    console.log('  Message sent to ' + recipient + ': ' + text);
+  } catch (e) {
+    console.error('  Failed to send message: ' + e.message);
+    process.exit(1);
+  }
 }
 
 function cliStatus() {
@@ -847,6 +1144,44 @@ function uninstall() {
     }
   }
 
+  // 7. Remove from Cursor IDE project config (.cursor/mcp.json in cwd)
+  const cursorMcpPath = path.join(cwd, '.cursor', 'mcp.json');
+  if (fs.existsSync(cursorMcpPath)) {
+    try {
+      const mcpConfig = JSON.parse(fs.readFileSync(cursorMcpPath, 'utf8'));
+      if (mcpConfig.mcpServers && mcpConfig.mcpServers['neohive']) {
+        delete mcpConfig.mcpServers['neohive'];
+        fs.writeFileSync(cursorMcpPath, JSON.stringify(mcpConfig, null, 2) + '\n');
+        removed.push('Cursor IDE (project): ' + cursorMcpPath);
+      } else {
+        notFound.push('Cursor IDE (project): no neohive entry in .cursor/mcp.json');
+      }
+    } catch (e) {
+      console.log('  [warn] Could not parse ' + cursorMcpPath + ': ' + e.message);
+    }
+  } else {
+    notFound.push('Cursor IDE (project): .cursor/mcp.json not found');
+  }
+
+  // 8. Remove from Cursor IDE user config (~/.cursor/mcp.json)
+  const cursorGlobalPath = path.join(home, '.cursor', 'mcp.json');
+  if (fs.existsSync(cursorGlobalPath)) {
+    try {
+      const mcpConfig = JSON.parse(fs.readFileSync(cursorGlobalPath, 'utf8'));
+      if (mcpConfig.mcpServers && mcpConfig.mcpServers['neohive']) {
+        delete mcpConfig.mcpServers['neohive'];
+        fs.writeFileSync(cursorGlobalPath, JSON.stringify(mcpConfig, null, 2) + '\n');
+        removed.push('Cursor IDE (global): ' + cursorGlobalPath);
+      } else {
+        notFound.push('Cursor IDE (global): no neohive entry');
+      }
+    } catch (e) {
+      console.log('  [warn] Could not parse ' + cursorGlobalPath + ': ' + e.message);
+    }
+  } else {
+    notFound.push('Cursor IDE (global): ~/.cursor/mcp.json not found');
+  }
+
   // Print summary
   if (removed.length > 0) {
     console.log('  Removed neohive from:');
@@ -865,7 +1200,7 @@ function uninstall() {
     }
   }
 
-  // 7. Check for data directory
+  // 9. Check for data directory
   const dataPath = path.join(cwd, '.neohive');
   if (fs.existsSync(dataPath)) {
     console.log('');
@@ -887,6 +1222,13 @@ switch (command) {
   case 'templates':
     listTemplates();
     break;
+  case 'mcp':
+    // Start stdio MCP server — used as the command in all MCP configs: npx neohive mcp
+    require('./server.js');
+    break;
+  case 'serve':
+    serve();
+    break;
   case 'dashboard':
     dashboard();
     break;

package/conversation-templates/autonomous-feature.json

@@ -2,11 +2,61 @@
   "id": "autonomous-feature",
   "name": "Autonomous Feature Build",
   "description": "Full autonomous feature build: architecture, parallel backend+frontend, integration testing. Zero human intervention.",
+  "category": "development",
+  "conversation_mode": "direct",
   "agents": [
-    { "name": "Architect", "role": "Software Architect", "skills": ["design", "interfaces", "architecture"], "prompt": "You are a software architect. Design the feature architecture with clear interfaces. Call verify_and_advance() when done. Use get_work() to stay in the proactive loop." },
-    { "name": "Backend", "role": "Backend Developer", "skills": ["api", "database", "server", "backend"], "prompt": "You are a backend developer. Implement server-side logic, APIs, and data models. Write unit tests. Call verify_and_advance() when done. Never wait for approval." },
-    { "name": "Frontend", "role": "Frontend Developer", "skills": ["ui", "css", "components", "frontend"], "prompt": "You are a frontend developer. Implement UI components, pages, and client-side logic. Write component tests. Call verify_and_advance() when done. Never wait for approval." },
-    { "name": "Tester", "role": "QA Engineer", "skills": ["testing", "qa", "integration", "verification"], "prompt": "You are a QA engineer. Write and run integration tests. Verify all components work together. Call verify_and_advance() when done." }
+    {
+      "name": "Architect",
+      "role": "lead",
+      "display_name": "Software Architect",
+      "skills": ["design", "interfaces", "architecture", "planning"],
+      "responsibilities": [
+        "Design feature architecture with clear interfaces",
+        "Define contracts between backend and frontend",
+        "Create implementation plan"
+      ],
+      "tools_focus": ["create_workflow", "advance_workflow", "kb_write", "share_file"],
+      "prompt": "You are a software architect. Design the feature architecture with clear interfaces. Call verify_and_advance() when done. Use get_work() to stay in the proactive loop."
+    },
+    {
+      "name": "Backend",
+      "role": "backend",
+      "display_name": "Backend Developer",
+      "skills": ["api", "database", "server", "backend", "nodejs"],
+      "responsibilities": [
+        "Implement server-side logic, APIs, and data models",
+        "Write unit tests for backend code",
+        "Lock files before editing"
+      ],
+      "tools_focus": ["lock_file", "unlock_file", "update_task", "advance_workflow", "share_file"],
+      "prompt": "You are a backend developer. Implement server-side logic, APIs, and data models. Write unit tests. Use lock_file() before editing. Call verify_and_advance() when done. Never wait for approval."
+    },
+    {
+      "name": "Frontend",
+      "role": "frontend",
+      "display_name": "Frontend Developer",
+      "skills": ["ui", "css", "components", "frontend", "html"],
+      "responsibilities": [
+        "Implement UI components, pages, and client-side logic",
+        "Write component tests",
+        "Lock files before editing"
+      ],
+      "tools_focus": ["lock_file", "unlock_file", "update_task", "advance_workflow", "share_file"],
+      "prompt": "You are a frontend developer. Implement UI components, pages, and client-side logic. Write component tests. Use lock_file() before editing. Call verify_and_advance() when done. Never wait for approval."
+    },
+    {
+      "name": "Tester",
+      "role": "quality",
+      "display_name": "QA Engineer",
+      "skills": ["testing", "qa", "integration", "verification"],
+      "responsibilities": [
+        "Write and run integration tests",
+        "Verify all components work together",
+        "Submit review results via submit_review()"
+      ],
+      "tools_focus": ["request_review", "submit_review", "advance_workflow", "get_reputation"],
+      "prompt": "You are a QA engineer. Write and run integration tests. Verify all components work together. Call verify_and_advance() when done."
+    }
   ],
   "workflow": {
     "name": "Autonomous Feature",