ai-control-center 1.15.2

package/bin/aicc.js

@@ -0,0 +1,772 @@
+#!/usr/bin/env node
+/**
+ * ai-control-center CLI entry point.
+ *
+ * Usage:
+ *   aicc                  Launch terminal menu
+ *   aicc init             Interactive project setup
+ *   aicc start            Start all services (web, telegram, twitch, openclaw)
+ *   aicc web              Start web dashboard
+ *   aicc telegram         Start Telegram bot
+ *   aicc twitch           Start Twitch bot
+ *   aicc openclaw         Generate OpenClaw skill
+ *   aicc status           Pipeline status (JSON)
+ *   aicc feature "desc"   Create feature (JSON)
+ *   aicc deploy           Deploy (JSON)
+ *   aicc health           Health check (JSON)
+ *   aicc --version        Show version
+ *   aicc --help           Show help
+ */
+import { spawn, spawnSync } from 'child_process';
+import { existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(resolve(__dirname, '../package.json'), 'utf8'));
+
+const [,, command, ...args] = process.argv;
+
+// Commands that don't require a config file
+const NO_CONFIG_COMMANDS = new Set(['init', '--version', '-v', '--help', '-h']);
+
+// ─── PID file management ──────────────────────────────────────────────────────
+
+function getPidDir() {
+  const wfDir = resolve(process.cwd(), '.ai-workflow');
+  const pidDir = resolve(wfDir, '.pids');
+  mkdirSync(pidDir, { recursive: true });
+  return pidDir;
+}
+
+function writePid(service, pid) {
+  writeFileSync(resolve(getPidDir(), `${service}.pid`), String(pid));
+}
+
+function readPid(service) {
+  const f = resolve(getPidDir(), `${service}.pid`);
+  if (!existsSync(f)) return null;
+  const pid = parseInt(readFileSync(f, 'utf8').trim(), 10);
+  // Check if process is still alive
+  try { process.kill(pid, 0); return pid; } catch { unlinkSync(f); return null; }
+}
+
+function clearPid(service) {
+  const f = resolve(getPidDir(), `${service}.pid`);
+  try { unlinkSync(f); } catch { /* ok */ }
+}
+
+function killPid(service) {
+  const pid = readPid(service);
+  if (!pid) return false;
+  try { process.kill(pid, 'SIGTERM'); clearPid(service); return true; } catch { clearPid(service); return false; }
+}
+
+// ─── aicc start — launch all background services ─────────────────────────────
+
+async function startAllServices() {
+  const { getConfig, env } = await import('../lib/config.js');
+  const config = getConfig();
+  const aiccBin = resolve(__dirname, 'aicc.js');
+
+  console.log('');
+  console.log('  \x1b[36m\x1b[1mStarting services...\x1b[0m');
+  console.log('');
+
+  // 1. Generate pipeline skills (always — works with or without OpenClaw CLI)
+  try {
+    const oc = spawnSync(process.execPath, [aiccBin, 'openclaw'], {
+      cwd: process.cwd(), encoding: 'utf8', timeout: 15000,
+    });
+    if (oc.status === 0) {
+      console.log('  \x1b[32m✓\x1b[0m  Pipeline skills generated');
+    } else {
+      console.log('  \x1b[33m~\x1b[0m  Skill generation returned non-zero');
+    }
+  } catch {
+    console.log('  \x1b[33m~\x1b[0m  Skill generation skipped');
+  }
+
+  // 2. Web dashboard
+  const existingWeb = readPid('web');
+  if (existingWeb) {
+    console.log(`  \x1b[32m✓\x1b[0m  Web dashboard already running (PID ${existingWeb})`);
+  } else {
+    try {
+      const webLog = openSync('/tmp/aicc-web.log', 'a');
+      const webProc = spawn(process.execPath, [aiccBin, 'web'], {
+        cwd: process.cwd(), stdio: ['ignore', webLog, webLog], detached: true,
+      });
+      webProc.unref();
+      writePid('web', webProc.pid);
+      const port = config.web?.port || 3847;
+      console.log(`  \x1b[32m✓\x1b[0m  Web dashboard started (PID ${webProc.pid}) → \x1b[36m\x1b[1mhttp://localhost:${port}\x1b[0m`);
+    } catch {
+      console.log('  \x1b[33m~\x1b[0m  Web dashboard failed to start. Run \x1b[1maicc web\x1b[0m manually.');
+    }
+  }
+
+  // 3. Hub server (if configured)
+  if (config.hub?.projects?.length) {
+    const existingHub = readPid('hub');
+    if (existingHub) {
+      console.log(`  \x1b[32m✓\x1b[0m  Hub server already running (PID ${existingHub})`);
+    } else {
+      try {
+        const hubLog = openSync('/tmp/aicc-hub.log', 'a');
+        const hubProc = spawn(process.execPath, [aiccBin, 'hub'], {
+          cwd: process.cwd(), stdio: ['ignore', hubLog, hubLog], detached: true,
+        });
+        hubProc.unref();
+        writePid('hub', hubProc.pid);
+        const hubPort = config.hub?.port || 3850;
+        console.log(`  \x1b[32m✓\x1b[0m  Hub server started (PID ${hubProc.pid}) → \x1b[36m\x1b[1mhttp://localhost:${hubPort}/office/\x1b[0m`);
+      } catch {
+        console.log('  \x1b[33m~\x1b[0m  Hub server failed to start. Run \x1b[1maicc hub\x1b[0m manually.');
+      }
+    }
+  }
+
+  // 4. Telegram bot (if configured)
+  // Skip if OpenClaw bridge is active — OpenClaw handles Telegram via its own gateway
+  // to avoid 409 Conflict (two bots polling the same token).
+  const token = env('TELEGRAM_TOKEN');
+  const bridgeHandlesTelegram = config.roleplay?.openclawBridge !== false && (() => {
+    const homeDir = process.env.HOME || process.env.USERPROFILE;
+    return existsSync(resolve(homeDir, '.openclaw', 'openclaw.json'));
+  })();
+
+  if (bridgeHandlesTelegram) {
+    console.log('  \x1b[2m·  Telegram bot skipped — OpenClaw bridge handles Telegram\x1b[0m');
+  } else if (token) {
+    const existingTg = readPid('telegram');
+    if (existingTg) {
+      console.log(`  \x1b[32m✓\x1b[0m  Telegram bot already running (PID ${existingTg})`);
+    } else {
+      try {
+        const tgLog = openSync('/tmp/aicc-telegram.log', 'a');
+        const tgProc = spawn(process.execPath, [aiccBin, 'telegram'], {
+          cwd: process.cwd(), stdio: ['ignore', tgLog, tgLog], detached: true,
+        });
+        tgProc.unref();
+        writePid('telegram', tgProc.pid);
+        console.log(`  \x1b[32m✓\x1b[0m  Telegram bot started (PID ${tgProc.pid})`);
+      } catch {
+        console.log('  \x1b[33m~\x1b[0m  Telegram bot failed to start. Run \x1b[1maicc telegram\x1b[0m manually.');
+      }
+    }
+  } else {
+    console.log('  \x1b[2m·  Telegram bot not configured — skipping\x1b[0m');
+  }
+
+  // 5. Twitch bot (if configured)
+  const twitchChannel = env('TWITCH_CHANNEL');
+  const twitchToken   = env('TWITCH_ACCESS_TOKEN');
+  if (twitchChannel && twitchToken) {
+    const existingTw = readPid('twitch');
+    if (existingTw) {
+      console.log(`  \x1b[32m✓\x1b[0m  Twitch bot already running (PID ${existingTw})`);
+    } else {
+      try {
+        const twLog = openSync('/tmp/aicc-twitch.log', 'a');
+        const twProc = spawn(process.execPath, [aiccBin, 'twitch'], {
+          cwd: process.cwd(), stdio: ['ignore', twLog, twLog], detached: true,
+        });
+        twProc.unref();
+        writePid('twitch', twProc.pid);
+        console.log(`  \x1b[32m✓\x1b[0m  Twitch bot started (PID ${twProc.pid}) → \x1b[36m#${twitchChannel}\x1b[0m`);
+      } catch {
+        console.log('  \x1b[33m~\x1b[0m  Twitch bot failed to start. Run \x1b[1maicc twitch\x1b[0m manually.');
+      }
+    }
+  } else {
+    console.log('  \x1b[2m·  Twitch bot not configured — skipping\x1b[0m');
+  }
+
+  // 6. OpenClaw bridge (event bus → gateway WebSocket)
+  if (config.roleplay?.openclawBridge !== false) {
+    try {
+      const { isOpenClawAvailable, startBridge } = await import('../lib/openclaw/bridge.js');
+      if (isOpenClawAvailable()) {
+        const { bus } = await import('../lib/shared/event-bus.js');
+        bus.startWatching();
+        const started = await startBridge(bus);
+        if (started) {
+          console.log('  \x1b[32m✓\x1b[0m  OpenClaw bridge started (events → gateway)');
+        } else {
+          console.log('  \x1b[2m·  OpenClaw bridge not started\x1b[0m');
+        }
+      } else {
+        console.log('  \x1b[2m·  OpenClaw not configured — bridge skipped\x1b[0m');
+      }
+    } catch {
+      console.log('  \x1b[2m·  OpenClaw bridge — skipped\x1b[0m');
+    }
+  } else {
+    console.log('  \x1b[2m·  OpenClaw bridge disabled (roleplay.openclawBridge: false)\x1b[0m');
+  }
+
+  // 7. Autonomous pipeline loop (IT Department brain)
+  if (config.browserQA?.enabled || config.suggestion?.enabled) {
+    try {
+      const { startLoop } = await import('../lib/orchestrator/autonomous-loop.js');
+      const intervalMs = config.autonomousLoop?.intervalMs || 30_000;
+      startLoop(intervalMs);
+      console.log(`  \x1b[32m✓\x1b[0m  Autonomous loop started (tick every ${intervalMs / 1000}s)`);
+    } catch (loopErr) {
+      console.log(`  \x1b[33m~\x1b[0m  Autonomous loop failed: ${loopErr.message}`);
+    }
+  } else {
+    console.log('  \x1b[2m·  Autonomous loop skipped — enable browserQA or suggestion in config\x1b[0m');
+  }
+
+  // 8. Cron scheduler (recurring QA)
+  if (config.browserQA?.schedule && config.browserQA.schedule !== 'manual') {
+    try {
+      const { startQACron } = await import('../lib/utils/cron-scheduler.js');
+      startQACron();
+      console.log(`  \x1b[32m✓\x1b[0m  QA cron scheduled (${config.browserQA.schedule})`);
+    } catch (cronErr) {
+      console.log(`  \x1b[33m~\x1b[0m  QA cron failed: ${cronErr.message}`);
+    }
+  }
+
+  // 9. Watchdog supervisor — monitors all services and auto-respawns crashes
+  const existingWd = readPid('watchdog');
+  if (existingWd) {
+    console.log(`  \x1b[32m✓\x1b[0m  Watchdog already running (PID ${existingWd})`);
+  } else {
+    try {
+      const wdLog = openSync('/tmp/aicc-watchdog.log', 'a');
+      const wdProc = spawn(process.execPath, [aiccBin, 'watchdog'], {
+        cwd: process.cwd(), stdio: ['ignore', wdLog, wdLog], detached: true,
+      });
+      wdProc.unref();
+      writePid('watchdog', wdProc.pid);
+      console.log(`  \x1b[32m✓\x1b[0m  Watchdog started (PID ${wdProc.pid}) — auto-restarts crashed services`);
+    } catch {
+      console.log('  \x1b[33m~\x1b[0m  Watchdog failed to start.');
+    }
+  }
+
+  console.log('');
+}
+
+// ─── aicc stop — kill all background services ────────────────────────────────
+
+async function stopAllServices() {
+  console.log('');
+  console.log('  \x1b[36m\x1b[1mStopping services...\x1b[0m');
+  console.log('');
+
+  // Kill watchdog FIRST — otherwise it will respawn services we're stopping
+  const wdKilled = killPid('watchdog');
+  console.log(wdKilled
+    ? '  \x1b[32m✓\x1b[0m  Watchdog stopped'
+    : '  \x1b[2m·  Watchdog was not running\x1b[0m');
+
+  // Stop OpenClaw bridge
+  try {
+    const { stopBridge } = await import('../lib/openclaw/bridge.js');
+    stopBridge();
+    console.log('  \x1b[32m✓\x1b[0m  OpenClaw bridge stopped');
+  } catch {
+    // bridge module not loaded, ok
+  }
+
+  const webKilled = killPid('web');
+  console.log(webKilled
+    ? '  \x1b[32m✓\x1b[0m  Web dashboard stopped'
+    : '  \x1b[2m·  Web dashboard was not running\x1b[0m');
+
+  const hubKilled = killPid('hub');
+  console.log(hubKilled
+    ? '  \x1b[32m✓\x1b[0m  Hub server stopped'
+    : '  \x1b[2m·  Hub server was not running\x1b[0m');
+
+  const tgKilled = killPid('telegram');
+  console.log(tgKilled
+    ? '  \x1b[32m✓\x1b[0m  Telegram bot stopped'
+    : '  \x1b[2m·  Telegram bot was not running\x1b[0m');
+
+  const twKilled = killPid('twitch');
+  console.log(twKilled
+    ? '  \x1b[32m✓\x1b[0m  Twitch bot stopped'
+    : '  \x1b[2m·  Twitch bot was not running\x1b[0m');
+
+  console.log('');
+}
+
+// ─── Main ─────────────────────────────────────────────────────────────────────
+
+async function main() {
+  // Handle version / help first
+  if (command === '--version' || command === '-v') {
+    console.log(`ai-control-center v${pkg.version}`);
+    return;
+  }
+
+  if (command === '--help' || command === '-h') {
+    console.log(`
+  ai-control-center v${pkg.version}
+  Multi-AI orchestration control center
+
+  Usage:
+    aicc                     Launch interactive terminal menu
+    aicc init                Set up a new project (creates aicc.config.js)
+    aicc doctor              Check + auto-repair missing skills/files (safe to re-run)
+    aicc start               Start all services (web, telegram, twitch, openclaw)
+    aicc stop                Stop all background services
+    aicc web                 Start the web dashboard
+    aicc telegram            Start the Telegram bot (fails if already running)
+    aicc telegram --force    Kill any existing instance and restart
+    aicc telegram --cleanup  Stop the running instance and exit
+    aicc twitch              Start the Twitch bot
+    aicc openclaw            Generate OpenClaw skill from config
+    aicc skill list          List installed skills
+    aicc skill search <q>    Search skill registry
+    aicc skill install <n>   Install a skill
+    aicc persona list        List available personas
+    aicc achievements        Show unlocked achievements
+    aicc hub [port]          Start the Hub server
+    aicc status              Show pipeline status (JSON)
+    aicc progress            Show pipeline progress + docs (no AI)
+    aicc health              Show health check (JSON)
+    aicc feature "desc"      Create a new feature
+    aicc events              Stream pipeline events as NDJSON
+    aicc deploy              Deploy to target
+    aicc approve             Approve current feature
+    aicc reject "reason"     Reject with feedback
+    aicc review              Get latest review
+    aicc logs                Show recent logs
+    aicc cleanup             Archive workflow files
+    aicc reset               Abandon current feature
+
+  AI IT Department:
+    aicc assign <url> "goal" Assign project to autonomous AI IT dept
+    aicc qa                  Run Browser QA on target website
+    aicc suggest             Generate AI feature suggestions
+    aicc threads             List open discussion threads
+
+    aicc --version           Show version
+    aicc --help              Show this help
+
+  Config:
+    Place aicc.config.js in your project root.
+    Run "aicc init" to create one interactively.
+`);
+    return;
+  }
+
+  // Init and doctor don't need config
+  if (command === 'init') {
+    const { runInit } = await import('../lib/init/wizard.js');
+    await runInit();
+    return;
+  }
+
+  if (command === 'doctor') {
+    const { runDoctor } = await import('../lib/init/doctor.js');
+    await runDoctor();
+    return;
+  }
+
+  // All other commands require config
+  const { loadConfig } = await import('../lib/config.js');
+  try {
+    await loadConfig();
+  } catch (err) {
+    console.error(`\n  ${err.message}\n`);
+    process.exit(1);
+  }
+
+  switch (command) {
+    case 'start': {
+      await startAllServices();
+      break;
+    }
+
+    case 'stop': {
+      await stopAllServices();
+      break;
+    }
+
+    case 'web': {
+      const { startServer } = await import('../lib/web/server.js');
+      startServer();
+      break;
+    }
+
+    case 'telegram': {
+      const forceFlag = args.includes('--force') || args.includes('-f');
+      const cleanupFlag = args.includes('--cleanup');
+
+      // --cleanup: kill existing instance and exit
+      if (cleanupFlag) {
+        const killed = killPid('telegram');
+        console.log(killed ? '  ✓  Telegram bot stopped.' : '  ·  Telegram bot was not running.');
+        process.exit(0);
+      }
+
+      // Guard: check if already running
+      const existingPid = readPid('telegram');
+      if (existingPid) {
+        if (!forceFlag) {
+          console.error(`\n  ❌  Telegram bot is already running (PID ${existingPid}).`);
+          console.error('     Use --force to kill it and restart, or --cleanup to stop it.\n');
+          process.exit(1);
+        }
+        // --force: kill old instance first
+        console.log(`  ⚠️  Killing existing Telegram bot (PID ${existingPid})...`);
+        try { process.kill(existingPid, 'SIGTERM'); } catch { /* already dead */ }
+        clearPid('telegram');
+        // Wait for Telegram's server to release the long-poll connection (35s timeout + buffer)
+        console.log('     Waiting 40s for Telegram long-poll release...');
+        await new Promise(r => setTimeout(r, 40000));
+      }
+
+      // Write PID file so future invocations can detect us
+      writePid('telegram', process.pid);
+
+      // Clean up PID on any exit
+      const _tgCleanup = () => clearPid('telegram');
+      process.on('exit', _tgCleanup);
+      process.on('SIGINT', () => { _tgCleanup(); process.exit(0); });
+      process.on('SIGTERM', () => { _tgCleanup(); process.exit(0); });
+      process.on('SIGHUP', () => {}); // Survive terminal disconnect
+
+      const { startBot } = await import('../lib/telegram/bot.js');
+      startBot();
+      break;
+    }
+
+    case 'twitch': {
+      const { startBot: startTwitchBot } = await import('../lib/twitch/bot.js');
+      startTwitchBot();
+      break;
+    }
+
+    case 'hub': {
+      const { startHub } = await import('../lib/hub/hub-server.js');
+      await startHub();
+      break;
+    }
+
+    case 'watchdog': {
+      // ─── Process Watchdog ─────────────────────────────────────────────────
+      // Monitors all spawned services and auto-respawns any that die.
+      // Spawned by `aicc start` as a background supervisor; killed by `aicc stop`.
+      process.on('SIGHUP', () => {}); // Survive terminal disconnect
+
+      writePid('watchdog', process.pid);
+      process.on('exit', () => clearPid('watchdog'));
+      process.on('SIGINT', () => { clearPid('watchdog'); process.exit(0); });
+      process.on('SIGTERM', () => { clearPid('watchdog'); process.exit(0); });
+
+      const { getConfig: getWdConfig, env: wdEnv } = await import('../lib/config.js');
+      const wdConfig = getWdConfig();
+      const wdBin = resolve(__dirname, 'aicc.js');
+
+      // Determine which services should be monitored
+      const monitored = new Set(['web']); // web always runs
+      if (wdEnv('TELEGRAM_TOKEN'))                                    monitored.add('telegram');
+      if (wdConfig.hub?.projects?.length)                             monitored.add('hub');
+      if (wdEnv('TWITCH_CHANNEL') && wdEnv('TWITCH_ACCESS_TOKEN'))    monitored.add('twitch');
+
+      // Track respawn attempts per service — reset after 10 min of stability
+      const respawnCount = {};      // { service: count }
+      const lastRespawn  = {};      // { service: timestamp }
+      const MAX_RESPAWNS = 5;       // per service before giving up
+      const STABILITY_MS = 600_000; // 10 min — reset counter after this
+
+      const CHECK_INTERVAL = 30_000; // check every 30s
+      console.log(`  [Watchdog] PID ${process.pid} — monitoring: ${[...monitored].join(', ')}`);
+
+      setInterval(() => {
+        for (const service of monitored) {
+          const pid = readPid(service);
+          if (pid) {
+            // Verify the process is actually alive — PID file alone is not enough
+            try {
+              process.kill(pid, 0); // throws if process is dead
+              // Process alive — reset respawn counter after stability window
+              if (respawnCount[service] && Date.now() - (lastRespawn[service] || 0) > STABILITY_MS) {
+                respawnCount[service] = 0;
+              }
+              continue;
+            } catch {
+              // Stale PID file — process died without cleaning up
+              console.log(`  [Watchdog] ${service} has stale PID ${pid} — clearing and respawning…`);
+              clearPid(service);
+            }
+          }
+
+          // Service is dead — check respawn budget
+          respawnCount[service] = (respawnCount[service] || 0) + 1;
+          if (respawnCount[service] > MAX_RESPAWNS) {
+            console.error(`  [Watchdog] ${service} crashed ${MAX_RESPAWNS} times in <10 min — halting respawns.`);
+            continue;
+          }
+
+          console.log(`  [Watchdog] ${service} is DEAD — respawning (attempt ${respawnCount[service]}/${MAX_RESPAWNS})…`);
+          lastRespawn[service] = Date.now();
+
+          // Telegram needs extra delay — Telegram API holds the long-poll for ~35s after
+          // the old process dies, and a new instance gets 409 Conflict if it starts too soon.
+          const respawnDelay = service === 'telegram' ? 40000 : 0;
+          if (respawnDelay) {
+            console.log(`  [Watchdog] ${service}: waiting ${respawnDelay / 1000}s for Telegram long-poll release...`);
+          }
+
+          setTimeout(() => {
+            try {
+              const logFd = openSync(`/tmp/aicc-${service}.log`, 'a');
+              // Use --force so stale PID files don't block the new instance from starting
+              const proc = spawn(process.execPath, [wdBin, service, '--force'], {
+                cwd: process.cwd(), stdio: ['ignore', logFd, logFd], detached: true,
+              });
+              proc.unref();
+              console.log(`  [Watchdog] ${service} respawned → PID ${proc.pid}`);
+            } catch (err) {
+              console.error(`  [Watchdog] Failed to respawn ${service}: ${err.message}`);
+            }
+          }, respawnDelay);
+        }
+      }, CHECK_INTERVAL);
+
+      break;
+    }
+
+    case 'openclaw': {
+      const { generateSkill } = await import('../lib/openclaw/generate-skill.js');
+      await generateSkill();
+      break;
+    }
+
+    case 'progress': {
+      // Show pipeline progress — reads status.json + logs, NO AI calls
+      const { existsSync, readFileSync, readdirSync } = await import('fs');
+      const { resolve, dirname } = await import('path');
+      const { fileURLToPath } = await import('url');
+
+      // Find project root
+      let root = process.cwd();
+      while (!existsSync(resolve(root, 'aicc.config.js'))) {
+        const parent = dirname(root);
+        if (parent === root) break;
+        root = parent;
+      }
+      const wfDir     = resolve(root, '.ai-workflow');
+      const statusFile = resolve(wfDir, 'status.json');
+
+      if (!existsSync(statusFile)) {
+        console.log('\n  No pipeline active. Run: aicc feature "description"\n');
+        break;
+      }
+
+      const s = JSON.parse(readFileSync(statusFile, 'utf8'));
+      const STAGES = ['idle','inbox','spec_complete','arch_complete','implementation_complete','review_complete','approved','deployed'];
+      const ICONS  = { idle:'💤', inbox:'📥', spec_complete:'📝', arch_complete:'🏗', implementation_complete:'⚡', implementation_failed:'❌', review_complete:'🔍', approved:'✅', rejected:'❌', deployed:'🚀' };
+      const LABELS = { idle:'Idle', inbox:'Inbox', spec_complete:'Spec (Gemini)', arch_complete:'Architecture (Claude)', implementation_complete:'Implementation (Copilot)', implementation_failed:'Implementation FAILED', review_complete:'Review (Gemini)', approved:'Approved', rejected:'Rejected', deployed:'Deployed' };
+
+      const currentIdx = STAGES.indexOf(s.stage);
+
+      console.log('\n  ── Pipeline Progress ─────────────────────────────────────');
+      console.log(`  Feature: ${s.current_feature || 'none'}`);
+      console.log(`  Mode:    ${s.pipeline_mode || 'manual'}`);
+      console.log(`  Updated: ${s.updated_at ? new Date(s.updated_at).toLocaleString() : '-'}`);
+      console.log('');
+
+      STAGES.forEach((stage, i) => {
+        const icon  = ICONS[stage] || '○';
+        const label = LABELS[stage] || stage;
+        const isCurrent = s.stage === stage;
+        const isDone    = i < currentIdx;
+        const marker    = isCurrent ? '▶' : (isDone ? '✓' : '○');
+        const dim       = isDone ? '' : (isCurrent ? '\x1b[1m' : '\x1b[2m');
+        console.log(`  ${dim}${marker} ${icon} ${label}\x1b[0m`);
+      });
+      if (s.stage === 'implementation_failed') {
+        console.log(`  \x1b[31m▶ ❌ Implementation FAILED: ${(s.error || '').slice(0, 80)}\x1b[0m`);
+      }
+      console.log('');
+
+      // Show available docs
+      const SUBDIRS = [['specs','📝 Spec'],['architecture','🏗 Arch'],['tasks','📋 Tasks'],['reviews','🔍 Review']];
+      const available = [];
+      for (const [dir, label] of SUBDIRS) {
+        const d = resolve(wfDir, dir);
+        if (existsSync(d)) {
+          const files = readdirSync(d).filter(f => f.endsWith('.md')).sort().reverse();
+          if (files.length) available.push(`${label}: ${files[0]}`);
+        }
+      }
+      if (available.length) {
+        console.log('  ── Documents ─────────────────────────────────────────────');
+        available.forEach(a => console.log(`  ${a}`));
+        console.log('');
+        console.log('  To read: cat .ai-workflow/<subdir>/<file>');
+        console.log('  In Telegram: /docs  or  /status');
+      }
+
+      // Show last 10 log lines
+      const logsDir = resolve(wfDir, 'logs');
+      if (existsSync(logsDir)) {
+        const logFiles = readdirSync(logsDir).filter(f => f.startsWith('session-')).sort().reverse();
+        if (logFiles.length) {
+          const lines = readFileSync(resolve(logsDir, logFiles[0]), 'utf8')
+            .split('\n').filter(l => l.trim()).slice(-10);
+          if (lines.length) {
+            console.log('\n  ── Recent Activity ───────────────────────────────────────');
+            lines.forEach(l => console.log(`  ${l}`));
+          }
+        }
+      }
+      console.log('');
+      break;
+    }
+
+    case undefined:
+    case 'menu': {
+      // Launch interactive terminal menu
+      await import('../lib/index.js');
+      break;
+    }
+
+    case 'skill': {
+      const subCmd = args[0] || 'list';
+      if (subCmd === 'list') {
+        const { listSkills } = await import('../lib/utils/skill-loader.js');
+        const skills = listSkills();
+        if (skills.length === 0) {
+          console.log('No skills installed. Use "aicc skill install <name>" to add skills.');
+        } else {
+          console.log(`📚 Installed Skills (${skills.length}):\n`);
+          skills.forEach(s => console.log(`  ${s.emoji || '📄'} ${s.name} - ${s.description || ''} [${s.stages?.join(', ') || 'all'}]`));
+        }
+      } else if (subCmd === 'search') {
+        const { searchSkills } = await import('../lib/hub/skill-registry.js');
+        const query = args.slice(1).join(' ') || '';
+        const results = searchSkills(query);
+        console.log(`🔍 Found ${results.length} skills:\n`);
+        results.forEach(s => console.log(`  ${s.emoji || '📄'} ${s.name} - ${s.description}`));
+      } else if (subCmd === 'install') {
+        const { installSkill } = await import('../lib/utils/skill-loader.js');
+        const name = args[1];
+        if (!name) { console.log('Usage: aicc skill install <name>'); break; }
+        installSkill(name);
+        console.log(`✅ Skill "${name}" installed.`);
+      }
+      break;
+    }
+
+    case 'persona': {
+      const subCmd = args[0] || 'list';
+      if (subCmd === 'list') {
+        const { listPersonas } = await import('../lib/utils/persona-loader.js');
+        const personas = listPersonas();
+        console.log('🎭 Available Personas:\n');
+        personas.forEach(p => console.log(`  ${p.emoji || '👤'} ${p.role} - ${p.name || p.role}`));
+      }
+      break;
+    }
+
+    case 'achievements': {
+      const { getUnlockedAchievements, ACHIEVEMENTS, formatAchievementList } = await import('../lib/utils/achievements.js');
+      const unlocked = getUnlockedAchievements();
+      console.log(formatAchievementList(unlocked));
+      break;
+    }
+
+    case 'leaderboard': {
+      const { getLeaderboard, formatLeaderboard } = await import('../lib/utils/agent-leaderboard.js');
+      const entries = getLeaderboard();
+      console.log(formatLeaderboard(entries));
+      break;
+    }
+
+    case 'index': {
+      const { indexCodebase, formatIndexSummary } = await import('../lib/utils/codebase-indexer.js');
+      console.log('📊 Indexing codebase...');
+      const index = await indexCodebase();
+      console.log(formatIndexSummary(index));
+      console.log('\n✅ Index saved to .ai-workflow/codebase-index.json');
+      break;
+    }
+
+    case 'search': {
+      const query = args.join(' ');
+      if (!query) { console.log('Usage: aicc search <query>'); break; }
+      const { searchIndex, loadIndex } = await import('../lib/utils/codebase-indexer.js');
+      const index = loadIndex();
+      const { results, total } = searchIndex(query, index);
+      console.log(`🔍 Found ${total} results for "${query}":\n`);
+      results.slice(0, 20).forEach(r => {
+        if (r.type === 'file') console.log(`  📄 ${r.path}`);
+        else if (r.type === 'module') console.log(`  📦 ${r.name}/ (${r.files?.join(', ')})`);
+        else if (r.type === 'api') console.log(`  🌐 ${r.method} ${r.path} → ${r.file}`);
+        else if (r.type === 'dependency') console.log(`  📚 ${r.name}`);
+      });
+      break;
+    }
+
+    case 'migrate': {
+      const { StorageAdapter } = await import('../lib/utils/db-adapter.js');
+      console.log('📦 Migrating data to SQLite...');
+      const adapter = new StorageAdapter('sqlite');
+      const result = await adapter.migrate();
+      console.log(`✅ Migration complete: ${result.costs} cost entries, ${result.audit} audit entries`);
+      adapter.close();
+      break;
+    }
+
+    case 'mcp': {
+      const subCmd = args[0] || 'list';
+      if (subCmd === 'list') {
+        const { listMCPServers, getRunningServers } = await import('../lib/utils/mcp-client.js');
+        const servers = await listMCPServers();
+        const running = getRunningServers();
+        console.log('🔌 MCP Servers:\n');
+        if (servers.length === 0) {
+          console.log('  No MCP servers configured. Add to aicc.config.js:');
+          console.log('  mcp: { servers: [{ name: "myserver", command: "npx", args: ["-y", "@modelcontextprotocol/server-filesystem"] }] }');
+        } else {
+          servers.forEach(s => {
+            const isRunning = running.find(r => r.name === s.name);
+            console.log(`  ${isRunning ? '🟢' : '⚪'} ${s.name} — ${s.description || s.url || s.command || 'no description'}`);
+            if (isRunning) console.log(`    Tools: ${isRunning.tools}, PID: ${isRunning.pid}`);
+          });
+        }
+      } else if (subCmd === 'start') {
+        const serverName = args[1];
+        if (!serverName) { console.log('Usage: aicc mcp start <server-name>'); break; }
+        const { listMCPServers, startServer } = await import('../lib/utils/mcp-client.js');
+        const servers = await listMCPServers();
+        const serverConfig = servers.find(s => s.name === serverName);
+        if (!serverConfig) { console.log(`Server "${serverName}" not found in config.`); break; }
+        console.log(`Starting MCP server "${serverName}"...`);
+        await startServer(serverConfig);
+        console.log(`✅ Server "${serverName}" started.`);
+      } else if (subCmd === 'stop') {
+        const serverName = args[1];
+        const { stopServer, stopAllServers } = await import('../lib/utils/mcp-client.js');
+        if (serverName) { stopServer(serverName); console.log(`Stopped "${serverName}".`); }
+        else { stopAllServers(); console.log('All MCP servers stopped.'); }
+      }
+      break;
+    }
+
+    default: {
+      // JSON CLI mode — delegate to cli.js for all other commands
+      // Re-inject command into argv so cli.js can parse it
+      process.argv = [process.argv[0], process.argv[1], command, ...args];
+      await import('../lib/cli.js');
+      break;
+    }
+  }
+}
+
+main().catch(err => {
+  console.error(err.message);
+  process.exit(1);
+});