fivocell 1.0.4 → 2.0.0

package/dist/cli.js

@@ -37,6 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runConnect = runConnect;
 const commander_1 = require("commander");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
@@ -1443,6 +1444,791 @@ daemonCmd
             console.log(`   Stale PID found: ${status.pid}`);
     }
 });
+daemonCmd
+    .command('install-service')
+    .description('Install as Windows scheduled task (auto-start at logon, auto-restart on crash)')
+    .action(async () => {
+    const { installService } = await Promise.resolve().then(() => __importStar(require('./daemon/lifecycle')));
+    const r = installService();
+    console.log(r.success ? `✅ ${r.message}` : `❌ ${r.message}`);
+});
+program
+    .command('rescan')
+    .description('Re-scan codebase and refresh pattern library')
+    .option('--all', 'Scan all sub-projects (capped at 20,000 files)')
+    .action(async (opts) => {
+    const { scanCodebase, saveOnboarding } = await Promise.resolve().then(() => __importStar(require('./onboarding-scan')));
+    const startDir = process.cwd();
+    const scanAll = opts.all || false;
+    console.log(C.primary(scanAll ? '  🔄 Re-scanning ALL projects...' : '  🔄 Re-scanning codebase...'));
+    const result = scanCodebase(startDir, {
+        timeBudgetMs: scanAll ? 30000 : 15000,
+        maxFiles: scanAll ? 20000 : 2000,
+        detectAllStacks: scanAll,
+    });
+    saveOnboarding(result);
+    const onboardingMarker = path.join(os.homedir(), '.fivo', 'cell', '.onboarding-done');
+    try {
+        fs.writeFileSync(onboardingMarker, new Date().toISOString(), 'utf-8');
+    }
+    catch { }
+    console.log(C.success(`  ✅ Scanned ${result.filesScanned.toLocaleString()} files · ${result.totalLines.toLocaleString()} lines · ${result.patterns.length.toLocaleString()} patterns`));
+    if (result.stack.length > 0) {
+        console.log(C.dim(`     Stack: ${result.stack.slice(0, 6).map(s => s.name).join(', ')}`));
+    }
+    console.log(C.dim(`     Patterns merged into your taste profile.`));
+});
+program
+    .command('profile')
+    .description('Build YOUR user profile: products, stack fingerprint, common features, missing features')
+    .option('--root <dir>', 'Root directory to scan (defaults to parent of CWD)', process.cwd())
+    .action(async (opts) => {
+    const { buildUserProfile, saveUserProfile, loadUserProfile } = await Promise.resolve().then(() => __importStar(require('./user-intelligence')));
+    const startDir = opts.root || process.cwd();
+    console.log(C.primary('  🧠 Building your USER profile (not AI style)...'));
+    const profile = buildUserProfile(startDir);
+    saveUserProfile(profile);
+    console.log(C.success(`  ✅ Found ${profile.products.length} products across ${profile.products.reduce((a, p) => a + p.projects.length, 0)} projects`));
+    console.log();
+    for (const prod of profile.products) {
+        console.log(C.bold(`  📦 ${prod.name.toUpperCase()}`) + C.dim(` (${prod.projects.length} projects · latest ${prod.latestVersion})`));
+        if (prod.description)
+            console.log(C.dim(`     ${prod.description}`));
+        console.log(C.dim(`     ${prod.projects.join(' · ')}`));
+        if (prod.commonFeatures.length > 0) {
+            console.log(C.dim(`     Features: ${prod.commonFeatures.join(', ')}`));
+        }
+        console.log();
+    }
+    if (profile.goToStack.length > 0) {
+        console.log(C.bold('  📦 Your go-to stack:'));
+        for (const s of profile.goToStack.slice(0, 8)) {
+            console.log(`     • ${s.name} — ${s.reason}`);
+        }
+        console.log();
+    }
+    if (profile.missingFeatures.length > 0) {
+        console.log(C.bold('  💡 You might want to add:'));
+        for (const m of profile.missingFeatures.slice(0, 5)) {
+            console.log(C.dim(`     ❌ ${m.name} — ${m.suggestion}`));
+        }
+        console.log();
+    }
+    console.log(C.dim(`  Saved to: ~/.fivo/cell/user-profile.json + user-profile.md`));
+});
+program
+    .command('taste')
+    .description('See your saved user profile in human-readable form')
+    .action(async () => {
+    const { loadUserProfile } = await Promise.resolve().then(() => __importStar(require('./user-intelligence')));
+    const profile = loadUserProfile();
+    if (!profile) {
+        console.log(C.dim('  No profile yet. Run `cell profile` to build one.'));
+        return;
+    }
+    console.log(C.bold('  🧠 Your User Profile'));
+    console.log(C.dim('  ─────────────────────────────────────────'));
+    console.log();
+    console.log(C.bold(`  🏷️  ${profile.products.length} products you build:`));
+    for (const prod of profile.products) {
+        console.log();
+        console.log(`     📦 ${prod.name.toUpperCase()} (${prod.projects.length} projects · latest ${prod.latestVersion})`);
+        if (prod.description)
+            console.log(C.dim(`        ${prod.description}`));
+        if (prod.commonStack.length > 0) {
+            console.log(C.dim(`        Stack: ${prod.commonStack.slice(0, 5).map(s => s.name).join(', ')}`));
+        }
+        if (prod.commonFeatures.length > 0) {
+            console.log(C.dim(`        Features: ${prod.commonFeatures.join(', ')}`));
+        }
+    }
+    console.log();
+    console.log(C.bold('  📦 Your go-to stack (across all products):'));
+    for (const s of profile.goToStack.slice(0, 10)) {
+        console.log(`     • ${s.name} — ${s.reason} (${Math.round(s.confidence * 100)}%)`);
+    }
+    console.log();
+    console.log(C.bold('  ✅ Features you build in every project:'));
+    for (const f of profile.commonFeatures) {
+        console.log(`     • ${f.name} — ${f.projectCount}/${14} projects`);
+    }
+    console.log();
+    if (profile.missingFeatures.length > 0) {
+        console.log(C.bold('  💡 Features you might want to add:'));
+        for (const m of profile.missingFeatures) {
+            console.log();
+            console.log(`     ❌ ${m.name}`);
+            console.log(C.dim(`        ${m.reason}`));
+            console.log(C.dim(`        → ${m.suggestion}`));
+        }
+    }
+    console.log();
+    console.log(C.dim(`  Full markdown: ~/.fivo/cell/user-profile.md`));
+});
+program
+    .command('taste-interview')
+    .description('Tell Cell about YOU directly (5 quick questions) — complements auto-scan')
+    .action(async () => {
+    const C2 = C;
+    const { loadUserProfile, saveUserProfile } = await Promise.resolve().then(() => __importStar(require('./user-intelligence')));
+    const profile = loadUserProfile() || {
+        name: '',
+        products: [],
+        goToStack: [],
+        commonFeatures: [],
+        missingFeatures: [],
+        workStyle: { isSolo: true, doesRAndD: false, shipsVersions: false, buildsCloud: false, buildsWeb: false },
+        generatedAt: new Date().toISOString(),
+    };
+    console.log();
+    console.log(C2.primary.bold('  🎤 FIVO Cell — Taste Interview'));
+    console.log(C2.dim('  ─────────────────────────────────────────'));
+    console.log(C2.dim('  Cell ne tujhe samjha liya, ab tu bhi bata:'));
+    console.log();
+    const prompts = [
+        { key: 'name', q: 'Tera naam kya hai? (Cell tujhe isse bula kare)' },
+        { key: 'mainProduct', q: 'Tera MAIN product kya hai?', options: ['Fivo', 'PULSE', 'Dono', 'Kuch aur'] },
+        { key: 'mainRole', q: 'Tu kya karta hai?', options: ['Founder/CEO', 'Solo dev', 'Tech lead', 'AI-assisted dev', 'Designer + Dev'] },
+        { key: 'teamSize', q: 'Tera team kitna bada hai?', options: ['Sirf main', '2-3 log', '5-10 log', '10+ log'] },
+        { key: 'audience', q: 'Tera audience kaun hai?', options: ['Developers', 'Business users', 'Consumers', 'Mixed'] },
+        { key: 'topWish', q: 'Next project me AI se kya banwana chahta hai? (one line)' },
+        { key: 'biggestPain', q: 'Sabse bada pain kya hai abhi? (one line)' },
+        { key: 'avoidStack', q: 'Kaunsa stack AVOID karta hai? (comma separated)' },
+    ];
+    const readline = require('readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(res => rl.question(q, (ans) => res(ans.trim())));
+    for (const p of prompts) {
+        let hint = '';
+        if (p.options)
+            hint = ` (${p.options.join(' / ')})`;
+        const ans = await ask(C2.primary(`  ${p.q}${hint}\n  > `));
+        profile[p.key] = ans;
+    }
+    rl.close();
+    saveUserProfile(profile);
+    console.log();
+    console.log(C2.success('  ✅ Profile updated! Cell ab tujhe aur better samjhega.'));
+    console.log(C2.dim('     Run `cell taste` to see your full profile.'));
+});
+program
+    .command('style')
+    .description('Talk to Cell about HOW you work (16 questions, ~3 min) — learns your work style, not code style')
+    .action(async () => {
+    const C2 = C;
+    const { WORK_STYLE_QUESTIONS, loadWorkStyle, saveWorkStyle, applyAnswer, emptyWorkStyle } = await Promise.resolve().then(() => __importStar(require('./work-style')));
+    console.log();
+    console.log(C2.primary.bold('  🎤 FIVO Cell — Work Style Interview'));
+    console.log(C2.dim('  ─────────────────────────────────────────'));
+    console.log(C2.dim('  Code style AI likhta hai — yeh interview tere KAAM KI STYLE samjhega.'));
+    console.log(C2.dim('  Skip kar sakta hai — sirf Enter daba, ya quick type kar.'));
+    console.log();
+    const profile = loadWorkStyle() || emptyWorkStyle();
+    const readline = require('readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(res => rl.question(q, (ans) => res(ans.trim())));
+    for (const q of WORK_STYLE_QUESTIONS) {
+        const optionsHint = q.options ? C2.dim(`  Options: ${q.options.join(' / ')}`) : '';
+        const helpHint = q.helpText ? C2.dim(`  ℹ ${q.helpText}`) : '';
+        console.log();
+        console.log(C2.primary.bold(`  Q${WORK_STYLE_QUESTIONS.indexOf(q) + 1}/${WORK_STYLE_QUESTIONS.length}: ${q.q}`));
+        if (optionsHint)
+            console.log(optionsHint);
+        if (helpHint)
+            console.log(helpHint);
+        const ans = await ask('  ▸ ');
+        applyAnswer(profile, q.key, ans);
+    }
+    rl.close();
+    profile.updatedAt = new Date().toISOString();
+    saveWorkStyle(profile);
+    console.log();
+    console.log(C2.success('  ✅ Work style saved! Cell ab tujhe samjhega.'));
+    console.log(C2.dim('     Run `cell style` again to update. Run `cell style-show` to see it.'));
+});
+program
+    .command('style-quick')
+    .description('Quick work-style capture — just 5 essentials in one go')
+    .action(async () => {
+    const C2 = C;
+    const { loadWorkStyle, saveWorkStyle, applyAnswer, emptyWorkStyle } = await Promise.resolve().then(() => __importStar(require('./work-style')));
+    console.log();
+    console.log(C2.primary.bold('  ⚡ FIVO Cell — Quick Style (5 questions)'));
+    console.log(C2.dim('  ─────────────────────────────────────────'));
+    console.log(C2.dim('  Freeform likh ya Enter daba — jo mann me aaye.'));
+    console.log();
+    const readline = require('readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(res => rl.question(q, (ans) => res(ans.trim())));
+    const profile = loadWorkStyle() || emptyWorkStyle();
+    const a1 = await ask(C2.primary('  1️⃣  Tera naam?\n  ▸ '));
+    if (a1)
+        applyAnswer(profile, 'identity.name', a1);
+    const a2 = await ask(C2.primary('  2️⃣  Tu kya banata hai? (product builder / tool builder / dono / experiments / client)\n  ▸ '));
+    if (a2)
+        applyAnswer(profile, 'workType.primaryKind', a2);
+    const a3 = await ask(C2.primary('  3️⃣  Goal kya hai? (1 product bada / multiple / lifestyle / exit / seekhna)\n  ▸ '));
+    if (a3)
+        applyAnswer(profile, 'goals.primary', a3);
+    const a4 = await ask(C2.primary('  4️⃣  SABSE BADA pain? (time / ideas / execute / marketing / money / focus / burnout)\n  ▸ '));
+    if (a4)
+        applyAnswer(profile, 'pain.biggest', a4);
+    const a5 = await ask(C2.primary('  5️⃣  Next project me kya banana hai? (1 line)\n  ▸ '));
+    if (a5)
+        applyAnswer(profile, 'goals.wishNextProject', a5);
+    rl.close();
+    profile.updatedAt = new Date().toISOString();
+    saveWorkStyle(profile);
+    console.log();
+    console.log(C2.success('  ✅ Quick style saved! Cell ab tujhe samjhega.'));
+    console.log(C2.dim('     Run `cell style-show` to see it. Run `cell style` for the full 16-question interview.'));
+});
+program
+    .command('style-apply')
+    .description('Apply your learned style to AI tool configs (Cursor .cursorrules, Claude CLAUDE.md, Copilot, Antigravity, AGENT.md, Prettier, ESLint)')
+    .option('--tools <list>', 'Comma-separated tools: agent,cursor,claude,copilot,antigravity,prettier,eslint', 'agent,cursor,claude,copilot,antigravity,prettier,eslint')
+    .option('--force', 'Overwrite existing style files')
+    .option('--dir <dir>', 'Target directory (defaults to CWD)', process.cwd())
+    .action(async (opts) => {
+    const C2 = C;
+    const { buildStyleSummary, writeStyleFiles } = await Promise.resolve().then(() => __importStar(require('./style-pull')));
+    const target = opts.dir || process.cwd();
+    const tools = (opts.tools || 'agent,cursor,claude,copilot,antigravity,prettier,eslint').split(',').map(s => s.trim()).filter(Boolean);
+    console.log(C2.primary('  🎨 Reading your learned style from ~/.fivo/cell/...'));
+    const summary = buildStyleSummary(target);
+    console.log(C2.success(`  ✅ Loaded ${summary.topPatterns.length} top patterns + formatting rules`));
+    console.log();
+    console.log(C2.bold('  📐 Detected style:'));
+    console.log(C2.dim(`     ${summary.formatting.semicolons ? '✓' : '✗'} Semicolons`));
+    console.log(C2.dim(`     ✓ Quotes: ${summary.formatting.quotes}`));
+    console.log(C2.dim(`     ✓ Indent: ${summary.formatting.indentSize} ${summary.formatting.indentStyle}s`));
+    console.log(C2.dim(`     ✓ Line width: ${summary.formatting.lineWidth}`));
+    console.log();
+    console.log(C2.primary(`  📝 Writing style files to: ${target}`));
+    const result = writeStyleFiles(target, summary, { tools, force: opts.force });
+    for (const f of result.written) {
+        console.log(C2.success(`     ✓ ${f}`));
+    }
+    for (const f of result.skipped) {
+        console.log(C2.dim(`     - ${f} (already exists, use --force)`));
+    }
+    console.log();
+    console.log(C2.bold('  💡 Next steps:'));
+    console.log(C2.dim('     1. Open this folder in Cursor / Claude Code / VSCode'));
+    console.log(C2.dim('     2. AI tools will auto-detect AGENT.md / CLAUDE.md / .cursorrules'));
+    console.log(C2.dim('     3. Every new code will follow your style automatically'));
+    console.log();
+    console.log(C2.dim('     Other projects: `cell style-apply --dir "C:\\path\\to\\other\\project"`'));
+});
+program
+    .command('style-extract')
+    .description('Extract style from current project into your learned profile (so other projects can use it)')
+    .option('--dir <dir>', 'Project to extract style from (defaults to CWD)', process.cwd())
+    .action(async (opts) => {
+    const C2 = C;
+    const { scanCodebase, saveOnboarding } = await Promise.resolve().then(() => __importStar(require('./onboarding-scan')));
+    const target = opts.dir || process.cwd();
+    console.log(C2.primary(`  📥 Extracting style from: ${target}`));
+    const result = scanCodebase(target, { timeBudgetMs: 15000, maxFiles: 2000 });
+    saveOnboarding(result);
+    console.log(C2.success(`  ✅ Extracted ${result.patterns.length} patterns`));
+    console.log(C2.dim(`     Files: ${result.filesScanned}, Lines: ${result.totalLines.toLocaleString()}`));
+    console.log();
+    console.log(C2.dim('  Style merged into ~/.fivo/cell/onboarding.json'));
+    console.log(C2.dim('  Now use `cell style-apply` in any project to apply this style.'));
+});
+program
+    .command('goal')
+    .description('🎯 Track your learning goals')
+    .argument('[text]', 'Goal text to add (quote it for multi-word goals)')
+    .option('--done', 'Mark most recent active goal as complete')
+    .action(async (text, opts) => {
+    const C2 = C;
+    const fs2 = require('fs');
+    const goalPath = path.join(os.homedir(), '.fivo', 'cell', 'goals.json');
+    let goals = [];
+    if (fs2.existsSync(goalPath)) {
+        try {
+            goals = JSON.parse(fs2.readFileSync(goalPath, 'utf-8')).goals || [];
+        }
+        catch { }
+    }
+    if (opts.done) {
+        const active = goals.filter((g) => g.status === 'active');
+        if (active.length > 0) {
+            active[active.length - 1].status = 'completed';
+            active[active.length - 1].progress = 100;
+            console.log(C2.success(`  ✅ Marked "${active[active.length - 1].text}" as complete!`));
+        }
+        else {
+            console.log(C2.dim('  No active goals to complete.'));
+        }
+    }
+    else if (text) {
+        goals.push({ text, status: 'active', progress: 0, addedAt: new Date().toISOString(), notes: '' });
+        console.log(C2.success(`  ✅ Goal added: "${text}"`));
+    }
+    else {
+        console.log(C2.bold('  🎯 Your Goals:'));
+        if (goals.length === 0) {
+            console.log(C2.dim('     No goals yet. Add one: cell goal "learn Go"'));
+        }
+        for (const g of goals) {
+            const icons = { active: '⏳', completed: '✅', stalled: '🟡', abandoned: '❌' };
+            const bar = '█'.repeat(Math.floor(g.progress / 10)) + '░'.repeat(10 - Math.floor(g.progress / 10));
+            console.log(`     ${icons[g.status]} [${g.status}] ${g.text} ${C2.dim(`[${bar}] ${g.progress}%`)}`);
+            console.log(C2.dim(`        ${g.addedAt.slice(0, 10)}`));
+        }
+    }
+    const dir = path.join(os.homedir(), '.fivo', 'cell');
+    if (!fs2.existsSync(dir))
+        fs2.mkdirSync(dir, { recursive: true });
+    fs2.writeFileSync(goalPath, JSON.stringify({ goals, updatedAt: new Date().toISOString() }, null, 2), 'utf-8');
+});
+program
+    .command('community-compare')
+    .description('🌍 Compare yourself with 12,400+ developers: adoption trends, blind spots, rankings')
+    .action(async () => {
+    const C2 = C;
+    const { buildCommunityIntel, saveCommunityIntel } = await Promise.resolve().then(() => __importStar(require('./community-intelligence')));
+    console.log(C2.primary('  🌍 Comparing with community of 12,400+ developers...\n'));
+    const report = buildCommunityIntel();
+    saveCommunityIntel(report);
+    console.log(C2.bold(`  📊 YOUR POSITION: ${report.summary.yourPosition}`));
+    console.log();
+    console.log(C2.bold('  📈 TECH TRENDS (what 12K+ devs are doing):'));
+    for (const t of report.trends) {
+        const icon = t.adoption === 'hot' ? '🔥' : t.adoption === 'rising' ? '📈' : '📉';
+        const check = t.userHasIt ? C2.success('✓') : C2.dim('✗');
+        console.log(`     ${icon} ${t.technology.padEnd(16)} ${t.adoption.toString().padEnd(10)} ${t.users} ${check} ${t.userScore}`);
+    }
+    console.log();
+    console.log(C2.bold('  📐 YOU vs COMMUNITY:'));
+    for (const c of report.comparisons) {
+        const v = c.verdict === 'ahead' ? '🚀' : c.verdict === 'unique' ? '💎' : c.verdict === 'behind' ? '📉' : '✅';
+        console.log(`     ${v} ${c.metric.padEnd(20)} ${c.you} vs ${c.communityAverage} avg (${c.percentile})`);
+    }
+    console.log();
+    console.log(C2.bold('  🎯 BLIND SPOT CHECK (vs community):'));
+    for (const b of report.blindSpotCheck) {
+        console.log(`     ${b.area.padEnd(22)} ${b.yourFiles} files vs ${b.communityAvgFiles} avg`);
+        console.log(C2.dim(`        → ${b.recommendation}`));
+    }
+    console.log();
+    console.log(C2.bold('  🛠️ WHAT SUCCESSFUL DEVS USE:'));
+    for (const w of report.whatOthersUse) {
+        console.log(`     • ${w}`);
+    }
+    console.log();
+    console.log(C2.dim('  📁 Saved: ~/.fivo/cell/community-report.json + .md'));
+});
+program
+    .command('team-intel')
+    .description('👥 Team intelligence: collaborators, skills, knowledge silos, collaboration graph')
+    .option('--root <dir>', 'Root directory to analyze', process.cwd())
+    .action(async (opts) => {
+    const C2 = C;
+    const { buildTeamIntelReport, saveTeamIntel } = await Promise.resolve().then(() => __importStar(require('./team-intelligence')));
+    const startDir = opts.root || path.dirname(process.cwd());
+    console.log(C2.primary('  👥 Analyzing team dynamics across all projects...\n'));
+    const report = buildTeamIntelReport(startDir);
+    saveTeamIntel(report);
+    console.log(C2.bold(`  📊 TEAM: ${report.summary.teamSize} people · ${report.summary.totalCommits} commits · ${report.summary.totalProjects} projects`));
+    console.log();
+    for (const c of report.collaborators.slice(0, 6)) {
+        const roleIcon = c.role === 'owner' ? '👑' : c.role === 'maintainer' ? '🔧' : c.role === 'visitor' ? '👋' : '👤';
+        console.log(`     ${roleIcon} ${c.name.padEnd(22)} ${c.role.toString().padEnd(12)} ${c.commits} commits · ${(c.linesAdded + c.linesRemoved).toLocaleString()} LOC · ${c.projects.length} projects`);
+        console.log(C2.dim(`        ${c.firstCommit} → ${c.lastCommit} | Best: ${c.topHour} on ${c.topDay}`));
+    }
+    if (report.collaborators.length > 6) {
+        console.log(C2.dim(`     ...and ${report.collaborators.length - 6} more`));
+    }
+    console.log();
+    if (report.edges.length > 0) {
+        console.log(C2.bold('  🔗 COLLABORATION:'));
+        for (const e of report.edges.slice(0, 3)) {
+            console.log(`     ${e.source} ↔ ${e.target} — ${e.strength} (${e.sharedFiles} files)`);
+        }
+        console.log();
+    }
+    if (report.skills.length > 0) {
+        console.log(C2.bold('  🗺️ TEAM SKILLS:'));
+        for (const s of report.skills) {
+            const riskIcon = s.risk === 'high' ? '🔴' : s.risk === 'medium' ? '🟡' : '🟢';
+            console.log(`     ${riskIcon} ${s.area.padEnd(20)} ${s.coverage.toString().padEnd(14)} risk: ${s.risk} — ${s.description}`);
+        }
+        console.log();
+    }
+    if (report.summary.knowledgeSilos.length > 0) {
+        console.log(C2.bold(`  ⚠️  KNOWLEDGE SILOS: ${report.summary.knowledgeSilos.join(', ')}`));
+        console.log();
+    }
+    if (report.recommendations.length > 0) {
+        for (const r of report.recommendations)
+            console.log(`     💡 ${r}`);
+    }
+    console.log();
+    console.log(C2.dim('  📁 Saved: ~/.fivo/cell/team-intel.json + .md'));
+});
+program
+    .command('insights')
+    .description('🔮 Your growth report: level assessment, trends, strengths, what to focus on next')
+    .action(async () => {
+    const C2 = C;
+    const { buildInsightReport, saveInsightReport } = await Promise.resolve().then(() => __importStar(require('./insight-generator')));
+    console.log(C2.primary('  🔮 Generating your growth insights...\n'));
+    const report = buildInsightReport();
+    saveInsightReport(report);
+    const levelIcons = { senior: '🏆', mid: '🔥', junior: '🌱', unclear: '❓' };
+    console.log(C2.bold(`  ${levelIcons[report.level.currentLevel]} CURRENT LEVEL: ${report.level.currentLevel.toUpperCase()} (${report.level.confidence}% confidence)`));
+    if (report.level.evidence.length > 0) {
+        for (const e of report.level.evidence)
+            console.log(`     ✅ ${e}`);
+    }
+    console.log();
+    console.log(C2.bold(`  ⏩ NEXT LEVEL: ${report.level.nextLevel.toUpperCase()} | ETA: ${report.level.timeToNextLevel}`));
+    console.log();
+    console.log(C2.bold('  📈 TRENDS:'));
+    for (const t of report.trends) {
+        const d = t.direction === 'improving' ? '📈' : t.direction === 'declining' ? '📉' : t.direction === 'insufficient-data' ? '📊' : '➡️';
+        console.log(`     ${d} ${t.metric.padEnd(22)} ${t.direction.toUpperCase().padEnd(20)} ${C2.dim(t.details)}`);
+    }
+    console.log();
+    if (report.strengths.length > 0) {
+        console.log(C2.bold(`  💪 STRENGTHS:`));
+        for (const s of report.strengths.slice(0, 5))
+            console.log(`     • ${s}`);
+        console.log();
+    }
+    if (report.growthStory.length > 0) {
+        console.log(C2.bold('  📖 GROWTH STORY:'));
+        for (const g of report.growthStory)
+            console.log(`     ${g}`);
+        console.log();
+    }
+    if (report.nextFocus.length > 0) {
+        console.log(C2.bold('  🎯 FOCUS ON:'));
+        for (const n of report.nextFocus)
+            console.log(`     🔥 ${n}`);
+        console.log();
+    }
+    console.log(C2.dim('  📁 Saved: ~/.fivo/cell/insights.json + .md'));
+    console.log(C2.dim(`  📊 Snapshots: ${report.snapshotCount} | Days tracked: ${report.daysTracked}`));
+    console.log(C2.dim(`  💡 Run weekly: cell intelligence && cell journey && cell insights`));
+});
+program
+    .command('journey')
+    .description('📅 Your developer journey: timeline, skill progression, context chains, goals')
+    .option('--root <dir>', 'Root directory to analyze', process.cwd())
+    .action(async (opts) => {
+    const C2 = C;
+    const { buildJourneyReport, saveJourneyReport } = await Promise.resolve().then(() => __importStar(require('./journey-memory')));
+    const startDir = opts.root || path.dirname(process.cwd());
+    console.log(C2.primary('  📅 Mapping your developer journey...\n'));
+    const report = buildJourneyReport(startDir);
+    saveJourneyReport(report);
+    console.log(C2.bold(`  🎯 SUMMARY:`));
+    console.log(`     Active since:     ${report.summary.activeSince}`);
+    console.log(`     Projects:         ${report.summary.totalProjects}`);
+    console.log(`     Languages:        ${report.summary.languagesLearned}`);
+    console.log(`     Commits:          ${report.summary.totalCommits}`);
+    console.log(`     Growth rate:      ${report.summary.growthRate}`);
+    console.log();
+    console.log(C2.bold('  📅 TIMELINE (last 15 events):'));
+    for (const e of report.timeline.slice(-15)) {
+        const icon = e.type === 'first-use' ? '🆕' : e.type === 'milestone' ? '🏆' : e.type === 'shipped' ? '🚀' : '📍';
+        console.log(`     ${icon} ${e.date.slice(0, 10)} — ${e.detail} (${e.project})`);
+    }
+    console.log();
+    console.log(C2.bold('  📈 SKILL PROGRESSION:'));
+    for (const s of report.skills) {
+        const icons = { mastered: '🏆', proficient: '✅', intermediate: '📖', beginner: '🆕' };
+        console.log(`     ${icons[s.currentLevel]} ${s.area.padEnd(14)} ${s.currentLevel.toString().padEnd(12)} ${s.metrics.totalFiles} files ${s.metrics.cleanFileRatio}% clean`);
+    }
+    console.log();
+    if (report.chains.length > 0) {
+        console.log(C2.bold('  🔗 CONTEXT CHAINS (patterns reused across projects):'));
+        for (const c of report.chains.slice(0, 5)) {
+            console.log(`     ${c.pattern.padEnd(24)} ${c.reusedIn.length} projects · ${Math.round(c.successRate * 100)}% success`);
+        }
+        console.log();
+    }
+    if (report.goals.recommendations.length > 0) {
+        console.log(C2.bold('  💡 RECOMMENDATIONS:'));
+        for (const r of report.goals.recommendations.slice(0, 4)) {
+            console.log(`     • ${r}`);
+        }
+        console.log();
+    }
+    console.log(C2.dim('  📁 Saved: ~/.fivo/cell/journey.json + .md'));
+    console.log(C2.dim('  📁 History: ~/.fivo/cell/memory/journey-*.json'));
+});
+program
+    .command('intelligence')
+    .description('🧠 Your complete behavior profile: repeat mistakes, blind spots, bug history, decisions, tech mastery')
+    .option('--root <dir>', 'Root directory to analyze', process.cwd())
+    .action(async (opts) => {
+    const C2 = C;
+    const { buildIntelligenceReport, saveIntelligenceReport } = await Promise.resolve().then(() => __importStar(require('./behavior-intelligence')));
+    const startDir = opts.root || process.cwd();
+    console.log(C2.primary('  🧠 Analyzing your developer DNA...\n'));
+    const report = buildIntelligenceReport(startDir);
+    saveIntelligenceReport(report);
+    console.log(C2.bold(`  📊 ${report.projectCount} projects · ${report.totalFiles} files\n`));
+    console.log(C2.bold('  🔁 REPEAT MISTAKES:'));
+    if (report.mistakes.length === 0) {
+        console.log(C2.dim('     ✅ No repeat mistakes detected'));
+    }
+    else {
+        for (const m of report.mistakes.slice(0, 5)) {
+            const icon = m.stillHappening ? '⚠️' : '✅';
+            console.log(`     ${icon} [${m.category}] ${m.pattern}`);
+            console.log(C2.dim(`        ${m.count}x | Last: ${m.lastOccurrence.slice(0, 10)} | Still: ${m.stillHappening ? 'YES' : 'resolved'}`));
+        }
+    }
+    console.log();
+    console.log(C2.bold('  🎯 BLIND SPOTS:'));
+    for (const b of report.blindSpots) {
+        const sev = b.severity === 'high' ? '🔴' : b.severity === 'medium' ? '🟡' : '🟢';
+        console.log(`     ${sev} ${b.area.padEnd(18)} ${C2.dim(`${b.fileCount} files`)}`);
+        console.log(C2.dim(`        → ${b.fix}`));
+    }
+    console.log();
+    console.log(C2.bold('  🧩 PROBLEM-SOLVING STYLE:'));
+    console.log(`     • File org: ${report.problemSolving.fileOrganization}`);
+    console.log(`     • Docs: ${Math.round(report.problemSolving.comments.ratio * 100)}% files`);
+    console.log(`     • Functions: S:${report.problemSolving.functionSizes.small} M:${report.problemSolving.functionSizes.medium} L:${report.problemSolving.functionSizes.large} XL:${report.problemSolving.functionSizes.xlarge}`);
+    console.log();
+    console.log(C2.bold('  ⏰ TIME PATTERNS:'));
+    console.log(`     • Best: ${report.timePatterns.bestHours} on ${report.timePatterns.mostProductiveDay}`);
+    console.log();
+    console.log(C2.bold('  🐛 BUG HISTORY:'));
+    console.log(`     • ${report.bugHistory.length} bugs, ${report.bugHistory.filter(b => b.wasReverted).length} reverted`);
+    console.log();
+    console.log(C2.bold('  📋 DECISIONS:'));
+    console.log(`     • ${report.decisions.length} decisions tracked`);
+    console.log();
+    console.log(C2.bold('  🗺️ TECH MASTERY:'));
+    for (const t of report.techMastery.slice(0, 6)) {
+        const masteryIcons = { mastered: '🏆', proficient: '✅', learning: '📖', new: '🆕' };
+        console.log(`     ${masteryIcons[t.assessment]} ${t.language.padEnd(15)} ${C2.dim(`${t.fileCount} files · ${t.lineCount.toLocaleString()} lines · ${t.assessment}`)}`);
+    }
+    console.log();
+    console.log(C2.dim('  📁 Saved: ~/.fivo/cell/intelligence.json + .md'));
+    console.log(C2.dim('  📁 History: ~/.fivo/cell/memory/intelligence-*.json'));
+    console.log();
+    console.log(C2.bold('  💡 Cell ab tera BEST MATE ban raha hai — har run pe aur seekhega.'));
+});
+program
+    .command('focus')
+    .description('Your CO-FOUNDER view: which projects to KEEP, which to PAUSE, which to DELETE')
+    .option('--root <dir>', 'Root directory to scan (defaults to parent of CWD)', process.cwd())
+    .action(async (opts) => {
+    const C2 = C;
+    const { buildFocusReport, renderFocusMd } = await Promise.resolve().then(() => __importStar(require('./focus-report')));
+    const startDir = opts.root || path.dirname(process.cwd());
+    console.log(C2.primary('  🎯 Cell scanning your portfolio...\n'));
+    const report = buildFocusReport(startDir);
+    console.log(C2.bold('  📊 TERE 23+ PROJECTS KA STATUS:\n'));
+    const statusEmoji = { active: '🟢', stalled: '🟡', abandoned: '🔴', fresh: '⚪' };
+    const actionLabel = {
+        keep: '🔥 KEEP',
+        pause: '⏸️  PAUSE',
+        archive: '📦 ARCHIVE',
+        delete: '🗑️  DELETE',
+        resurrect: '💎 RESURRECT',
+    };
+    const allProjects = [
+        ...report.topPicks.map(p => ({ ...p, sortOrder: 0 })),
+        ...report.shouldResurrect.map(p => ({ ...p, sortOrder: 1 })),
+        ...report.shouldPause.map(p => ({ ...p, sortOrder: 2 })),
+        ...report.shouldArchive.map(p => ({ ...p, sortOrder: 3 })),
+    ];
+    for (const p of allProjects.sort((a, b) => a.lastModifiedDays - b.lastModifiedDays)) {
+        console.log(`  ${statusEmoji[p.status]} ${C2.bold(p.name.padEnd(35))} ${C2.dim(`${p.lastModifiedDays}d ago · ${p.totalFiles} files`)}`);
+        console.log(`     ${C2.dim(actionLabel[p.recommendedAction])} — ${p.reason}`);
+        if (p.description)
+            console.log(`     ${C2.dim(`"${p.description}"`)}`);
+    }
+    console.log();
+    console.log(C2.bold('  💡 CELL KI ADVICE:\n'));
+    for (const a of report.overallAdvice) {
+        console.log(`     ${a}`);
+    }
+    const mdPath = path.join(os.homedir(), '.fivo', 'cell', 'focus-report.md');
+    try {
+        const { writeFileSync, mkdirSync, existsSync } = require('fs');
+        const dir = path.join(os.homedir(), '.fivo', 'cell');
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(mdPath, renderFocusMd(report), 'utf-8');
+        console.log();
+        console.log(C2.dim(`  Full report: ${mdPath}`));
+    }
+    catch { }
+});
+program
+    .command('install')
+    .description('One-command setup: daemon + watcher + AI tools auto-start. Run once, forget forever.')
+    .action(async () => {
+    const C2 = C;
+    console.log();
+    console.log(C2.primary.bold('  🔧 FIVO Cell — One-Time Setup'));
+    console.log(C2.dim('  ─────────────────────────────────────────'));
+    console.log();
+    const steps = [];
+    try {
+        const { installService } = await Promise.resolve().then(() => __importStar(require('./daemon/lifecycle')));
+        const r = installService();
+        steps.push({ name: 'Auto-start at Windows logon', ok: r.success, detail: r.message });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        steps.push({ name: 'Auto-start at Windows logon', ok: false, detail: message });
+    }
+    try {
+        const { ensureDaemon } = await Promise.resolve().then(() => __importStar(require('./daemon/lifecycle')));
+        const ok = await ensureDaemon({ silent: true });
+        steps.push({ name: 'Daemon running now', ok, detail: ok ? 'Daemon started and healthy on port 9876' : 'Daemon failed to start' });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        steps.push({ name: 'Daemon running now', ok: false, detail: message });
+    }
+    steps.push({
+        name: 'File watcher',
+        ok: true,
+        detail: 'Will auto-start at every Windows logon via the watch-loop in fivo-cell-daemon.bat (respawns automatically if it ever dies). To start right now: cell start',
+    });
+    const onboardingMarker = path.join(os.homedir(), '.fivo', 'cell', '.onboarding-done');
+    const existingOnboarding = path.join(os.homedir(), '.fivo', 'cell', 'onboarding.json');
+    if (fs.existsSync(existingOnboarding) || fs.existsSync(onboardingMarker)) {
+        steps.push({
+            name: 'Codebase knowledge',
+            ok: true,
+            detail: 'Already onboarded. Run `cell rescan` to refresh.',
+        });
+    }
+    else {
+        console.log();
+        console.log(C2.primary.bold('  🧠 I ALREADY KNOW YOUR CODEBASE'));
+        console.log(C2.dim('  ────────────────────────────────────────'));
+        console.log();
+        try {
+            const { scanCodebase, saveOnboarding } = await Promise.resolve().then(() => __importStar(require('./onboarding-scan')));
+            const result = scanCodebase(process.cwd(), { timeBudgetMs: 5000 });
+            const stackTop = result.stack.slice(0, 4).map(s => `${s.name}${s.version ? ' ' + s.version : ''}`).join(' · ');
+            const stylePatterns = result.patterns.filter(p => p.category === 'style');
+            const styleMatch = stylePatterns.length > 0
+                ? Math.round((stylePatterns.filter(p => p.confidence > 0.5).length / stylePatterns.length) * 100)
+                : 0;
+            const styleTop = stylePatterns.filter(p => p.confidence > 0.5).slice(0, 3).map(p => p.description.split(' ').slice(0, 2).join(' ').toLowerCase()).join('/') || 'mixed';
+            const archTop = result.patterns.filter(p => p.category === 'architecture' && p.confidence > 0.5).length;
+            const testTop = result.patterns.filter(p => p.category === 'testing' && p.confidence > 0.5).length;
+            const hubLine = result.hubs.length > 0
+                ? result.hubs.slice(0, 2).map(h => `${path.basename(h.file)} (${h.importedBy})`).join(' · ')
+                : 'none yet';
+            const issueLine = result.issues.length > 0
+                ? `${result.issues.length} (${result.issues.slice(0, 2).map(i => i.description.split(' ').slice(0, 4).join(' ')).join(' · ')})`
+                : 'none';
+            console.log(`  ${C2.dim('Scanned')} ${result.filesScanned} ${C2.dim('files ·')} ${result.totalLines.toLocaleString()} ${C2.dim('lines ·')} ${result.totalFunctions} ${C2.dim('functions')}`);
+            console.log(`  ${C2.dim('Learned')} ${result.patterns.length} ${C2.dim('patterns · background scan continues...')}`);
+            console.log();
+            console.log(`  ${C2.accent('Stack:')}  ${stackTop || 'plain JS/TS'}`);
+            console.log(`  ${C2.accent('Style:')}  ${styleTop} (${styleMatch}% match) · ${result.patterns.filter(p => p.category === 'style').length} patterns`);
+            console.log(`  ${C2.accent('Arch:')}   ${archTop} architecture patterns detected`);
+            console.log(`  ${C2.accent('Tests:')}  ${testTop} testing patterns detected`);
+            console.log(`  ${C2.accent('Hubs:')}   ${hubLine}`);
+            console.log(`  ${C2.accent('Issues:')} ${issueLine}`);
+            console.log();
+            console.log(C2.dim('  Full scan continues in background. Run `cell status` in 30s for the complete picture.'));
+            saveOnboarding(result);
+            setTimeout(() => {
+                try {
+                    const { scanCodebase: fullScan, saveOnboarding: saveFull } = require('./onboarding-scan');
+                    const full = fullScan(process.cwd(), { timeBudgetMs: 30000 });
+                    saveFull(full);
+                    try {
+                        fs.writeFileSync(onboardingMarker, new Date().toISOString(), 'utf-8');
+                    }
+                    catch { }
+                    try {
+                        const { PatternStore } = require('./core/pattern-store');
+                        const cellDir = path.join(os.homedir(), '.fivo', 'cell');
+                        const store = new PatternStore(cellDir);
+                        for (const p of full.patterns) {
+                            try {
+                                store.addOrUpdatePattern(p.category, p.description, 'codebase', 'detected', true, p.examples.slice(0, 3), 'global', 'onboarding', p.language || 'unknown');
+                            }
+                            catch { }
+                        }
+                        store.save();
+                    }
+                    catch { }
+                }
+                catch { }
+            }, 100);
+            steps.push({
+                name: 'Codebase knowledge',
+                ok: true,
+                detail: `${result.patterns.length} patterns learned from ${result.filesScanned} files. Full scan continues in background.`,
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            steps.push({ name: 'Codebase knowledge', ok: false, detail: message });
+        }
+    }
+    try {
+        const r = runConnect({ silent: true });
+        steps.push({ name: 'AI tools configured', ok: true, detail: r.targets.length > 0 ? `Configured: ${r.targets.join(', ')}` : 'All 5 AI tools already configured' });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        steps.push({ name: 'AI tools configured', ok: false, detail: message });
+    }
+    for (const s of steps) {
+        const icon = s.ok ? C2.success('  ✅') : C2.warn('  ⚠️ ');
+        console.log(`${icon} ${s.name}`);
+        console.log(C2.dim(`     ${s.detail}`));
+    }
+    console.log();
+    console.log(C2.primary.bold('  🎉 Setup complete. You never need to run this again.'));
+    console.log();
+    console.log(C2.info('  Anytime you want to see what Cell learned:'));
+    console.log(C2.primary.bold('     cell status'));
+    console.log();
+    console.log(C2.dim('  Cell is now invisible infrastructure:'));
+    console.log(C2.dim('    • Daemon auto-starts at every Windows logon'));
+    console.log(C2.dim('    • Watcher auto-respawns if it ever dies'));
+    console.log(C2.dim('    • AI tools can use 30 MCP tools on demand'));
+    console.log(C2.dim('    • Any `cell` command auto-starts the daemon if needed'));
+    console.log();
+});
+daemonCmd
+    .command('uninstall-service')
+    .description('Remove Windows scheduled task')
+    .action(async () => {
+    const { uninstallService } = await Promise.resolve().then(() => __importStar(require('./daemon/lifecycle')));
+    const r = uninstallService();
+    console.log(r.success ? `✅ ${r.message}` : `❌ ${r.message}`);
+});
+daemonCmd
+    .command('service-status')
+    .description('Check Windows scheduled task status')
+    .action(async () => {
+    const { serviceStatus } = await Promise.resolve().then(() => __importStar(require('./daemon/lifecycle')));
+    const s = serviceStatus();
+    if (!s.installed) {
+        console.log(`❌ Service '${s.taskName}' is NOT installed. Run: cell daemon install-service`);
+    }
+    else if (s.running) {
+        console.log(`✅ Service '${s.taskName}' is INSTALLED and RUNNING (auto-restart on crash).`);
+    }
+    else {
+        console.log(`⚠️  Service '${s.taskName}' is INSTALLED but not running.`);
+    }
+});
 // ─── Top-level start/stop shortcuts ────────────────────
 program
     .command('start')
@@ -1454,6 +2240,11 @@ program
         const result = await startDaemon();
         console.log(C.success(`✅ Daemon started (PID: ${result.pid}, Port: ${result.port})`));
         console.log(C.info(`   Health: http://localhost:${result.port}/health`));
+        try {
+            const { firstRunGreeting } = await Promise.resolve().then(() => __importStar(require('./first-run')));
+            await firstRunGreeting();
+        }
+        catch { }
         // Auto-start file watcher in background
         try {
             const scriptPath = process.argv[1];
@@ -1468,6 +2259,20 @@ program
         catch {
             console.log(C.dim('\n   Run `cell watch` manually for auto-learning'));
         }
+        // Auto-start MCP server in background
+        try {
+            const scriptPath = process.argv[1];
+            (0, child_process_1.spawn)('node', [scriptPath, 'mcp'], {
+                detached: true,
+                stdio: 'ignore',
+                cwd: process.cwd(),
+            }).unref();
+            console.log(C.success('\n🔌 MCP Server: Running on http://localhost:9877/mcp'));
+            console.log(C.dim('   Connect Gemini CLI, Codex CLI, Cursor, Claude Code'));
+        }
+        catch {
+            console.log(C.dim('\n   Run `cell mcp` manually for AI tool connections'));
+        }
         console.log(C.dim('   Stop daemon: cell stop\n'));
     }
     catch (err) {
@@ -1483,6 +2288,147 @@ program
     const result = stopDaemon();
     console.log(result.success ? C.success(`✅ ${result.message}`) : C.warn(`⚠️ ${result.message}`));
 });
+program
+    .command('mcp')
+    .description('Start the MCP server (JSON-RPC on port 9877) for AI tool connections')
+    .option('-p, --port <port>', 'Port (default: 9877)', '9877')
+    .action((options) => {
+    const port = parseInt(options.port, 10);
+    const { startMCPServer, TOOLS, RESOURCES } = require('./mcp-server');
+    startMCPServer(port);
+    console.log('MCP server running. Available tools: ' + TOOLS.length + ' | Resources: ' + RESOURCES.length);
+    console.log('Connect your AI tools to: http://localhost:' + port + '/mcp');
+});
+function runConnect(opts = {}) {
+    const home = os.homedir();
+    const cursorDir = path.join(process.cwd(), '.cursor');
+    const cursorFile = path.join(cursorDir, 'mcp.json');
+    const claudeFile = path.join(process.cwd(), '.mcp.json');
+    const dotCursorFile = path.join(home, '.cursor', 'mcp.json');
+    let created = 0;
+    const targets = [];
+    const cellMCPConfig = {
+        mcpServers: {
+            cell: {
+                type: 'url',
+                url: 'http://localhost:9877/mcp',
+                description: 'FIVO Cell — anticipatory intelligence engine. 30 tools, 8 resources.',
+            },
+        },
+    };
+    const json = JSON.stringify(cellMCPConfig, null, 2);
+    if (!fs.existsSync(cursorFile)) {
+        if (!fs.existsSync(cursorDir))
+            fs.mkdirSync(cursorDir, { recursive: true });
+        fs.writeFileSync(cursorFile, json);
+        if (!opts.silent)
+            console.log(C.success('✅ .cursor/mcp.json created'));
+        created++;
+        targets.push('Cursor (project)');
+    }
+    if (!fs.existsSync(dotCursorFile)) {
+        const globalCursorDir = path.join(home, '.cursor');
+        if (!fs.existsSync(globalCursorDir))
+            fs.mkdirSync(globalCursorDir, { recursive: true });
+        fs.writeFileSync(dotCursorFile, json);
+        if (!opts.silent)
+            console.log(C.success('✅ ~/.cursor/mcp.json created (global)'));
+        created++;
+        targets.push('Cursor (global)');
+    }
+    if (!fs.existsSync(claudeFile)) {
+        fs.writeFileSync(claudeFile, json);
+        if (!opts.silent)
+            console.log(C.success('✅ .mcp.json created (Claude Code)'));
+        created++;
+        targets.push('Claude Code');
+    }
+    const geminiDir = path.join(home, '.gemini');
+    const geminiFile = path.join(geminiDir, 'settings.json');
+    const antigravityFile = path.join(geminiDir, 'config', 'mcp_config.json');
+    const cellMcpConfig = { transport: 'url', serverURL: 'http://localhost:9877/mcp' };
+    let geminiUpdated = false;
+    if (fs.existsSync(geminiFile)) {
+        let gemini = JSON.parse(fs.readFileSync(geminiFile, 'utf-8'));
+        if (!gemini.mcpServers)
+            gemini.mcpServers = {};
+        if (!gemini.mcpServers.cell) {
+            gemini.mcpServers.cell = cellMcpConfig;
+            fs.writeFileSync(geminiFile, JSON.stringify(gemini, null, 2));
+            geminiUpdated = true;
+        }
+    }
+    else {
+        if (!fs.existsSync(geminiDir))
+            fs.mkdirSync(geminiDir, { recursive: true });
+        fs.writeFileSync(geminiFile, JSON.stringify({
+            mcpServers: { cell: cellMcpConfig },
+        }, null, 2));
+        geminiUpdated = true;
+    }
+    if (geminiUpdated) {
+        if (!opts.silent)
+            console.log(C.success('✅ ~/.gemini/settings.json created/updated'));
+        created++;
+        targets.push('Gemini CLI');
+    }
+    const antigravityDir = path.dirname(antigravityFile);
+    if (!fs.existsSync(antigravityDir))
+        fs.mkdirSync(antigravityDir, { recursive: true });
+    let antiUpdated = false;
+    if (fs.existsSync(antigravityFile)) {
+        let anti = JSON.parse(fs.readFileSync(antigravityFile, 'utf-8'));
+        if (!anti.mcpServers)
+            anti.mcpServers = {};
+        if (!anti.mcpServers.cell) {
+            anti.mcpServers.cell = { serverURL: 'http://localhost:9877/mcp' };
+            fs.writeFileSync(antigravityFile, JSON.stringify(anti, null, 2));
+            antiUpdated = true;
+        }
+    }
+    else {
+        fs.writeFileSync(antigravityFile, JSON.stringify({
+            mcpServers: { cell: { serverURL: 'http://localhost:9877/mcp' } },
+        }, null, 2));
+        antiUpdated = true;
+    }
+    if (antiUpdated) {
+        if (!opts.silent)
+            console.log(C.success('✅ ~/.gemini/config/mcp_config.json created/updated (Antigravity)'));
+        created++;
+        targets.push('Antigravity');
+    }
+    const codexDir = path.join(home, '.codex');
+    const codexFile = path.join(codexDir, 'config.json');
+    if (!fs.existsSync(codexFile)) {
+        if (!fs.existsSync(codexDir))
+            fs.mkdirSync(codexDir, { recursive: true });
+        fs.writeFileSync(codexFile, JSON.stringify({
+            mcp: { servers: { cell: { type: 'url', url: 'http://localhost:9877/mcp' } } },
+        }, null, 2));
+        if (!opts.silent)
+            console.log(C.success('✅ ~/.codex/config.json created'));
+        created++;
+        targets.push('Codex CLI');
+    }
+    if (!opts.silent) {
+        console.log();
+        if (created > 0) {
+            console.log(C.accent(`${created} config files created. Restart your AI tools to connect.`));
+        }
+        else {
+            console.log(C.dim('All config files already exist. Cell is ready.'));
+        }
+        console.log(C.dim('Run `cell start` first if daemon + MCP server are not running.'));
+    }
+    return { created, targets };
+}
+program
+    .command('connect')
+    .description('Auto-generate MCP config files for detected AI tools (Cursor, Claude Code, Gemini)')
+    .action(() => {
+    runConnect();
+});
 program
     .command('cloud')
     .description('Manage cloud sync')
@@ -1602,7 +2548,32 @@ program
                     projectId: path.basename(process.cwd()),
                 };
                 capture.captureEditDiff(previous, current, ctx);
-                const result = cascade.extract(previous, current, lang);
+                const daemonUrl = process.env.CELL_DAEMON_URL || 'http://localhost:9876';
+                try {
+                    const postData = JSON.stringify({
+                        type: 'edit_diff',
+                        originalCode: previous,
+                        editedCode: current,
+                        context: ctx,
+                    });
+                    const url = new URL(`${daemonUrl}/signal`);
+                    const req = require('http').request({
+                        hostname: url.hostname,
+                        port: url.port || 9876,
+                        path: url.pathname,
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'Content-Length': Buffer.byteLength(postData),
+                        },
+                        timeout: 3000,
+                    }, () => { });
+                    req.on('error', () => { });
+                    req.write(postData);
+                    req.end();
+                }
+                catch { }
+                const result = cascade.extract(previous, current, lang);
                 const spots = blindSpots.analyze(current, lang);
                 naming.analyze(current);
                 structure.analyze(current);
@@ -1786,6 +2757,1209 @@ program
         console.log(C.success('\n  ✅ Auto-start disabled\n'));
     }
 }));
+// ─── Database Management ──────────────────────────────
+program
+    .command('migrate')
+    .description('Migrate all JSON data to SQLite (idempotent)')
+    .action(async () => {
+    const spinner = (await Promise.resolve().then(() => __importStar(require('ora')))).default('Migrating JSON → SQLite...').start();
+    try {
+        const { initializeDatabase, migrateJsonToSqlite } = await Promise.resolve().then(() => __importStar(require('./core/database')));
+        initializeDatabase();
+        const stats = migrateJsonToSqlite();
+        spinner.succeed(`Migrated ${stats.total} records`);
+        console.log(C.dim(`\n  📊 patterns: ${stats.patterns}`));
+        console.log(C.dim(`  📊 scans: ${stats.scans}`));
+        console.log(C.dim(`  📊 behavior events: ${stats.behaviorEvents}`));
+        console.log(C.dim(`  📊 journey events: ${stats.journeyEvents}`));
+        console.log(C.dim(`  📊 skills: ${stats.skills}`));
+        console.log(C.dim(`  📊 collaborators: ${stats.collaborators}`));
+        console.log(C.dim(`  📊 silos: ${stats.silos}`));
+        console.log(C.dim(`  📊 community: ${stats.communitySignals}`));
+        console.log(C.dim(`  📊 projects: ${stats.projects}`));
+        console.log(C.dim(`  📊 insights: ${stats.insights}`));
+        console.log(C.dim(`  📊 config: ${stats.configEntries}`));
+        console.log(C.dim(`  📊 user profiles: ${stats.userProfiles}`));
+        console.log(C.success(`\n  ✅ Migration complete. cell.db now has all your data.`));
+        console.log(C.dim(`  📁 ~/.fivo/cell/cell.db\n`));
+    }
+    catch (e) {
+        spinner.fail(`Migration failed: ${e.message}`);
+    }
+});
+program
+    .command('db-init')
+    .description('Initialize SQLite database (first-run setup)')
+    .action(async () => {
+    try {
+        const { initializeDatabase, getDatabaseStats } = await Promise.resolve().then(() => __importStar(require('./core/database')));
+        initializeDatabase();
+        const stats = getDatabaseStats();
+        const tableCount = Object.keys(stats).filter(k => k !== 'db_path' && k !== 'db_size_bytes').length;
+        console.log(C.success(`\n  ✅ Database initialized: ${tableCount} tables\n`));
+        console.log(C.dim(`  📁 ${stats['db_path']}`));
+        console.log(C.dim(`  💾 ${(stats['db_size_bytes'] / 1024).toFixed(1)} KB\n`));
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ DB init failed: ${e.message}\n`));
+    }
+});
+program
+    .command('db-stats')
+    .description('Show SQLite database statistics')
+    .action(async () => {
+    try {
+        const { initializeDatabase, getDatabaseStats } = await Promise.resolve().then(() => __importStar(require('./core/database')));
+        initializeDatabase();
+        const stats = getDatabaseStats();
+        console.log(C.bold('\n  📊 Cell Database Statistics\n'));
+        for (const [table, info] of Object.entries(stats)) {
+            if (table === 'db_path' || table === 'db_size_bytes')
+                continue;
+            const { rows } = info;
+            console.log(C.dim(`  ${table.padEnd(25)} ${rows} rows`));
+        }
+        console.log(C.dim(`\n  📁 ${stats['db_path']}`));
+        console.log(C.dim(`  💾 ${(stats['db_size_bytes'] / 1024).toFixed(1)} KB`));
+        console.log('');
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ DB error: ${e.message}\n`));
+    }
+});
+program
+    .command('backup')
+    .description('Backup cell.db to timestamped file')
+    .action(async () => {
+    try {
+        const { initializeDatabase, backupDatabase } = await Promise.resolve().then(() => __importStar(require('./core/database')));
+        initializeDatabase();
+        const backupPath = backupDatabase();
+        console.log(C.success(`\n  ✅ Backup saved: ${backupPath}\n`));
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Backup failed: ${e.message}\n`));
+    }
+});
+program
+    .command('db-optimize')
+    .description('VACUUM, ANALYZE, and check DB integrity')
+    .action(async () => {
+    try {
+        const { initializeDatabase, optimizeDatabase } = await Promise.resolve().then(() => __importStar(require('./core/database')));
+        initializeDatabase();
+        const stats = optimizeDatabase();
+        console.log(C.success('\n  ✅ Database optimized\n'));
+        console.log(C.dim(`  💾 ${(stats['db_size_bytes'] / 1024).toFixed(1)} KB\n`));
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Optimize failed: ${e.message}\n`));
+    }
+});
+program
+    .command('db-export')
+    .description('Export SQLite data to JSON for debugging')
+    .action(async () => {
+    try {
+        const { initializeDatabase, getDb } = await Promise.resolve().then(() => __importStar(require('./core/database')));
+        initializeDatabase();
+        const db = getDb();
+        const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").all();
+        const exportDir = path.join(os.homedir(), '.fivo', 'cell', 'exports');
+        if (!fs.existsSync(exportDir))
+            fs.mkdirSync(exportDir, { recursive: true });
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        for (const { name } of tables) {
+            try {
+                const rows = db.prepare(`SELECT * FROM "${name}" LIMIT 1000`).all();
+                fs.writeFileSync(path.join(exportDir, `${name}-${timestamp}.json`), JSON.stringify(rows, null, 2));
+            }
+            catch { /* skip tables that error */ }
+        }
+        console.log(C.success(`\n  ✅ Exported to: ${exportDir}\n`));
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Export failed: ${e.message}\n`));
+    }
+});
+// ─── Session Memory ───────────────────────────────────
+program
+    .command('sessions')
+    .description('Show recent cross-tool sessions')
+    .option('-t, --tool <name>', 'Filter by tool (cursor, claude, windsurf, etc.)')
+    .option('-l, --limit <n>', 'Max sessions to show', '10')
+    .action(async (opts) => {
+    try {
+        const { SessionMemory } = await Promise.resolve().then(() => __importStar(require('./core/session-memory')));
+        const sm = new SessionMemory();
+        const sessions = opts.tool
+            ? sm.getSessionsByTool(opts.tool, Number(opts.limit))
+            : sm.getRecentSessions(Number(opts.limit));
+        if (sessions.length === 0) {
+            console.log(C.dim('\n  📭 No sessions recorded yet. Sessions auto-record when daemon runs.\n'));
+            return;
+        }
+        console.log(C.bold(`\n  🕐 Recent Sessions (${sessions.length})\n`));
+        for (const s of sessions) {
+            const tool = C.primary(s.toolName.padEnd(12));
+            const project = C.warn(s.project.padEnd(20));
+            const start = C.dim(formatTime(s.startTime));
+            const decisions = s.keyDecisions.length > 0 ? C.dim(` | ${s.keyDecisions.length} decisions`) : '';
+            const files = s.filesTouched.length > 0 ? C.dim(` | ${s.filesTouched.length} files`) : '';
+            console.log(`  ${tool} ${project} ${start}${decisions}${files}`);
+        }
+        const stats = sm.getSessionStats();
+        console.log(C.dim(`\n  📊 ${stats.totalSessions} sessions across ${stats.byTool?.length || 0} tools`));
+        console.log(C.dim(`  ⏱ Avg session: ${stats.avgSessionMinutes}m\n`));
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ ${e.message}\n`));
+    }
+});
+program
+    .command('search-sessions')
+    .description('Search past sessions for decisions, files, or context')
+    .argument('<query>', 'Search query (e.g. "auth", "payment", "webhook")')
+    .action(async (query) => {
+    try {
+        const { SessionMemory } = await Promise.resolve().then(() => __importStar(require('./core/session-memory')));
+        const sm = new SessionMemory();
+        const results = sm.searchSessions(query);
+        if (results.length === 0) {
+            console.log(C.dim(`\n  🔍 No sessions found matching "${query}"\n`));
+            return;
+        }
+        console.log(C.bold(`\n  🔍 "${query}" found in ${results.length} sessions\n`));
+        for (const r of results) {
+            console.log(`  ${C.primary(r.session.toolName.padEnd(12))} ${C.warn(r.session.project.padEnd(20))} ${C.dim(formatTime(r.session.startTime))}`);
+            for (const m of r.matches) {
+                console.log(C.dim(`    ↳ ${m.slice(0, 100)}`));
+            }
+            console.log('');
+        }
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ ${e.message}\n`));
+    }
+});
+program
+    .command('bugs')
+    .description('Show bug history and repeat mistakes')
+    .option('-p, --project <name>', 'Filter by project')
+    .action(async (opts) => {
+    try {
+        const { SessionMemory } = await Promise.resolve().then(() => __importStar(require('./core/session-memory')));
+        const sm = new SessionMemory();
+        const bugs = sm.getBugHistory(opts.project);
+        const repeats = sm.getRepeatBugs();
+        if (repeats.length > 0) {
+            console.log(C.bold('\n  🐛 REPEAT MISTAKES\n'));
+            for (const r of repeats) {
+                console.log(`  ${C.error('⚠')} ${r.description.slice(0, 80)}${C.dim(` (${r.count}x, ${r.files.length} files)`)}`);
+            }
+        }
+        else {
+            console.log(C.dim('\n  🎉 No repeat bugs detected yet.\n'));
+        }
+        if (bugs.length > 0) {
+            console.log(C.bold(`\n  📋 Bug History (${bugs.length})\n`));
+            for (const b of bugs.slice(0, 10)) {
+                console.log(`  ${C.dim(formatTime(b.occurredAt))} ${b.location.slice(0, 30).padEnd(32)} ${b.rootCause.slice(0, 40)}`);
+            }
+            console.log('');
+        }
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ ${e.message}\n`));
+    }
+});
+program
+    .command('decisions')
+    .description('Show decision history — technologies chosen, outcomes')
+    .option('-p, --project <name>', 'Filter by project')
+    .action(async (opts) => {
+    try {
+        const { SessionMemory } = await Promise.resolve().then(() => __importStar(require('./core/session-memory')));
+        const sm = new SessionMemory();
+        const decisions = sm.getDecisionHistory(opts.project);
+        const summary = sm.getDecisionSummary();
+        if (summary.length > 0) {
+            console.log(C.bold('\n  📊 Decision Summary\n'));
+            for (const s of summary) {
+                const pct = s.wasRightPct >= 70 ? C.success(`${s.wasRightPct}%`) : s.wasRightPct >= 40 ? C.warn(`${s.wasRightPct}%`) : C.error(`${s.wasRightPct}%`);
+                console.log(`  ${C.primary(s.technology.padEnd(20))} ${s.times}x chosen | ${pct} right`);
+            }
+        }
+        if (decisions.length > 0) {
+            console.log(C.bold(`\n  📜 Decision History (${decisions.length})\n`));
+            for (const d of decisions.slice(0, 10)) {
+                const icon = d.wasRight === true ? C.success('✅') : d.wasRight === false ? C.error('❌') : C.dim('⬜');
+                console.log(`  ${icon} ${C.primary(d.technology.padEnd(20))} ${d.reason.slice(0, 50)}${C.dim(` | ${formatTime(d.createdAt)}`)}`);
+            }
+            console.log('');
+        }
+        else {
+            console.log(C.dim('\n  📭 No decisions recorded yet.\n'));
+        }
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ ${e.message}\n`));
+    }
+});
+function formatTime(iso) {
+    try {
+        const d = new Date(iso);
+        return d.toLocaleDateString('en-US', { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' });
+    }
+    catch {
+        return iso.slice(0, 16);
+    }
+}
+// ─── Context Injection ────────────────────────────────
+program
+    .command('context')
+    .description('Generate @cell context block for AI tools')
+    .option('-p, --project <path>', 'Project path for specific context')
+    .option('-t, --tool <name>', 'AI tool: cursor, claude, windsurf, copilot, antigravity')
+    .option('-c, --compact', 'Compact format for prompt injection')
+    .action(async (opts) => {
+    try {
+        const { initializeDatabase } = await Promise.resolve().then(() => __importStar(require('./core/database')));
+        const { buildContext, formatContextForInjection } = await Promise.resolve().then(() => __importStar(require('./core/prompt-builder')));
+        initializeDatabase();
+        const ctx = buildContext(opts.project, opts.tool);
+        const text = formatContextForInjection(ctx, opts.compact);
+        console.log(C.bold('\n  🧠 @cell Context Block\n'));
+        console.log(C.dim('  ─────────────────────────────────────────'));
+        console.log(text.split('\n').map((l) => '  ' + l).join('\n'));
+        console.log(C.dim('\n  ─────────────────────────────────────────'));
+        console.log(C.success(`  ✅ Use @cell in any AI tool — it already knows you.`));
+        console.log(C.dim(`  💡 Tip: Copy this into Cursor / Claude Code / Windsurf\n`));
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Context failed: ${e.message}\n`));
+    }
+});
+// ─── Context Injection ────────────────────────────────
+program
+    .command('context-apply')
+    .description('Write @cell context into all AI tool configs (.cursorrules, CLAUDE.md, etc.)')
+    .option('-p, --project <path>', 'Root path to apply context to')
+    .action(async (opts) => {
+    const dir = opts.project || process.cwd();
+    try {
+        const { initializeDatabase } = await Promise.resolve().then(() => __importStar(require('./core/database')));
+        const { buildContext, formatContextForInjection } = await Promise.resolve().then(() => __importStar(require('./core/prompt-builder')));
+        initializeDatabase();
+        const cellBlock = '\n\n# ─── @cell Context — Auto-generated by FIVO Cell ───\n' +
+            '# Update: cell context-apply\n' +
+            formatContextForInjection(buildContext(dir, undefined), true)
+                .split('\n').map((l) => '# ' + l).join('\n') +
+            '\n# ─── End @cell Context ───\n';
+        const configs = [
+            { path: path.join(dir, '.cursorrules'), name: 'Cursor' },
+            { path: path.join(dir, 'CLAUDE.md'), name: 'Claude Code' },
+            { path: path.join(dir, '.antigravity-rules.md'), name: 'Antigravity' },
+            { path: path.join(dir, '.github', 'copilot-instructions.md'), name: 'Copilot' },
+            { path: path.join(dir, 'AGENT.md'), name: 'OpenCode' },
+        ];
+        let applied = 0;
+        for (const cfg of configs) {
+            try {
+                const exists = fs.existsSync(cfg.path);
+                let content = exists ? fs.readFileSync(cfg.path, 'utf-8') : '';
+                const marker = '# ─── @cell Context';
+                if (content.includes(marker)) {
+                    content = content.split(marker)[0].trimEnd();
+                }
+                const parent = path.dirname(cfg.path);
+                if (!fs.existsSync(parent))
+                    fs.mkdirSync(parent, { recursive: true });
+                fs.writeFileSync(cfg.path, content + '\n' + cellBlock);
+                console.log(C.success(`  ✅ ${cfg.name.padEnd(15)} → ${cfg.path}`));
+                applied++;
+            }
+            catch (e) {
+                console.log(C.dim(`  ⚠ ${cfg.name.padEnd(15)} — skipped (${String(e).slice(0, 40)})`));
+            }
+        }
+        console.log(C.success(`\n  🧠 @cell context applied to ${applied} tool configs\n`));
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Failed: ${e.message}\n`));
+    }
+});
+// ─── Predictive Intelligence ─────────────────────────
+program
+    .command('predict')
+    .description('Show all active predictions — pre-failures, decision regrets, scope creep, energy')
+    .option('-p, --project <name>', 'Filter by project')
+    .option('-t, --type <type>', 'Filter: pre_failure|decision_regret|complexity_trap|scope_creep|energy|stack')
+    .action(async (opts) => {
+    try {
+        const { getAllPredictions } = await Promise.resolve().then(() => __importStar(require('./predictive-intelligence')));
+        const predictions = getAllPredictions(opts.project);
+        const filtered = opts.type ? predictions.filter((p) => p.type === opts.type) : predictions;
+        if (filtered.length === 0) {
+            console.log(C.dim('\n  🎉 No predictions — you\'re in a good zone.\n'));
+            return;
+        }
+        const sevIcon = { critical: C.error('🔴'), warning: C.warn('🟡'), info: C.primary('🔵') };
+        console.log(C.bold(`\n  🔮 Predictions (${filtered.length})\n`));
+        for (const p of filtered.slice(0, 15)) {
+            const icon = sevIcon[p.severity] || '⚪';
+            const conf = `${Math.round(p.confidence * 100)}%`;
+            console.log(`  ${icon} ${C.bold(p.title)} ${C.dim(`[${p.type}] ${conf}`)}`);
+            console.log(`    ${p.message}`);
+            if (p.suggestedAction)
+                console.log(`    ${C.dim('→')} ${C.primary(p.suggestedAction)}`);
+            console.log();
+        }
+        const critCount = filtered.filter((p) => p.severity === 'critical').length;
+        const warnCount = filtered.filter((p) => p.severity === 'warning').length;
+        console.log(C.dim(`  ${critCount} critical · ${warnCount} warning · ${filtered.length - critCount - warnCount} info\n`));
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Predict failed: ${e.message}\n`));
+    }
+});
+program
+    .command('predict-risk <file>')
+    .description('Risk score + prediction for a specific file')
+    .action(async (file) => {
+    try {
+        const { calculateFileRisk } = await Promise.resolve().then(() => __importStar(require('./predictive-intelligence')));
+        const risk = calculateFileRisk(file);
+        const score = risk.score;
+        const color = score >= 70 ? C.error : score >= 40 ? C.warn : C.success;
+        console.log(C.bold(`\n  🎯 Risk Score: ${color(`${score}/100`)} for ${file}\n`));
+        if (risk.factors.length === 0) {
+            console.log(C.dim('  No risk factors detected.\n'));
+        }
+        else {
+            console.log(C.bold('  Risk Factors:'));
+            for (const f of risk.factors) {
+                console.log(`    ${C.warn('+')} ${f.name} ${C.dim(`(weight: ${f.weight})`)}: ${f.reason}`);
+            }
+            console.log();
+        }
+        if (risk.predictions.length > 0) {
+            console.log(C.bold('  Related Predictions:'));
+            for (const p of risk.predictions.slice(0, 5)) {
+                console.log(`    ${C.primary('→')} ${p.title}: ${p.message.slice(0, 80)}`);
+            }
+            console.log();
+        }
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Risk calculation failed: ${e.message}\n`));
+    }
+});
+program
+    .command('predict-time <feature>')
+    .description('Estimate completion time for a feature based on history')
+    .action(async (feature) => {
+    try {
+        const { estimateFeatureTime } = await Promise.resolve().then(() => __importStar(require('./predictive-intelligence')));
+        const estimate = estimateFeatureTime(feature);
+        const conf = `${Math.round(estimate.confidence * 100)}%`;
+        console.log(C.bold(`\n  ⏱ Time Estimate: ${C.primary(feature)}\n`));
+        console.log(`    Estimated: ${C.bold(`${estimate.estimatedHours} hours`)} ${C.dim(`(confidence: ${conf})`)}`);
+        console.log(`    Based on: ${estimate.similarPastFeatures} similar past features`);
+        if (estimate.basedOn.length > 0) {
+            console.log(C.dim('\n    Evidence:'));
+            for (const b of estimate.basedOn.slice(0, 3)) {
+                console.log(`    ${C.dim('·')} ${b}`);
+            }
+        }
+        console.log();
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Time estimate failed: ${e.message}\n`));
+    }
+});
+// ─── Cross-Model Memory ────────────────────────────────
+program
+    .command('tool-compare')
+    .description('Compare all AI tools — acceptance rate, best/worst tasks, recommendations')
+    .action(async () => {
+    try {
+        const { compareTools } = await Promise.resolve().then(() => __importStar(require('./cross-model-memory')));
+        const tools = compareTools();
+        if (tools.length === 0) {
+            console.log(C.dim('\n  No tool data yet. Use `cell sessions` to track tool usage.\n'));
+            return;
+        }
+        console.log(C.bold(`\n  🔄 Tool Comparison (${tools.length} tools)\n`));
+        for (const t of tools) {
+            const acc = `${Math.round(t.acceptanceRate * 100)}%`;
+            const color = t.acceptanceRate >= 0.7 ? C.success : t.acceptanceRate >= 0.5 ? C.warn : C.error;
+            console.log(`  ${color('●')} ${C.bold(t.tool)} ${C.dim(`${t.totalSessions} sessions · ${t.avgSessionMinutes}m avg`)}`);
+            console.log(`    Acceptance: ${color(acc)}`);
+            if (t.bestFor.length > 0)
+                console.log(`    ${C.success('✓')} Best for: ${t.bestFor.join(', ')}`);
+            if (t.worstFor.length > 0)
+                console.log(`    ${C.error('✗')} Worst for: ${t.worstFor.join(', ')}`);
+            console.log(`    ${C.dim(t.recommendation)}`);
+            console.log();
+        }
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Tool compare failed: ${e.message}\n`));
+    }
+});
+program
+    .command('tool-suggest <task>')
+    .description('Suggest best AI tool for a specific task type')
+    .action(async (task) => {
+    try {
+        const { suggestTool } = await Promise.resolve().then(() => __importStar(require('./cross-model-memory')));
+        const suggestions = suggestTool(task);
+        if (suggestions.length === 0) {
+            console.log(C.dim(`\n  No data for task "${task}" yet.\n`));
+            return;
+        }
+        console.log(C.bold(`\n  🎯 Best tool for "${task}"\n`));
+        for (const s of suggestions) {
+            const acc = `${Math.round(s.successRate * 100)}%`;
+            const color = s.successRate >= 0.7 ? C.success : s.successRate >= 0.5 ? C.warn : C.error;
+            const conf = `${Math.round(s.confidence * 100)}%`;
+            console.log(`  ${color('→')} ${C.bold(s.tool)} ${C.dim(`(confidence: ${conf})`)}`);
+            console.log(`    Success: ${color(acc)} · Based on ${s.basedOnSessions} sessions`);
+            console.log(`    ${C.dim(s.reason)}`);
+            console.log();
+        }
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Tool suggest failed: ${e.message}\n`));
+    }
+});
+program
+    .command('model-history')
+    .description('Per-model interaction history — sessions, files, decisions')
+    .action(async () => {
+    try {
+        const { getModelHistory } = await Promise.resolve().then(() => __importStar(require('./cross-model-memory')));
+        const history = getModelHistory();
+        if (history.length === 0) {
+            console.log(C.dim('\n  No model history yet. Start sessions with `cell session-start`.\n'));
+            return;
+        }
+        console.log(C.bold(`\n  📊 Model History\n`));
+        for (const h of history) {
+            console.log(`  ${C.primary('●')} ${C.bold(h.tool)} ${C.dim(`${h.sessionsCount} sessions`)}`);
+            console.log(`    Files touched: ${h.totalFilesTouched} · Decisions: ${h.totalDecisions}`);
+            console.log(`    Avg session: ${h.avgSessionMinutes}m · Last used: ${h.lastUsed.slice(0, 10)}`);
+            console.log();
+        }
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Model history failed: ${e.message}\n`));
+    }
+});
+program
+    .command('tool-context <tool>')
+    .description('Show tool-specific @cell context for an AI tool')
+    .action(async (tool) => {
+    try {
+        const { buildToolSpecificContext } = await Promise.resolve().then(() => __importStar(require('./cross-model-memory')));
+        const ctx = buildToolSpecificContext(tool);
+        console.log(C.bold(`\n  🧠 @cell for ${tool}\n`));
+        console.log(ctx);
+        console.log();
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Tool context failed: ${e.message}\n`));
+    }
+});
+// ─── Team Intelligence ──────────────────────────────────
+program
+    .command('team-health')
+    .description('Team health score — bus factor, silos, skill gaps, strengths')
+    .option('-p, --project <name>', 'Filter by project')
+    .action(async (opts) => {
+    try {
+        const { getTeamHealth } = await Promise.resolve().then(() => __importStar(require('./team-collaboration')));
+        const h = getTeamHealth(opts.project);
+        const color = h.score >= 70 ? C.success : h.score >= 40 ? C.warn : C.error;
+        console.log(C.bold(`\n  🏥 Team Health: ${color(`${h.score}/100`)}\n`));
+        console.log(`  Bus Factor: ${C.primary(String(h.busFactor))} · Knowledge Silos: ${C.warn(String(h.siloCount))}`);
+        if (h.strengths.length > 0) {
+            console.log(C.bold('\n  Strengths:'));
+            for (const s of h.strengths)
+                console.log(`    ${C.success('✓')} ${s}`);
+        }
+        if (h.skillGaps.length > 0) {
+            console.log(C.bold('\n  Skill Gaps:'));
+            for (const g of h.skillGaps)
+                console.log(`    ${C.warn('⚠')} ${g}`);
+        }
+        if (h.recommendations.length > 0) {
+            console.log(C.bold('\n  Recommendations:'));
+            for (const r of h.recommendations)
+                console.log(`    ${C.primary('→')} ${r}`);
+        }
+        console.log();
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Team health failed: ${e.message}\n`));
+    }
+});
+program
+    .command('team-retro')
+    .description('Auto-generate sprint retrospective from git + pattern data')
+    .option('-d, --days <days>', 'Lookback period in days', '14')
+    .option('-p, --project <name>', 'Filter by project')
+    .action(async (opts) => {
+    try {
+        const { generateSprintRetro } = await Promise.resolve().then(() => __importStar(require('./team-collaboration')));
+        const retro = generateSprintRetro(parseInt(opts.days) || 14, opts.project);
+        console.log(C.bold(`\n  📋 Sprint Retro: ${retro.period}\n`));
+        console.log(`  Events: ${retro.commits} · Bugs fixed: ${C.primary(String(retro.bugsFixed))} · Patterns: ${retro.newPatterns}`);
+        if (retro.topContributors.length > 0) {
+            console.log(C.bold('\n  Top Contributors:'));
+            for (const c of retro.topContributors)
+                console.log(`    ${C.primary('●')} ${c.name}: ${c.commits} sessions`);
+        }
+        if (retro.keyDecisions.length > 0) {
+            console.log(C.bold('\n  Key Decisions:'));
+            for (const d of retro.keyDecisions)
+                console.log(`    ${C.dim('·')} ${d}`);
+        }
+        console.log(C.dim(`\n  ${retro.summary}\n`));
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Retro failed: ${e.message}\n`));
+    }
+});
+program
+    .command('team-onboard <team>')
+    .description('Generate onboarding package for a new team member')
+    .option('-p, --project <name>', 'Filter by project')
+    .action(async (team, opts) => {
+    try {
+        const { generateOnboardingDoc } = await Promise.resolve().then(() => __importStar(require('./team-collaboration')));
+        const doc = generateOnboardingDoc(team, opts.project);
+        console.log(C.bold(`\n  📦 Onboarding: ${doc.teamName}\n`));
+        console.log(`  Stack: ${doc.stack.join(', ') || 'unknown'}`);
+        console.log(`  Patterns: ${doc.patterns.length} learned`);
+        if (doc.keyMembers.length > 0) {
+            console.log(C.bold('\n  Key Members:'));
+            for (const m of doc.keyMembers)
+                console.log(`    ${C.primary('●')} ${m.name}: ${m.expertise.join(', ')}`);
+        }
+        if (doc.whoToAsk.length > 0) {
+            console.log(C.bold('\n  Who to Ask:'));
+            for (const w of doc.whoToAsk)
+                console.log(`    ${w.area} → ${C.primary(w.person)}`);
+        }
+        if (doc.commonBugs.length > 0) {
+            console.log(C.bold('\n  Common Bugs:'));
+            for (const b of doc.commonBugs)
+                console.log(`    ${C.warn('⚠')} ${b}`);
+        }
+        if (doc.firstWeekTasks.length > 0) {
+            console.log(C.bold('\n  First Week:'));
+            for (let i = 0; i < doc.firstWeekTasks.length; i++) {
+                console.log(`    ${C.dim(`${i + 1}.`)} ${doc.firstWeekTasks[i]}`);
+            }
+        }
+        console.log();
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Onboard failed: ${e.message}\n`));
+    }
+});
+program
+    .command('team-style')
+    .description('Show merged team coding style')
+    .option('-p, --project <name>', 'Filter by project')
+    .action(async (opts) => {
+    try {
+        const { composeTeamStyle } = await Promise.resolve().then(() => __importStar(require('./team-collaboration')));
+        const style = composeTeamStyle(opts.project);
+        console.log(C.bold(`\n  🎨 Team Style\n`));
+        console.log(`  Stack: ${style.languages.join(', ') || 'unknown'}`);
+        console.log(`  Test Coverage: ${style.testCoverage}`);
+        console.log(`  Code Review: ${style.codeReviewStyle}`);
+        console.log(`  Avg Files/Session: ${style.avgFileSize}`);
+        if (style.patterns.length > 0) {
+            console.log(C.bold('\n  Top Patterns:'));
+            for (const p of style.patterns.slice(0, 5))
+                console.log(`    ${C.dim('·')} ${p}`);
+        }
+        console.log();
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Team style failed: ${e.message}\n`));
+    }
+});
+program
+    .command('team-silos')
+    .description('Detect knowledge silos and single points of failure')
+    .action(async () => {
+    try {
+        const { detectKnowledgeSilos, calculateBusFactor, suggestKnowledgeTransfer } = await Promise.resolve().then(() => __importStar(require('./team-collaboration')));
+        const silos = detectKnowledgeSilos();
+        const bus = calculateBusFactor();
+        const transfers = suggestKnowledgeTransfer();
+        console.log(C.bold(`\n  🔒 Knowledge Silos (${silos.length})\n`));
+        if (silos.length === 0) {
+            console.log(C.dim('  No knowledge silos detected.'));
+        }
+        else {
+            for (const s of silos.slice(0, 8)) {
+                const icon = s.riskLevel === 'high' ? C.error('🔴') : s.riskLevel === 'medium' ? C.warn('🟡') : C.success('🟢');
+                console.log(`  ${icon} ${C.bold(s.name)} ${C.dim(`(bus: ${s.busFactor})`)}`);
+                console.log(`    ${s.description}`);
+            }
+        }
+        console.log(C.bold(`\n  🚌 Bus Factor: ${bus.overallScore}/100`));
+        if (bus.singlePointsOfFailure.length > 0) {
+            console.log(C.warn('\n  Single Points of Failure:'));
+            for (const spf of bus.singlePointsOfFailure)
+                console.log(`    ${C.error('⚠')} ${spf}`);
+        }
+        if (transfers.length > 0) {
+            console.log(C.bold('\n  📚 Suggested Knowledge Transfers:'));
+            for (const t of transfers.slice(0, 5)) {
+                console.log(`    ${C.primary('→')} ${t.area}: ${t.from} → ${t.to} ${C.dim(`[${t.priority}]`)}`);
+            }
+        }
+        console.log();
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Silos failed: ${e.message}\n`));
+    }
+});
+program
+    .command('handoff')
+    .description('Generate context handoff for team member transition')
+    .argument('<from>', 'Person handing off')
+    .argument('<to>', 'Person receiving')
+    .argument('<project>', 'Project name')
+    .action(async (from, to, project) => {
+    try {
+        const { generateHandoff } = await Promise.resolve().then(() => __importStar(require('./team-collaboration')));
+        const h = generateHandoff(from, to, project);
+        console.log(C.bold(`\n  🤝 Handoff: ${h.from} → ${h.to} (${h.project})\n`));
+        if (h.keyDecisions.length > 0) {
+            console.log(C.bold('  Key Decisions:'));
+            for (const d of h.keyDecisions)
+                console.log(`    ${C.dim('·')} ${d}`);
+        }
+        if (h.blockers.length > 0) {
+            console.log(C.bold('\n  Known Issues:'));
+            for (const b of h.blockers)
+                console.log(`    ${C.warn('⚠')} ${b}`);
+        }
+        if (h.contextNotes) {
+            console.log(C.bold('\n  Context:'));
+            console.log(`    ${h.contextNotes}`);
+        }
+        console.log();
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Handoff failed: ${e.message}\n`));
+    }
+});
+// ─── Community Intelligence ─────────────────────────────
+program
+    .command('community-compare')
+    .description('Compare your skills against community benchmarks')
+    .action(async () => {
+    try {
+        const { benchmarkPersonal, benchmarkBlindSpots } = await Promise.resolve().then(() => __importStar(require('./community-v2')));
+        const benchmarks = benchmarkPersonal();
+        const blindSpots = benchmarkBlindSpots();
+        console.log(C.bold('\n  📊 Personal vs Community\n'));
+        for (const b of benchmarks) {
+            const color = b.verdict === 'ahead' ? C.success : b.verdict === 'behind' ? C.warn : C.primary;
+            const icon = b.verdict === 'ahead' ? '✓' : b.verdict === 'behind' ? '⚠' : '·';
+            console.log(`  ${color(icon)} ${C.bold(b.metric)} ${C.dim(`(${b.percentile}th percentile)`)}`);
+            console.log(`    ${b.detail}`);
+        }
+        console.log(C.bold('\n  🎯 Blind Spot Benchmark\n'));
+        for (const bs of blindSpots.slice(0, 5)) {
+            const color = bs.percentile >= 60 ? C.success : C.warn;
+            console.log(`  ${color('●')} ${bs.area} ${C.dim(`(${bs.percentile}th percentile)`)}`);
+            console.log(`    ${bs.description}`);
+            console.log(`    ${C.dim(bs.recommendation)}`);
+        }
+        console.log();
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Compare failed: ${e.message}\n`));
+    }
+});
+program
+    .command('community-trends')
+    .description('Show technology and pattern trends from community')
+    .action(async () => {
+    try {
+        const { detectTrends, getCommunityStats } = await Promise.resolve().then(() => __importStar(require('./community-v2')));
+        const trends = detectTrends();
+        const stats = getCommunityStats();
+        console.log(C.bold(`\n  📈 Community Trends (${stats.totalDevelopers} devs)\n`));
+        for (const t of trends.slice(0, 10)) {
+            const icon = t.direction === 'rising' ? C.success('↑') : t.direction === 'declining' ? C.error('↓') : C.dim('→');
+            const yours = t.userHasIt ? C.success(' [YOU USE THIS]') : '';
+            console.log(`  ${icon} ${C.bold(t.technology)} ${C.dim(`${t.adoption}% adoption`)}${yours}`);
+        }
+        console.log();
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Trends failed: ${e.message}\n`));
+    }
+});
+program
+    .command('community-insights')
+    .description('Actionable community insights — benchmarks, blind spots, trends')
+    .action(async () => {
+    try {
+        const { generateInsights } = await Promise.resolve().then(() => __importStar(require('./community-v2')));
+        const insights = generateInsights();
+        if (insights.length === 0) {
+            console.log(C.dim('\n  No insights yet. Use `cell community-compare` to start.\n'));
+            return;
+        }
+        console.log(C.bold(`\n  💡 Community Insights (${insights.length})\n`));
+        for (const i of insights.slice(0, 10)) {
+            const icon = i.type === 'benchmark' ? '📊' : i.type === 'blind_spot' ? '🎯' : i.type === 'trend' ? '📈' : '✅';
+            console.log(`  ${icon} ${C.bold(i.title)}`);
+            console.log(`    ${i.message}`);
+            if (i.suggestedAction)
+                console.log(`    ${C.primary('→')} ${i.suggestedAction}`);
+            console.log();
+        }
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Insights failed: ${e.message}\n`));
+    }
+});
+program
+    .command('community-challenges')
+    .description('Show weekly community challenges')
+    .action(async () => {
+    try {
+        const { getWeeklyChallenges } = await Promise.resolve().then(() => __importStar(require('./community-v2')));
+        const challenges = getWeeklyChallenges();
+        console.log(C.bold('\n  🏆 Weekly Challenges\n'));
+        for (const c of challenges) {
+            const diff = c.difficulty === 'easy' ? C.success('Easy') : c.difficulty === 'medium' ? C.warn('Medium') : C.error('Hard');
+            console.log(`  ${C.bold(c.title)} ${C.dim(`[${diff}]`)}`);
+            console.log(`    ${c.description}`);
+            console.log(`    ${C.dim(`${c.participants} participants · Reward: ${c.reward}`)}`);
+            console.log();
+        }
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Challenges failed: ${e.message}\n`));
+    }
+});
+// ─── Advanced Personal Intelligence ─────────────────────
+program
+    .command('rhythm')
+    .description('Show coding rhythm — best hours, best days, flow patterns')
+    .action(async () => {
+    try {
+        const { detectCodingRhythm } = await Promise.resolve().then(() => __importStar(require('./personal-intelligence')));
+        const r = detectCodingRhythm();
+        console.log(C.bold('\n  ⏰ Coding Rhythm\n'));
+        console.log(`  Best Hours: ${C.success(r.bestHours.join(', ') || 'no data')}`);
+        console.log(`  Best Days: ${C.success(r.bestDays.join(', ') || 'no data')}`);
+        console.log(`  Worst Hours: ${C.error(r.worstHours.join(', ') || 'no data')}`);
+        console.log(`  Worst Days: ${C.error(r.worstDays.join(', ') || 'no data')}`);
+        console.log(`  Avg Session: ${C.primary(String(r.avgSessionMinutes))}min · Optimal: ${C.primary(String(r.optimalSessionMinutes))}min`);
+        console.log(`  Peak Flow: ${C.success(r.peakFlowWindow)}`);
+        console.log();
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Rhythm failed: ${e.message}\n`));
+    }
+});
+program
+    .command('burnout')
+    .description('Check for burnout signals — error rate, session length, reverts')
+    .action(async () => {
+    try {
+        const { detectBurnout } = await Promise.resolve().then(() => __importStar(require('./personal-intelligence')));
+        const b = detectBurnout();
+        const color = b.severity === 'none' ? C.success : b.severity === 'mild' ? C.warn : C.error;
+        console.log(C.bold(`\n  🔥 Burnout Check: ${color(b.severity.toUpperCase())}\n`));
+        console.log(`  Signals: ${b.signals.length}`);
+        for (const s of b.signals)
+            console.log(`    ${C.warn('⚠')} ${s}`);
+        console.log(`  ${C.dim(`Error rate: ${b.metrics.errorRateTrend}`)}`);
+        console.log(`  ${C.dim(`Session length: ${b.metrics.sessionLengthTrend}`)}`);
+        console.log(`  ${C.dim(`Reverts: ${b.metrics.revertRate}`)}`);
+        console.log(`\n  ${C.primary(b.suggestion)}\n`);
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Burnout check failed: ${e.message}\n`));
+    }
+});
+program
+    .command('mastery')
+    .description('Technology mastery map — per-language progress and confidence')
+    .action(async () => {
+    try {
+        const { getTechMasteryMap } = await Promise.resolve().then(() => __importStar(require('./personal-intelligence')));
+        const mastery = getTechMasteryMap();
+        if (mastery.length === 0) {
+            console.log(C.dim('\n  No technologies tracked yet.\n'));
+            return;
+        }
+        console.log(C.bold(`\n  🗺️ Technology Mastery (${mastery.length})\n`));
+        for (const m of mastery) {
+            const stageIcon = m.stage === 'mastered' ? C.success('★') : m.stage === 'advanced' ? C.primary('●') : m.stage === 'proficient' ? C.warn('◐') : C.dim('○');
+            const stageColor = m.stage === 'mastered' ? C.success : m.stage === 'advanced' ? C.primary : m.stage === 'proficient' ? C.warn : C.dim;
+            console.log(`  ${stageIcon} ${C.bold(m.language)} ${stageColor(m.stage)} ${C.dim(`${m.monthsActive}mo · ${m.fileCount} files`)}`);
+            console.log(`    Confidence: ${m.confidence}% · Actual: ${m.actualPerformance}% · Gap: ${m.confidenceGap}%`);
+        }
+        console.log();
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Mastery failed: ${e.message}\n`));
+    }
+});
+program
+    .command('growth')
+    .description('Career trajectory — current level, senior readiness, recommendations')
+    .action(async () => {
+    try {
+        const { getCareerTrajectory } = await Promise.resolve().then(() => __importStar(require('./personal-intelligence')));
+        const t = getCareerTrajectory();
+        const levelColor = t.currentLevel === 'senior' || t.currentLevel === 'staff' ? C.success : t.currentLevel === 'mid' ? C.primary : C.warn;
+        console.log(C.bold(`\n  📈 Career Trajectory\n`));
+        console.log(`  Level: ${levelColor(t.currentLevel.toUpperCase())} ${C.dim(`(${t.levelConfidence}% confidence)`)}`);
+        console.log(`  Senior Readiness: ${C.primary(String(t.seniorReadiness))}% · ETA: ${t.monthsToSenior} months`);
+        console.log(`  Growth Rate: ${t.growthRate}% per month`);
+        if (t.strongAreas.length > 0) {
+            console.log(C.bold('\n  Strong Areas:'));
+            for (const a of t.strongAreas)
+                console.log(`    ${C.success('✓')} ${a}`);
+        }
+        if (t.weakAreas.length > 0) {
+            console.log(C.bold('\n  Weak Areas:'));
+            for (const a of t.weakAreas)
+                console.log(`    ${C.warn('⚠')} ${a}`);
+        }
+        if (t.recommendations.length > 0) {
+            console.log(C.bold('\n  Recommendations:'));
+            for (const r of t.recommendations)
+                console.log(`    ${C.primary('→')} ${r}`);
+        }
+        console.log();
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Growth failed: ${e.message}\n`));
+    }
+});
+program
+    .command('insights-weekly')
+    .description('Weekly digest — sessions, bugs, decisions, highlights')
+    .action(async () => {
+    try {
+        const { generateWeeklyDigest } = await Promise.resolve().then(() => __importStar(require('./personal-intelligence')));
+        const d = generateWeeklyDigest();
+        console.log(C.bold(`\n  📋 Weekly Digest: ${d.period}\n`));
+        console.log(`  Sessions: ${C.primary(String(d.totalSessions))} · Bugs: ${d.totalBugs} · Decisions: ${d.totalDecisions} · Patterns: ${d.newPatterns}`);
+        console.log(`  Top Languages: ${d.topLanguages.join(', ') || 'none'}`);
+        if (d.highlights.length > 0) {
+            console.log(C.bold('\n  Highlights:'));
+            for (const h of d.highlights)
+                console.log(`    ${C.success('✓')} ${h}`);
+        }
+        if (d.areasToFocus.length > 0) {
+            console.log(C.bold('\n  Focus Areas:'));
+            for (const f of d.areasToFocus)
+                console.log(`    ${C.warn('⚠')} ${f}`);
+        }
+        console.log();
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Weekly digest failed: ${e.message}\n`));
+    }
+});
+// ─── Production Hardening ───────────────────────────────
+program
+    .command('health')
+    .description('System health — DB status, memory, uptime, platform')
+    .action(async () => {
+    try {
+        const { getHealthStatus } = await Promise.resolve().then(() => __importStar(require('./production')));
+        const h = getHealthStatus();
+        const color = h.status === 'healthy' ? C.success : h.status === 'degraded' ? C.warn : C.error;
+        console.log(C.bold(`\n  🏥 System Health: ${color(h.status.toUpperCase())}\n`));
+        console.log(`  Uptime: ${C.primary(formatUptime(h.uptime))}`);
+        console.log(`  Platform: ${h.platform} · Node: ${process.version}`);
+        console.log(`  DB: ${color(h.dbStatus)} · Size: ${formatBytes(h.dbSizeBytes)}`);
+        console.log(`  Memory: ${C.primary(String(h.memoryUsageMB))}MB`);
+        console.log(`  Last Scan: ${h.lastScan}`);
+        console.log(`  Version: ${h.version}`);
+        console.log();
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Health check failed: ${e.message}\n`));
+    }
+});
+program
+    .command('metrics')
+    .description('System metrics — queries/sec, patterns, sessions, DB tables')
+    .action(async () => {
+    try {
+        const { getMetrics } = await Promise.resolve().then(() => __importStar(require('./production')));
+        const m = getMetrics();
+        console.log(C.bold('\n  📊 System Metrics\n'));
+        console.log(`  Queries/sec: ${C.primary(String(m.queriesPerSecond))}`);
+        console.log(`  Patterns: ${C.primary(String(m.patternsCount))}`);
+        console.log(`  Sessions: ${m.sessionsCount}`);
+        console.log(`  DB Size: ${formatBytes(m.dbSizeBytes)}`);
+        console.log(`  Memory: ${m.memoryUsageMB}MB`);
+        console.log(`  Uptime: ${formatUptime(m.uptimeSeconds)}`);
+        console.log(C.bold('\n  Table Counts:'));
+        for (const [table, count] of Object.entries(m.dbTableCounts).sort((a, b) => b[1] - a[1]).slice(0, 10)) {
+            console.log(`    ${table}: ${count}`);
+        }
+        console.log();
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Metrics failed: ${e.message}\n`));
+    }
+});
+program
+    .command('security')
+    .description('Security status — auth, encryption, rate limits')
+    .action(async () => {
+    try {
+        const { generateToken, rotateAuthToken } = await Promise.resolve().then(() => __importStar(require('./production')));
+        const config = JSON.parse(require('fs').readFileSync(require('path').join(require('os').homedir(), '.fivo', 'cell', 'security.json'), 'utf-8'));
+        console.log(C.bold('\n  🔒 Security Status\n'));
+        console.log(`  Auth Token: ${config.authToken.slice(0, 8)}...${config.authToken.slice(-4)}`);
+        console.log(`  Rate Limit: ${config.rateLimitPerMinute}/min`);
+        console.log(`  Last Rotation: ${config.lastTokenRotation}`);
+        console.log(`  Encryption: ${config.encryptionEnabled ? C.success('Enabled') : C.warn('Disabled')}`);
+        console.log();
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Security check failed: ${e.message}\n`));
+    }
+});
+program
+    .command('backup')
+    .description('Create backup of cell database')
+    .action(async () => {
+    try {
+        const { autoBackup } = await Promise.resolve().then(() => __importStar(require('./production')));
+        const result = autoBackup();
+        if (result) {
+            console.log(C.success(`\n  ✅ Backup created: ${result.path}`));
+            console.log(`  Size: ${formatBytes(result.size)}\n`);
+        }
+        else {
+            console.log(C.error('\n  ❌ Backup failed\n'));
+        }
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Backup failed: ${e.message}\n`));
+    }
+});
+program
+    .command('optimize')
+    .description('Optimize database — VACUUM, ANALYZE, prune')
+    .action(async () => {
+    try {
+        const { optimizeDatabase } = await Promise.resolve().then(() => __importStar(require('./production')));
+        const result = optimizeDatabase();
+        console.log(C.success('\n  ✅ Database optimized\n'));
+        console.log(`  Before: ${formatBytes(result.before.dbSizeBytes)}`);
+        console.log(`  After: ${formatBytes(result.after.dbSizeBytes)}`);
+        console.log(`  Freed: ${formatBytes(result.freed)}\n`);
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Optimize failed: ${e.message}\n`));
+    }
+});
+// ─── IDE Intelligence ──────────────────────────────────────
+program
+    .command('debug-style')
+    .description('Debugging style — console.log vs debugger, efficiency, recommendations')
+    .action(async () => {
+    try {
+        const { initializeIDETables, getDebugStyle } = await Promise.resolve().then(() => __importStar(require('./ide-intelligence')));
+        initializeIDETables();
+        const s = getDebugStyle();
+        console.log(C.bold('\n  🐛 Debug Style\n'));
+        console.log(`  Total Sessions: ${C.primary(String(s.totalSessions))}`);
+        console.log(`  Preferred: ${C.primary(s.preferredMethod)}`);
+        console.log(`  Console.log: ${C.primary(s.consoleLogPercent + '%')}`);
+        console.log(`  Debugger: ${s.debuggerPercent + '%'}%`);
+        console.log(`  Avg Resolution: ${s.avgResolutionTimeMs}ms`);
+        console.log(`  Efficiency: ${C.primary(String(s.efficiencyScore))}/100`);
+        console.log(`\n  ${C.dim(s.recommendation)}\n`);
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Debug style failed: ${e.message}\n`));
+    }
+});
+program
+    .command('prompt-style')
+    .description('Prompt style — length, structure, iteration patterns')
+    .action(async () => {
+    try {
+        const { initializeIDETables, getPromptStyle } = await Promise.resolve().then(() => __importStar(require('./ide-intelligence')));
+        initializeIDETables();
+        const s = getPromptStyle();
+        console.log(C.bold('\n  💬 Prompt Style\n'));
+        console.log(`  Total Prompts: ${C.primary(String(s.totalPrompts))}`);
+        console.log(`  Avg Words: ${C.primary(String(s.avgWordCount))}`);
+        console.log(`  Style: ${C.primary(s.preferredStyle)}`);
+        console.log(`  Code-First: ${s.structureBreakdown['code-first'] || 0}%`);
+        console.log(`  Avg Iterations: ${s.avgIterations}`);
+        console.log(`  Acceptance: ${C.primary(s.acceptanceRate + '%')}`);
+        console.log(`  Best Length: ${s.bestPromptLength}`);
+        console.log(`\n  ${C.dim(s.recommendation)}\n`);
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Prompt style failed: ${e.message}\n`));
+    }
+});
+program
+    .command('focus')
+    .description('Focus analysis — deep work, shallow work, tab switching')
+    .action(async () => {
+    try {
+        const { initializeIDETables, getFocusAnalysis } = await Promise.resolve().then(() => __importStar(require('./ide-intelligence')));
+        initializeIDETables();
+        const f = getFocusAnalysis();
+        console.log(C.bold('\n  🎯 Focus Analysis\n'));
+        console.log(`  Total Focus: ${formatUptime(Math.round(f.totalFocusTimeMs / 1000))}`);
+        console.log(`  Deep Work: ${C.primary(f.deepWorkPercent + '%')}`);
+        console.log(`  Shallow Work: ${f.shallowWorkPercent}%`);
+        console.log(`  Avg Block: ${formatUptime(Math.round(f.avgFocusBlockMs / 1000))}`);
+        console.log(`  Longest: ${formatUptime(Math.round(f.longestFocusMs / 1000))}`);
+        console.log(`  Peak Hour: ${f.peakFocusHour}:00`);
+        console.log(`  Score: ${C.primary(String(f.focusScore))}/100`);
+        console.log(`\n  ${C.dim(f.recommendation)}\n`);
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Focus analysis failed: ${e.message}\n`));
+    }
+});
+program
+    .command('ide-insights')
+    .description('Full IDE intelligence — debug, prompt, focus, copy-paste, refactor combined')
+    .action(async () => {
+    try {
+        const { initializeIDETables, getIDEInsights } = await Promise.resolve().then(() => __importStar(require('./ide-intelligence')));
+        initializeIDETables();
+        const i = getIDEInsights();
+        console.log(C.bold('\n  🧠 IDE Intelligence Overview\n'));
+        console.log(`  Overall Score: ${C.primary(String(i.overallScore))}/100`);
+        console.log(`  Debug Efficiency: ${i.debug.efficiencyScore}/100`);
+        console.log(`  Prompt Acceptance: ${i.prompt.acceptanceRate}%`);
+        console.log(`  Focus Score: ${i.focus.focusScore}/100`);
+        console.log(`  Copy-Paste Events: ${i.copyPaste.length}`);
+        console.log(`  Refactor Events: ${i.refactor.length}`);
+        console.log(`  Stuck Events: ${i.stuck.length}`);
+        if (i.topInsights.length > 0) {
+            console.log(C.bold('\n  Top Insights:'));
+            for (const insight of i.topInsights) {
+                console.log(`    ${C.dim('→')} ${insight}`);
+            }
+        }
+        console.log();
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ IDE insights failed: ${e.message}\n`));
+    }
+});
+// ─── Cloud Sync ────────────────────────────────────────────────
+program
+    .command('cloud-status')
+    .description('Cloud sync status — pending, sent, failed, device ID')
+    .action(async () => {
+    try {
+        const { getSyncStatus } = await Promise.resolve().then(() => __importStar(require('./cloud-sync')));
+        const s = getSyncStatus();
+        console.log(C.bold('\n  ☁️  Cloud Sync Status\n'));
+        console.log(`  Device: ${C.primary(s.deviceId.slice(0, 12))}...`);
+        console.log(`  Anonymous: ${C.primary(s.anonymousId)}`);
+        console.log(`  Pending: ${s.pending}`);
+        console.log(`  Sent: ${C.success(String(s.sent))}`);
+        console.log(`  Failed: ${s.failed > 0 ? C.error(String(s.failed)) : C.success('0')}`);
+        console.log(`  Last Sync: ${s.lastSync || 'never'}`);
+        console.log();
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Cloud status failed: ${e.message}\n`));
+    }
+});
+program
+    .command('cloud-validate')
+    .description('Validate a payload for cloud sync — check forbidden fields + size')
+    .argument('[data]', 'JSON data to validate')
+    .action(async (data) => {
+    try {
+        const { validatePayload } = await Promise.resolve().then(() => __importStar(require('./cloud-sync')));
+        const payload = data ? JSON.parse(data) : { test: 'example', language: 'typescript' };
+        const v = validatePayload(payload);
+        console.log(C.bold('\n  🔍 Payload Validation\n'));
+        console.log(`  Valid: ${v.valid ? C.success('YES') : C.error('NO')}`);
+        console.log(`  Size: ${v.payloadSize}B / ${v.maxPayloadSize}B`);
+        if (v.blockedFields.length > 0) {
+            console.log(`  Blocked: ${C.error(v.blockedFields.join(', '))}`);
+        }
+        if (v.errors.length > 0) {
+            console.log(`  Errors: ${C.error(v.errors.join('; '))}`);
+        }
+        console.log();
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Validate failed: ${e.message}\n`));
+    }
+});
+program
+    .command('cloud-queue')
+    .description('Show offline queue — pending, failed, sent')
+    .action(async () => {
+    try {
+        const { getPendingQueue, retryFailedEntries } = await Promise.resolve().then(() => __importStar(require('./cloud-sync')));
+        const pending = getPendingQueue();
+        const failed = retryFailedEntries();
+        console.log(C.bold('\n  📦 Offline Queue\n'));
+        console.log(`  Pending: ${C.primary(String(pending.length))}`);
+        console.log(`  Retryable: ${failed.length}`);
+        if (pending.length > 0) {
+            console.log(C.bold('\n  Pending Entries:'));
+            for (const e of pending.slice(0, 5)) {
+                console.log(`    ${C.dim(e.timestamp)} — ${e.priority} — ${e.status}`);
+            }
+        }
+        console.log();
+    }
+    catch (e) {
+        console.log(C.error(`\n  ❌ Queue failed: ${e.message}\n`));
+    }
+});
+function formatUptime(seconds) {
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    const s = seconds % 60;
+    if (h > 0)
+        return `${h}h ${m}m`;
+    if (m > 0)
+        return `${m}m ${s}s`;
+    return `${s}s`;
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${Math.round(bytes / 1024)}KB`;
+    return `${Math.round(bytes / (1024 * 1024))}MB`;
+}
 // ─── Number Command Interception ──────────────────────
 const rawArgs = process.argv.slice(2);
 if (rawArgs.length === 0) {
@@ -1796,5 +3970,21 @@ const nums = parseNumberArg(rawArgs[0]);
 if (nums.length > 0) {
     runNumbers(nums);
 }
+const SKIP_DAEMON_COMMANDS = new Set([
+    'start', 'stop', 'restart', 'status',
+    'install-service', 'uninstall-service', 'service-status',
+    'install', 'mcp', 'connect', 'init', 'run', 'help',
+    '--help', '-h', '--version', '-V',
+]);
+program.hook('preAction', async (thisCommand) => {
+    const cmdName = thisCommand.name();
+    if (SKIP_DAEMON_COMMANDS.has(cmdName))
+        return;
+    const parentName = thisCommand.parent?.name();
+    if (parentName === 'daemon')
+        return;
+    const { ensureDaemon } = await Promise.resolve().then(() => __importStar(require('./daemon/lifecycle')));
+    await ensureDaemon({ silent: true });
+});
 program.parse(process.argv);
 //# sourceMappingURL=cli.js.map