fivocell 4.3.0 → 4.3.2

package/dist/walls/07-runtime/cli/cli.js

@@ -0,0 +1,3183 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+const figlet_1 = __importDefault(require("figlet"));
+const gradient_string_1 = __importDefault(require("gradient-string"));
+const database_1 = require("../../06-memory/database/database");
+const layers_1 = require("../../05-community/stats/layers");
+const cli_repl_1 = require("./cli-repl");
+(0, database_1.initializeDatabase)();
+const C = {
+    primary: chalk_1.default.hex('#FF6B35'),
+    success: chalk_1.default.green,
+    warn: chalk_1.default.yellow,
+    dim: chalk_1.default.dim,
+    bold: chalk_1.default.bold,
+    num: (s) => chalk_1.default.hex('#FF6B35').bold(s),
+};
+const project = path.basename(process.cwd());
+// ─── Parse ──────────────────────────────────────────────────────────────────
+// Parse args, treating double-quoted values as single tokens (so paths with spaces survive).
+function parseArgs(argv) {
+    const out = [];
+    let buf = '';
+    let inQuote = false;
+    for (const a of argv) {
+        if (inQuote) {
+            buf += ' ' + a;
+            if (a.endsWith('"')) {
+                out.push(buf.slice(0, -1));
+                buf = '';
+                inQuote = false;
+            }
+        }
+        else if (a.startsWith('"') && !a.endsWith('"')) {
+            buf = a.slice(1);
+            inQuote = true;
+        }
+        else if (a.startsWith('"') && a.endsWith('"') && a.length > 1) {
+            out.push(a.slice(1, -1));
+        }
+        else {
+            out.push(a);
+        }
+    }
+    if (buf)
+        out.push(buf);
+    return out;
+}
+const args = parseArgs(process.argv.slice(2));
+const cmd = args[0] || '';
+// Module-level state for watch-editor (must be declared before switch)
+let activeMonitor = null;
+let monitorStateFile = null;
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+switch (cmd) {
+    case '--version':
+    case '-v':
+    case 'version':
+        doVersion();
+        break;
+    case 'start':
+        doStart();
+        break;
+    case 'stop':
+        doStop();
+        break;
+    case 'setup':
+        doSetup().catch((e) => {
+            const msg = e instanceof Error ? e.message : String(e);
+            console.log(C.warn('  Setup crashed: ' + msg));
+            process.exit(1);
+        });
+        break;
+    case 'scan':
+        doScan();
+        break;
+    case 'analyze':
+        doAnalyze();
+        break;
+    case 'status':
+        doStatus();
+        break;
+    case 'session':
+        doSession();
+        break;
+    case 'decisions':
+        doDecisions();
+        break;
+    case 'team':
+        doTeam();
+        break;
+    case 'community':
+        doCommunity();
+        break;
+    case 'watch':
+        doWatch();
+        break;
+    case 'blindspots':
+        doBlindspots();
+        break;
+    case 'doctor':
+        doDoctor().catch((e) => {
+            const msg = e instanceof Error ? e.message : String(e);
+            console.log(C.warn('  Doctor failed: ' + msg));
+            process.exit(1);
+        });
+        break;
+    case 'context':
+        doContext();
+        break;
+    case 'mcp-config':
+        doMcpConfig();
+        break;
+    case 'replay':
+        doReplay();
+        break;
+    case 'continue':
+        doContinue();
+        break;
+    case 'bridge':
+        doBridge();
+        break;
+    case 'watch-editor':
+        doWatchEditor();
+        break;
+    case 'switch-back':
+        doSwitchBack();
+        break;
+    case 'branches':
+        doBranches();
+        break;
+    case 'lessons':
+        doLessons();
+        break;
+    case 'evolution':
+        doEvolution();
+        break;
+    case 'focus':
+        doFocus();
+        break;
+    case 'why':
+        doWhy();
+        break;
+    case 'repl':
+    case '-i':
+    case '--interactive':
+        doRepl();
+        break;
+    case 'help':
+    case '--help':
+    case '-h':
+        doHelp();
+        break;
+    default:
+        // If no command and TTY → open interactive REPL; else show status (safe default for scripts/automation)
+        if (!cmd && process.stdin.isTTY) {
+            doRepl();
+        }
+        else {
+            doStatus();
+        }
+        break;
+}
+// ─── cell start ─────────────────────────────────────────────────────────────
+function doStart() {
+    const banner = figlet_1.default.textSync('CELL', { font: 'ANSI Shadow', horizontalLayout: 'fitted' });
+    console.log((0, gradient_string_1.default)(['#FF6B35', '#FFAB91'])(banner));
+    console.log(C.dim('  Starting everything...\n'));
+    // 0. First-run greeting
+    try {
+        const { firstRunGreeting } = require('../setup/first-run');
+        firstRunGreeting();
+    }
+    catch { }
+    // 1. Check if daemon is already running (cheap /health probe) — if so,
+    //    skip restart and just print status. This makes `cell start` re-run safe.
+    const http = require('http');
+    const probeReq = http.request({
+        hostname: '127.0.0.1', port: 9876, path: '/health', method: 'GET', timeout: 1000,
+    }, (res) => {
+        if (res.statusCode === 200) {
+            let data = '';
+            res.on('data', (chunk) => { data += chunk ? chunk.toString() : ''; });
+            res.on('end', () => {
+                let up = 0;
+                try {
+                    up = JSON.parse(data).uptimeSeconds || 0;
+                }
+                catch { }
+                const upH = Math.floor(up / 3600);
+                const upM = Math.floor((up % 3600) / 60);
+                const upStr = upH > 0 ? `${upH}h ${upM}m` : upM > 0 ? `${upM}m` : `${up}s`;
+                console.log(C.success(`  Daemon: already running on port 9876 (uptime ${upStr})`));
+                printProjectStatusAndExit();
+            });
+        }
+        else {
+            startDaemon();
+        }
+    });
+    probeReq.on('error', () => { startDaemon(); });
+    probeReq.on('timeout', () => { probeReq.destroy(); startDaemon(); });
+    probeReq.end();
+}
+function startDaemon() {
+    // 1. Kill any stale daemon (clean restart)
+    try {
+        const { stopDaemon } = require('../daemon/lifecycle');
+        stopDaemon();
+        // Wait for port to be released
+        const { execSync } = require('child_process');
+        execSync('timeout /t 1 /nobreak >nul 2>&1', { stdio: 'ignore' });
+    }
+    catch { }
+    try {
+        const fsMod = require('fs');
+        const osMod = require('os');
+        const pidFile = require('path').join(osMod.homedir(), '.fivo', 'cell', 'daemon.pid');
+        try {
+            fsMod.unlinkSync(pidFile);
+        }
+        catch { }
+    }
+    catch { }
+    // 2. Start daemon as detached background process
+    console.log(C.primary('  Starting daemon + MCP...'));
+    try {
+        const { spawn } = require('child_process');
+        const pathMod = require('path');
+        const fsMod = require('fs');
+        const osMod = require('os');
+        const serverPath = pathMod.join(__dirname, '..', 'daemon', 'server.js');
+        const logFile = pathMod.join(osMod.homedir(), '.fivo', 'cell', 'daemon.log');
+        fsMod.mkdirSync(pathMod.dirname(logFile), { recursive: true });
+        const out = fsMod.openSync(logFile, 'a');
+        const err = fsMod.openSync(logFile, 'a');
+        const child = spawn('node', [serverPath], {
+            detached: true,
+            stdio: ['ignore', out, err],
+        });
+        child.unref();
+        // Write PID
+        const pidFile = pathMod.join(osMod.homedir(), '.fivo', 'cell', 'daemon.pid');
+        fsMod.mkdirSync(pathMod.dirname(pidFile), { recursive: true });
+        fsMod.writeFileSync(pidFile, String(child.pid), 'utf-8');
+        console.log(C.success(`  Daemon + MCP started (PID: ${child.pid})`));
+        console.log(C.dim('  Daemon + MCP: http://localhost:9876'));
+        console.log(C.dim('  MCP endpoint: POST http://localhost:9876/mcp'));
+        console.log();
+        // Give the daemon a moment to bind to the port, then print project status.
+        setTimeout(() => { printProjectStatusAndExit(); }, 500);
+    }
+    catch (e) {
+        console.log(C.warn('  Start failed: ' + String(e)));
+        process.exit(1);
+    }
+}
+function printProjectStatusAndExit() {
+    try {
+        const { detectProject, checkScanState, checkWatchState, checkMcpState, isDaemonRunning } = require('../setup/setup');
+        const httpMod = require('http');
+        const project = detectProject(process.cwd());
+        const scan = checkScanState(process.cwd());
+        const watch = checkWatchState(project.name);
+        const mcp = checkMcpState(os.homedir());
+        console.log();
+        console.log(C.bold('  Project:'), C.num(project.name), C.dim(`(${project.source})`));
+        console.log();
+        console.log(`    ${scan.done ? C.success('OK') : C.dim('--')}  scan:   ${scan.reason}`);
+        console.log(`    ${watch.done ? C.success('OK') : C.dim('--')}  watch:  ${watch.reason}`);
+        console.log(`    ${mcp.done === mcp.total ? C.success('OK') : C.dim('--')}  mcp:    ${mcp.done}/${mcp.total} IDEs wired${mcp.needsWrite.length > 0 ? C.warn(' (need: ' + mcp.needsWrite.join(', ') + ')') : ''}`);
+        console.log();
+        const allReady = scan.done && watch.done && mcp.done === mcp.total;
+        if (allReady) {
+            console.log(C.dim('  Cell is fully ready. Use @cell in your AI chat.'));
+        }
+        else {
+            console.log(C.primary('  Run: cell setup  (one-time, idempotent) to finish setup'));
+        }
+        console.log();
+        process.exit(0);
+    }
+    catch {
+        console.log(C.dim('  Next: cell scan  (scan codebase + build layers)'));
+        console.log(C.dim('  Then: cell status'));
+        console.log();
+        process.exit(0);
+    }
+}
+// ─── cell stop ──────────────────────────────────────────────────────────────
+function doStop() {
+    console.log(C.dim('  Stopping Cell daemon...'));
+    try {
+        const { stopDaemon } = require('../daemon/lifecycle');
+        const result = stopDaemon();
+        console.log(result.success ? C.success(`  ${result.message}`) : C.warn(`  ${result.message}`));
+    }
+    catch (e) {
+        console.log(C.warn('  Stop failed: ' + String(e)));
+    }
+    console.log();
+}
+// ─── cell analyze ───────────────────────────────────────────────────────────
+function doAnalyze() {
+    console.log();
+    console.log(C.bold('  Cell AI Analysis'));
+    console.log(C.dim('  ────────────────'));
+    console.log();
+    const sub = args[1] || '';
+    // ─── Save AI-generated insights ────────────────────────────────────
+    if (sub === '--save' && args[2]) {
+        const category = args[2];
+        console.log(C.primary(`  Save AI insights for: ${category}`));
+        console.log(C.dim('  Paste the AI-generated response below (Ctrl+Z or Ctrl+D to finish):'));
+        console.log();
+        // Read from stdin
+        const chunks = [];
+        process.stdin.on('data', (chunk) => chunks.push(chunk));
+        process.stdin.on('end', () => {
+            const content = Buffer.concat(chunks).toString().trim();
+            if (content) {
+                const { saveAIInsight } = require('../../03-knowledge/decisions/ai-bridge');
+                saveAIInsight(project, category, content);
+                console.log(C.success(`  Insights saved: ${category}`));
+                console.log(C.dim(`  .cell/personal/insights/${category}.md`));
+                console.log();
+                process.exit(0);
+            }
+            else {
+                console.log(C.warn('  No content provided.'));
+                console.log();
+                process.exit(1);
+            }
+        });
+        process.stdin.resume();
+        return;
+    }
+    // ─── Show insights ─────────────────────────────────────────────────
+    if (sub === '--show') {
+        const { getAIInsights } = require('../../03-knowledge/decisions/ai-bridge');
+        const insights = getAIInsights(project);
+        if (insights.length === 0) {
+            console.log(C.dim('  No AI insights yet. Run: cell analyze'));
+            console.log();
+            return;
+        }
+        for (const i of insights) {
+            console.log(C.bold(`  ${i.category}`));
+            console.log(C.dim(`  ${i.timestamp} | Source: ${i.source}`));
+            console.log(i.content.substring(0, 300));
+            console.log(C.dim('  ...'));
+            console.log();
+        }
+        return;
+    }
+    // ─── Default: Generate prompts ─────────────────────────────────────
+    const { getAnalysisCommand } = require('../../03-knowledge/decisions/ai-bridge');
+    const { intro, prompts } = getAnalysisCommand(process.cwd());
+    console.log(C.dim(intro));
+    console.log();
+    for (const p of prompts) {
+        console.log(C.bold(`  ━━━ ${p.title} ━━━`));
+        console.log(C.dim(`  Tokens: ~${p.tokensEstimate} | Category: ${p.category}`));
+        console.log();
+        const promptLines = p.prompt.split('\n');
+        for (const line of promptLines.slice(0, 10)) {
+            console.log(`  ${C.dim('│')} ${line}`);
+        }
+        if (promptLines.length > 10) {
+            console.log(`  ${C.dim('│')} ... (${promptLines.length - 10} more lines)`);
+        }
+        console.log();
+        console.log(C.primary(`  → Copy to AI tool, get answer, then: cell analyze --save ${p.category}`));
+        console.log();
+    }
+    console.log(C.dim('  cell analyze --show    View saved insights'));
+    console.log();
+}
+// ─── cell scan ───────────────────────────────────────────────────────────────
+function doScan() {
+    const banner = figlet_1.default.textSync('CELL', { font: 'ANSI Shadow', horizontalLayout: 'fitted' });
+    console.log((0, gradient_string_1.default)(['#FF6B35', '#FFAB91'])(banner));
+    console.log(C.dim('  Scanning codebase + building all layers...\n'));
+    // ─── Flag parsing ─────────────────────────────────────────────────────
+    // --no-rules  → skip writing AGENTS.md and .cursorrules to project root
+    // --force-rules → overwrite existing AGENTS.md/.cursorrules (otherwise keep user edits)
+    const noRules = args.includes('--no-rules');
+    const forceRules = args.includes('--force-rules');
+    // First positional arg (after `scan`) is an optional explicit path.
+    // Default to current working directory (process.cwd()) — never to
+    // path.basename(cwd) which is a *name*, not a directory path.
+    const scanPathArg = args.find((a, i) => i >= 1 && !a.startsWith('--'));
+    const scanCwd = scanPathArg ? path.resolve(scanPathArg) : process.cwd();
+    let scanProject = path.basename(scanCwd);
+    try {
+        const { detectProject } = require('../setup/setup');
+        scanProject = detectProject(scanCwd).name;
+    }
+    catch { }
+    try {
+        const { scanCodebase } = require('../../02-scanner/blindspots/code-scanner');
+        const result = scanCodebase(scanCwd, scanProject);
+        console.log(C.success(`  [1/2] Scanned ${result.filesScanned} files, ${result.totalLines.toLocaleString()} lines`));
+        (0, layers_1.populateAllLayers)({
+            profile: result.profile,
+            patterns: result.patterns,
+            project: scanProject,
+        });
+        console.log(C.success('  [2/2] Populated all layers:'));
+        console.log(C.dim('    .cell/personal/  — profile, style, errors, decisions'));
+        console.log(C.dim('    .cell/team/      — shared patterns, blind spots'));
+        console.log(C.dim('    .cell/community/ — community patterns, trends'));
+        // ─── AI rules files (AGENTS.md, .cursorrules) ─────────────────────────
+        if (!noRules) {
+            const { writeCellRules } = require('../../01-context/context/agents-md');
+            const rulesResult = writeCellRules(scanCwd, { overwrite: forceRules });
+            const lines = [];
+            if (rulesResult.agentsMd === 'written')
+                lines.push('AGENTS.md');
+            if (rulesResult.cursorRules === 'written')
+                lines.push('.cursorrules');
+            if (lines.length > 0) {
+                console.log(C.success(`  [3/3] Wrote AI rules: ${lines.join(', ')} (idempotent — kept existing files)`));
+            }
+            else {
+                console.log(C.dim('  [3/3] AI rules: AGENTS.md + .cursorrules already present (kept as-is)'));
+            }
+        }
+        else {
+            console.log(C.dim('  [3/3] AI rules: skipped (--no-rules)'));
+        }
+        // ─── Top 5 fixes ────────────────────────────────────────────────────
+        try {
+            const { scanDirectoryForBlindSpots, getTopFixes, getCategorySummary } = require('../../../core/enhanced-blind-spots');
+            const spots = scanDirectoryForBlindSpots(scanCwd, 200);
+            const topFixes = getTopFixes(spots, 5);
+            if (topFixes.length > 0) {
+                console.log();
+                console.log(C.bold('  Top 5 fixes first:'));
+                for (let i = 0; i < topFixes.length; i++) {
+                    const s = topFixes[i];
+                    console.log(`  ${C.num(String(i + 1))}. ${s.message}`);
+                    console.log(`     ${C.dim(s.filePath + ':' + s.lineNumber)}`);
+                }
+            }
+            const catSummary = getCategorySummary(spots);
+            if (catSummary.length > 0) {
+                console.log();
+                console.log(C.dim('  Category breakdown:'));
+                for (const c of catSummary.slice(0, 6)) {
+                    console.log(C.dim(`    ${c.category}: ${c.count} (${c.topSeverity})`));
+                }
+            }
+        }
+        catch { }
+        console.log();
+        console.log(C.dim('  Run: cell status'));
+        console.log();
+        try {
+            const { markFirstScan } = require('../setup/cell-state');
+            markFirstScan();
+        }
+        catch { }
+        try {
+            const { captureCurrentBranchSnapshot } = require('../../03-knowledge/decisions/branch-snapshot');
+            captureCurrentBranchSnapshot(scanProject, scanCwd);
+        }
+        catch { }
+    }
+    catch (e) {
+        console.log(C.warn('  Scan failed: ' + String(e)));
+        console.log();
+    }
+}
+// ─── cell setup (idempotent one-time project setup) ─────────────────────────
+/**
+ * One-command setup for a new project. Runs scan + watcher + MCP config
+ * with full idempotency — safe to re-run any number of times. Skips steps
+ * that are already done and only does the missing pieces.
+ *
+ * Flags:
+ *   --project <name>  Override project name (default: package.json name or folder basename)
+ *   --no-rules        Skip writing AGENTS.md / .cursorrules
+ *   --force-rules     Overwrite existing AGENTS.md / .cursorrules
+ *   --skip-scan       Don't run scan
+ *   --skip-watch      Don't start watcher
+ *   --skip-mcp        Don't write MCP configs
+ *   --dir <path>      Watch dir (default: cwd)
+ *   --dry-run         Print what would happen, don't change anything
+ */
+async function doSetup() {
+    const banner = figlet_1.default.textSync('CELL', { font: 'ANSI Shadow', horizontalLayout: 'fitted' });
+    console.log((0, gradient_string_1.default)(['#FF6B35', '#FFAB91'])(banner));
+    console.log(C.dim('  Setting up project (idempotent)...\n'));
+    // ─── Flag parsing ─────────────────────────────────────────────────────
+    const noRules = args.includes('--no-rules');
+    const forceRules = args.includes('--force-rules');
+    const skipScan = args.includes('--skip-scan');
+    const skipWatch = args.includes('--skip-watch');
+    const skipMcp = args.includes('--skip-mcp');
+    const dryRun = args.includes('--dry-run');
+    const projectIdx = args.indexOf('--project');
+    const projectName = projectIdx > 0 ? args[projectIdx + 1] : undefined;
+    const dirIdx = args.indexOf('--dir');
+    const dir = dirIdx > 0 ? args[dirIdx + 1] : undefined;
+    try {
+        const { runSetup, detectProject, checkScanState, checkWatchState, checkMcpState, isDaemonRunning, } = require('../setup/setup');
+        const cwd = process.cwd();
+        const project = detectProject(cwd, projectName);
+        console.log(C.bold(`  Project: ${C.num(project.name)}`));
+        console.log(C.dim(`  Source:  ${project.source}${project.packageJsonPath ? ' (' + project.packageJsonPath + ')' : ''}`));
+        console.log(C.dim(`  Cwd:     ${cwd}`));
+        if (dryRun)
+            console.log(C.warn('  Mode:    DRY RUN (no changes will be made)'));
+        console.log();
+        // ─── Daemon check ────────────────────────────────────────────────────
+        const daemonUp = await isDaemonRunning();
+        if (daemonUp) {
+            console.log(C.success('  [daemon] running on http://localhost:9876'));
+        }
+        else {
+            console.log(C.warn('  [daemon] not running — watcher will be skipped'));
+            console.log(C.dim('           run `cell start` to bring it up, then re-run `cell setup`'));
+        }
+        console.log();
+        // ─── Pre-flight state report ────────────────────────────────────────
+        if (!dryRun) {
+            const scan = checkScanState(cwd);
+            const watch = daemonUp ? checkWatchState(project.name) : { done: false, reason: 'daemon not running' };
+            const mcp = checkMcpState(os.homedir());
+            console.log(C.bold('  Pre-flight:'));
+            console.log(`    scan:   ${scan.done ? C.success('done') : C.dim('missing')} (${scan.reason})`);
+            console.log(`    watch:  ${watch.done ? C.success('active') : C.dim('inactive')} (${watch.reason})`);
+            console.log(`    mcp:    ${mcp.done}/${mcp.total} IDEs wired${mcp.needsWrite.length > 0 ? C.warn(' (need: ' + mcp.needsWrite.join(', ') + ')') : ''}`);
+            console.log();
+            const allDone = scan.done && watch.done && mcp.done === mcp.total;
+            if (allDone) {
+                console.log(C.success('  Already fully set up — nothing to do.'));
+                console.log(C.dim('  Tip: re-run anytime; it is safe and idempotent.'));
+                console.log();
+                return;
+            }
+        }
+        // ─── Run setup ───────────────────────────────────────────────────────
+        const start = Date.now();
+        const result = await runSetup({
+            cwd,
+            homedir: os.homedir(),
+            noRules,
+            forceRules,
+            projectName,
+            skipScan,
+            skipWatch: skipWatch || !daemonUp,
+            skipMcp,
+            dir,
+            dryRun,
+        });
+        const ms = Date.now() - start;
+        // ─── Result summary ─────────────────────────────────────────────────
+        console.log(C.bold('  Result:'));
+        console.log(`    ${result.scan.done ? C.success('OK') : C.warn('FAIL')}  scan:   ${result.scan.reason}`);
+        console.log(`    ${result.watch.done ? C.success('OK') : C.warn('FAIL')}  watch:  ${result.watch.reason}`);
+        const mcpOk = result.mcp.done === result.mcp.total;
+        console.log(`    ${mcpOk ? C.success('OK') : C.warn('PARTIAL')}  mcp:    ${result.mcp.done}/${result.mcp.total} IDEs wired${result.mcp.written.length > 0 ? ' (' + result.mcp.written.length + ' just written)' : ''}`);
+        console.log();
+        if (result.warnings.length > 0) {
+            console.log(C.warn('  Warnings:'));
+            for (const w of result.warnings)
+                console.log(C.warn(`    ! ${w}`));
+            console.log();
+        }
+        if (result.errors.length > 0) {
+            console.log(C.warn('  Errors:'));
+            for (const e of result.errors)
+                console.log(C.warn(`    x ${e}`));
+            console.log();
+        }
+        // ─── Final verdict ──────────────────────────────────────────────────
+        const allGood = result.scan.done && result.watch.done && mcpOk && result.errors.length === 0;
+        if (allGood) {
+            console.log(C.success(`  Setup complete in ${ms}ms. Cell is ready.`));
+            try {
+                const { markSetupCompleted } = require('../setup/cell-state');
+                markSetupCompleted();
+            }
+            catch { }
+        }
+        else {
+            console.log(C.warn(`  Setup finished in ${ms}ms with warnings (see above).`));
+        }
+        console.log();
+        console.log(C.bold('  Next commands:'));
+        console.log(`  ${C.num('1.')} ${C.primary('cell context')}       See what Cell knows about your project`);
+        console.log(`  ${C.num('2.')} ${C.primary('cell blindspots --top')}  See your top fixes`);
+        console.log(`  ${C.primary('3.')} ${C.primary('cell bridge start')}  Connect your IDE`);
+        console.log(`  ${C.num('4.')} ${C.primary('cell continue')}       Resume your last session`);
+        console.log();
+        console.log(C.dim('  Run cell doctor anytime to check health.'));
+        console.log();
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.log(C.warn('  Setup failed: ' + msg));
+        console.log();
+    }
+    process.exit(0);
+}
+// ─── cell status ────────────────────────────────────────────────────────────
+function semiLabel(s) {
+    if (s === 'with semicolons' || s === 'always')
+        return 'always';
+    if (s === 'no semicolons' || s === 'never')
+        return 'never';
+    if (s === 'mixed')
+        return 'mixed';
+    return s;
+}
+// ─── cell --version / -v / version ───────────────────────────────────────────
+function doVersion() {
+    const pkg = require('../../../../package.json');
+    console.log(`${C.primary('cell')} v${C.num(pkg.version)}`);
+    console.log(C.dim(`  ${pkg.description}`));
+    console.log();
+    // Live info that's useful at a glance
+    try {
+        const http = require('http');
+        http.get('http://localhost:9876/health', (res) => {
+            let data = '';
+            res.on('data', (c) => { data += c || ''; });
+            res.on('end', () => {
+                const live = res.statusCode === 200 ? C.success('running') : C.warn(`status ${res.statusCode}`);
+                console.log(`  Daemon:  ${live} on port 9876`);
+                console.log(`  Tools:   67 MCP tools registered`);
+                console.log(`  License: Apache-2.0`);
+                console.log();
+            });
+        }).on('error', () => {
+            console.log(`  Daemon:  ${C.warn('not running')} — start with: cell start`);
+            console.log(`  Tools:   67 MCP tools (ready when daemon starts)`);
+            console.log(`  License: Apache-2.0`);
+            console.log();
+        });
+    }
+    catch { }
+}
+function doStatus() {
+    // ─── Flag passthroughs (Pre-Launch Test 1 + Test 3) ────────────────────
+    // Allow `cell status --session` and `cell status --decisions` as
+    // documented in the pre-launch test suite. The dedicated `cell session`
+    // and `cell decisions` top-level commands still work.
+    if (args[1] === '--session') {
+        doSession();
+        return;
+    }
+    if (args[1] === '--decisions') {
+        doDecisions();
+        return;
+    }
+    const banner = figlet_1.default.textSync('CELL', { font: 'ANSI Shadow', horizontalLayout: 'fitted' });
+    console.log((0, gradient_string_1.default)(['#FF6B35', '#FFAB91'])(banner));
+    console.log();
+    // Check daemon
+    const http = require('http');
+    try {
+        http.get('http://localhost:9876/health', (res) => {
+            let data = '';
+            res.on('data', (c) => data += c);
+            res.on('end', () => {
+                console.log(C.success('  Daemon: Running'));
+                showProjectStatus();
+            });
+        }).on('error', () => {
+            console.log(C.warn('  Daemon: Not running (run: cell start)'));
+            showProjectStatus();
+        });
+    }
+    catch {
+        showProjectStatus();
+    }
+}
+function showProjectStatus() {
+    const { getDeveloperProfile } = require('../../02-scanner/blindspots/code-scanner');
+    const profile = getDeveloperProfile(project);
+    if (!profile) {
+        console.log(C.warn(`\n  No profile for "${project}". Run: cell start`));
+        console.log();
+        return;
+    }
+    console.log();
+    console.log(C.bold(`  Project: ${project}`));
+    // ─── Personal Layer ──────────────────────────────────────────────────────
+    console.log();
+    console.log(C.bold('  📂 Personal Layer'));
+    console.log(C.dim('  ─────────────────'));
+    // Stack fingerprint (from stack-detector)
+    try {
+        const { detectProjectDNA } = require('../../02-scanner/stack/stack-detector');
+        const dna = detectProjectDNA(process.cwd());
+        if (dna && dna.stack.trustScore > 0) {
+            const s = dna.stack;
+            console.log(`  Stack:  ${C.num(s.languages?.join(', ') || '')} · ${s.frontend !== 'none' ? s.frontend + ' + ' : ''}${s.backend}${s.database[0] !== 'none' ? ' · ' + s.database.join(', ') : ''}`);
+            console.log(`          ${s.orm !== 'none' ? 'ORM: ' + s.orm + ' · ' : ''}Test: ${s.testing.join(', ')}${s.validation !== 'none' ? ' · Validation: ' + s.validation : ''}`);
+            console.log(`  Arch:   ${dna.architecture.type} (${dna.architecture.confidence}), Entry: ${dna.architecture.entryPoints.join(', ')}`);
+            console.log(`  Style:  ${C.num(profile.quoteStyle)} quotes, ${C.num(semiLabel(profile.semicolonStyle))} semis, ${C.num(profile.indentStyle)}`);
+        }
+        else {
+            console.log(`  Style:   ${C.num(profile.quoteStyle)} quotes, ${C.num(semiLabel(profile.semicolonStyle))} semis, ${C.num(profile.indentStyle)}`);
+        }
+    }
+    catch {
+        console.log(`  Style:   ${C.num(profile.quoteStyle)} quotes, ${C.num(semiLabel(profile.semicolonStyle))} semis, ${C.num(profile.indentStyle)}`);
+    }
+    console.log(`  Code:    ${C.num(profile.functionStyle)} functions, ${C.num(profile.asyncStyle)}, ${C.num(profile.errorHandling)} errors`);
+    if (profile.strengths.length) {
+        for (const s of profile.strengths)
+            console.log(`    ${C.success('+')} ${s}`);
+    }
+    if (profile.improvements.length) {
+        for (const i of profile.improvements)
+            console.log(`    ${C.warn('!')} ${i}`);
+    }
+    // Show .cell/personal/ files
+    const personalDir = path.join(layers_1.CELL_DIR, 'personal');
+    if (fs.existsSync(personalDir)) {
+        const files = fs.readdirSync(personalDir);
+        console.log(C.dim(`    Files: ${files.join(', ')}`));
+    }
+    // Behavioral data
+    try {
+        const { getBehaviorSummary } = require('../../03-knowledge/decisions/behavioral-tracker');
+        const b = getBehaviorSummary(project);
+        if (b.totalErrors > 0 || b.totalDecisions > 0 || b.currentContext || b.stuckIssues.length > 0) {
+            console.log(C.bold('  Behavior:'));
+            if (b.totalErrors > 0)
+                console.log(`    Errors: ${b.totalErrors} logged`);
+            if (b.totalDecisions > 0)
+                console.log(`    Decisions: ${b.totalDecisions} logged`);
+            if (b.currentContext)
+                console.log(`    Working on: ${b.currentContext.task}`);
+            if (b.stuckIssues.length > 0)
+                console.log(`    Stuck: ${b.stuckIssues.length} issues`);
+        }
+    }
+    catch { }
+    // ─── Git Intelligence ────────────────────────────────────────────────────
+    try {
+        const { buildDeveloperIntelligence } = require('../../02-scanner/profile/developer-intelligence');
+        const gitIntel = buildDeveloperIntelligence(process.cwd());
+        if (gitIntel) {
+            console.log();
+            console.log(C.bold('  🧠 Git Intelligence'));
+            console.log(C.dim('  ──────────────────'));
+            console.log(`  Score: ${C.num(String(gitIntel.behavioralScore))}/100`);
+            if (gitIntel.timeSummary)
+                console.log(C.dim(`  ${gitIntel.timeSummary}`));
+            if (gitIntel.journeySummary)
+                console.log(C.dim(`  ${gitIntel.journeySummary}`));
+            if (gitIntel.topBlindSpots.length > 0) {
+                console.log(C.bold('  Top Blind Spots:'));
+                for (const bs of gitIntel.topBlindSpots.slice(0, 3)) {
+                    console.log(`    ${C.warn('!')} ${bs}`);
+                }
+            }
+            if (gitIntel.topMistakes.length > 0) {
+                console.log(C.bold('  Repeat Mistakes:'));
+                for (const m of gitIntel.topMistakes.slice(0, 3)) {
+                    console.log(`    ${C.warn('↻')} ${m}`);
+                }
+            }
+            if (gitIntel.topStrengths.length > 0) {
+                for (const s of gitIntel.topStrengths.slice(0, 3)) {
+                    console.log(`    ${C.success('+')} ${s}`);
+                }
+            }
+        }
+    }
+    catch { }
+    // ─── Predictions ─────────────────────────────────────────────────────────
+    try {
+        const { getQuickWarnings } = require('../../03-knowledge/decisions/predictive-engine');
+        const warnings = getQuickWarnings(project);
+        if (warnings.length > 0) {
+            console.log();
+            console.log(C.bold('  🔮 Predictions'));
+            console.log(C.dim('  ──────────────'));
+            for (const w of warnings) {
+                console.log(`  ${w}`);
+            }
+        }
+    }
+    catch { }
+    // ─── Team Layer ──────────────────────────────────────────────────────────
+    console.log();
+    console.log(C.bold('  👥 Team Layer'));
+    console.log(C.dim('  ─────────────'));
+    const teamData = (0, layers_1.getTeamMembers)();
+    if (teamData && teamData.members && teamData.members.length > 0) {
+        for (const m of teamData.members) {
+            console.log(`    ${C.success('•')} ${m.name} — ${m.role}`);
+        }
+    }
+    else {
+        console.log(C.dim('    No team members. Add: cell team add <name>'));
+    }
+    const teamPatterns = (0, layers_1.getTeamPatterns)();
+    if (teamPatterns && teamPatterns.patterns && teamPatterns.patterns.length > 0) {
+        console.log(C.dim(`    Shared patterns: ${teamPatterns.patterns.length}`));
+    }
+    const teamBlinds = (0, layers_1.getTeamBlindSpots)();
+    if (teamBlinds && teamBlinds.blindSpots && teamBlinds.blindSpots.length > 0) {
+        console.log(C.warn(`    Blind spots: ${teamBlinds.blindSpots.length}`));
+    }
+    // ─── Community Layer ─────────────────────────────────────────────────────
+    console.log();
+    console.log(C.bold('  🌐 Community Layer'));
+    console.log(C.dim('  ──────────────────'));
+    const commPatterns = (0, layers_1.getCommunityPatterns)();
+    if (commPatterns && commPatterns.patterns && commPatterns.patterns.length > 0) {
+        console.log(C.dim(`    Patterns shared: ${commPatterns.patterns.length}`));
+    }
+    else {
+        console.log(C.dim('    No community patterns yet. Run: cell community'));
+    }
+    const commTrends = (0, layers_1.getCommunityTrends)();
+    if (commTrends && commTrends.trends && commTrends.trends.length > 0) {
+        console.log(C.dim(`    Trends: ${commTrends.trends.length}`));
+    }
+    const commRank = (0, layers_1.getCommunityRankings)();
+    if (commRank && commRank.rankings && commRank.rankings.length > 0) {
+        console.log(C.dim(`    Rankings: ${commRank.rankings.length}`));
+    }
+    console.log();
+}
+// ─── cell status --session (Pre-Launch Test 1) ──────────────────────────────
+function doSession() {
+    console.log();
+    console.log(C.bold('  Cell Session — Last Activity'));
+    console.log(C.dim('  ───────────────────────────────'));
+    console.log();
+    try {
+        const { getLastTouchedFile, getPatternCounts, getBehaviorSummary } = require('../../03-knowledge/decisions/behavioral-tracker');
+        const last = getLastTouchedFile(project);
+        const patterns = getPatternCounts(project);
+        const behavior = getBehaviorSummary(project);
+        if (last) {
+            const ago = formatTimeAgo(parseSqliteUtc(last.lastTouched));
+            console.log(`  Last file:    ${C.num(last.file)}`);
+            console.log(`  Time:         ${ago} (${last.touchCount} touch${last.touchCount === 1 ? '' : 'es'})`);
+        }
+        else {
+            console.log(C.dim('  Last file:    (none yet — save a file to start tracking)'));
+        }
+        console.log(`  Patterns:     ${C.num(String(patterns.total))} detected`);
+        if (Object.keys(patterns.byCategory).length > 0) {
+            const catStr = Object.entries(patterns.byCategory)
+                .slice(0, 5)
+                .map(([cat, n]) => `${cat}=${n}`)
+                .join(', ');
+            console.log(C.dim(`                ${catStr}`));
+        }
+        if (behavior.currentContext) {
+            console.log(`  Current task: ${C.num(behavior.currentContext.task)}`);
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(C.warn(`  Session lookup failed: ${msg}`));
+    }
+    console.log();
+}
+// ─── cell status --decisions (Pre-Launch Test 3) ────────────────────────────
+function doDecisions() {
+    console.log();
+    console.log(C.bold('  Cell Decisions — Recent Activity'));
+    console.log(C.dim('  ─────────────────────────────────'));
+    console.log();
+    try {
+        const { getRecentDecisionsWithAgo, getBehaviorSummary } = require('../../03-knowledge/decisions/behavioral-tracker');
+        const decisions = getRecentDecisionsWithAgo(project, 5);
+        const behavior = getBehaviorSummary(project);
+        if (decisions.length === 0) {
+            console.log(C.dim('  No decisions logged yet.'));
+            console.log(C.dim('  Decisions are auto-logged when AI suggestions are accepted/rejected in your IDE.'));
+        }
+        else {
+            for (const d of decisions) {
+                const verdict = d.worked ? C.success('Accepted') : C.warn('Rejected');
+                console.log(`  ${verdict}  ${d.decision}`);
+                console.log(C.dim(`          ${d.ago}${d.file ? ' · ' + d.file : ''}`));
+            }
+        }
+        console.log();
+        console.log(C.dim(`  Total: ${behavior.totalDecisions} decision${behavior.totalDecisions === 1 ? '' : 's'} logged`));
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(C.warn(`  Decisions lookup failed: ${msg}`));
+    }
+    console.log();
+}
+function formatTimeAgo(ts) {
+    const diff = Date.now() - ts;
+    if (diff < 0)
+        return 'just now';
+    const sec = Math.floor(diff / 1000);
+    if (sec < 60)
+        return `${sec} second${sec === 1 ? '' : 's'} ago`;
+    const min = Math.floor(sec / 60);
+    if (min < 60)
+        return `${min} minute${min === 1 ? '' : 's'} ago`;
+    const hr = Math.floor(min / 60);
+    if (hr < 24)
+        return `${hr} hour${hr === 1 ? '' : 's'} ago`;
+    const day = Math.floor(hr / 24);
+    if (day < 30)
+        return `${day} day${day === 1 ? '' : 's'} ago`;
+    const month = Math.floor(day / 30);
+    return `${month} month${month === 1 ? '' : 's'} ago`;
+}
+/**
+ * Parse a SQLite `datetime('now')` string into a JS millisecond timestamp.
+ * SQLite's datetime() returns UTC time as a string like "2026-06-05 09:20:26"
+ * (no timezone marker). JS `new Date(str)` would treat this as LOCAL time,
+ * which causes a 5h30m offset in IST. We force UTC interpretation by
+ * appending "Z" or by replacing the space with "T" + "Z".
+ */
+function parseSqliteUtc(s) {
+    if (!s)
+        return 0;
+    // Already has TZ marker
+    if (s.endsWith('Z') || /[+-]\d{2}:?\d{2}$/.test(s)) {
+        return new Date(s).getTime();
+    }
+    // Replace space separator with T, append Z
+    return new Date(s.replace(' ', 'T') + 'Z').getTime();
+}
+// ─── cell team ──────────────────────────────────────────────────────────────
+function doTeam() {
+    console.log();
+    console.log(C.bold('  Cell Team'));
+    console.log(C.dim('  ─────────'));
+    console.log();
+    const db = (0, database_1.getDb)();
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS team_members (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      role TEXT DEFAULT 'developer',
+      joined_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+    const sub = args[1] || '';
+    // ─── team push ──────────────────────────────────────────────────────
+    if (sub === 'push') {
+        console.log(C.primary('  Pushing your patterns to team...'));
+        const { teamPush } = require('../../04-team/collab/team-git');
+        const name = args[2];
+        if (!name) {
+            console.log(C.warn('  Usage: cell team push <your-name> [role]'));
+            console.log();
+            return;
+        }
+        const role = args[3] || 'developer';
+        const result = teamPush(name, role);
+        console.log(result.success ? C.success(`  ${result.message}`) : C.warn(`  ${result.message}`));
+        console.log();
+        return;
+    }
+    // ─── team pull ──────────────────────────────────────────────────────
+    if (sub === 'pull') {
+        console.log(C.primary('  Pulling team data...'));
+        const { teamPull } = require('../../04-team/collab/team-git');
+        const result = teamPull();
+        if (result.success) {
+            console.log(C.success(`  ${result.message}`));
+            console.log(C.dim(`  Members: ${result.newMembers}, Patterns: ${result.newPatterns}`));
+        }
+        else {
+            console.log(C.warn(`  ${result.message}`));
+        }
+        console.log();
+        return;
+    }
+    // ─── team onboard ───────────────────────────────────────────────────
+    if (sub === 'onboard' && args[2]) {
+        const newMember = args[2];
+        const teamPath = path.join(process.cwd(), '.cell', 'team');
+        console.log(C.primary(`  Generating onboarding guide for ${newMember}...`));
+        const { generateOnboardingGuide, formatOnboardingText } = require('../../04-team/collab/team-intel');
+        const guide = generateOnboardingGuide(teamPath, newMember);
+        if (guide) {
+            console.log(formatOnboardingText(guide));
+        }
+        else {
+            console.log(C.warn('  No team data found. Run: cell team push <your-name> first.'));
+        }
+        console.log();
+        return;
+    }
+    // ─── team status ────────────────────────────────────────────────────
+    if (sub === 'status') {
+        const { teamStatus } = require('../../04-team/collab/team-git');
+        const intel = teamStatus();
+        if (!intel) {
+            console.log(C.dim('  No team data. Run: cell team push <your-name>'));
+            console.log();
+            return;
+        }
+        console.log(C.bold(`  Team: ${intel.summary.totalMembers} members`));
+        console.log(C.dim(`  Patterns: ${intel.summary.totalPatterns}, Bus Factor: ${intel.summary.avgBusFactor}`));
+        console.log();
+        if (intel.members.length > 0) {
+            console.log(C.bold('  Members:'));
+            for (const m of intel.members) {
+                console.log(`    ${C.success('•')} ${m.name} (${m.role}) — ${m.patterns} patterns`);
+                if (m.strengths.length > 0)
+                    console.log(C.dim(`      Strengths: ${m.strengths.join(', ')}`));
+            }
+            console.log();
+        }
+        if (intel.knowledgeMap.length > 0) {
+            console.log(C.bold('  Knowledge Map:'));
+            for (const k of intel.knowledgeMap) {
+                const risk = k.busFactor <= 1 ? C.warn('⚠ BUS=1') : C.dim(`bus=${k.busFactor}`);
+                console.log(`    ${k.area}: ${k.experts.join(', ')}  ${risk}`);
+            }
+            console.log();
+        }
+        if (intel.sharedPatterns.length > 0) {
+            console.log(C.bold('  Top Shared Patterns:'));
+            for (const p of intel.sharedPatterns.slice(0, 5)) {
+                console.log(`    ${C.dim('•')} ${p.name}: ${p.value} (${p.count}x)`);
+            }
+            console.log();
+        }
+        if (intel.summary.strongestArea)
+            console.log(C.success(`  + Strongest: ${intel.summary.strongestArea}`));
+        if (intel.summary.weakestArea)
+            console.log(C.warn(`  ! Weakest: ${intel.summary.weakestArea}`));
+        // Team pattern library
+        const teamPath = path.join(process.cwd(), '.cell', 'team');
+        try {
+            const { buildTeamPatternLibrary } = require('../../04-team/collab/team-intel');
+            const rules = buildTeamPatternLibrary(teamPath);
+            if (rules.length > 0) {
+                console.log(C.bold('  📋 Pattern Library:'));
+                const doRules = rules.filter((r) => r.type === 'do').slice(0, 3);
+                const dontRules = rules.filter((r) => r.type === 'dont').slice(0, 2);
+                for (const r of doRules) {
+                    console.log(`    ${C.success('✓')} ${r.rule} (${r.agreement}% agreement)`);
+                }
+                for (const r of dontRules) {
+                    console.log(`    ${C.warn('✗')} ${r.rule}`);
+                }
+            }
+        }
+        catch { }
+        if (intel.summary.criticalBlindSpots > 0)
+            console.log(C.warn(`  ! ${intel.summary.criticalBlindSpots} critical blind spots`));
+        console.log();
+        return;
+    }
+    // ─── team silos ─────────────────────────────────────────────────────
+    if (sub === 'silos') {
+        const { detectKnowledgeSilos } = require('../../04-team/collab/team-collaboration');
+        const silos = detectKnowledgeSilos();
+        console.log(C.bold(`  Knowledge Silos: ${silos.length}`));
+        console.log();
+        if (silos.length === 0) {
+            console.log(C.dim('  No silos detected. Knowledge is well distributed.'));
+        }
+        else {
+            for (const s of silos.slice(0, 10)) {
+                const riskColor = s.riskLevel === 'high' ? C.warn : s.riskLevel === 'medium' ? C.primary : C.dim;
+                console.log(`    ${riskColor('●')} ${s.name} — ${s.knowledgeArea}`);
+                console.log(C.dim(`      ${s.members.join(', ')} (bus factor: ${s.busFactor})`));
+            }
+        }
+        console.log();
+        return;
+    }
+    // ─── team bus-factor ───────────────────────────────────────────────
+    if (sub === 'bus-factor') {
+        const { calculateBusFactor } = require('../../04-team/collab/team-collaboration');
+        const report = calculateBusFactor();
+        console.log(C.bold(`  Bus Factor: ${report.overallScore}/100`));
+        console.log();
+        if (report.singlePointsOfFailure.length > 0) {
+            console.log(C.warn('  Single Points of Failure:'));
+            for (const spof of report.singlePointsOfFailure.slice(0, 5)) {
+                console.log(C.warn(`    ⚠ ${spof}`));
+            }
+            console.log();
+        }
+        if (report.members.length > 0) {
+            console.log(C.dim('  Top members:'));
+            for (const m of report.members.slice(0, 5)) {
+                console.log(`    ${m.name}: score ${m.score} (${m.risk} risk)`);
+            }
+        }
+        console.log();
+        return;
+    }
+    // ─── team health ───────────────────────────────────────────────────
+    if (sub === 'health') {
+        const { getTeamHealth } = require('../../04-team/collab/team-collaboration');
+        const health = getTeamHealth(args[2]);
+        console.log(C.bold(`  Team Health: ${health.score}/100`));
+        console.log();
+        console.log(C.dim(`  Bus factor: ${health.busFactor}, Silos: ${health.siloCount}, Edges: ${health.collaborationEdges}`));
+        if (health.strengths.length > 0) {
+            console.log(C.success('  Strengths:'));
+            for (const s of health.strengths.slice(0, 3))
+                console.log(C.success(`    + ${s}`));
+        }
+        if (health.skillGaps.length > 0) {
+            console.log(C.warn('  Skill gaps:'));
+            for (const g of health.skillGaps.slice(0, 3))
+                console.log(C.warn(`    ! ${g}`));
+        }
+        if (health.recommendations.length > 0) {
+            console.log(C.primary('  Recommendations:'));
+            for (const r of health.recommendations.slice(0, 3))
+                console.log(`    → ${r}`);
+        }
+        console.log();
+        return;
+    }
+    // ─── community sub-commands ─────────────────────────────────────────
+    if (sub === 'community' || sub === 'comm') {
+        const csub = args[2];
+        if (csub === 'stats') {
+            const { getCommunityStats } = require('../../06-memory/stores/community-store');
+            const stats = getCommunityStats();
+            console.log(C.bold('  Community Stats'));
+            console.log(C.dim(`  Patterns: ${stats.totalPatterns}, Insights: ${stats.totalInsights}, Benchmarks: ${stats.totalBenchmarks}`));
+            console.log(C.dim(`  Total votes: ${stats.totalVotes}`));
+            if (Object.keys(stats.byCategory).length > 0) {
+                console.log(C.dim('  By category:'));
+                for (const [cat, count] of Object.entries(stats.byCategory)) {
+                    console.log(`    ${cat}: ${count}`);
+                }
+            }
+            console.log();
+            return;
+        }
+        if (csub === 'share' && args[3]) {
+            const { shareCommunityPattern, validatePrivacy } = require('../../06-memory/stores/community-store');
+            const rule = args[3];
+            const category = args[4] || 'general';
+            const language = args[5];
+            const validation = validatePrivacy(rule);
+            if (!validation.safe) {
+                console.log(C.warn('  Blocked — privacy violations:'));
+                for (const e of validation.errors)
+                    console.log(C.warn(`    ✗ ${e}`));
+                console.log();
+                return;
+            }
+            const result = shareCommunityPattern({ category, rule, language });
+            console.log(C.success(`  Shared: ${result.patternId}`));
+            if (result.warnings.length > 0) {
+                console.log(C.dim('  Warnings:'));
+                for (const w of result.warnings)
+                    console.log(C.dim(`    - ${w}`));
+            }
+            console.log();
+            return;
+        }
+        if (csub === 'trends') {
+            const { getTechEvolution } = require('../../06-memory/stores/community-store');
+            const trends = getTechEvolution();
+            console.log(C.bold('  Technology Trends'));
+            for (const t of trends.slice(0, 10)) {
+                const arrow = t.trend30d > 0 ? C.success('↑') : t.trend30d < 0 ? C.warn('↓') : C.dim('→');
+                console.log(`    ${arrow} ${t.technology} — ${t.adoptionPhase} (${t.currentUsage} signals)`);
+            }
+            console.log();
+            return;
+        }
+        console.log(C.dim('  Usage: cell team community [stats|share <rule> <category>|trends]'));
+        console.log();
+        return;
+    }
+    // ─── team usage (Phase 6) ──────────────────────────────────────────
+    if (sub === 'usage') {
+        const { getUsageDashboard, getDecisionPatterns, detectRepeatMistakes, getBurnoutSignals } = require('../../06-memory/stores/usage-intelligence-store');
+        const project = args[2] || 'Fivo-Cell';
+        const dash = getUsageDashboard(project);
+        console.log(C.bold(`  Usage Dashboard — ${project}`));
+        console.log();
+        console.log(C.dim(`  Decisions: ${dash.decisions.total} (${dash.decisions.right} right, ${dash.decisions.wrong} wrong)`));
+        if (dash.decisions.topPatterns.length > 0) {
+            console.log(C.bold('  Decision Patterns:'));
+            for (const p of dash.decisions.topPatterns.slice(0, 3)) {
+                console.log(`    ${p.advice}`);
+            }
+        }
+        console.log();
+        console.log(C.dim(`  Mistakes: ${dash.mistakes.total} repeated (${dash.mistakes.critical} critical)`));
+        if (dash.mistakes.top.length > 0) {
+            for (const m of dash.mistakes.top.slice(0, 3)) {
+                console.log(`    ${C.warn('!')} ${m.errorType} (${m.count}x) — ${m.suggestion}`);
+            }
+        }
+        console.log();
+        console.log(C.dim(`  AI: ${dash.ai.modelsUsed} models, avg acceptance ${dash.ai.avgAcceptance}%`));
+        if (dash.ai.topModel !== 'none')
+            console.log(C.dim(`  Top model: ${dash.ai.topModel}`));
+        console.log();
+        console.log(C.dim(`  Productivity: flow ${dash.productivity.flowScore}, friction ${dash.productivity.frictionScore}`));
+        console.log();
+        console.log(C.dim(`  Skills: ${dash.skills.improving} improving, ${dash.skills.plateau} plateau, ${dash.skills.regressing} regressing`));
+        console.log();
+        const burnoutColor = dash.burnout.risk === 'high' ? C.warn : dash.burnout.risk === 'medium' ? C.primary : C.success;
+        console.log(burnoutColor(`  Burnout risk: ${dash.burnout.risk.toUpperCase()}`));
+        if (dash.burnout.signals.length > 0) {
+            for (const s of dash.burnout.signals)
+                console.log(C.dim(`    - ${s}`));
+        }
+        console.log(C.dim(`  ${dash.burnout.advice}`));
+        console.log();
+        return;
+    }
+    if (sub === 'add' && args[2]) {
+        const name = args[2];
+        const role = args[3] || 'developer';
+        db.prepare('INSERT INTO team_members (name, role) VALUES (?, ?)').run(name, role);
+        const members = db.prepare('SELECT name, role, joined_at FROM team_members').all();
+        (0, layers_1.saveTeamMembers)(members.map((m) => ({ name: m.name, role: m.role, joinedAt: m.joined_at })));
+        console.log(C.success(`  Added: ${name} (${role})`));
+        console.log(C.dim('  Saved to .cell/team/members.json'));
+        console.log();
+        return;
+    }
+    if (sub === 'remove' && args[2]) {
+        db.prepare('DELETE FROM team_members WHERE name = ?').run(args[2]);
+        const members = db.prepare('SELECT name, role, joined_at FROM team_members').all();
+        (0, layers_1.saveTeamMembers)(members.map((m) => ({ name: m.name, role: m.role, joinedAt: m.joined_at })));
+        console.log(C.success(`  Removed: ${args[2]}`));
+        console.log();
+        return;
+    }
+    // Default: show member list + team commands
+    const members = db.prepare('SELECT name, role, joined_at FROM team_members').all();
+    if (members.length === 0) {
+        console.log(C.dim('  No team members yet.'));
+        console.log();
+    }
+    console.log(C.bold('  Members:'));
+    for (const m of members) {
+        console.log(`    ${C.num(m.name)} — ${m.role}`);
+    }
+    console.log();
+    console.log('  Commands:');
+    console.log(`    ${C.primary('cell team push <name>')}    Share your patterns with team`);
+    console.log(`    ${C.primary('cell team pull')}          Pull team data from git`);
+    console.log(`    ${C.primary('cell team status')}        Team intelligence dashboard`);
+    console.log(`    ${C.primary('cell team silos')}         Knowledge silo detection`);
+    console.log(`    ${C.primary('cell team bus-factor')}    Bus factor analysis`);
+    console.log(`    ${C.primary('cell team health [proj]')} Team health score`);
+    console.log(`    ${C.primary('cell team community')}     Community stats/share/trends`);
+    console.log(`    ${C.primary('cell team usage [proj]')}  Personal usage intelligence`);
+    console.log(`    ${C.primary('cell team add/remove')}     Manage members`);
+    console.log();
+}
+// ─── cell watch ─────────────────────────────────────────────────────────────
+function doWatch() {
+    console.log();
+    console.log(C.bold('  Cell Live Watcher'));
+    console.log(C.dim('  ─────────────────'));
+    console.log();
+    const sub = args[1] || 'daemon';
+    // Parse flags first so positional args don't get eaten by --limit / --type.
+    // Examples supported:
+    //   cell watch events
+    //   cell watch events fivo-cell
+    //   cell watch events fivo-cell --limit 10
+    //   cell watch events fivo-cell --type file_save
+    //   cell watch events --limit 5 --type file_create
+    const watchArgs = args.slice(2);
+    const { positional } = require('../watcher/watch-cli').parseWatchFlags(watchArgs);
+    const watchLimit = require('../watcher/watch-cli').parseWatchLimit(watchArgs);
+    const watchEventType = require('../watcher/watch-cli').parseWatchEventType(watchArgs);
+    const project = positional[0] || path.basename(process.cwd());
+    const dir = positional[1] || process.cwd();
+    // If invoked with no subcommand: run as a long-lived watcher daemon (for .bat auto-restart loop)
+    if (sub === 'daemon' || sub === '') {
+        runWatchDaemon(project, dir);
+        return;
+    }
+    try {
+        const liveWatcher = require('../watcher/live-watcher');
+        const http = require('http');
+        function callDaemon(toolName, toolArgs) {
+            return new Promise((resolve, reject) => {
+                const body = JSON.stringify({ method: 'tools/call', params: { name: toolName, arguments: toolArgs } });
+                const req = http.request({ hostname: '127.0.0.1', port: 9876, path: '/mcp', method: 'POST', headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) } }, (res) => {
+                    let data = '';
+                    res.on('data', (chunk) => { data += chunk; });
+                    res.on('end', () => {
+                        try {
+                            const parsed = JSON.parse(data);
+                            resolve(parsed.result || parsed);
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
+                    });
+                });
+                req.on('error', reject);
+                req.write(body);
+                req.end();
+            });
+        }
+        if (sub === 'start' || sub === 'stop') {
+            // Watcher state lives in daemon's in-memory map; CLI must talk to daemon
+            const toolName = sub === 'start' ? 'cell_watch_start' : 'cell_watch_stop';
+            const toolArgs = { project };
+            if (sub === 'start')
+                toolArgs.dir = dir;
+            callDaemon(toolName, toolArgs).then((r) => {
+                const ok = sub === 'start' ? r.started : r.stopped;
+                console.log(ok ? C.success(`  ✓ ${r.message}`) : C.warn(`  ! ${r.message}`));
+                console.log();
+            }).catch((e) => {
+                const msg = e instanceof Error ? e.message : String(e);
+                console.log(C.warn(`  Daemon not running (${msg}). Start with: cell start`));
+                console.log();
+            });
+            return;
+        }
+        if (sub === 'events') {
+            const { isValidEventType } = require('../watcher/watch-cli');
+            const typeFilter = isValidEventType(watchEventType) ? watchEventType : undefined;
+            const events = liveWatcher.getLiveEvents(project, watchLimit, typeFilter);
+            if (events.length === 0) {
+                const hint = typeFilter
+                    ? `No ${typeFilter} events for ${project} in the last ${watchLimit}.`
+                    : `No live events for ${project} yet. Start watcher with: cell watch start ${project}`;
+                console.log(C.dim(`  ${hint}`));
+            }
+            else {
+                const header = typeFilter
+                    ? `Recent ${typeFilter} events for ${project} (${events.length}, limit ${watchLimit}):`
+                    : `Recent events for ${project} (${events.length}, limit ${watchLimit}):`;
+                console.log(C.bold(`  ${header}`));
+                for (const e of events) {
+                    const icon = e.eventType === 'file_save' ? '~' : e.eventType === 'file_create' ? '+' : e.eventType === 'file_delete' ? '-' : e.eventType === 'file_rename' ? '>' : e.eventType === 'git_commit' ? '@' : '*';
+                    console.log(`    ${C.dim(icon)} ${C.dim(e.createdAt)} ${e.eventType}: ${C.num(e.filePath)}`);
+                }
+            }
+        }
+        else if (sub === 'refresh') {
+            const result = liveWatcher.performAutoRefresh(project, true);
+            console.log(C.success(`  ✓ Refresh logged: ${result.details} (${result.durationMs}ms)`));
+        }
+        else if (sub === 'check') {
+            const check = liveWatcher.checkIfNeedsRefresh(project);
+            const needs = check.needsRefresh;
+            console.log(needs ? C.warn(`  ⚠ Needs refresh: ${check.reason}`) : C.success(`  ✓ ${check.reason}`));
+            console.log(C.dim(`  Data age: ${check.dataAge} | Recommended: ${check.recommendedAction}`));
+        }
+        else {
+            // status
+            const status = liveWatcher.getWatcherStatus(project);
+            const active = liveWatcher.getActiveWatchers();
+            if (status && status.active) {
+                console.log(C.success(`  ● ${project}: ${C.bold('LIVE')} — ${status.eventCount} events, last: ${status.lastEventAt || 'never'}`));
+            }
+            else {
+                console.log(C.dim(`  ○ ${project}: not watched`));
+            }
+            if (active.length > 1 || (active.length === 1 && active[0]?.project !== project)) {
+                console.log();
+                console.log(C.bold('  Other active watchers:'));
+                for (const a of active) {
+                    if (a.project !== project)
+                        console.log(`    ● ${a.project} (${a.eventCount} events)`);
+                }
+            }
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(C.warn(`  Watch error: ${msg}`));
+    }
+    console.log();
+}
+// ─── cell blindspots ────────────────────────────────────────────────────────
+function doBlindspots() {
+    console.log();
+    console.log(C.bold('  Cell Blind Spots'));
+    console.log(C.dim('  ────────────────'));
+    console.log();
+    const showTop = args.includes('--top');
+    const topN = (() => {
+        const idx = args.indexOf('--top');
+        if (idx >= 0 && args[idx + 1] && /^\d+$/.test(args[idx + 1]))
+            return parseInt(args[idx + 1], 10);
+        return 5;
+    })();
+    const dirArg = args.find((a, i) => i >= 1 && !a.startsWith('--') && a !== String(topN));
+    const dir = dirArg || process.cwd();
+    const maxFiles = parseInt(args.find((a, i) => i >= 1 && !a.startsWith('--') && /^\d+$/.test(a) && a !== String(topN)) || '200', 10);
+    try {
+        const { scanDirectoryForBlindSpots, formatBlindSpotReport, summarizeBlindSpots, getTopFixes, getCategorySummary } = require('../../../core/enhanced-blind-spots');
+        console.log(C.dim(`  Scanning ${dir} (max ${maxFiles} files)...`));
+        const spots = scanDirectoryForBlindSpots(dir, maxFiles);
+        console.log();
+        if (showTop) {
+            const topFixes = getTopFixes(spots, topN);
+            console.log(C.bold(`  Top ${topFixes.length} fixes first:`));
+            for (let i = 0; i < topFixes.length; i++) {
+                const s = topFixes[i];
+                const score = s.priorityScore ? ` (score ${s.priorityScore.toFixed(1)})` : '';
+                console.log(`  ${C.num(String(i + 1))}. ${s.message}${score}`);
+                console.log(`     ${C.dim(s.filePath + ':' + s.lineNumber)} → ${s.recommendation}`);
+            }
+            console.log();
+        }
+        else {
+            console.log(formatBlindSpotReport(spots));
+        }
+        const catSummary = getCategorySummary(spots);
+        if (catSummary.length > 0) {
+            console.log();
+            console.log(C.bold('  By category:'));
+            for (const c of catSummary) {
+                console.log(`    ${C.num(String(c.count))} ${c.category} (top: ${c.topSeverity})`);
+            }
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(C.warn(`  Blind spot scan failed: ${msg}`));
+    }
+    console.log();
+}
+// ─── cell doctor ─────────────────────────────────────────────────────────────
+async function doDoctor() {
+    console.log();
+    console.log(C.bold('  Cell Doctor — Health Check'));
+    console.log(C.dim('  ─────────────────────────'));
+    console.log();
+    const { detectProject, checkScanState, checkWatchState, checkMcpState, isDaemonRunning, } = require('../setup/setup');
+    const cwd = process.cwd();
+    const project = detectProject(cwd);
+    const issues = [];
+    const passes = [];
+    // 1. Git repo
+    const gitDir = path.join(cwd, '.git');
+    if (fs.existsSync(gitDir)) {
+        console.log(`  ${C.success('OK')}  Git repo detected`);
+        passes.push('git');
+    }
+    else {
+        console.log(`  ${C.warn('--')}  Git repo not found (optional, but recommended)`);
+        issues.push('git');
+    }
+    // 2. Node/TypeScript project
+    const pkgJson = path.join(cwd, 'package.json');
+    const tsconfig = path.join(cwd, 'tsconfig.json');
+    if (fs.existsSync(pkgJson)) {
+        console.log(`  ${C.success('OK')}  Node.js project detected (package.json)`);
+        passes.push('node');
+    }
+    else {
+        console.log(`  ${C.warn('--')}  No package.json found (non-Node project?)`);
+        issues.push('node');
+    }
+    if (fs.existsSync(tsconfig)) {
+        console.log(`  ${C.success('OK')}  TypeScript project detected (tsconfig.json)`);
+        passes.push('typescript');
+    }
+    // 3. .cell folder
+    const cellDir = path.join(cwd, '.cell');
+    if (fs.existsSync(cellDir)) {
+        const personalDir = path.join(cellDir, 'personal');
+        const fileCount = fs.existsSync(personalDir) ? fs.readdirSync(personalDir).length : 0;
+        console.log(`  ${C.success('OK')}  .cell/ folder exists (${fileCount} personal files)`);
+        passes.push('cell-dir');
+    }
+    else {
+        console.log(`  ${C.warn('--')}  No .cell/ folder found`);
+        issues.push('cell-dir');
+    }
+    // 4. SQLite DB
+    const dbPath = path.join(os.homedir(), '.fivo', 'cell', 'cell.db');
+    if (fs.existsSync(dbPath)) {
+        try {
+            const stat = fs.statSync(dbPath);
+            const sizeMB = (stat.size / 1024 / 1024).toFixed(1);
+            console.log(`  ${C.success('OK')}  SQLite DB exists (${sizeMB} MB)`);
+            passes.push('db');
+        }
+        catch {
+            console.log(`  ${C.warn('--')}  SQLite DB exists but not readable`);
+            issues.push('db');
+        }
+    }
+    else {
+        console.log(`  ${C.warn('--')}  No SQLite DB found`);
+        issues.push('db');
+    }
+    // 5. Last scan
+    const scan = checkScanState(cwd);
+    if (scan.done) {
+        console.log(`  ${C.success('OK')}  Scan completed (${scan.reason})`);
+        passes.push('scan');
+    }
+    else {
+        console.log(`  ${C.warn('--')}  No scan found (${scan.reason})`);
+        issues.push('scan');
+    }
+    // 6. Daemon / bridge status
+    const daemonUp = await isDaemonRunning();
+    if (daemonUp) {
+        console.log(`  ${C.success('OK')}  Daemon running on http://localhost:9876`);
+        passes.push('daemon');
+    }
+    else {
+        console.log(`  ${C.warn('--')}  Daemon not running`);
+        issues.push('daemon');
+    }
+    // 7. Watcher status
+    const watch = checkWatchState(project.name);
+    if (watch.done) {
+        console.log(`  ${C.success('OK')}  Watcher active (${watch.reason})`);
+        passes.push('watcher');
+    }
+    else {
+        console.log(`  ${C.warn('--')}  Watcher not active (${watch.reason})`);
+        if (daemonUp)
+            issues.push('watcher');
+    }
+    // 8. Bridge status
+    try {
+        const { discoverBridgePort } = require('../watcher/socket-bridge');
+        const port = discoverBridgePort();
+        if (port) {
+            console.log(`  ${C.success('OK')}  Bridge reachable (port ${port})`);
+            passes.push('bridge');
+        }
+        else {
+            console.log(`  ${C.warn('--')}  Bridge not running`);
+            issues.push('bridge');
+        }
+    }
+    catch {
+        console.log(`  ${C.warn('--')}  Bridge not running`);
+        issues.push('bridge');
+    }
+    // 9. AGENTS.md / .cursorrules
+    const agentsMd = path.join(cwd, 'AGENTS.md');
+    const cursorRules = path.join(cwd, '.cursorrules');
+    const rulesFound = [];
+    if (fs.existsSync(agentsMd))
+        rulesFound.push('AGENTS.md');
+    if (fs.existsSync(cursorRules))
+        rulesFound.push('.cursorrules');
+    if (rulesFound.length > 0) {
+        console.log(`  ${C.success('OK')}  AI rules: ${rulesFound.join(', ')}`);
+        passes.push('rules');
+    }
+    else {
+        console.log(`  ${C.warn('--')}  No AGENTS.md or .cursorrules found`);
+        issues.push('rules');
+    }
+    // 10. MCP config
+    const mcp = checkMcpState(os.homedir());
+    if (mcp.done > 0) {
+        console.log(`  ${C.success('OK')}  MCP config: ${mcp.done}/${mcp.total} IDEs wired`);
+        passes.push('mcp');
+    }
+    else {
+        console.log(`  ${C.warn('--')}  No MCP configs found (run: cell mcp-config)`);
+        issues.push('mcp');
+    }
+    // 11. First-run state
+    const firstRunFile = path.join(os.homedir(), '.fivo', 'cell', '.first-run-shown');
+    const stateFile = path.join(os.homedir(), '.fivo', 'cell', 'cell-state.json');
+    if (fs.existsSync(stateFile)) {
+        try {
+            const state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+            console.log(`  ${C.success('OK')}  First-run state: setup at ${state.setup_completed || 'unknown'}`);
+            passes.push('first-run');
+        }
+        catch {
+            console.log(`  ${C.dim('--')}  First-run state file exists but unreadable`);
+        }
+    }
+    else if (fs.existsSync(firstRunFile)) {
+        console.log(`  ${C.success('OK')}  First-run greeting shown`);
+        passes.push('first-run');
+    }
+    else {
+        console.log(`  ${C.dim('--')}  First-run not completed yet`);
+        issues.push('first-run');
+    }
+    // ─── Summary ──────────────────────────────────────────────────────────
+    console.log();
+    const total = passes.length + issues.length;
+    if (issues.length === 0) {
+        console.log(C.success(`  All ${total} checks passed. Cell is fully healthy.`));
+    }
+    else {
+        console.log(C.warn(`  ${passes.length}/${total} checks passed, ${issues.length} need attention:`));
+        console.log();
+        const recovery = {
+            'cell-dir': 'cell scan',
+            'db': 'cell start',
+            'scan': 'cell scan',
+            'daemon': 'cell start',
+            'watcher': 'cell start  (then: cell watch start)',
+            'bridge': 'cell bridge start',
+            'rules': 'cell scan  (writes AGENTS.md + .cursorrules)',
+            'mcp': 'cell mcp-config',
+            'first-run': 'cell setup',
+            'git': 'git init',
+            'node': 'npm init -y',
+        };
+        for (const issue of issues) {
+            const fix = recovery[issue];
+            if (fix) {
+                console.log(`    ${C.warn('!')} ${issue}: Run ${C.primary(fix)}`);
+            }
+        }
+    }
+    console.log();
+    try {
+        const { markDoctorRun } = require('../setup/cell-state');
+        markDoctorRun();
+    }
+    catch { }
+}
+// Long-lived watcher daemon — auto-attaches to current project, runs forever.
+// Used by fivo-cell-daemon.bat to keep a watcher alive in the background.
+function runWatchDaemon(project, dir) {
+    const liveWatcher = require('../watcher/live-watcher');
+    const result = liveWatcher.startWatcher(project, dir);
+    if (!result.started) {
+        // "already running" means the daemon process already has a watcher; keep this process alive anyway
+        console.log(`  Watcher for ${project}: ${result.message}`);
+    }
+    else {
+        console.log(`  ✓ Watcher attached: ${result.message}`);
+    }
+    console.log(`  Watching ${dir} for changes. Press Ctrl+C to stop.`);
+    console.log();
+    // Keep the process alive — the file watcher uses fs.watch which keeps the event loop busy,
+    // but we add an explicit interval as a belt-and-braces guard against premature exit.
+    const keepAlive = setInterval(() => { }, 60_000);
+    process.on('SIGINT', () => {
+        clearInterval(keepAlive);
+        liveWatcher.stopWatcher(project);
+        console.log(`\n  Watcher stopped for ${project}.`);
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        clearInterval(keepAlive);
+        liveWatcher.stopWatcher(project);
+        process.exit(0);
+    });
+}
+// ─── cell community ─────────────────────────────────────────────────────────
+function doCommunity() {
+    console.log();
+    console.log(C.bold('  Cell Community'));
+    console.log(C.dim('  ──────────────'));
+    console.log();
+    const sub = args[1] || '';
+    if (sub === 'share') {
+        try {
+            const { sharePatterns } = require('../../05-community/stats/community-intel');
+            const result = sharePatterns();
+            console.log(result.success ? C.success(`  ${result.message}`) : C.warn(`  ${result.message}`));
+            console.log(C.dim('  Anonymous — only pattern types shared, zero code.'));
+        }
+        catch {
+            console.log(C.warn('  Share failed. Run cell scan first.'));
+        }
+        console.log();
+        return;
+    }
+    if (sub === 'browse' || sub === '') {
+        try {
+            const { generateCommunityReport } = require('../../05-community/stats/community-intel');
+            const report = generateCommunityReport();
+            if (report.patterns.length > 0) {
+                console.log(C.bold(`  📊 Top Patterns (${report.patterns.length} total):`));
+                for (const p of report.patterns.slice(0, 8)) {
+                    console.log(`    ${C.num(String(p.percentage))}% ${p.category}: ${p.description}`);
+                }
+                console.log();
+            }
+            if (report.benchmarks.length > 0) {
+                console.log(C.bold('  📈 Benchmarks:'));
+                for (const b of report.benchmarks) {
+                    console.log(`    ${b.metric}: ${C.num(String(b.percentile))}th percentile — ${b.interpretation}`);
+                }
+                console.log();
+            }
+            if (report.topStacks.length > 0) {
+                console.log(C.bold('  🏗️ Top Stacks:'));
+                for (const s of report.topStacks) {
+                    console.log(`    ${C.success('•')} ${s.stack} (${s.count}x)`);
+                }
+                console.log();
+            }
+            if (report.topBlindSpots.length > 0) {
+                console.log(C.bold('  ⚠️ Common Blind Spots:'));
+                for (const b of report.topBlindSpots) {
+                    console.log(`    ${C.warn('!')} ${b.blindSpot} (${b.percentage}%)`);
+                }
+                console.log();
+            }
+        }
+        catch {
+            console.log(C.dim('  No community data yet. Run: cell scan first.'));
+        }
+        return;
+    }
+    console.log('  Commands:');
+    console.log('    cell community browse   Browse community patterns & benchmarks');
+    console.log('    cell community share    Share patterns anonymously');
+    console.log();
+}
+// ─── cell context ───────────────────────────────────────────────────────────
+function doContext() {
+    const positionalArgs = args.slice(1).filter(a => !a.startsWith('--'));
+    const projectArg = positionalArgs[0] || project;
+    const toolArg = positionalArgs[1] || 'claude-code';
+    let showLive = true;
+    let asJson = false;
+    let port = null;
+    let host = '127.0.0.1';
+    let shortMode = false;
+    let fullMode = false;
+    for (let i = 2; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--no-live') {
+            showLive = false;
+            continue;
+        }
+        if (a === '--json') {
+            asJson = true;
+            continue;
+        }
+        if (a === '--short') {
+            shortMode = true;
+            continue;
+        }
+        if (a === '--full') {
+            fullMode = true;
+            continue;
+        }
+        if (typeof a === 'string' && a.startsWith('--port='))
+            port = parseInt(a.split('=')[1], 10) || null;
+        if (typeof a === 'string' && a.startsWith('--host='))
+            host = a.split('=')[1] || '127.0.0.1';
+    }
+    // Try to discover bridge port from pid file if not specified
+    if (port === null) {
+        try {
+            const { discoverBridgePort } = require('../watcher/socket-bridge');
+            const discovered = discoverBridgePort();
+            if (discovered)
+                port = discovered;
+        }
+        catch { /* ignore */ }
+    }
+    if (port === null)
+        port = 9877;
+    // Async wrapper to print live state then static context (in order).
+    const run = async () => {
+        let liveStates = [];
+        let liveError;
+        if (showLive) {
+            try {
+                const { queryBridgeEditorStates } = require('../watcher/socket-bridge');
+                const result = await queryBridgeEditorStates(projectArg, port, host);
+                liveStates = result.states;
+                liveError = result.error;
+            }
+            catch (e) {
+                liveError = e?.message || String(e);
+            }
+        }
+        if (asJson) {
+            let ctx;
+            try {
+                const { buildContext } = require('../../01-context/context/prompt-builder');
+                ctx = buildContext(projectArg, toolArg);
+            }
+            catch (e) {
+                console.log(JSON.stringify({ error: e?.message || String(e) }));
+                return;
+            }
+            console.log(JSON.stringify({
+                ...ctx,
+                liveEditorStates: liveStates,
+                liveError: liveError,
+            }, null, 2));
+            return;
+        }
+        // Print live state at top
+        if (showLive) {
+            if (liveStates.length > 0) {
+                console.log(C.bold('  ── Live Editor State (Feature #2) ──'));
+                for (const s of liveStates) {
+                    const dirtyMark = s.isDirty ? C.warn(' [unsaved]') : '';
+                    console.log(`  ${C.primary(s.editorName)}: ${s.filePath}:${s.line}:${s.column}${dirtyMark}`);
+                    if (s.language)
+                        console.log(C.dim(`    language: ${s.language}`));
+                    if (s.unsavedBuffer) {
+                        const allLines = s.unsavedBuffer.split('\n');
+                        const head = allLines.slice(0, 5);
+                        console.log(C.dim(`    unsaved (${s.unsavedLength || s.unsavedBuffer.length} chars):`));
+                        for (const line of head) {
+                            console.log(C.dim(`      ${line.length > 80 ? line.slice(0, 77) + '...' : line}`));
+                        }
+                        if (allLines.length > 5) {
+                            console.log(C.dim(`      ... ${allLines.length - 5} more lines`));
+                        }
+                    }
+                }
+                console.log('');
+            }
+            else if (liveError) {
+                console.log(C.dim('  ── Live Editor State ──'));
+                console.log(C.dim(`  Bridge not reachable (${liveError}). Start with: cell bridge start`));
+                console.log('');
+            }
+            else {
+                console.log(C.dim('  ── Live Editor State ──'));
+                console.log(C.dim(`  No editors connected for "${projectArg}"`));
+                console.log(C.dim('  Start an editor that pushes to the bridge (or run cell bridge status)'));
+                console.log('');
+            }
+        }
+        // Static project context
+        try {
+            const { buildContext, formatContextForTool } = require('../../01-context/context/prompt-builder');
+            const ctx = buildContext(projectArg, toolArg);
+            const text = formatContextForTool(ctx, toolArg, projectArg);
+            if (shortMode) {
+                const lines = text.split('\n');
+                const shortLines = [];
+                let inCore = false;
+                let coreCount = 0;
+                for (const line of lines) {
+                    if (line.startsWith('## ') || line.startsWith('# ')) {
+                        if (coreCount > 0)
+                            break;
+                        inCore = true;
+                    }
+                    if (inCore) {
+                        shortLines.push(line);
+                        if (line.trim() && !line.startsWith('#') && !line.startsWith('─'))
+                            coreCount++;
+                    }
+                }
+                if (shortLines.length === 0) {
+                    const first5 = lines.slice(0, 5);
+                    console.log(first5.join('\n'));
+                    console.log(C.dim(`  ... (${lines.length} total lines. Use --full to see all)`));
+                }
+                else {
+                    console.log(shortLines.join('\n'));
+                    console.log(C.dim(`  ... (${lines.length} total lines. Use --full or no flag for default)`));
+                }
+            }
+            else if (fullMode) {
+                console.log(text);
+            }
+            else {
+                console.log(text);
+            }
+            try {
+                const { markFirstContext } = require('../setup/cell-state');
+                markFirstContext();
+            }
+            catch { }
+            try {
+                const { captureCurrentBranchSnapshot } = require('../../03-knowledge/decisions/branch-snapshot');
+                captureCurrentBranchSnapshot(projectArg, process.cwd());
+            }
+            catch { }
+        }
+        catch (e) {
+            console.log(C.warn('  No context available yet.'));
+            console.log(C.dim('  Run these commands first:'));
+            console.log(C.primary('    cell scan'));
+            console.log(C.primary('    cell doctor'));
+        }
+    };
+    run();
+}
+// ─── cell replay — show full session timeline ──────────────────────────────
+function doReplay() {
+    // args[1] = project (optional, defaults to cwd)
+    // args[2] = sessionId (optional)
+    // --since <ISO>
+    // --until <ISO>
+    // --type file_save,cursor_move,...
+    // --file <path>
+    // --format text|json|markdown|compact
+    // --group minute|hour|file|type
+    // --limit <n>
+    // --recent <n>     (replay last N events, ignoring other filters)
+    // --summary        (just show session summary, no events)
+    // --last           (shorthand for --recent 50)
+    const projectArg = args[1] || project;
+    let sessionId;
+    let since;
+    let until;
+    let eventTypes;
+    let filePath;
+    let filePattern;
+    let format = 'text';
+    let groupBy = 'none';
+    let limit;
+    let recent;
+    let summaryOnly = false;
+    for (let i = 2; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--since' && i + 1 < args.length) {
+            since = args[++i];
+            continue;
+        }
+        if (a.startsWith('--since=')) {
+            since = a.slice('--since='.length);
+            continue;
+        }
+        if (a === '--until' && i + 1 < args.length) {
+            until = args[++i];
+            continue;
+        }
+        if (a.startsWith('--until=')) {
+            until = a.slice('--until='.length);
+            continue;
+        }
+        if (a === '--type' && i + 1 < args.length) {
+            eventTypes = args[++i].split(',');
+            continue;
+        }
+        if (a.startsWith('--type=')) {
+            eventTypes = a.slice('--type='.length).split(',');
+            continue;
+        }
+        if (a === '--file' && i + 1 < args.length) {
+            filePath = args[++i];
+            continue;
+        }
+        if (a.startsWith('--file=')) {
+            filePath = a.slice('--file='.length);
+            continue;
+        }
+        if (a === '--pattern' && i + 1 < args.length) {
+            filePattern = args[++i];
+            continue;
+        }
+        if (a.startsWith('--pattern=')) {
+            filePattern = a.slice('--pattern='.length);
+            continue;
+        }
+        if (a === '--format' && i + 1 < args.length) {
+            format = args[++i];
+            continue;
+        }
+        if (a.startsWith('--format=')) {
+            format = a.slice('--format='.length);
+            continue;
+        }
+        if (a === '--group' && i + 1 < args.length) {
+            groupBy = args[++i];
+            continue;
+        }
+        if (a.startsWith('--group=')) {
+            groupBy = a.slice('--group='.length);
+            continue;
+        }
+        if (a === '--limit' && i + 1 < args.length) {
+            limit = parseInt(args[++i], 10);
+            continue;
+        }
+        if (a.startsWith('--limit=')) {
+            limit = parseInt(a.slice('--limit='.length), 10);
+            continue;
+        }
+        if (a === '--recent' && i + 1 < args.length) {
+            recent = parseInt(args[++i], 10);
+            continue;
+        }
+        if (a.startsWith('--recent=')) {
+            recent = parseInt(a.slice('--recent='.length), 10);
+            continue;
+        }
+        if (a === '--last') {
+            recent = 50;
+            continue;
+        }
+        if (a === '--summary') {
+            summaryOnly = true;
+            continue;
+        }
+        if (a === '--session' && i + 1 < args.length) {
+            sessionId = parseInt(args[++i], 10);
+            continue;
+        }
+        if (a.startsWith('--session=')) {
+            sessionId = parseInt(a.slice('--session='.length), 10);
+            continue;
+        }
+        if (/^\d+$/.test(a) && sessionId === undefined) {
+            sessionId = parseInt(a, 10);
+            continue;
+        }
+    }
+    let result;
+    try {
+        const { replay, replayRecent, summarizeSession, renderSessionSummary } = require('../../01-context/sessions/replay');
+        if (recent !== undefined) {
+            result = replayRecent(projectArg, recent, format);
+        }
+        else {
+            result = replay({
+                project: projectArg,
+                sessionId,
+                eventTypes: eventTypes,
+                since,
+                until,
+                filePath,
+                filePattern,
+                limit,
+                format,
+                groupBy,
+            });
+        }
+        if (summaryOnly && sessionId !== undefined) {
+            const summary = summarizeSession(projectArg, sessionId);
+            if (!summary) {
+                console.log(C.warn(`  No session #${sessionId} found for project "${projectArg}".`));
+                return;
+            }
+            console.log(renderSessionSummary(summary));
+            return;
+        }
+        if (result.filteredCount === 0) {
+            console.log(C.warn(`  No${eventTypes ? ' ' + eventTypes.join(',') : ''} events to replay yet.`));
+            console.log(C.dim(`  Project: ${projectArg}`));
+            console.log(C.dim('  Start capturing by running:'));
+            console.log(C.primary('    cell scan'));
+            console.log(C.primary('    cell session start --tool claude-code'));
+            console.log(C.primary('    cell bridge start'));
+            return;
+        }
+        console.log(result.formatted);
+    }
+    catch (e) {
+        console.log(C.warn('  Replay failed: ' + (e?.message || String(e))));
+    }
+}
+// ─── cell continue — resume last session with full context ────────────────
+function doContinue() {
+    // args[1] = project (optional, defaults to cwd)
+    // args[2] = tool (optional, e.g. 'cursor', 'claude-code')
+    // --tool <name>    tool to format context for
+    // --no-snapshot    skip writing the session-end snapshot
+    const projectArg = args[1] || project;
+    let toolArg = args[2] || 'claude-code';
+    let writeSnapshot = true;
+    for (let i = 2; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--tool' && i + 1 < args.length) {
+            toolArg = args[++i];
+            continue;
+        }
+        if (a.startsWith('--tool=')) {
+            toolArg = a.slice('--tool='.length);
+            continue;
+        }
+        if (a === '--no-snapshot') {
+            writeSnapshot = false;
+            continue;
+        }
+    }
+    try {
+        const { SessionMemory } = require('../../01-context/sessions/session-memory');
+        const { linkSessionToRecentEvents, recordSessionStart, recordSessionEnd, recordFileFocus } = require('../../01-context/sessions/event-capture');
+        const { summarizeSession, renderSessionSummary } = require('../../01-context/sessions/replay');
+        const { buildContext, formatContextForTool } = require('../../01-context/context/prompt-builder');
+        const mem = new SessionMemory();
+        // 1) Find the last session for this project
+        const lastSession = mem.getLastSessionForProject(projectArg);
+        if (!lastSession) {
+            console.log(C.warn('  No previous session found for this project.'));
+            console.log(C.dim('  Start one with:'));
+            console.log(C.primary('    cell session start --tool claude-code'));
+            console.log(C.dim('  Then: cell continue  (resume anytime)'));
+            return;
+        }
+        // 2) Show summary of the last session
+        const summary = summarizeSession(projectArg, lastSession.id);
+        if (summary) {
+            console.log(C.bold('  ── Last Session ──'));
+            console.log(renderSessionSummary(summary));
+            console.log('');
+        }
+        // 3) Open a new session
+        const newSessionId = mem.startSession(toolArg, projectArg);
+        recordSessionStart({ project: projectArg, sessionId: newSessionId, toolName: toolArg });
+        const linked = linkSessionToRecentEvents(projectArg, newSessionId, true);
+        console.log(C.success(`  ✓ New session #${newSessionId} started in ${toolArg}`));
+        if (linked > 0) {
+            console.log(C.dim(`  Linked ${linked} recent events to this session`));
+        }
+        console.log('');
+        // 4) Build and show the cross-tool context block
+        try {
+            const ctx = buildContext(projectArg, toolArg);
+            const text = formatContextForTool(ctx, toolArg, projectArg);
+            console.log(C.bold('  ── Context to inject ──'));
+            console.log(text);
+        }
+        catch (e) {
+            console.log(C.warn('  Could not build context (run cell scan first).'));
+        }
+        // 5) Print session ID for later use with `cell replay --session <id>`
+        console.log('');
+        console.log(C.dim(`  To replay this session later: cell replay ${projectArg} ${newSessionId}`));
+        console.log(C.dim(`  To end this session: cell session end ${newSessionId} ${projectArg}`));
+    }
+    catch (e) {
+        console.log(C.warn('  Continue failed: ' + (e?.message || String(e))));
+    }
+}
+// ─── cell bridge — bidirectional editor↔daemon socket ────────────────────
+function doBridge() {
+    // args[1] = subcommand: start | stop | status | kill (default: status)
+    // --port <n>     port to bind (default 9877)
+    // --host <ip>    host to bind (default 127.0.0.1)
+    // --foreground   don't detach (default for tests/debug)
+    const sub = args[1] || 'status';
+    let port = 9877;
+    let host = '127.0.0.1';
+    for (let i = 2; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--port' && i + 1 < args.length) {
+            port = parseInt(args[++i], 10);
+            continue;
+        }
+        if (a.startsWith('--port=')) {
+            port = parseInt(a.slice('--port='.length), 10);
+            continue;
+        }
+        if (a === '--host' && i + 1 < args.length) {
+            host = args[++i];
+            continue;
+        }
+        if (a.startsWith('--host=')) {
+            host = a.slice('--host='.length);
+            continue;
+        }
+    }
+    try {
+        const { startBridge, stopBridge, getBridgeInfo, isBridgeRunning, killStaleBridge, discoverBridgePort, } = require('../watcher/socket-bridge');
+        if (sub === 'start') {
+            if (isBridgeRunning()) {
+                const info = getBridgeInfo();
+                console.log(C.warn(`  Bridge already running on port ${info.port} (${info.clientCount} clients, ${info.totalEventsReceived} events received)`));
+                return;
+            }
+            startBridge(port, host)
+                .then((info) => {
+                console.log(C.success(`  ✓ Bridge started on ${info.host}:${info.port}`));
+                console.log(C.dim(`  Editors can connect to ws://${info.host}:${info.port} (newline-delimited JSON)`));
+                console.log(C.dim(`  To stop: cell bridge stop`));
+                try {
+                    const { markBridgeStarted } = require('../setup/cell-state');
+                    markBridgeStarted();
+                }
+                catch { }
+            })
+                .catch((e) => {
+                console.log(C.warn('  Bridge start failed: ' + e.message));
+            });
+        }
+        else if (sub === 'stop') {
+            const ok = stopBridge();
+            if (ok) {
+                console.log(C.success('  ✓ Bridge stopped'));
+            }
+            else {
+                console.log(C.dim('  Bridge was not running'));
+            }
+        }
+        else if (sub === 'kill') {
+            const killed = killStaleBridge();
+            if (killed) {
+                console.log(C.success('  ✓ Killed stale bridge process'));
+            }
+            else {
+                console.log(C.dim('  No stale bridge found'));
+            }
+        }
+        else {
+            // status
+            const info = getBridgeInfo();
+            const discovered = discoverBridgePort();
+            const liveInfo = discovered && !info.running
+                ? { running: true, port: discovered, host: host, startedAt: C.dim('(another process)'), clientCount: -1, totalEventsReceived: -1, clients: [] }
+                : info;
+            const i = liveInfo;
+            console.log(C.bold('  Cell Bridge'));
+            console.log('  ───────────');
+            console.log(`  Running:    ${i.running ? C.success('yes') : C.dim('no')}`);
+            console.log(`  Port:       ${i.port}`);
+            console.log(`  Host:       ${i.host}`);
+            console.log(`  Started:    ${i.startedAt || C.dim('(never)')}`);
+            console.log(`  Clients:    ${i.clientCount >= 0 ? i.clientCount : '?'}`);
+            console.log(`  Events rx:  ${i.totalEventsReceived >= 0 ? i.totalEventsReceived : '?'}`);
+            if (i.clients && i.clients.length > 0) {
+                console.log('');
+                console.log(C.dim('  Connected clients:'));
+                for (const c of i.clients) {
+                    console.log(C.dim(`    #${c.id} ${c.remoteAddress}:${c.remotePort} project=${c.project} events=${c.eventsReceived}`));
+                }
+            }
+            if (!info.running) {
+                console.log('');
+                console.log(C.dim('  To start: cell bridge start [--port 9877] [--host 127.0.0.1]'));
+            }
+        }
+    }
+    catch (e) {
+        console.log(C.warn('  Bridge failed: ' + (e?.message || String(e))));
+    }
+}
+// ─── cell watch-editor (Feature #2: push active editor state to bridge) ────
+function monitorStatePath(project) {
+    const os = require('os');
+    const path = require('path');
+    const fs = require('fs');
+    const dir = path.join(os.tmpdir(), 'fivo-cell');
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    return path.join(dir, `watch-editor-${project}.json`);
+}
+function readMonitorState(project) {
+    const fs = require('fs');
+    const p = monitorStatePath(project);
+    try {
+        if (!fs.existsSync(p))
+            return null;
+        return JSON.parse(fs.readFileSync(p, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeMonitorState(project, data) {
+    const fs = require('fs');
+    try {
+        fs.writeFileSync(monitorStatePath(project), JSON.stringify(data, null, 2));
+    }
+    catch { /* ignore */ }
+}
+function clearMonitorState(project) {
+    const fs = require('fs');
+    try {
+        fs.unlinkSync(monitorStatePath(project));
+    }
+    catch { /* ignore */ }
+}
+function doWatchEditor() {
+    const sub = (args[1] || 'status').toString();
+    // Find --project=... flag, or fall back to positional args[2] or cwd basename
+    const projectFlag = args.find((a) => typeof a === 'string' && a.startsWith('--project='));
+    const project = projectFlag ? projectFlag.split('=')[1] : ((args[2] && !String(args[2]).startsWith('--')) ? String(args[2]) : path.basename(process.cwd()));
+    const intervalArg = args.find((a) => typeof a === 'string' && a.startsWith('--interval='));
+    const portArg = args.find((a) => typeof a === 'string' && a.startsWith('--port='));
+    const hostArg = args.find((a) => typeof a === 'string' && a.startsWith('--host='));
+    const interval = parseInt(intervalArg ? intervalArg.split('=')[1] : '3000', 10);
+    let port = portArg ? parseInt(portArg.split('=')[1], 10) : null;
+    const host = (hostArg ? hostArg.split('=')[1] : '127.0.0.1') || '127.0.0.1';
+    // Try to discover bridge port from pid file if not specified
+    if (port === null) {
+        try {
+            const { discoverBridgePort } = require('../watcher/socket-bridge');
+            const discovered = discoverBridgePort();
+            if (discovered)
+                port = discovered;
+        }
+        catch { /* ignore */ }
+    }
+    if (port === null)
+        port = 9877;
+    try {
+        const { EditorMonitor, getActiveWindow, parseTitleToState } = require('../watcher/editor-monitor');
+        if (sub === 'start') {
+            if (activeMonitor) {
+                console.log(C.warn('  Monitor already running in this process'));
+                return;
+            }
+            const prev = readMonitorState(project);
+            if (prev && prev.running) {
+                console.log(C.warn(`  Monitor for "${project}" already started at ${prev.startTime}`));
+                console.log(C.dim('  Use `cell watch-editor stop --project ' + project + '` first'));
+                return;
+            }
+            const monitor = new EditorMonitor({
+                project,
+                intervalMs: interval,
+                bridgeHost: host,
+                bridgePort: port,
+                fileBaseDir: process.cwd(),
+                watchFiles: true,
+                onState: (s) => {
+                    if (process.env.CELL_VERBOSE) {
+                        console.log(C.dim(`  [${new Date().toISOString()}] ${s.editorName}: ${s.filePath} [${s.isDirty ? 'unsaved' : 'clean'}]`));
+                    }
+                },
+                onError: (e) => {
+                    if (process.env.CELL_VERBOSE)
+                        console.error(C.warn('  ' + e.message));
+                },
+                onSkip: (reason) => {
+                    if (process.env.CELL_VERBOSE)
+                        console.log(C.dim('  skip: ' + reason));
+                },
+            });
+            monitor.start();
+            activeMonitor = monitor;
+            monitorStateFile = project;
+            writeMonitorState(project, { running: true, startTime: new Date().toISOString(), pid: process.pid, project, port, host, interval });
+            console.log(C.success(`  Watch-editor started for project "${project}"`));
+            console.log(C.dim(`  Bridge: ${host}:${port}  |  Interval: ${interval}ms`));
+            console.log(C.dim('  State will appear in `cell context ' + project + '`'));
+            console.log(C.dim('  Press Ctrl+C to stop'));
+            // Keep the process alive
+            process.on('SIGINT', () => {
+                console.log(C.dim('\n  Stopping watch-editor...'));
+                if (activeMonitor)
+                    activeMonitor.stop();
+                clearMonitorState(project);
+                process.exit(0);
+            });
+            process.on('SIGTERM', () => {
+                if (activeMonitor)
+                    activeMonitor.stop();
+                clearMonitorState(project);
+                process.exit(0);
+            });
+        }
+        else if (sub === 'stop') {
+            if (activeMonitor) {
+                activeMonitor.stop();
+                activeMonitor = null;
+            }
+            clearMonitorState(project);
+            console.log(C.success(`  Watch-editor stopped for "${project}"`));
+        }
+        else if (sub === 'status') {
+            const local = activeMonitor ? activeMonitor.getInfo() : null;
+            const saved = readMonitorState(project);
+            if (local) {
+                console.log(C.bold(`  Watch-editor (in-process) — ${project}`));
+                console.log(`  Running:    ${C.success('yes')}`);
+                console.log(`  Started:    ${local.startTime}`);
+                console.log(`  Polls:      ${local.pollsCompleted}`);
+                console.log(`  Detected:   ${local.statesDetected}`);
+                console.log(`  Pushed:     ${local.statesPushed}`);
+                console.log(`  Bridge:     ${local.bridgeConnected ? C.success('connected') : C.warn('not connected')}`);
+                if (local.lastState) {
+                    console.log(`  Last:       ${local.lastState.editorName} → ${local.lastState.filePath}${local.lastState.isDirty ? ' [unsaved]' : ''}`);
+                }
+            }
+            else if (saved) {
+                console.log(C.bold(`  Watch-editor (saved state) — ${project}`));
+                console.log(`  Started:    ${saved.startTime}`);
+                console.log(`  PID:        ${saved.pid}${saved.pid && !isPidAlive(saved.pid) ? C.warn(' (not running)') : ''}`);
+                console.log(`  Bridge:     ${saved.host}:${saved.port}`);
+                console.log(`  Interval:   ${saved.interval}ms`);
+            }
+            else {
+                console.log(C.dim(`  No watch-editor session for "${project}"`));
+                console.log(C.dim('  Start with: cell watch-editor start --project ' + project));
+            }
+        }
+        else if (sub === 'check') {
+            // One-shot check — useful for testing
+            getActiveWindow().then((win) => {
+                if (!win) {
+                    console.log(C.dim('  No active window detected'));
+                    return;
+                }
+                console.log(`  Active: ${win.processName} (PID ${win.pid})`);
+                console.log(`  Title:  ${win.title}`);
+                const state = parseTitleToState(win.title, win.processName, project, process.cwd());
+                if (state) {
+                    console.log(C.success('  Parsed:'));
+                    console.log(`    editor:  ${state.editorName}`);
+                    console.log(`    file:    ${state.filePath}`);
+                    console.log(`    line:    ${state.line}`);
+                    console.log(`    dirty:   ${state.isDirty}`);
+                    console.log(`    lang:    ${state.language || 'unknown'}`);
+                }
+                else {
+                    console.log(C.warn('  Could not parse title into editor state'));
+                }
+            });
+        }
+        else {
+            console.log(C.dim('  Usage: cell watch-editor <start|stop|status|check> [--project NAME] [--interval 3000] [--port 9877] [--host 127.0.0.1]'));
+        }
+    }
+    catch (e) {
+        console.log(C.warn('  watch-editor failed: ' + (e?.message || String(e))));
+    }
+}
+// ─── cell mcp-config (Pre-Launch: auto-register all IDEs) ────────────────────
+/**
+ * Auto-write MCP config for every supported IDE. Detects which config files
+ * exist and creates/updates the cell MCP entry in each.
+ *
+ * Supported IDEs:
+ *   - Cursor:        ~/.cursor/mcp.json
+ *   - Gemini CLI:    ~/.gemini/settings.json
+ *   - Antigravity:   ~/.gemini/config/mcp_config.json
+ *   - Codex:         ~/.codex/config.json
+ *   - OpenCode:      ~/.config/opencode/opencode.jsonc
+ */
+function doMcpConfig() {
+    console.log();
+    console.log(C.bold('  Cell MCP Auto-Config'));
+    console.log(C.dim('  ─────────────────────'));
+    console.log();
+    const { writeMcpConfig, getMcpTargets } = require('../../../core/mcp-config');
+    const homedir = os.homedir();
+    const targets = getMcpTargets(homedir);
+    const result = writeMcpConfig(homedir);
+    for (const t of targets) {
+        if (result.written.includes(t.configPath)) {
+            const action = fs.existsSync(t.configPath) ? 'updated' : 'created';
+            console.log(`  ${C.success('✓')} ${t.name.padEnd(14)} ${C.dim(action)} — ${t.configPath}`);
+        }
+    }
+    for (const s of result.skipped) {
+        console.log(`  ${C.warn('!')} ${s.name}: ${s.reason}`);
+    }
+    console.log();
+    console.log(`  ${C.success('Done')}: ${result.written.length} config file${result.written.length === 1 ? '' : 's'} written`);
+    if (result.skipped.length > 0)
+        console.log(C.dim(`  ${result.skipped.length} skipped (parse errors)`));
+    console.log();
+    console.log(C.dim('  Restart your IDE to load the new MCP config.'));
+    console.log(C.dim('  Make sure `cell start` is running for tools to connect.'));
+    console.log();
+}
+// ─── cell repl (interactive mode with tab completion) ────────────────────────
+/**
+ * Interactive REPL — opened by `cell` (no args) in a TTY, or by `cell repl`.
+ * User types a command (with or without leading `/`), press Enter to run.
+ * Type `/` then Tab to see all commands. Type `exit`/`quit` to leave.
+ *
+ * Tab completion: when the input starts with `/`, returns matching commands.
+ * Otherwise no completion (user is typing a command name without prefix).
+ */
+function showReplHelp() {
+    console.log();
+    console.log(C.bold('  Commands:'));
+    console.log(C.dim('  ────────'));
+    for (const [name, desc] of cli_repl_1.REPL_COMMANDS) {
+        const padded = name.padEnd(14);
+        console.log(`    ${C.primary('/' + padded)} ${C.dim(desc)}`);
+    }
+    console.log();
+    console.log(C.dim('  Type a command and press Enter. Use /<TAB> to filter.'));
+    console.log(C.dim('  Tab completion works after `/` — try typing `/s` then Tab.'));
+    console.log();
+}
+function doRepl() {
+    // Only run if stdin is a TTY. If piped (e.g. `echo help | cell`), fall back to status.
+    if (!process.stdin.isTTY) {
+        doStatus();
+        return;
+    }
+    const readline = require('readline');
+    const { spawn } = require('child_process');
+    const pathMod = require('path');
+    // Show banner
+    console.log();
+    const banner = figlet_1.default.textSync('CELL', { font: 'ANSI Shadow', horizontalLayout: 'fitted' });
+    console.log((0, gradient_string_1.default)(['#FF6B35', '#FFAB91'])(banner));
+    console.log(C.dim('  Interactive REPL — type a command, / for list, exit to quit'));
+    console.log();
+    // First-run greeting
+    try {
+        const { firstRunGreeting } = require('../setup/first-run');
+        firstRunGreeting();
+    }
+    catch { }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: C.primary('cell> '),
+        completer: cli_repl_1.replCompleter,
+        terminal: true,
+    });
+    // Track command history
+    const historyFile = pathMod.join(os.homedir(), '.fivo', 'cell', 'repl_history');
+    try {
+        const fsMod = require('fs');
+        if (fsMod.existsSync(historyFile)) {
+            const lines = fsMod.readFileSync(historyFile, 'utf8').split('\n').filter(Boolean);
+            // readline.history is an array; pushing to it adds to up-arrow memory
+            for (const l of lines)
+                rl.history.push(l);
+        }
+    }
+    catch { }
+    const persistHistory = () => {
+        try {
+            const fsMod = require('fs');
+            const pathMod2 = require('path');
+            fsMod.mkdirSync(pathMod2.dirname(historyFile), { recursive: true });
+            // Keep last 100 commands
+            const recent = rl.history.slice(-100);
+            fsMod.writeFileSync(historyFile, recent.join('\n') + '\n', 'utf8');
+        }
+        catch { }
+    };
+    rl.prompt();
+    rl.on('line', (line) => {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            rl.prompt();
+            return;
+        }
+        // Handle exit
+        if (trimmed === 'exit' || trimmed === 'quit' || trimmed === 'q') {
+            persistHistory();
+            console.log(C.dim('  Bye!'));
+            rl.close();
+            return;
+        }
+        // Strip leading `/` if present
+        const cmd = (0, cli_repl_1.stripSlash)(trimmed);
+        // In-REPL help (no spawn overhead)
+        if (cmd === 'help' || cmd === '?') {
+            showReplHelp();
+            rl.prompt();
+            return;
+        }
+        // In-REPL version (avoid child spawn for trivial info)
+        if (cmd === 'version' || cmd === '--version' || cmd === '-v') {
+            try {
+                const pkg = require('../../../../package.json');
+                console.log(`${C.primary('cell')} v${C.num(pkg.version)}`);
+            }
+            catch { }
+            rl.prompt();
+            return;
+        }
+        // Validate the command is known (so typos get a hint instead of a silent no-op)
+        const firstToken = cmd.split(/\s+/)[0];
+        if (!(0, cli_repl_1.isKnownCommand)(firstToken)) {
+            console.log(C.warn(`  Unknown command: ${firstToken}`));
+            console.log(C.dim('  Type `help` for the list, or `/` then Tab.'));
+            console.log();
+            rl.prompt();
+            return;
+        }
+        // Spawn cell <cmd> as child process (shares stdio so output is real-time)
+        const cellPath = pathMod.join(__dirname, 'cli.js');
+        const childArgs = cmd.split(/\s+/);
+        const child = spawn(process.execPath, [cellPath, ...childArgs], {
+            stdio: 'inherit',
+        });
+        child.on('exit', (code) => {
+            if (code !== 0 && code !== null) {
+                console.log(C.dim(`  (exit ${code})`));
+            }
+            console.log();
+            rl.prompt();
+        });
+        child.on('error', (err) => {
+            console.log(C.warn(`  Failed to run command: ${err.message}`));
+            console.log();
+            rl.prompt();
+        });
+    });
+    rl.on('close', () => {
+        persistHistory();
+        console.log();
+        process.exit(0);
+    });
+}
+// ─── cell switch-back ──────────────────────────────────────────────────────
+function doSwitchBack() {
+    const switchArgs = process.argv.slice(3);
+    const branch = switchArgs[0];
+    if (!branch) {
+        console.log();
+        console.log(C.bold('  Branch Context Recovery'));
+        console.log(C.dim('  ──────────────────────'));
+        console.log();
+        console.log('  Usage: cell switch-back <branch-name>');
+        console.log();
+        console.log('  Shows saved context for a branch (goal, files, errors, decisions).');
+        console.log();
+        console.log('  Examples:');
+        console.log('    cell switch-back feature-auth');
+        console.log('    cell switch-back fix/login-bug');
+        console.log();
+        return;
+    }
+    console.log();
+    console.log(C.bold(`  Branch: ${branch}`));
+    console.log(C.dim('  ──────────────────────'));
+    console.log();
+    let project = path.basename(process.cwd());
+    try {
+        const { detectProject } = require('../setup/setup');
+        const detected = detectProject(process.cwd());
+        project = detected.name;
+    }
+    catch { }
+    // Try real saved context first
+    try {
+        const { loadBranchSnapshot } = require('../../03-knowledge/decisions/branch-snapshot');
+        const snapshot = loadBranchSnapshot(project, branch);
+        if (snapshot) {
+            if (snapshot.goal)
+                console.log(`  Goal:     ${C.primary(snapshot.goal)}`);
+            if (snapshot.filesTouched && snapshot.filesTouched.length > 0) {
+                console.log(`  Files:    ${C.num(String(snapshot.filesTouched.length))} touched`);
+                for (const f of snapshot.filesTouched.slice(0, 8)) {
+                    console.log(C.dim(`    - ${f}`));
+                }
+                if (snapshot.filesTouched.length > 8) {
+                    console.log(C.dim(`    ... ${snapshot.filesTouched.length - 8} more`));
+                }
+            }
+            if (snapshot.pendingTasks && snapshot.pendingTasks.length > 0) {
+                console.log(`  Pending:  ${snapshot.pendingTasks.length} task(s)`);
+                for (const t of snapshot.pendingTasks.slice(0, 5)) {
+                    console.log(C.warn(`    ! ${t}`));
+                }
+            }
+            if (snapshot.recentErrors && snapshot.recentErrors.length > 0) {
+                console.log(`  Errors:   ${snapshot.recentErrors.length} recent`);
+                for (const e of snapshot.recentErrors.slice(0, 3)) {
+                    console.log(C.warn(`    x ${e}`));
+                }
+            }
+            if (snapshot.recentDecisions && snapshot.recentDecisions.length > 0) {
+                console.log(`  Recent commits:`);
+                for (const d of snapshot.recentDecisions.slice(0, 5)) {
+                    console.log(C.dim(`    - ${d}`));
+                }
+            }
+            if (snapshot.lastActiveAt) {
+                console.log(C.dim(`  Last active: ${snapshot.lastActiveAt}`));
+            }
+            console.log();
+            console.log(C.dim('  Restore context:'));
+            console.log('    1. git checkout ' + branch);
+            console.log('    2. cell context');
+            console.log();
+            return;
+        }
+    }
+    catch { }
+    // Fallback to name parser
+    const { GitBranchPreGenerator } = require('../../03-knowledge/decisions/git-branch-pregenerator');
+    const gen = new GitBranchPreGenerator();
+    const summary = gen.getIntentSummary(branch);
+    const parsed = gen.parseBranchName(branch);
+    console.log(C.dim('  (No saved context for this branch — showing inferred intent)'));
+    console.log();
+    console.log(`  Type: ${C.primary(parsed.type)}`);
+    console.log(`  Intent: ${parsed.intent}`);
+    console.log(`  Summary: ${summary}`);
+    console.log();
+    const patterns = gen.generateFiles(branch, [], 'typescript');
+    if (patterns.length > 0) {
+        console.log(C.dim('  Expected files:'));
+        for (const f of patterns) {
+            console.log(`    ${C.primary(f.path)} (${f.type})`);
+        }
+        console.log();
+    }
+    console.log(C.dim('  Save real context by running:'));
+    console.log(C.primary('    cell scan'));
+    console.log(C.primary('    cell context'));
+    console.log();
+    console.log(C.dim('  Restore context:'));
+    console.log('    1. git checkout ' + branch);
+    console.log('    2. cell context');
+    console.log();
+}
+// ─── cell branches ──────────────────────────────────────────────────────────
+function doBranches() {
+    console.log();
+    console.log(C.bold('  Known Branches'));
+    console.log(C.dim('  ──────────────'));
+    console.log();
+    let project = path.basename(process.cwd());
+    try {
+        const { detectProject } = require('../setup/setup');
+        const detected = detectProject(process.cwd());
+        project = detected.name;
+    }
+    catch { }
+    try {
+        const { listBranchSnapshots } = require('../../03-knowledge/decisions/branch-snapshot');
+        const snapshots = listBranchSnapshots(project);
+        if (snapshots.length === 0) {
+            console.log(C.dim('  No branch context saved yet.'));
+            console.log();
+            console.log(C.dim('  Save context by running cell scan or cell context on a branch.'));
+            console.log();
+            return;
+        }
+        for (const s of snapshots) {
+            const active = s.lastActiveAt ? s.lastActiveAt.slice(0, 10) : 'unknown';
+            const goalStr = s.goal ? ` — ${s.goal}` : '';
+            const fileCount = s.filesTouched?.length || 0;
+            console.log(`  ${C.primary(s.branch)}${goalStr}`);
+            console.log(C.dim(`    Last active: ${active} | Files: ${fileCount} | Commits: ${s.recentDecisions?.length || 0}`));
+        }
+        console.log();
+        console.log(C.dim(`  ${snapshots.length} branch(es) tracked. Run cell switch-back <branch> for details.`));
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(C.warn(`  Branch list failed: ${msg}`));
+    }
+    // Also show git branches
+    try {
+        const { execSync } = require('child_process');
+        const gitBranches = execSync('git branch --list', { encoding: 'utf8' }).trim();
+        if (gitBranches) {
+            console.log();
+            console.log(C.dim('  Git branches:'));
+            for (const line of gitBranches.split('\n').filter(Boolean)) {
+                console.log(C.dim(`    ${line}`));
+            }
+        }
+    }
+    catch { }
+    console.log();
+}
+// ─── cell lessons ──────────────────────────────────────────────────────────
+function doLessons() {
+    const { getAvoidSuggestions, getFailureStats, getAllFailureRecords } = require('../../03-knowledge/decisions/failure-memory');
+    const lessonArgs = process.argv.slice(3);
+    const topic = lessonArgs[0];
+    let lessonProject = project;
+    try {
+        const { detectProject } = require('../setup/setup');
+        lessonProject = detectProject().name;
+    }
+    catch { }
+    console.log();
+    console.log(C.bold('  Engineering Lessons'));
+    console.log(C.dim('  ──────────────────'));
+    console.log();
+    const stats = getFailureStats(lessonProject);
+    if (stats.totalTracked === 0) {
+        console.log(C.warn('  No lessons recorded yet.'));
+        console.log();
+        console.log(C.dim('  Lessons are learned from pattern rejections during:'));
+        console.log(C.dim('    - AI code suggestions'));
+        console.log(C.dim('    - Code review feedback'));
+        console.log(C.dim('    - Scanner repeat issues'));
+        console.log();
+        console.log(C.dim('  Start collecting:'));
+        console.log(C.primary('    cell scan'));
+        console.log(C.primary('    cell blindspots --top'));
+        return;
+    }
+    console.log(`  Tracked: ${stats.totalTracked} patterns`);
+    console.log(`  Critical: ${stats.criticalCount} | High: ${stats.highCount} | Medium: ${stats.mediumCount} | Low: ${stats.lowCount}`);
+    console.log(`  Avg failure rate: ${Math.round(stats.avgFailureRate * 100)}%`);
+    console.log();
+    const suggestions = getAvoidSuggestions(0.5, lessonProject);
+    if (topic) {
+        const filtered = suggestions.filter((s) => s.description.toLowerCase().includes(topic.toLowerCase()) ||
+            s.patternId.toLowerCase().includes(topic.toLowerCase()));
+        if (filtered.length === 0) {
+            console.log(`  No lessons found for "${topic}".`);
+        }
+        else {
+            console.log(C.bold(`  Lessons for "${topic}":`));
+            console.log();
+            for (const s of filtered.slice(0, 10)) {
+                const icon = s.severity === 'critical' ? '!!!' : s.severity === 'high' ? '!!' : s.severity === 'medium' ? '!' : '-';
+                console.log(`  ${C.warn(icon)} ${s.description}`);
+                console.log(`     Failure rate: ${Math.round(s.failureRate * 100)}% (${s.severity})`);
+                console.log(`     ${s.alternativeDescription}`);
+                console.log();
+            }
+        }
+    }
+    else {
+        if (suggestions.length === 0) {
+            console.log('  No lessons to show yet. Keep building!');
+        }
+        else {
+            console.log(C.bold('  Top lessons (patterns to avoid):'));
+            console.log();
+            for (const s of suggestions.slice(0, 10)) {
+                const icon = s.severity === 'critical' ? '!!!' : s.severity === 'high' ? '!!' : s.severity === 'medium' ? '!' : '-';
+                console.log(`  ${C.warn(icon)} ${s.description}`);
+                console.log(`     Failure rate: ${Math.round(s.failureRate * 100)}% (${s.severity})`);
+                console.log(`     ${s.alternativeDescription}`);
+                console.log();
+            }
+        }
+    }
+    console.log(C.dim('  Use: cell lessons <topic>  to filter by topic'));
+    console.log();
+}
+// ─── cell evolution ────────────────────────────────────────────────────────
+function doEvolution() {
+    const { buildJourneyReport, saveJourneyReport } = require('../../03-knowledge/decisions/journey-memory');
+    const evoArgs = process.argv.slice(3);
+    const dir = evoArgs[0] || process.cwd();
+    const showStack = evoArgs.includes('--stack');
+    let evoProject = project;
+    try {
+        const { detectProject } = require('../setup/setup');
+        evoProject = detectProject(dir).name;
+    }
+    catch {
+        try {
+            const pkgPath = require('path').join(dir, 'package.json');
+            const pkg = JSON.parse(require('fs').readFileSync(pkgPath, 'utf-8'));
+            if (pkg.name)
+                evoProject = pkg.name;
+        }
+        catch { }
+    }
+    console.log();
+    console.log(C.bold('  Project Evolution Map'));
+    console.log(C.dim('  ────────────────────'));
+    console.log();
+    if (showStack) {
+        try {
+            const rows = (0, database_1.getDb)().prepare(`SELECT stack_json, file_count, line_count, scanned_at FROM stack_history WHERE LOWER(project) = LOWER(?) ORDER BY scanned_at ASC`).all(evoProject);
+            if (rows.length === 0) {
+                console.log(C.dim('  No stack history yet. Run: cell scan'));
+            }
+            else {
+                console.log(C.bold('  Stack Timeline:'));
+                console.log();
+                let prevStack = '';
+                for (const row of rows) {
+                    const date = String(row.scanned_at).slice(0, 10);
+                    let langs = {};
+                    try {
+                        langs = JSON.parse(String(row.stack_json));
+                    }
+                    catch { }
+                    const langList = Object.entries(langs).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([l, c]) => `${l}(${c})`).join(', ');
+                    const currentStack = Object.keys(langs).sort().join(',');
+                    const changed = prevStack && prevStack !== currentStack;
+                    const marker = changed ? C.warn('CHANGED') : C.dim('same');
+                    console.log(`  ${date}  ${langList || 'unknown'}  ${row.file_count} files  ${row.line_count} lines  ${marker}`);
+                    prevStack = currentStack;
+                }
+            }
+        }
+        catch (e) {
+            console.log(C.warn(`  Stack history failed: ${e?.message || String(e)}`));
+        }
+        console.log();
+        return;
+    }
+    console.log('  Building journey report...');
+    try {
+        const report = buildJourneyReport(dir);
+        const savedPath = saveJourneyReport(report);
+        console.log();
+        console.log(C.bold('  Summary'));
+        console.log(`  Projects: ${report.summary.totalProjects}`);
+        console.log(`  Active since: ${report.summary.activeSince}`);
+        console.log(`  Languages: ${report.summary.languagesLearned}`);
+        console.log(`  Total commits: ${report.summary.totalCommits}`);
+        console.log(`  Top language: ${report.summary.mostUsedLanguage}`);
+        console.log(`  Top skill: ${report.summary.topSkill}`);
+        console.log(`  Growth: ${report.summary.growthRate}`);
+        console.log();
+        if (report.skills.length > 0) {
+            console.log(C.bold('  Skill Progression'));
+            console.log();
+            for (const s of report.skills.slice(0, 8)) {
+                const bar = '█'.repeat(Math.min(s.metrics.cleanFileRatio / 10, 10));
+                console.log(`  ${s.area.padEnd(15)} ${s.currentLevel.padEnd(14)} ${bar} ${s.metrics.cleanFileRatio}% clean`);
+            }
+            console.log();
+        }
+        if (report.chains.length > 0) {
+            console.log(C.bold('  Reused Patterns'));
+            console.log();
+            for (const c of report.chains.slice(0, 5)) {
+                console.log(`  ${c.pattern} (${Math.round(c.successRate * 100)}% success)`);
+                console.log(`    Used in: ${c.firstUsed.project}${c.reusedIn.length > 0 ? ', ' + c.reusedIn.map((r) => r.project).join(', ') : ''}`);
+            }
+            console.log();
+        }
+        if (report.goals.recommendations.length > 0) {
+            console.log(C.bold('  Recommendations'));
+            console.log();
+            for (const rec of report.goals.recommendations.slice(0, 5)) {
+                console.log(`  -> ${rec}`);
+            }
+            console.log();
+        }
+        console.log(C.dim(`  Full report: ${savedPath}`));
+        console.log(C.dim('  Also saved as: ~/.fivo/cell/journey.md'));
+        console.log();
+    }
+    catch (e) {
+        console.log(C.warn(`  Failed to build evolution map: ${e instanceof Error ? e.message : String(e)}`));
+        console.log();
+    }
+}
+// ─── cell help ──────────────────────────────────────────────────────────────
+function doHelp() {
+    console.log();
+    console.log(C.bold('  Cell Commands'));
+    console.log(C.dim('  ─────────────'));
+    console.log();
+    console.log(`  ${C.primary('cell start')}       Start daemon + MCP (port 9876) — re-run safe`);
+    console.log(`  ${C.primary('cell stop')}        Stop daemon`);
+    console.log(`  ${C.primary('cell setup')}       One-time project setup: scan + watcher + MCP (idempotent)`);
+    console.log(`  ${C.primary('cell doctor')}      Health check — diagnose what's missing and how to fix`);
+    console.log(`  ${C.primary('cell --version')}   Print version + daemon status`);
+    console.log(`  ${C.primary('cell mcp-config')}  Auto-register cell MCP in Cursor/Antigravity/Codex/OpenCode`);
+    console.log(`  ${C.primary('cell scan')}        Scan codebase + build layers`);
+    console.log(`  ${C.primary('cell analyze')}     AI prompts from scan data`);
+    console.log(`  ${C.primary('cell status')}      What Cell knows about you`);
+    console.log(`  ${C.primary('cell status --session')}  Last touched file + patterns (Pre-Launch Test 1)`);
+    console.log(`  ${C.primary('cell status --decisions')}  Recent decisions with verdict (Pre-Launch Test 3)`);
+    console.log(`  ${C.primary('cell session')}     Same as cell status --session`);
+    console.log(`  ${C.primary('cell decisions')}   Same as cell status --decisions`);
+    console.log(`  ${C.primary('cell team')}        Team collaboration (git-based)`);
+    console.log(`  ${C.primary('cell community')}   Community patterns + benchmarks`);
+    console.log(`  ${C.primary('cell watch [start|stop|events|check|status] [proj] [dir]')}  Live file watcher`);
+    console.log(`  ${C.primary('cell watch daemon [proj] [dir]')}  Run as long-lived watcher (for .bat)`);
+    console.log(`  ${C.primary('cell blindspots [dir] [maxFiles]')}  Scan for blind spots (15+ types)`);
+    console.log(`  ${C.primary('cell blindspots --top [N]')}          Show top N prioritized fixes (default 5)`);
+    console.log(`  ${C.primary('cell context [project] [tool] [--short|--full]')}  Inject @cell context block`);
+    console.log(`  ${C.primary('cell switch-back <branch>')}  Restore branch context`);
+    console.log(`  ${C.primary('cell branches')}         List known branches with last context`);
+    console.log(`  ${C.primary('cell lessons [topic]')}  Engineering lessons from failures`);
+    console.log(`  ${C.primary('cell evolution [dir] [--stack]')}  Project evolution map + stack timeline`);
+    console.log(`  ${C.primary('cell focus [dir]')}     Focus report — active/stalled/abandoned projects`);
+    console.log(`  ${C.primary('cell why <topic>')}     Search decisions by topic`);
+    console.log(`  ${C.primary('cell repl')}        Interactive REPL with / completion (or just run \`cell\` in a TTY)`);
+    console.log(`  ${C.primary('cell help')}        Show this help`);
+    console.log();
+    console.log(C.dim('  Install: npm i -g fivocell'));
+    console.log(C.dim('  Then: cell start'));
+    console.log();
+}
+// ─── cell focus ────────────────────────────────────────────────────────────
+function doFocus() {
+    const { buildFocusReport, renderFocusMd } = require('../../03-knowledge/decisions/focus-report');
+    const focusArgs = process.argv.slice(3);
+    const rootDir = focusArgs[0] || path.dirname(process.cwd());
+    const asJson = focusArgs.includes('--json');
+    console.log();
+    console.log(C.bold('  Focus Report — Project Activity'));
+    console.log(C.dim('  ───────────────────────────────'));
+    console.log();
+    try {
+        const report = buildFocusReport(rootDir);
+        if (asJson) {
+            console.log(JSON.stringify(report, null, 2));
+            return;
+        }
+        console.log(`  Total: ${report.totalProjects} projects`);
+        console.log(`  Active: ${C.success(String(report.active))} | Stalled: ${C.warn(String(report.stalled))} | Abandoned: ${C.primary(String(report.abandoned))} | Fresh: ${report.fresh}`);
+        console.log();
+        if (report.topPicks.length > 0) {
+            console.log(C.bold('  Keep doing this:'));
+            for (const p of report.topPicks) {
+                console.log(`  ${C.success('>>')} ${p.name} — ${p.reason}`);
+            }
+            console.log();
+        }
+        if (report.shouldPause.length > 0) {
+            console.log(C.bold('  Pause / Decide:'));
+            for (const p of report.shouldPause) {
+                console.log(`  ${C.warn('??')} ${p.name} (${p.lastModifiedDays}d silent) — ${p.reason}`);
+            }
+            console.log();
+        }
+        if (report.shouldArchive.length > 0) {
+            console.log(C.bold('  Archive:'));
+            for (const p of report.shouldArchive) {
+                console.log(`  ${C.dim('..')} ${p.name} (${p.lastModifiedDays}d silent) — ${p.reason}`);
+            }
+            console.log();
+        }
+        if (report.shouldResurrect.length > 0) {
+            console.log(C.bold('  Resurrect:'));
+            for (const p of report.shouldResurrect) {
+                console.log(`  ${C.primary('!!')} ${p.name} (${p.lastModifiedDays}d silent) — ${p.reason}`);
+            }
+            console.log();
+        }
+        if (report.overallAdvice.length > 0) {
+            console.log(C.bold('  Advice:'));
+            for (const a of report.overallAdvice) {
+                console.log(`  ${C.dim('>')} ${a}`);
+            }
+        }
+    }
+    catch (e) {
+        console.log(C.warn(`  Focus report failed: ${e?.message || String(e)}`));
+        console.log(C.dim('  Tip: run from a parent directory containing multiple projects'));
+    }
+    console.log();
+}
+// ─── cell why <topic> ──────────────────────────────────────────────────────
+function doWhy() {
+    const whyArgs = process.argv.slice(3);
+    const topic = whyArgs[0];
+    if (!topic) {
+        console.log();
+        console.log(C.bold('  Cell Why — Decision Search'));
+        console.log(C.dim('  ───────────────────────────'));
+        console.log();
+        console.log(C.dim('  Usage: cell why <topic>'));
+        console.log(C.dim('  Example: cell why typescript'));
+        console.log(C.dim('  Example: cell why testing'));
+        console.log();
+        return;
+    }
+    const db = (0, database_1.getDb)();
+    console.log();
+    console.log(C.bold(`  Why — Decisions about "${topic}"`));
+    console.log(C.dim('  ─────────────────────────────'));
+    console.log();
+    const likeTopic = `%${topic}%`;
+    try {
+        const decisionRows = db.prepare(`
+      SELECT technology, reason, outcome, was_right, project, created_at
+      FROM decisions
+      WHERE technology LIKE ? OR reason LIKE ? OR outcome LIKE ?
+      ORDER BY created_at DESC LIMIT 10
+    `).all(likeTopic, likeTopic, likeTopic);
+        const decisionOutcomeRows = db.prepare(`
+      SELECT technology, reason, outcome, was_right, confidence, context, project, created_at
+      FROM decision_outcomes
+      WHERE technology LIKE ? OR reason LIKE ? OR outcome LIKE ? OR context LIKE ?
+      ORDER BY created_at DESC LIMIT 10
+    `).all(likeTopic, likeTopic, likeTopic, likeTopic);
+        const logRows = db.prepare(`
+      SELECT decision, approach, result, worked, file_path as file, decided_at
+      FROM decision_log
+      WHERE decision LIKE ? OR approach LIKE ? OR result LIKE ?
+      ORDER BY decided_at DESC LIMIT 10
+    `).all(likeTopic, likeTopic, likeTopic);
+        let found = 0;
+        if (decisionRows.length > 0) {
+            console.log(C.bold('  Technology Decisions:'));
+            for (const r of decisionRows) {
+                const verdict = Number(r.was_right) ? C.success('Right') : C.warn('Wrong');
+                console.log(`  ${verdict}  ${r.technology || r.reason}`);
+                if (r.reason)
+                    console.log(C.dim(`     Reason: ${r.reason}`));
+                if (r.outcome)
+                    console.log(C.dim(`     Outcome: ${r.outcome}`));
+                if (r.project)
+                    console.log(C.dim(`     Project: ${r.project}`));
+                console.log();
+            }
+            found += decisionRows.length;
+        }
+        if (decisionOutcomeRows.length > 0) {
+            console.log(C.bold('  Decision Outcomes:'));
+            for (const r of decisionOutcomeRows) {
+                const verdict = Number(r.was_right) ? C.success('Right') : C.warn('Wrong');
+                console.log(`  ${verdict}  ${r.technology || r.reason}`);
+                if (r.reason)
+                    console.log(C.dim(`     Reason: ${r.reason}`));
+                if (r.outcome)
+                    console.log(C.dim(`     Outcome: ${r.outcome}`));
+                if (r.context)
+                    console.log(C.dim(`     Context: ${r.context}`));
+                if (r.confidence)
+                    console.log(C.dim(`     Confidence: ${r.confidence}%`));
+                console.log();
+            }
+            found += decisionOutcomeRows.length;
+        }
+        if (logRows.length > 0) {
+            console.log(C.bold('  Session Decisions:'));
+            for (const r of logRows) {
+                const verdict = Number(r.worked) ? C.success('Worked') : C.warn("Didn't");
+                console.log(`  ${verdict}  ${r.decision}`);
+                if (r.approach)
+                    console.log(C.dim(`     Approach: ${r.approach}`));
+                if (r.result)
+                    console.log(C.dim(`     Result: ${r.result}`));
+                if (r.file)
+                    console.log(C.dim(`     File: ${r.file}`));
+                console.log();
+            }
+            found += logRows.length;
+        }
+        if (found === 0) {
+            console.log(C.dim(`  No decisions found about "${topic}".`));
+            console.log();
+            console.log(C.dim('  Decisions are logged when you:'));
+            console.log(C.dim('    - Accept/reject AI suggestions in your IDE'));
+            console.log(C.dim('    - Run cell scan + cell setup'));
+            console.log(C.dim('    - Use the decision MCP tool'));
+        }
+    }
+    catch (e) {
+        console.log(C.warn(`  Search failed: ${e?.message || String(e)}`));
+    }
+    console.log();
+}
+// test touch 14:40:59
+//# sourceMappingURL=cli.js.map