magi-ai 0.1.0

package/dist/bin/magi.js

@@ -0,0 +1,634 @@
+#!/usr/bin/env node
+import { Command, Option } from 'commander';
+import chalk from 'chalk';
+import { randomBytes } from 'node:crypto';
+import { createInterface } from 'node:readline/promises';
+import { readFile } from 'node:fs/promises';
+import { Magi } from '../src/index.js';
+import { printDeliberation, printHeader } from '../src/reporters/console.js';
+import { initializeTui } from '../src/cli/tui-setup.js';
+import { formatDeliberationJson } from '../src/reporters/json.js';
+import { formatDeliberationMarkdown } from '../src/reporters/markdown.js';
+import { setupGracefulShutdown } from '../src/utils/shutdown.js';
+import { loadUserConfigSafe, mergeWithDefaults } from '../src/config/user-config.js';
+import { setLocale, detectLocale } from '../src/cli/i18n.js';
+import { validateFile } from '../src/utils/file-validator.js';
+import { detectLanguage } from '../src/utils/language-detector.js';
+import { collectProjectContext, collectRelatedFiles } from '../src/context/auto-collector.js';
+setupGracefulShutdown();
+// ── CLI confirmation helper ──────────────────────────────────────
+async function confirmDestructiveAction(description) {
+    if (!process.stdin.isTTY) {
+        console.error(chalk.red('  Error: TTY required for destructive operations. Use --force for non-interactive mode.'));
+        return false;
+    }
+    const token = `yes-${randomBytes(2).toString('hex')}`;
+    console.log(description);
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), 30_000);
+    try {
+        const answer = await rl.question(chalk.dim(`  続行するには "${token}" と入力してください (30秒でタイムアウト): `), { signal: ac.signal });
+        return answer.trim() === token;
+    }
+    catch {
+        console.log(chalk.dim('  タイムアウトまたはキャンセルされました。'));
+        return false;
+    }
+    finally {
+        clearTimeout(timer);
+        rl.close();
+    }
+}
+// ── User config loading ──────────────────────────────────────────
+let cachedUserConfig;
+let cachedMagiConfig;
+/** Load raw user config (includes tui/language). Initializes locale on first load. */
+async function getRawUserConfig() {
+    if (cachedUserConfig !== undefined)
+        return cachedUserConfig;
+    cachedUserConfig = (await loadUserConfigSafe()) ?? undefined;
+    // Apply language setting globally for i18n
+    setLocale(cachedUserConfig?.language ?? detectLocale());
+    return cachedUserConfig;
+}
+async function getUserConfig() {
+    if (cachedMagiConfig !== undefined)
+        return cachedMagiConfig;
+    const raw = await getRawUserConfig();
+    cachedMagiConfig = raw ? mergeWithDefaults(raw) : undefined;
+    return cachedMagiConfig;
+}
+/** Build Magi config by merging user config with command-level overrides. */
+async function buildMagiConfig(overrides = {}) {
+    const base = await getUserConfig();
+    return { ...base, ...overrides };
+}
+/** Resolve TUI enabled: CLI flag overrides user config, default true. */
+async function resolveTuiEnabled(cliFlag) {
+    // Commander sets opts.tui=false only when --no-tui is explicitly passed
+    if (!cliFlag)
+        return false;
+    const raw = await getRawUserConfig();
+    return raw?.tui?.enabled ?? true;
+}
+/** Resolve sound enabled: CLI flag overrides user config. */
+async function resolveSoundEnabled(cliFlag) {
+    if (cliFlag !== undefined)
+        return cliFlag;
+    const raw = await getRawUserConfig();
+    return raw?.tui?.soundEnabled ?? false;
+}
+const program = new Command();
+program
+    .name('magi')
+    .description('MAGI System - Multi-AI CLI Deliberation Framework')
+    .version('0.1.0');
+program
+    .command('deliberate')
+    .description('Start a MAGI deliberation on a topic')
+    .argument('<prompt>', 'The topic or question to deliberate')
+    .addOption(new Option('-t, --type <type>', 'Task type').default('custom')
+    .choices(['code-review', 'architecture-decision', 'bug-analysis', 'implementation-plan', 'security-audit', 'custom']))
+    .option('-r, --rounds <n>', 'Maximum rounds', '3')
+    .option('-o, --output <format>', 'Output format: console, json, markdown', 'console')
+    .option('--no-cross-exam', 'Skip cross-examination phase')
+    .option('--no-cache', 'Disable result caching')
+    .addOption(new Option('--deadlock <strategy>', 'Deadlock strategy')
+    .choices(['escalate', 'melchior-tiebreak', 'highest-confidence', 'human-in-the-loop']))
+    .option('--no-tui', 'Disable Evangelion-themed full-screen TUI mode')
+    .option('--sound', 'Enable terminal bell for MAGI TUI events')
+    .option('--berserk', 'Enable BERSERK mode (5 strategies × 3 units, unanimous deathmatch)')
+    .option('--no-auto-context', 'Disable automatic project context collection')
+    .option('--file-access', 'Allow CLIs to read project files during deliberation')
+    .action(async (prompt, opts) => {
+    const fileAccess = opts.fileAccess ? { enabled: true } : undefined;
+    const magiConfig = await buildMagiConfig({ logLevel: 'warn', cacheEnabled: opts.cache, ...(fileAccess && { fileAccess }) });
+    const magi = new Magi(magiConfig);
+    const tuiEnabled = await resolveTuiEnabled(opts.tui);
+    const soundEnabled = await resolveSoundEnabled(opts.sound);
+    const { tuiInstance } = await initializeTui(magi.getEventBus(), tuiEnabled, { soundEnabled });
+    // Collect project context if enabled
+    let context;
+    if (opts.autoContext) {
+        try {
+            const ctx = await collectProjectContext();
+            if (ctx.charCount > 0)
+                context = ctx.text;
+        }
+        catch { /* graceful degradation */ }
+    }
+    try {
+        let result;
+        if (opts.berserk) {
+            // BERSERK mode: bypass normal orchestrator
+            result = await magi.deliberateBerserk({
+                type: opts.type,
+                title: prompt.slice(0, 80),
+                description: prompt,
+                context,
+            });
+        }
+        else {
+            const phases = opts.crossExam
+                ? ['initial-opinion', 'cross-examination', 'final-vote']
+                : ['initial-opinion', 'final-vote'];
+            const consensusOverride = opts.deadlock
+                ? { deadlockStrategy: opts.deadlock }
+                : undefined;
+            const maxRounds = parseInt(opts.rounds, 10);
+            if (Number.isNaN(maxRounds) || maxRounds < 1) {
+                console.error(chalk.red('\n  Error: --rounds must be a positive integer'));
+                process.exit(1);
+            }
+            result = await magi.deliberate({
+                type: opts.type,
+                title: prompt.slice(0, 80),
+                description: prompt,
+                context,
+                config: {
+                    maxRounds,
+                    phases,
+                    ...(consensusOverride && { consensus: consensusOverride }),
+                },
+            });
+        }
+        // Wait for user to see the result, then dispose TUI
+        if (tuiInstance)
+            await tuiInstance.waitForDismiss();
+        tuiInstance?.dispose();
+        switch (opts.output) {
+            case 'json':
+                console.log(formatDeliberationJson(result));
+                break;
+            case 'markdown':
+                console.log(formatDeliberationMarkdown(result));
+                break;
+            default:
+                printDeliberation(result);
+        }
+    }
+    catch (error) {
+        tuiInstance?.dispose();
+        console.error(chalk.red(`\n  Deliberation failed: ${String(error)}`));
+        process.exit(1);
+    }
+});
+program
+    .command('review')
+    .description('Code review deliberation')
+    .argument('<file>', 'File to review')
+    .option('-o, --output <format>', 'Output format', 'console')
+    .option('--no-cache', 'Disable result caching')
+    .option('--deadlock <strategy>', 'Deadlock strategy')
+    .option('--no-tui', 'Disable Evangelion-themed full-screen TUI mode')
+    .option('--sound', 'Enable terminal bell for MAGI TUI events')
+    .option('--no-auto-context', 'Disable automatic related file collection')
+    .option('--file-access', 'Allow CLIs to read project files during deliberation')
+    .action(async (file, opts) => {
+    // Validate file using shared file-validator
+    const validation = await validateFile(file, {
+        maxBytes: 524_288, // 512 KiB
+        rejectBinary: true,
+    });
+    if (!validation.ok) {
+        console.error(chalk.red(`\n  ${validation.error.message}`));
+        process.exit(1);
+    }
+    const content = await readFile(validation.file.absolutePath, 'utf-8');
+    const language = detectLanguage(file);
+    const fileAccess = opts.fileAccess ? { enabled: true } : undefined;
+    const magiConfig = await buildMagiConfig({ logLevel: 'warn', cacheEnabled: opts.cache, ...(fileAccess && { fileAccess }) });
+    const magi = new Magi(magiConfig);
+    const tuiEnabled = await resolveTuiEnabled(opts.tui);
+    const soundEnabled = await resolveSoundEnabled(opts.sound);
+    const { tuiInstance } = await initializeTui(magi.getEventBus(), tuiEnabled, { soundEnabled });
+    // Collect related files if auto-context enabled
+    let relatedArtifacts = [];
+    let context;
+    if (opts.autoContext) {
+        try {
+            const [related, projectCtx] = await Promise.allSettled([
+                collectRelatedFiles(file, content),
+                collectProjectContext(),
+            ]);
+            if (related.status === 'fulfilled')
+                relatedArtifacts = related.value;
+            if (projectCtx.status === 'fulfilled' && projectCtx.value.charCount > 0) {
+                context = projectCtx.value.text;
+            }
+        }
+        catch { /* graceful degradation */ }
+    }
+    try {
+        const consensusOverride = opts.deadlock
+            ? { deadlockStrategy: opts.deadlock }
+            : undefined;
+        const result = await magi.deliberate({
+            type: 'code-review',
+            title: `Code Review: ${file}`,
+            description: `Review the following code file for quality, correctness, security, and best practices.`,
+            artifacts: [
+                {
+                    type: 'file',
+                    path: validation.file.relativePath,
+                    content,
+                    language,
+                },
+                ...relatedArtifacts,
+            ],
+            context,
+            ...(consensusOverride && { config: { consensus: consensusOverride } }),
+        });
+        // Wait for user to see the result, then dispose TUI
+        if (tuiInstance)
+            await tuiInstance.waitForDismiss();
+        tuiInstance?.dispose();
+        switch (opts.output) {
+            case 'json':
+                console.log(formatDeliberationJson(result));
+                break;
+            case 'markdown':
+                console.log(formatDeliberationMarkdown(result));
+                break;
+            default:
+                printDeliberation(result);
+        }
+    }
+    catch (error) {
+        tuiInstance?.dispose();
+        console.error(chalk.red(`\n  Review failed: ${String(error)}`));
+        process.exit(1);
+    }
+});
+program
+    .command('decide')
+    .description('Architecture decision deliberation')
+    .argument('<question>', 'The architecture question to decide')
+    .option('-o, --output <format>', 'Output format', 'console')
+    .option('--no-cache', 'Disable result caching')
+    .option('--deadlock <strategy>', 'Deadlock strategy')
+    .option('--no-tui', 'Disable Evangelion-themed full-screen TUI mode')
+    .option('--sound', 'Enable terminal bell for MAGI TUI events')
+    .option('--no-auto-context', 'Disable automatic project context collection')
+    .option('--file-access', 'Allow CLIs to read project files during deliberation')
+    .action(async (question, opts) => {
+    const fileAccess = opts.fileAccess ? { enabled: true } : undefined;
+    const magiConfig = await buildMagiConfig({ logLevel: 'warn', cacheEnabled: opts.cache, ...(fileAccess && { fileAccess }) });
+    const magi = new Magi(magiConfig);
+    const tuiEnabled = await resolveTuiEnabled(opts.tui);
+    const soundEnabled = await resolveSoundEnabled(opts.sound);
+    const { tuiInstance } = await initializeTui(magi.getEventBus(), tuiEnabled, { soundEnabled });
+    // Collect project context if enabled
+    let context;
+    if (opts.autoContext) {
+        try {
+            const ctx = await collectProjectContext();
+            if (ctx.charCount > 0)
+                context = ctx.text;
+        }
+        catch { /* graceful degradation */ }
+    }
+    try {
+        const consensusOverride = opts.deadlock
+            ? { deadlockStrategy: opts.deadlock }
+            : undefined;
+        const result = await magi.deliberate({
+            type: 'architecture-decision',
+            title: question.slice(0, 80),
+            description: question,
+            context,
+            ...(consensusOverride && { config: { consensus: consensusOverride } }),
+        });
+        // Wait for user to see the result, then dispose TUI
+        if (tuiInstance)
+            await tuiInstance.waitForDismiss();
+        tuiInstance?.dispose();
+        switch (opts.output) {
+            case 'json':
+                console.log(formatDeliberationJson(result));
+                break;
+            case 'markdown':
+                console.log(formatDeliberationMarkdown(result));
+                break;
+            default:
+                printDeliberation(result);
+        }
+    }
+    catch (error) {
+        tuiInstance?.dispose();
+        console.error(chalk.red(`\n  Decision failed: ${String(error)}`));
+        process.exit(1);
+    }
+});
+program
+    .command('tokens')
+    .description('Show token usage summary for past deliberations')
+    .action(async () => {
+    printHeader();
+    const magi = new Magi(await buildMagiConfig({ logLevel: 'error' }));
+    const summaries = await magi.loadAllTokens();
+    if (summaries.length === 0) {
+        console.log(chalk.yellow('  No token data found.\n'));
+        return;
+    }
+    let grandTotal = 0;
+    for (const s of summaries) {
+        grandTotal += s.totalEstimatedTokens;
+        console.log(chalk.cyan(`  ${s.deliberationId}:`));
+        console.log(`    Tokens: ~${s.totalEstimatedTokens}  Records: ${s.recordCount}`);
+    }
+    console.log(chalk.bold(`\n  Total: ~${grandTotal} tokens\n`));
+});
+program
+    .command('watch')
+    .description('Start angel detection daemon (monitors git for suspicious changes)')
+    .option('-i, --interval <ms>', 'Polling interval in milliseconds', '30000')
+    .action(async (opts) => {
+    printHeader();
+    const pollIntervalMs = parseInt(opts.interval, 10);
+    if (Number.isNaN(pollIntervalMs) || pollIntervalMs < 1) {
+        console.error(chalk.red('\n  Error: --interval must be a positive integer (milliseconds)'));
+        process.exit(1);
+    }
+    const magi = new Magi(await buildMagiConfig({ logLevel: 'warn' }));
+    magi.on('angel:detected', (event) => {
+        const levelColor = event.threatLevel === 'RED' ? chalk.red
+            : event.threatLevel === 'ORANGE' ? chalk.yellow
+                : chalk.cyan;
+        console.log(levelColor(`\n  [ANGEL DETECTED] ${event.angel} — ${event.threatLevel}`));
+        console.log(`    Commit: ${event.commitHash}`);
+        console.log(`    Files:  ${event.affectedFiles.join(', ')}\n`);
+    });
+    console.log(chalk.cyan(`  Starting angel detection daemon (interval: ${opts.interval}ms)...`));
+    console.log(chalk.gray('  Press Ctrl+C to stop.\n'));
+    const handle = magi.runtime.startWatch({ pollIntervalMs });
+    process.on('SIGINT', () => {
+        handle.stop();
+        console.log(chalk.yellow('\n  Angel detection daemon stopped.'));
+        process.exit(0);
+    });
+});
+program
+    .command('self-destruct')
+    .description('Initiate MAGI self-destruct sequence (requires unanimous approval)')
+    .argument('<reason>', 'Reason for self-destruct')
+    .option('--force', 'Skip interactive confirmation')
+    .action(async (reason, opts) => {
+    printHeader();
+    // Interactive confirmation unless --force
+    if (!opts.force) {
+        const confirmed = await confirmDestructiveAction(chalk.red.bold('\n  ⚠ SELF-DESTRUCT SEQUENCE\n') +
+            chalk.gray(`  Reason: ${reason}\n`) +
+            chalk.yellow('  This will permanently destroy all MAGI deliberation data.\n'));
+        if (!confirmed) {
+            console.log(chalk.green('\n  Self-destruct ABORTED.\n'));
+            return;
+        }
+    }
+    const magi = new Magi(await buildMagiConfig({ logLevel: 'warn' }));
+    magi.on('selfdestruct:countdown', (event) => {
+        console.log(chalk.red(`    ${event.depth.label} (${event.depth.depth}m)`));
+    });
+    console.log(chalk.red.bold('\n  ⚠ SELF-DESTRUCT SEQUENCE INITIATED'));
+    console.log(chalk.gray(`  Reason: ${reason}\n`));
+    const motion = magi.admin.fileDestructMotion(reason);
+    console.log(chalk.yellow('  Awaiting votes from all MAGI units...'));
+    console.log(chalk.yellow('  (This is a ceremony — actual file deletion is the caller\'s responsibility)\n'));
+    for (const unit of ['MELCHIOR', 'BALTHASAR', 'CASPER']) {
+        console.log(chalk.cyan(`  ${unit}: APPROVE`));
+        magi.admin.castDestructVote(motion.id, unit, 'APPROVE');
+    }
+    if (magi.admin.getDestructPhase() === 'COUNTDOWN') {
+        console.log(chalk.red.bold('\n  UNANIMOUS APPROVAL — COUNTDOWN INITIATED\n'));
+        const result = await magi.admin.executeDestruct(motion.id);
+        console.log(chalk.red.bold('\n  SELF-DESTRUCT SEQUENCE COMPLETE'));
+        if (result.cipherMessage) {
+            console.log(chalk.magenta(`\n  裏コード: ${result.cipherMessage}`));
+        }
+    }
+    else {
+        console.log(chalk.green('\n  Self-destruct ABORTED — sequence cancelled.'));
+    }
+    console.log('');
+});
+program
+    .command('doctor')
+    .description('Check MAGI system health')
+    .action(async () => {
+    printHeader();
+    console.log(chalk.cyan('  Checking MAGI system health...\n'));
+    const magi = new Magi(await buildMagiConfig({ logLevel: 'error' }));
+    const results = await magi.healthCheck();
+    for (const [unit, result] of results) {
+        if (result instanceof Error) {
+            console.log(chalk.red(`  ✗ ${unit}: ${result.message}`));
+        }
+        else {
+            console.log(chalk.green(`  ✓ ${unit}: ${result}`));
+        }
+    }
+    console.log('');
+});
+program
+    .command('neon-genesis')
+    .description('Execute Neon Genesis — full MAGI system reset')
+    .argument('<reason>', 'Reason for the reset')
+    .option('--force', 'Skip interactive confirmation')
+    .action(async (reason, opts) => {
+    printHeader();
+    // Interactive confirmation unless --force
+    if (!opts.force) {
+        const confirmed = await confirmDestructiveAction(chalk.red.bold('\n  NEON GENESIS — 世界のやり直し\n') +
+            chalk.gray(`  Reason: ${reason}\n`) +
+            chalk.yellow('  This will permanently delete ALL deliberation data in .magi/\n'));
+        if (!confirmed) {
+            console.log(chalk.green('\n  Neon Genesis ABORTED.\n'));
+            return;
+        }
+    }
+    const magi = new Magi(await buildMagiConfig({ logLevel: 'warn' }));
+    magi.on('genesis:started', (e) => {
+        console.log(chalk.red.bold('\n  NEON GENESIS — 世界のやり直し'));
+        console.log(chalk.gray(`  Reset ID: ${e.resetId}`));
+        console.log(chalk.gray(`  Reason: ${reason}\n`));
+    });
+    magi.on('genesis:complete', (e) => {
+        console.log(chalk.cyan(`  Survival memories: ${e.survivalMemories}`));
+        console.log(chalk.cyan(`  Cipher preserved: ${e.cipherPreserved}`));
+    });
+    try {
+        // Always pass force=true since we already confirmed interactively
+        const log = await magi.admin.executeGenesis(reason, true);
+        console.log(chalk.green.bold('\n  Genesis complete.'));
+        console.log(chalk.gray(`  Previous deliberations: ${log.totalDeliberations}`));
+        console.log(chalk.gray(`  Reset at: ${log.resetAt}\n`));
+    }
+    catch (error) {
+        console.error(chalk.red(`\n  Neon Genesis failed: ${String(error)}`));
+        process.exit(1);
+    }
+});
+program
+    .command('iruel-battle')
+    .description('Run Iruel battle simulation (Byzantine fault tolerance test)')
+    .option('--simulation', 'Run full battle simulation')
+    .action(async (opts) => {
+    printHeader();
+    const magi = new Magi(await buildMagiConfig({ logLevel: 'warn' }));
+    magi.on('iruel:infiltration', (e) => {
+        const color = e.corruptionLevel === 'COMPROMISED' ? chalk.red
+            : e.corruptionLevel === 'UNDER_ATTACK' ? chalk.yellow
+                : chalk.cyan;
+        console.log(color(`  [IRUEL] ${e.unit} — ${e.corruptionLevel} (score: ${e.overallScore.toFixed(2)})`));
+    });
+    magi.on('iruel:counterhack', (e) => {
+        console.log(chalk.green(`  [COUNTER-HACK] ${e.strategy.name} → ${e.strategy.targetUnit}`));
+    });
+    magi.on('iruel:neutralized', (e) => {
+        console.log(chalk.green.bold(`\n  [NEUTRALIZED] Battle phase: ${e.phase}`));
+        console.log(chalk.gray(`  Compromised units: ${e.compromisedUnits.join(', ')}\n`));
+    });
+    console.log(chalk.red.bold('\n  IRUEL BATTLE — ビザンチン障害耐性テスト\n'));
+    if (opts.simulation) {
+        const result = await magi.diagnostics.simulateIruelBattle();
+        console.log(chalk.cyan(`  Final phase: ${result}\n`));
+    }
+    else {
+        console.log(chalk.yellow('  Use --simulation to run full battle sequence.\n'));
+        console.log(chalk.gray(`  Current phase: ${magi.diagnostics.getIruelPhase()}\n`));
+    }
+});
+program
+    .command('evolve')
+    .description('Run S² Engine self-evolution cycle')
+    .option('--dry-run', 'Generate proposals without applying (default)')
+    .option('--no-dry-run', 'Apply proposals for real')
+    .option('--no-meta', 'Skip meta-deliberation')
+    .option('--max-proposals <n>', 'Maximum proposals to generate', '3')
+    .action(async (opts) => {
+    printHeader();
+    const magi = new Magi(await buildMagiConfig({ logLevel: 'warn' }));
+    magi.on('evolution:started', (e) => {
+        console.log(chalk.cyan(`\n  S² Engine — Generation ${e.generation}`));
+    });
+    magi.on('evolution:proposal', (e) => {
+        console.log(chalk.yellow(`  [PROPOSAL] ${e.proposal.title} (${e.proposal.category}, confidence: ${(e.proposal.confidence * 100).toFixed(0)}%)`));
+    });
+    console.log(chalk.magenta.bold('\n  S² ENGINE — 自己進化\n'));
+    try {
+        const maxProposals = parseInt(opts.maxProposals, 10);
+        if (Number.isNaN(maxProposals) || maxProposals < 1) {
+            console.error(chalk.red('\n  Error: --max-proposals must be a positive integer'));
+            process.exit(1);
+        }
+        const gen = await magi.diagnostics.evolve({
+            dryRun: opts.dryRun !== false,
+            maxProposals,
+        });
+        console.log(chalk.green(`\n  Evolution cycle complete (Generation ${gen.generation})`));
+        console.log(chalk.gray(`  Proposals: ${gen.proposals.length}`));
+        console.log(chalk.gray(`  Approved: ${gen.proposals.filter(p => p.approvedByMeta).length}`));
+        console.log(chalk.gray(`  Diagnostics: ${gen.diagnostics.totalDeliberations} deliberations, ` +
+            `${(gen.diagnostics.consensusRate * 100).toFixed(0)}% consensus rate\n`));
+    }
+    catch (error) {
+        console.error(chalk.red(`\n  Evolution failed: ${String(error)}`));
+        process.exit(1);
+    }
+});
+program
+    .command('seele')
+    .description('Start Seele council session (distributed MAGI consensus)')
+    .option('--node <id>', 'Local node ID', 'MAGI-01')
+    .option('--port <port>', 'Server port', '7701')
+    .option('--simulation', 'Run simulated session')
+    .option('--attack', 'Include attack phase in simulation')
+    .action(async (opts) => {
+    printHeader();
+    const magi = new Magi(await buildMagiConfig({ logLevel: 'warn' }));
+    magi.on('seele:gathering', (e) => {
+        console.log(chalk.cyan(`  [GATHERING] ${e.nodes.length} nodes connected`));
+    });
+    magi.on('seele:attack', (e) => {
+        console.log(chalk.red(`  [ATTACK] ${e.attackers.join(', ')} → ${e.target}`));
+    });
+    magi.on('seele:concluded', (e) => {
+        console.log(chalk.green(`  [CONCLUDED] Decision: ${e.decision ?? 'N/A'}, Leader: ${e.leader ?? 'N/A'}`));
+    });
+    console.log(chalk.magenta.bold('\n  SEELE — 分散MAGI合議\n'));
+    if (opts.simulation) {
+        const session = await magi.admin.simulateSeele();
+        if (opts.node !== 'MAGI-01' || opts.port !== '7701') {
+            console.log(chalk.yellow('  Note: simulation mode uses the built-in in-memory topology; --node/--port are retained for CLI compatibility.'));
+        }
+        if (opts.attack) {
+            console.log(chalk.red('\n  Executing attack phase...'));
+            const result = await magi.admin.executeSeeleAttack(['MAGI-05', 'MAGI-06'], 'MAGI-01');
+            console.log(chalk.yellow(`  Defense held: ${result.defenseHeld}`));
+        }
+        console.log(chalk.cyan(`\n  Session: ${session.id.slice(0, 8)}`));
+        console.log(chalk.gray(`  Leader: ${session.leader}`));
+        console.log(chalk.gray(`  Decision: ${session.decision}`));
+        console.log(chalk.gray(`  Messages: ${session.messages.length}`));
+        console.log('\n' + magi.admin.formatSeelePanel() + '\n');
+    }
+    else {
+        console.log(chalk.yellow('  Use --simulation to run a simulated session.\n'));
+    }
+});
+// ── Setup & Config commands ──────────────────────────────────────
+program
+    .command('setup')
+    .description('Guided initial setup — detect CLIs and create .magi/config.json')
+    .action(async () => {
+    const { runSetup } = await import('../src/cli/commands/setup.js');
+    await runSetup();
+});
+program
+    .command('demo')
+    .description('Watch a pre-recorded MAGI deliberation')
+    .option('--speed <n>', 'Playback speed multiplier', '1')
+    .option('--no-tui', 'Disable TUI, use text mode')
+    .option('--sound', 'Enable terminal bell')
+    .action(async (opts) => {
+    const { runDemo } = await import('../src/cli/commands/demo.js');
+    const tuiEnabled = await resolveTuiEnabled(opts.tui ?? true);
+    const soundEnabled = await resolveSoundEnabled(opts.sound);
+    await runDemo({ ...opts, tui: tuiEnabled, sound: soundEnabled });
+});
+program
+    .command('config')
+    .description('View or edit user configuration')
+    .argument('[action]', 'show | set | reset')
+    .argument('[key]', 'config key (dot-path)')
+    .argument('[value]', 'new value')
+    .action(async (action, key, value) => {
+    const { handleConfig } = await import('../src/cli/commands/config-cmd.js');
+    await handleConfig(action, key, value);
+});
+// Default action: launch interactive REPL when no subcommand is provided
+program
+    .addOption(new Option('--log-level <level>', 'Log level').choices(['debug', 'info', 'warn', 'error']))
+    .option('--no-cache', 'Disable deliberation cache')
+    .action(async () => {
+    if (!process.stdin.isTTY) {
+        console.error('MAGI REPL requires an interactive terminal (TTY).');
+        process.exit(1);
+    }
+    const opts = program.opts();
+    const cliOverrides = {
+        ...(opts.logLevel ? { logLevel: opts.logLevel } : {}),
+        ...(opts.cache === false ? { cacheEnabled: false } : {}),
+    };
+    const magiConfig = await buildMagiConfig(cliOverrides);
+    const raw = await getRawUserConfig();
+    const { MagiRepl } = await import('../src/repl/magi-repl.js');
+    const repl = new MagiRepl({
+        magiConfig,
+        tuiEnabled: raw?.tui?.enabled ?? true,
+        soundEnabled: raw?.tui?.soundEnabled ?? false,
+    });
+    await repl.start();
+});
+program.parse();

package/dist/src/adapters/base.d.ts

@@ -0,0 +1,34 @@
+import type { ICliAdapter, AdapterConfig, AdapterRequest, AdapterResponse } from '../types/adapter.js';
+import { AdapterError } from '../types/adapter.js';
+import type { MagiUnit, CliTool } from '../types/core.js';
+export declare abstract class AbstractCliAdapter implements ICliAdapter {
+    protected config: AdapterConfig;
+    abstract readonly unit: MagiUnit;
+    abstract readonly tool: CliTool;
+    abstract readonly displayName: string;
+    constructor(config: AdapterConfig);
+    abstract supportsStructuredOutput(): boolean;
+    abstract supportsSystemPrompt(): boolean;
+    abstract buildCommand(request: AdapterRequest): string[];
+    /** All adapters use stdin for prompt delivery (security: no shell injection via args). */
+    protected usesStdinInput(): boolean;
+    /**
+     * Build stdin data with JSON output instructions and optional system context.
+     *
+     * Default implementation embeds CRITICAL INSTRUCTION and few-shot examples
+     * for CLIs that don't support structured output natively (Codex, Gemini).
+     * Subclasses with native structured output (Claude) should override this.
+     */
+    protected getStdinData(request: AdapterRequest): string;
+    healthCheck(): Promise<string>;
+    execute(request: AdapterRequest): Promise<AdapterResponse>;
+    protected executeOnce(request: AdapterRequest, timeoutMs: number): Promise<AdapterResponse>;
+    /**
+     * Parse the CLI's raw output into structured form.
+     *
+     * Default implementation uses extractJson for heuristic JSON extraction.
+     * All three adapters (Claude, Codex, Gemini) share this same logic.
+     */
+    protected parseResponse(raw: string): Omit<AdapterResponse, 'meta'>;
+    protected isRetryable(error: AdapterError): boolean;
+}