magi-ai 0.1.0

package/dist/src/repl/slash-commands.js

@@ -0,0 +1,725 @@
+/**
+ * Slash command registry for MAGI REPL.
+ *
+ * Each command returns a SlashCommandResult that tells the REPL
+ * whether to run a deliberation (with TUI) or just print inline output.
+ */
+import chalk from 'chalk';
+import { readFile } from 'node:fs/promises';
+import { EVA_PALETTE } from '../tui/colors.js';
+import { validateFile } from '../utils/file-validator.js';
+import { detectLanguage } from '../utils/language-detector.js';
+import { collectRelatedFiles, collectProjectContext } from '../context/auto-collector.js';
+const MAX_REVIEW_FILE_BYTES = 524_288; // 512 KiB
+const { frame, approve, reject, abstain, textPrimary, textSecondary, warning } = EVA_PALETTE;
+const FRAME_C = chalk.rgb(frame.r, frame.g, frame.b);
+const DIM_C = chalk.rgb(abstain.r, abstain.g, abstain.b);
+const TEXT_C = chalk.rgb(textSecondary.r, textSecondary.g, textSecondary.b);
+const OK_C = chalk.rgb(approve.r, approve.g, approve.b);
+const ERR_C = chalk.rgb(reject.r, reject.g, reject.b);
+const HEAD_C = chalk.rgb(textPrimary.r, textPrimary.g, textPrimary.b);
+const WARN_C = chalk.rgb(warning.r, warning.g, warning.b);
+// ── Input parser ────────────────────────────────────────────
+export function parseInput(input) {
+    if (!input.startsWith('/')) {
+        return { isSlash: false, command: '', args: input };
+    }
+    const spaceIdx = input.indexOf(' ');
+    if (spaceIdx === -1) {
+        return { isSlash: true, command: input.slice(1).toLowerCase(), args: '' };
+    }
+    return {
+        isSlash: true,
+        command: input.slice(1, spaceIdx).toLowerCase(),
+        args: input.slice(spaceIdx + 1).trim(),
+    };
+}
+// ── Levenshtein distance (for command suggestion) ───────────
+function levenshtein(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: n + 1 }, (_, i) => i);
+    for (let i = 1; i <= m; i++) {
+        let prev = dp[0];
+        dp[0] = i;
+        for (let j = 1; j <= n; j++) {
+            const tmp = dp[j];
+            dp[j] = a[i - 1] === b[j - 1]
+                ? prev
+                : 1 + Math.min(prev, dp[j], dp[j - 1]);
+            prev = tmp;
+        }
+    }
+    return dp[n];
+}
+export function suggestCommand(input, commands) {
+    if (!input)
+        return undefined;
+    let bestName;
+    let bestDist = Infinity;
+    for (const name of commands) {
+        if (name === input)
+            return undefined; // exact match — already in registry
+        const d = levenshtein(input, name);
+        if (d < bestDist) {
+            bestDist = d;
+            bestName = name;
+        }
+    }
+    // Threshold: distance <= 3 AND <= 50% of input length
+    if (bestDist <= 3 && bestDist <= Math.ceil(input.length / 2)) {
+        return bestName;
+    }
+    return undefined;
+}
+// ── Hierarchical command help ────────────────────────────────
+function opsHelp() {
+    return [
+        '', HEAD_C('  /ops — Runtime Operations:'), '',
+        TEXT_C('  /ops watch start [--interval <ms>]  ') + DIM_C('Start angel detection'),
+        TEXT_C('  /ops watch stop                     ') + DIM_C('Stop angel detection'),
+        TEXT_C('  /ops watch status                   ') + DIM_C('Show watch status'),
+        TEXT_C('  /ops scan <text>                    ') + DIM_C('Firewall scan'),
+        TEXT_C('  /ops prophecy <file>                ') + DIM_C('Dead Sea Scrolls prediction'),
+        '',
+    ].join('\n');
+}
+function diagHelp() {
+    return [
+        '', HEAD_C('  /diag — Diagnostics:'), '',
+        TEXT_C('  /diag iruel                         ') + DIM_C('Iruel battle simulation'),
+        TEXT_C('  /diag evolve [--max <n>]            ') + DIM_C('S² Engine evolution (dry-run)'),
+        TEXT_C('  /diag drift [unit]                  ') + DIM_C('Check drift for a unit'),
+        TEXT_C('  /diag lcl                           ') + DIM_C('Show LCL density'),
+        TEXT_C('  /diag chronicle                     ') + DIM_C('Gospel chronicle stats'),
+        '',
+    ].join('\n');
+}
+function adminHelp() {
+    return [
+        '', HEAD_C('  /admin — Admin (Dangerous Operations):'), '',
+        TEXT_C('  /admin seele [--attack]             ') + DIM_C('Seele council simulation'),
+        TEXT_C('  /admin self-destruct <reason>       ') + DIM_C('Self-destruct sequence'),
+        TEXT_C('  /admin genesis <reason>             ') + DIM_C('Neon Genesis (full reset)'),
+        '',
+    ].join('\n');
+}
+/** Thin wrapper: delegates to shared file-validator and maps result to REPL format. */
+async function validateWorkspaceFile(inputPath, opts) {
+    const result = await validateFile(inputPath, {
+        maxBytes: opts?.maxBytes,
+        rejectBinary: false, // binary check only for /review, not /ops prophecy
+    });
+    if (!result.ok) {
+        const { code, message } = result.error;
+        switch (code) {
+            case 'ENOENT':
+                return { output: ERR_C(`\n  File not found: ${inputPath}\n`) };
+            case 'EACCES':
+                return { output: ERR_C(`\n  Permission denied: ${inputPath}\n`) };
+            case 'PATH_TRAVERSAL':
+                return { output: ERR_C('\n  Error: path traversal denied.\n') };
+            case 'SYMLINK':
+                return { output: ERR_C('\n  Error: symlink targets are not allowed.\n') };
+            case 'NOT_FILE':
+                return { output: ERR_C(`\n  Not a regular file: ${inputPath}\n`) };
+            case 'TOO_LARGE':
+                return { output: ERR_C(`\n  ${message}\n`) };
+            default:
+                return { output: ERR_C(`\n  ${message}\n`) };
+        }
+    }
+    return {
+        file: {
+            absolutePath: result.file.absolutePath,
+            relativePath: result.file.relativePath,
+        },
+    };
+}
+// ── Command registry ────────────────────────────────────────
+export function createSlashCommands() {
+    const commands = new Map();
+    commands.set('help', {
+        description: 'Show available commands',
+        usage: '/help',
+        argKind: 'none',
+        async execute() {
+            const lines = [
+                '',
+                FRAME_C.bold('  Available Commands:'),
+                '',
+                TEXT_C('  /help             ') + DIM_C('Show this message'),
+                TEXT_C('  /doctor           ') + DIM_C('Check MAGI system health'),
+                TEXT_C('  /tokens           ') + DIM_C('Show token usage summary'),
+                TEXT_C('  /review <file>    ') + DIM_C('Code review deliberation'),
+                TEXT_C('  /decide <question>') + DIM_C('Architecture decision'),
+                TEXT_C('  /berserk <prompt> ') + DIM_C('BERSERK mode deliberation'),
+                TEXT_C('  /paste            ') + DIM_C('Multiline input (end with ".")'),
+                TEXT_C('  /sound            ') + DIM_C('Toggle sound on/off'),
+                TEXT_C('  /history          ') + DIM_C('Show recent deliberations'),
+                TEXT_C('  /status           ') + DIM_C('Show MAGI system dashboard'),
+                TEXT_C('  /export [file]    ') + DIM_C('Export last deliberation'),
+                TEXT_C('  /clear            ') + DIM_C('Clear screen'),
+                TEXT_C('  /reset            ') + DIM_C('Reset deliberation context'),
+                TEXT_C('  /quit             ') + DIM_C('Exit MAGI REPL'),
+                '',
+                FRAME_C.bold('  Command Groups:'),
+                '',
+                TEXT_C('  /ops <sub>        ') + DIM_C('Runtime operations (watch, scan, prophecy)'),
+                TEXT_C('  /diag <sub>       ') + DIM_C('Diagnostics (iruel, evolve, drift, lcl)'),
+                TEXT_C('  /admin <sub>      ') + DIM_C('Admin operations (seele, self-destruct, genesis)'),
+                TEXT_C('  /jobs [cancel <id>]') + DIM_C('Background job management'),
+                '',
+                FRAME_C.bold('  Setup & Config:'),
+                '',
+                TEXT_C('  /setup            ') + DIM_C('Guided initial setup'),
+                TEXT_C('  /config           ') + DIM_C('View/edit user configuration'),
+                TEXT_C('  /demo             ') + DIM_C('Watch pre-recorded deliberation'),
+                '',
+                DIM_C('  Or just type a question to start deliberation.'),
+                '',
+            ];
+            return { output: lines.join('\n') };
+        },
+    });
+    commands.set('doctor', {
+        description: 'Check MAGI system health',
+        usage: '/doctor',
+        argKind: 'none',
+        async execute(_args, magi) {
+            const results = await magi.healthCheck();
+            const lines = ['', HEAD_C('  MAGI System Health:'), ''];
+            for (const [unit, result] of results) {
+                if (result instanceof Error) {
+                    lines.push(ERR_C(`  ✗ ${unit}: ${result.message}`));
+                }
+                else {
+                    lines.push(OK_C(`  ✓ ${unit}: ${result}`));
+                }
+            }
+            lines.push('');
+            return { output: lines.join('\n') };
+        },
+    });
+    commands.set('tokens', {
+        description: 'Show token usage summary',
+        usage: '/tokens',
+        argKind: 'none',
+        async execute(_args, magi) {
+            const summaries = await magi.loadAllTokens();
+            if (summaries.length === 0) {
+                return { output: chalk.yellow('\n  No token data found.\n') };
+            }
+            let total = 0;
+            const lines = ['', HEAD_C('  Token Usage:'), ''];
+            for (const s of summaries) {
+                total += s.totalEstimatedTokens;
+                lines.push(DIM_C(`  ${s.deliberationId}: ~${s.totalEstimatedTokens} tokens (${s.recordCount} records)`));
+            }
+            lines.push('', chalk.bold(`  Total: ~${total} tokens`), '');
+            return { output: lines.join('\n') };
+        },
+    });
+    commands.set('review', {
+        description: 'Code review deliberation',
+        usage: '/review <file>',
+        argKind: 'file',
+        async execute(args) {
+            if (!args) {
+                return { output: chalk.yellow('\n  Usage: /review <file>\n') };
+            }
+            // Validate with binary rejection
+            const validation = await validateFile(args, {
+                maxBytes: MAX_REVIEW_FILE_BYTES,
+                rejectBinary: true,
+            });
+            if (!validation.ok) {
+                const { code, message } = validation.error;
+                switch (code) {
+                    case 'ENOENT':
+                        return { output: ERR_C(`\n  File not found: ${args}\n`) };
+                    case 'EACCES':
+                        return { output: ERR_C(`\n  Permission denied: ${args}\n`) };
+                    case 'BINARY':
+                        return { output: ERR_C(`\n  ${message}\n`) };
+                    default:
+                        return { output: ERR_C(`\n  ${message}\n`) };
+                }
+            }
+            const content = await readFile(validation.file.absolutePath, 'utf-8');
+            const language = detectLanguage(args);
+            // Collect related files (graceful degradation)
+            let relatedArtifacts = [];
+            let context;
+            try {
+                const [related, projectCtx] = await Promise.allSettled([
+                    collectRelatedFiles(args, content),
+                    collectProjectContext(),
+                ]);
+                if (related.status === 'fulfilled')
+                    relatedArtifacts = related.value;
+                if (projectCtx.status === 'fulfilled' && projectCtx.value.charCount > 0) {
+                    context = projectCtx.value.text;
+                }
+            }
+            catch { /* graceful degradation */ }
+            return {
+                deliberation: {
+                    task: {
+                        type: 'code-review',
+                        title: `Code Review: ${validation.file.relativePath}`,
+                        description: 'Review the following code file for quality, correctness, security, and best practices.',
+                        artifacts: [
+                            {
+                                type: 'file',
+                                path: validation.file.relativePath,
+                                content,
+                                language,
+                            },
+                            ...relatedArtifacts,
+                        ],
+                        context,
+                    },
+                },
+            };
+        },
+    });
+    commands.set('decide', {
+        description: 'Architecture decision deliberation',
+        usage: '/decide <question>',
+        argKind: 'freeform',
+        async execute(args) {
+            if (!args) {
+                return { output: chalk.yellow('\n  Usage: /decide <question>\n') };
+            }
+            // Collect project context (graceful degradation)
+            let context;
+            try {
+                const ctx = await collectProjectContext();
+                if (ctx.charCount > 0)
+                    context = ctx.text;
+            }
+            catch { /* graceful degradation */ }
+            return {
+                deliberation: {
+                    task: {
+                        type: 'architecture-decision',
+                        title: args.slice(0, 80),
+                        description: args,
+                        context,
+                    },
+                },
+            };
+        },
+    });
+    commands.set('berserk', {
+        description: 'BERSERK mode deliberation',
+        usage: '/berserk <prompt>',
+        argKind: 'freeform',
+        async execute(args) {
+            if (!args) {
+                return { output: chalk.yellow('\n  Usage: /berserk <prompt>\n') };
+            }
+            return {
+                deliberation: {
+                    task: {
+                        type: 'custom',
+                        title: args.slice(0, 80),
+                        description: args,
+                    },
+                    berserk: true,
+                },
+            };
+        },
+    });
+    commands.set('paste', {
+        description: 'Multiline input mode (end with ".")',
+        usage: '/paste',
+        argKind: 'none',
+        async execute() {
+            return { action: 'paste' };
+        },
+    });
+    commands.set('sound', {
+        description: 'Toggle sound on/off',
+        usage: '/sound',
+        argKind: 'none',
+        async execute() {
+            return { action: 'toggle-sound' };
+        },
+    });
+    commands.set('history', {
+        description: 'Show recent deliberations',
+        usage: '/history',
+        argKind: 'none',
+        async execute(_args, _magi, context) {
+            const history = context.getHistory();
+            if (history.length === 0) {
+                return { output: chalk.yellow('\n  No deliberation history in this session.\n') };
+            }
+            const lines = ['', HEAD_C('  Session History:'), ''];
+            for (const [i, entry] of history.entries()) {
+                const time = entry.timestamp.toLocaleTimeString();
+                lines.push(TEXT_C(`  ${i + 1}. [${time}] "${entry.title}"`));
+                lines.push(DIM_C(`     → ${entry.decision}: ${(entry.summary || '(no summary)').slice(0, 120)}`));
+            }
+            lines.push('');
+            return { output: lines.join('\n') };
+        },
+    });
+    commands.set('status', {
+        description: 'Show MAGI system dashboard',
+        usage: '/status',
+        argKind: 'none',
+        async execute(_args, magi) {
+            const status = await magi.getSystemStatus();
+            const lines = ['', HEAD_C('  MAGI System Status:'), ''];
+            const WARN_C = chalk.yellow;
+            for (const u of status.units) {
+                const healthStr = u.health instanceof Error
+                    ? ERR_C(u.health.message)
+                    : OK_C(String(u.health));
+                const cableStr = u.cableStatus === 'connected' ? OK_C('●')
+                    : u.cableStatus === 'degraded' ? WARN_C('◐')
+                        : ERR_C('○');
+                const syncPct = `${Math.round(u.syncRate * 100)}%`;
+                lines.push(`  ${TEXT_C(u.unit.padEnd(14))} ${cableStr} ${healthStr}  ${DIM_C('Sync:')} ${DIM_C(syncPct)}`);
+            }
+            lines.push('');
+            const streak = status.atFieldStreak;
+            const atLabel = streak >= 5
+                ? ERR_C(`  A.T.FIELD: WARNING (${streak} consecutive unanimous)`)
+                : DIM_C(`  A.T.FIELD: Level ${streak}`);
+            lines.push(atLabel, '');
+            return { output: lines.join('\n') };
+        },
+    });
+    commands.set('export', {
+        description: 'Export last deliberation',
+        usage: '/export [filename] [--json]',
+        argKind: 'freeform',
+        async execute(args) {
+            return { action: 'export', output: args || '' };
+        },
+    });
+    commands.set('clear', {
+        description: 'Clear screen',
+        usage: '/clear',
+        argKind: 'none',
+        async execute() {
+            return { action: 'clear' };
+        },
+    });
+    commands.set('reset', {
+        description: 'Reset deliberation context',
+        usage: '/reset',
+        argKind: 'none',
+        async execute() {
+            return { action: 'reset' };
+        },
+    });
+    commands.set('quit', {
+        description: 'Exit MAGI REPL',
+        usage: '/quit',
+        argKind: 'none',
+        async execute() {
+            return { action: 'quit' };
+        },
+    });
+    commands.set('exit', {
+        description: 'Exit MAGI REPL',
+        usage: '/exit',
+        argKind: 'none',
+        aliases: ['quit'],
+        async execute() {
+            return { action: 'quit' };
+        },
+    });
+    // ── Hierarchical command groups ────────────────────────────
+    // /ops - Runtime operations
+    commands.set('ops', {
+        description: 'Runtime operations (watch, scan, prophecy)',
+        usage: '/ops <subcommand>',
+        argKind: 'freeform',
+        async execute(args, magi) {
+            const [sub, ...rest] = (args || '').split(/\s+/);
+            const subArgs = rest.join(' ');
+            switch (sub) {
+                case 'watch': {
+                    const [action, ...watchRest] = subArgs.split(/\s+/);
+                    if (action === 'start') {
+                        const intervalMatch = watchRest.join(' ').match(/--interval\s+(\d+)/);
+                        const pollIntervalMs = intervalMatch ? parseInt(intervalMatch[1], 10) : undefined;
+                        if (pollIntervalMs !== undefined && pollIntervalMs < 1000) {
+                            return { output: WARN_C('  Minimum interval is 1000ms.') };
+                        }
+                        return { watch: { command: 'start', pollIntervalMs } };
+                    }
+                    if (action === 'stop') {
+                        return { watch: { command: 'stop' } };
+                    }
+                    if (action === 'status') {
+                        return { watch: { command: 'status' } };
+                    }
+                    return { output: opsHelp() };
+                }
+                case 'scan': {
+                    if (!subArgs)
+                        return { output: WARN_C('  Usage: /ops scan <text>') };
+                    const result = magi.runtime.scanFirewall(subArgs);
+                    const status = result.passed ? OK_C('PASSED') : ERR_C('BLOCKED');
+                    const lines = [`  Firewall scan: ${status} (score: ${result.totalScore.toFixed(2)})`];
+                    if (result.threats.length > 0) {
+                        for (const t of result.threats) {
+                            lines.push(ERR_C(`    Layer ${t.layer}: ${t.category} — ${t.description}`));
+                        }
+                    }
+                    return { output: lines.join('\n') };
+                }
+                case 'prophecy': {
+                    if (!subArgs)
+                        return { output: WARN_C('  Usage: /ops prophecy <file>') };
+                    const validated = await validateWorkspaceFile(subArgs, { maxBytes: MAX_REVIEW_FILE_BYTES });
+                    if ('output' in validated) {
+                        return { output: validated.output.trimEnd() };
+                    }
+                    try {
+                        const prophecy = await magi.runtime.analyzeFile(validated.file.absolutePath);
+                        const levelColor = prophecy.level === 'PROPHET' ? ERR_C
+                            : prophecy.level === 'ORACLE' ? WARN_C : DIM_C;
+                        return {
+                            output: [
+                                `  ${HEAD_C('Dead Sea Scrolls — 予言')}`,
+                                `  File: ${validated.file.relativePath}`,
+                                `  Probability: ${levelColor(`${(prophecy.probability * 100).toFixed(0)}% (${prophecy.level})`)}`,
+                                `  ${DIM_C(prophecy.narrative.slice(0, 200))}`,
+                            ].join('\n'),
+                        };
+                    }
+                    catch (error) {
+                        return { output: ERR_C(`  Prophecy failed: ${String(error)}`) };
+                    }
+                }
+                default:
+                    return { output: opsHelp() };
+            }
+        },
+    });
+    // /diag - Diagnostics
+    commands.set('diag', {
+        description: 'Diagnostics (iruel, evolve, drift, lcl, chronicle)',
+        usage: '/diag <subcommand>',
+        argKind: 'freeform',
+        async execute(args, magi) {
+            const [sub, ...rest] = (args || '').split(/\s+/);
+            const subArgs = rest.join(' ');
+            switch (sub) {
+                case 'iruel': {
+                    try {
+                        const phase = await magi.diagnostics.simulateIruelBattle();
+                        return { output: `  ${HEAD_C('Iruel Battle')} — Final phase: ${phase}` };
+                    }
+                    catch (error) {
+                        return { output: ERR_C(`  Iruel battle failed: ${String(error)}`) };
+                    }
+                }
+                case 'evolve': {
+                    const maxMatch = subArgs.match(/--max\s+(\d+)/);
+                    const maxProposals = maxMatch ? parseInt(maxMatch[1], 10) : 3;
+                    try {
+                        const gen = await magi.diagnostics.evolve({ dryRun: true, maxProposals });
+                        return {
+                            output: [
+                                `  ${HEAD_C('S² Engine — Generation')} ${gen.generation}`,
+                                `  Proposals: ${gen.proposals.length}`,
+                                `  Approved: ${gen.proposals.filter(p => p.approvedByMeta).length}`,
+                                `  Consensus rate: ${(gen.diagnostics.consensusRate * 100).toFixed(0)}%`,
+                            ].join('\n'),
+                        };
+                    }
+                    catch (error) {
+                        return { output: ERR_C(`  Evolution failed: ${String(error)}`) };
+                    }
+                }
+                case 'drift': {
+                    const unit = subArgs || 'MELCHIOR';
+                    const asi = magi.diagnostics.computeASI(unit);
+                    const drifting = magi.diagnostics.checkDrift(unit);
+                    const color = drifting ? ERR_C : OK_C;
+                    return {
+                        output: `  ${HEAD_C(unit)} ASI: ${color(asi.toFixed(3))} ${drifting ? ERR_C('DRIFT DETECTED') : OK_C('STABLE')}`,
+                    };
+                }
+                case 'lcl': {
+                    const phases = ['initial-opinion', 'cross-examination', 'final-vote'];
+                    const lines = [`  ${HEAD_C('LCL Density:')}`];
+                    for (const p of phases) {
+                        const d = magi.diagnostics.getLCLDensity(p);
+                        lines.push(`    ${p}: ${d.toFixed(2)}`);
+                    }
+                    return { output: lines.join('\n') };
+                }
+                case 'chronicle': {
+                    const count = magi.diagnostics.getChronicleEntryCount();
+                    return { output: `  ${HEAD_C('Gospel Chronicle:')} ${count} entries recorded.` };
+                }
+                default:
+                    return { output: diagHelp() };
+            }
+        },
+    });
+    // /admin - Dangerous operations
+    commands.set('admin', {
+        description: 'Admin operations (seele, self-destruct, genesis)',
+        usage: '/admin <subcommand>',
+        argKind: 'freeform',
+        async execute(args, magi) {
+            const [sub, ...rest] = (args || '').split(/\s+/);
+            const subArgs = rest.join(' ').trim();
+            switch (sub) {
+                case 'seele': {
+                    const attack = subArgs.includes('--attack');
+                    try {
+                        const session = await magi.admin.simulateSeele();
+                        const attackResult = attack
+                            ? await magi.admin.executeSeeleAttack(['MAGI-05', 'MAGI-06'], 'MAGI-01')
+                            : undefined;
+                        return {
+                            output: [
+                                `  ${HEAD_C('Seele Council')}`,
+                                `  Session: ${session.id.slice(0, 8)}`,
+                                `  Leader: ${session.leader ?? 'N/A'}`,
+                                `  Decision: ${session.decision ?? 'N/A'}`,
+                                ...(attackResult ? [`  Defense held: ${attackResult.defenseHeld}`] : []),
+                                '',
+                                magi.admin.formatSeelePanel(),
+                            ].join('\n'),
+                        };
+                    }
+                    catch (error) {
+                        return { output: ERR_C(`  Seele session failed: ${String(error)}`) };
+                    }
+                }
+                case 'self-destruct': {
+                    if (!subArgs)
+                        return { output: WARN_C('  Usage: /admin self-destruct <reason>') };
+                    return {
+                        confirm: {
+                            description: [
+                                '',
+                                ERR_C('  SELF-DESTRUCT SEQUENCE — 自爆シーケンス'),
+                                '',
+                                `  Reason: ${subArgs}`,
+                                '',
+                                WARN_C('  全MAGIユニットが全会一致で承認し、カウントダウンを開始します。'),
+                                WARN_C('  この操作は不可逆です。'),
+                                '',
+                            ].join('\n'),
+                            async execute() {
+                                const motion = magi.admin.fileDestructMotion(subArgs);
+                                for (const unit of ['MELCHIOR', 'BALTHASAR', 'CASPER']) {
+                                    magi.admin.castDestructVote(motion.id, unit, 'APPROVE');
+                                }
+                                const result = await magi.admin.executeDestruct(motion.id);
+                                return {
+                                    output: [
+                                        ERR_C('  SELF-DESTRUCT SEQUENCE COMPLETE'),
+                                        `  Phase: ${result.phase}`,
+                                        result.cipherMessage ? `  裏コード: ${result.cipherMessage}` : '',
+                                    ].filter(Boolean).join('\n'),
+                                };
+                            },
+                        },
+                    };
+                }
+                case 'genesis': {
+                    if (!subArgs)
+                        return { output: WARN_C('  Usage: /admin genesis <reason>') };
+                    return {
+                        confirm: {
+                            description: [
+                                '',
+                                ERR_C('  NEON GENESIS — 世界のやり直し'),
+                                '',
+                                WARN_C('  .magi/ 配下の全審議記録が削除されます。'),
+                                WARN_C('  10% の記憶のみ Fisher-Yates で次世代に引き継がれます。'),
+                                WARN_C('  .cipher ファイルは保全されます。'),
+                                '',
+                                ERR_C('  この操作は不可逆です。'),
+                                '',
+                            ].join('\n'),
+                            async execute() {
+                                const log = await magi.admin.executeGenesis(subArgs, true);
+                                return {
+                                    output: [
+                                        OK_C('  Genesis complete.'),
+                                        `  Previous deliberations: ${log.totalDeliberations}`,
+                                        `  Survival memories: ${log.survivalMemories.length}`,
+                                        `  Reset at: ${log.resetAt}`,
+                                    ].join('\n'),
+                                };
+                            },
+                        },
+                    };
+                }
+                default:
+                    return { output: adminHelp() };
+            }
+        },
+    });
+    // /jobs - Background job management
+    commands.set('jobs', {
+        description: 'List background jobs',
+        usage: '/jobs [cancel <id>]',
+        argKind: 'freeform',
+        async execute(args) {
+            return { action: 'jobs', output: args || '' };
+        },
+    });
+    // ── Setup / Config / Demo ─────────────────────────────────
+    commands.set('setup', {
+        description: 'Run guided initial setup',
+        usage: '/setup',
+        argKind: 'none',
+        async execute() {
+            return {
+                interactive: async () => {
+                    const { runSetup } = await import('../cli/commands/setup.js');
+                    await runSetup();
+                },
+            };
+        },
+    });
+    commands.set('config', {
+        description: 'View or edit user configuration',
+        usage: '/config [set <key> <value> | reset]',
+        argKind: 'freeform',
+        async execute(args) {
+            const { handleConfig } = await import('../cli/commands/config-cmd.js');
+            const parts = args.trim().split(/\s+/);
+            const action = parts[0] || undefined;
+            const key = parts[1] || undefined;
+            const value = parts.slice(2).join(' ') || undefined;
+            await handleConfig(action, key, value);
+            return { output: '' };
+        },
+    });
+    commands.set('demo', {
+        description: 'Watch a pre-recorded MAGI deliberation',
+        usage: '/demo [--speed <n>]',
+        argKind: 'freeform',
+        async execute(args) {
+            return {
+                interactive: async () => {
+                    const { runDemo } = await import('../cli/commands/demo.js');
+                    const speedMatch = args.match(/--speed\s+(\S+)/);
+                    await runDemo({
+                        speed: speedMatch?.[1],
+                        tui: false,
+                    });
+                },
+            };
+        },
+    });
+    return commands;
+}