magi-ai 0.1.0

package/dist/src/cache/deliberation-cache.js

@@ -0,0 +1,127 @@
+import { createHash } from 'node:crypto';
+/**
+ * In-memory cache for deliberation results.
+ * Keyed by a SHA-256 hash of task attributes (type + title + description + artifacts).
+ */
+export class DeliberationCache {
+    ttlMs;
+    maxEntries;
+    store = new Map();
+    inflight = new Map();
+    constructor(ttlMs = 3_600_000, // 1 hour default
+    maxEntries = 100) {
+        this.ttlMs = ttlMs;
+        this.maxEntries = maxEntries;
+    }
+    /**
+     * Compute a deterministic cache key from a MagiTask.
+     */
+    computeKey(task) {
+        const hash = createHash('sha256');
+        hash.update(task.type);
+        hash.update(task.title);
+        hash.update(task.description);
+        if (task.artifacts) {
+            hash.update(JSON.stringify(task.artifacts));
+        }
+        return hash.digest('hex');
+    }
+    /**
+     * Get a cached deliberation result.
+     * Returns null on miss or TTL expiry.
+     * Restores Date objects and sets fromCache=true.
+     */
+    get(task) {
+        const key = this.computeKey(task);
+        const entry = this.store.get(key);
+        if (!entry)
+            return null;
+        // TTL check (per-entry effectiveTtl includes jitter)
+        if (Date.now() - entry.cachedAt > entry.effectiveTtl) {
+            this.store.delete(key);
+            return null;
+        }
+        // Restore Date objects and mark as cached
+        return {
+            ...entry.deliberation,
+            startedAt: new Date(entry.deliberation.startedAt),
+            completedAt: new Date(entry.deliberation.completedAt),
+            rounds: entry.deliberation.rounds.map((r) => ({
+                ...r,
+                startedAt: new Date(r.startedAt),
+                completedAt: new Date(r.completedAt),
+            })),
+            fromCache: true,
+        };
+    }
+    /**
+     * Store a deliberation result in the cache.
+     */
+    set(task, deliberation) {
+        const key = this.computeKey(task);
+        if (this.store.size >= this.maxEntries && !this.store.has(key)) {
+            const oldestKey = this.store.keys().next().value;
+            if (oldestKey !== undefined)
+                this.store.delete(oldestKey);
+        }
+        // Add 0-10% jitter to stagger TTL expiry (cache stampede prevention)
+        const jitter = Math.floor(Math.random() * 0.1 * this.ttlMs);
+        this.store.set(key, {
+            deliberation,
+            cachedAt: Date.now(),
+            effectiveTtl: this.ttlMs + jitter,
+        });
+    }
+    /**
+     * Get from cache or compute. Prevents cache stampede by coalescing
+     * concurrent requests for the same cache key.
+     */
+    getOrCompute(task, compute) {
+        // Check cache first
+        const cached = this.get(task);
+        if (cached)
+            return Promise.resolve(cached);
+        const key = this.computeKey(task);
+        // Check inflight — coalesce if same key is already being computed
+        const existing = this.inflight.get(key);
+        if (existing)
+            return existing;
+        // Start computation and track it
+        const promise = compute().then(result => {
+            this.set(task, result);
+            this.inflight.delete(key);
+            return result;
+        }).catch(err => {
+            this.inflight.delete(key);
+            throw err;
+        });
+        this.inflight.set(key, promise);
+        return promise;
+    }
+    /**
+     * Remove all entries from the cache.
+     */
+    clear() {
+        this.store.clear();
+    }
+    /**
+     * Remove expired entries.
+     */
+    prune() {
+        const now = Date.now();
+        let pruned = 0;
+        for (const [key, entry] of this.store) {
+            if (now - entry.cachedAt > entry.effectiveTtl) {
+                this.store.delete(key);
+                pruned++;
+            }
+        }
+        return pruned;
+    }
+    /**
+     * Cache statistics.
+     */
+    stats() {
+        return { size: this.store.size, ttlMs: this.ttlMs, maxEntries: this.maxEntries, inflightCount: this.inflight.size };
+    }
+}

package/dist/src/cli/commands/config-cmd.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `magi config` — View and edit user configuration.
+ *
+ *   /config               — Show current settings
+ *   /config set <key> <value> — Change a setting
+ *   /config reset         — Delete config file
+ */
+export declare function handleConfigShow(): Promise<void>;
+export declare function handleConfigSet(key: string, value: string): Promise<void>;
+export declare function handleConfigReset(): Promise<void>;
+export declare function handleConfig(action?: string, key?: string, value?: string): Promise<void>;

package/dist/src/cli/commands/config-cmd.js

@@ -0,0 +1,190 @@
+/**
+ * `magi config` — View and edit user configuration.
+ *
+ *   /config               — Show current settings
+ *   /config set <key> <value> — Change a setting
+ *   /config reset         — Delete config file
+ */
+import chalk from 'chalk';
+import { unlink } from 'node:fs/promises';
+import { loadUserConfig, saveUserConfig, getUserConfigPath } from '../../config/user-config.js';
+import { t, setLocale } from '../i18n.js';
+import { logger } from '../../utils/logger.js';
+const _S = { BAR: '│', BAR_END: '└', STEP_DONE: '◇' };
+void _S;
+const DEADLOCK_LABELS = {
+    ja: {
+        'melchior-tiebreak': 'MELCHIOR優先',
+        'highest-confidence': '確信度で決定',
+        escalate: 'エスカレーション',
+        'human-in-the-loop': '人間に聞く',
+    },
+    en: {
+        'melchior-tiebreak': 'MELCHIOR decides',
+        'highest-confidence': 'Highest confidence',
+        escalate: 'Escalate',
+        'human-in-the-loop': 'Ask human',
+    },
+};
+// ── Show ─────────────────────────────────────────────────────────
+export async function handleConfigShow() {
+    const config = await loadUserConfig().catch(() => undefined);
+    if (config?.language)
+        setLocale(config.language);
+    if (!config) {
+        console.log('');
+        console.log(chalk.yellow(`  ${t('config_no_file')}`));
+        console.log(chalk.dim(`  ${t('config_no_file_hint')}`));
+        console.log('');
+        return;
+    }
+    const lang = config.language ?? 'en';
+    console.log('');
+    console.log(chalk.cyan.bold(`  ${t('config_title')}`));
+    console.log(chalk.dim(`  ${t('config_file')}: ${getUserConfigPath()}`));
+    console.log('');
+    if (config.enabledUnits) {
+        row(t('config_units'), config.enabledUnits.join(', '));
+    }
+    if (config.language) {
+        row(t('config_language'), config.language === 'ja' ? '日本語' : 'English');
+    }
+    const pl = config.defaultPipeline;
+    if (pl) {
+        if (pl.maxRounds !== undefined)
+            row(t('config_max_rounds'), String(pl.maxRounds));
+        if (pl.earlyConsensusExit !== undefined)
+            row(t('config_early_exit'), pl.earlyConsensusExit ? t('on') : t('off'));
+        if (pl.consensus?.deadlockStrategy) {
+            const label = DEADLOCK_LABELS[lang]?.[pl.consensus.deadlockStrategy] ?? pl.consensus.deadlockStrategy;
+            row(t('config_deadlock'), label);
+        }
+        if (pl.consensus?.quorum !== undefined)
+            row(t('config_quorum'), String(pl.consensus.quorum));
+        if (pl.phaseTimeoutMs !== undefined)
+            row(t('config_phase_timeout'), `${pl.phaseTimeoutMs / 1000}s`);
+    }
+    if (config.tui) {
+        if (config.tui.enabled !== undefined)
+            row(t('config_tui'), config.tui.enabled ? t('on') : t('off'));
+        if (config.tui.soundEnabled !== undefined)
+            row(t('config_sound'), config.tui.soundEnabled ? t('on') : t('off'));
+    }
+    if (config.logLevel)
+        row(t('config_log_level'), config.logLevel);
+    if (config.outputFormat)
+        row(t('config_output_format'), config.outputFormat);
+    if (config.cacheEnabled !== undefined)
+        row(t('config_cache'), config.cacheEnabled ? t('on') : t('off'));
+    if (config.fileAccess)
+        row(t('config_file_access'), config.fileAccess.enabled ? t('on') : t('off'));
+    console.log('');
+    console.log(chalk.dim(`  ${t('config_change_hint')}`));
+    console.log(chalk.dim(`  ${t('config_reset_hint')}`));
+    console.log('');
+}
+/** Compute display width accounting for CJK full-width characters. */
+function displayWidth(str) {
+    let w = 0;
+    for (const ch of str) {
+        const cp = ch.codePointAt(0) ?? 0;
+        // CJK Unified Ideographs, Hiragana, Katakana, Fullwidth forms, CJK symbols
+        if ((cp >= 0x3000 && cp <= 0x9FFF) ||
+            (cp >= 0xF900 && cp <= 0xFAFF) ||
+            (cp >= 0xFF01 && cp <= 0xFF60) ||
+            (cp >= 0xFFE0 && cp <= 0xFFE6) ||
+            (cp >= 0x20000 && cp <= 0x2FA1F)) {
+            w += 2;
+        }
+        else {
+            w += 1;
+        }
+    }
+    return w;
+}
+function row(label, value) {
+    const targetWidth = 24;
+    const pad = Math.max(0, targetWidth - displayWidth(label));
+    console.log(`  ${chalk.dim(label + ' '.repeat(pad))} ${chalk.white(value)}`);
+}
+// ── Set ──────────────────────────────────────────────────────────
+export async function handleConfigSet(key, value) {
+    const config = (await loadUserConfig().catch(() => undefined)) ?? {};
+    if (config.language)
+        setLocale(config.language);
+    try {
+        const parsed = parseValue(value);
+        setByPath(config, key, parsed);
+        await saveUserConfig(config);
+        console.log(chalk.green(`\n  ${t('config_set_ok')}: ${key} = ${JSON.stringify(parsed)}\n`));
+    }
+    catch (err) {
+        console.error(chalk.red(`\n  ${t('config_set_invalid')}`));
+        console.error(chalk.dim(`  ${err instanceof Error ? err.message : String(err)}\n`));
+    }
+}
+function parseValue(value) {
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    const num = Number(value);
+    if (!Number.isNaN(num) && Number.isFinite(num) && value.trim() !== '')
+        return num;
+    if (value.includes(','))
+        return value.split(',').map(s => s.trim());
+    return value;
+}
+const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+function setByPath(obj, path, value) {
+    const parts = path.split('.');
+    if (parts.some(p => DANGEROUS_KEYS.has(p))) {
+        throw new Error(`Invalid config path: "${path}" contains a forbidden property name`);
+    }
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (current[part] === undefined || typeof current[part] !== 'object' || current[part] === null) {
+            current[part] = {};
+        }
+        current = current[part];
+    }
+    current[parts[parts.length - 1]] = value;
+}
+// ── Reset ────────────────────────────────────────────────────────
+export async function handleConfigReset() {
+    const configPath = getUserConfigPath();
+    try {
+        await unlink(configPath);
+        console.log(chalk.green(`\n  ${t('config_reset_ok')}\n`));
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            console.log(chalk.yellow(`\n  ${t('config_reset_none')}\n`));
+        }
+        else {
+            logger.error('Failed to delete config', err);
+            console.error(chalk.red(`\n  Error\n`));
+        }
+    }
+}
+// ── Router ───────────────────────────────────────────────────────
+export async function handleConfig(action, key, value) {
+    switch (action) {
+        case undefined:
+        case 'show':
+            return handleConfigShow();
+        case 'set':
+            if (!key || value === undefined) {
+                console.log(chalk.dim(`\n  ${t('config_set_usage')}`));
+                console.log(chalk.dim('  e.g. /config set enabledUnits MELCHIOR,BALTHASAR'));
+                console.log(chalk.dim('       /config set defaultPipeline.maxRounds 5\n'));
+                return;
+            }
+            return handleConfigSet(key, value);
+        case 'reset':
+            return handleConfigReset();
+        default:
+            console.error(chalk.red(`\n  ${t('config_unknown_action')}: ${action}\n`));
+    }
+}

package/dist/src/cli/commands/demo.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `magi demo` — Watch a pre-recorded deliberation.
+ *
+ * Replays recorded MAGI events through the TUI or streaming reporter,
+ * allowing users to experience the deliberation flow without CLI setup.
+ */
+export interface DemoOptions {
+    speed?: string;
+    tui?: boolean;
+    sound?: boolean;
+}
+export declare function runDemo(opts: DemoOptions): Promise<void>;

package/dist/src/cli/commands/demo.js

@@ -0,0 +1,66 @@
+/**
+ * `magi demo` — Watch a pre-recorded deliberation.
+ *
+ * Replays recorded MAGI events through the TUI or streaming reporter,
+ * allowing users to experience the deliberation flow without CLI setup.
+ */
+import chalk from 'chalk';
+import { MagiEventBus } from '../../engine/events.js';
+import { DEMO_EVENTS } from '../../demo/recorded-deliberation.js';
+import { initializeTui } from '../tui-setup.js';
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+export async function runDemo(opts) {
+    const speed = Math.max(0.1, Math.min(10, parseFloat(opts.speed ?? '1')));
+    const useTui = opts.tui !== false;
+    const eventBus = new MagiEventBus();
+    const { tuiInstance } = await initializeTui(eventBus, useTui, { soundEnabled: opts.sound });
+    if (!tuiInstance) {
+        console.log(chalk.cyan.bold('\n  MAGI Demo — REST vs GraphQL\n'));
+        console.log(chalk.gray(`  再生速度: ${speed}x\n`));
+        // Text-mode event listener
+        eventBus.on('deliberation:start', (e) => {
+            console.log(chalk.cyan(`  [START] ${e.taskTitle}`));
+        });
+        eventBus.on('phase:start', (e) => {
+            console.log(chalk.yellow(`  [PHASE] ${e.phase} (Round ${e.roundNumber})`));
+        });
+        eventBus.on('unit:start', (e) => {
+            console.log(chalk.gray(`    ${e.unit} thinking...`));
+        });
+        eventBus.on('unit:complete', (e) => {
+            const voteColor = e.vote === 'APPROVE' ? chalk.green
+                : e.vote === 'REJECT' ? chalk.red
+                    : chalk.yellow;
+            console.log(voteColor(`    ${e.unit}: ${e.vote} (${(e.confidence * 100).toFixed(0)}%)`));
+            if (e.reasoningSummary) {
+                console.log(chalk.gray(`      ${e.reasoningSummary.slice(0, 120)}${e.reasoningSummary.length > 120 ? '...' : ''}`));
+            }
+        });
+        eventBus.on('deliberation:complete', (e) => {
+            const d = String(e.decision);
+            const color = d.includes('APPROVE') ? chalk.green.bold
+                : d.includes('REJECT') ? chalk.red.bold
+                    : chalk.yellow.bold;
+            console.log(color(`\n  [RESULT] ${String(e.decision)} — 全会一致`));
+            console.log(chalk.gray(`  Duration: ${(e.totalDurationMs / 1000).toFixed(1)}s (demo)\n`));
+        });
+    }
+    // Replay events
+    for (const event of DEMO_EVENTS) {
+        if (event.delayMs > 0) {
+            await sleep(event.delayMs / speed);
+        }
+        // Update emittedAt to current time for realistic display
+        const payload = { ...event.payload, emittedAt: new Date() };
+        const eventName = event.type;
+        // Safe cast: pre-recorded events are trusted
+        eventBus.emit(eventName, payload);
+    }
+    // Wait for TUI dismissal
+    if (tuiInstance) {
+        await tuiInstance.waitForDismiss();
+        tuiInstance.dispose();
+    }
+}

package/dist/src/cli/commands/setup.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `magi setup` — Guided initial setup.
+ *
+ * @clack/prompts inspired box-drawing UI.
+ * Detects AI CLIs, lets user choose configuration, saves to config.
+ */
+export declare function runSetup(): Promise<void>;

package/dist/src/cli/commands/setup.js

@@ -0,0 +1,182 @@
+/**
+ * `magi setup` — Guided initial setup.
+ *
+ * @clack/prompts inspired box-drawing UI.
+ * Detects AI CLIs, lets user choose configuration, saves to config.
+ */
+import chalk from 'chalk';
+import { detectAvailableCLIs, getAvailableUnits, suggestConfigurations } from '../../config/cli-detector.js';
+import { saveUserConfig, loadUserConfigSafe } from '../../config/user-config.js';
+import { interactiveSelect, interactiveConfirm, UserCancelledError } from '../interactive-select.js';
+import { t, setLocale, detectLocale, getLocale } from '../i18n.js';
+// ── Box-drawing ──────────────────────────────────────────────────
+const S = {
+    BAR: '│',
+    BAR_END: '└',
+    CORNER_TL: '┌',
+    STEP_ACTIVE: '◆',
+    STEP_DONE: '◇',
+    INFO: '●',
+};
+// ── Unit names ───────────────────────────────────────────────────
+const UNIT_NAMES = {
+    MELCHIOR: 'MELCHIOR (Claude)',
+    BALTHASAR: 'BALTHASAR (Codex)',
+    CASPER: 'CASPER (Gemini)',
+};
+// ── Main ─────────────────────────────────────────────────────────
+export async function runSetup() {
+    if (!process.stdin.isTTY) {
+        console.error(chalk.red(`  ${t('needs_tty')}`));
+        process.exit(1);
+    }
+    // Load existing config to detect saved language
+    const existing = await loadUserConfigSafe();
+    if (existing?.language) {
+        setLocale(existing.language);
+    }
+    else {
+        setLocale(detectLocale());
+    }
+    try {
+        await runSetupFlow(existing);
+    }
+    catch (err) {
+        if (err instanceof UserCancelledError) {
+            console.log('');
+            console.log(chalk.yellow(`  ${t('setup_cancelled')}`));
+            console.log('');
+            return;
+        }
+        throw err;
+    }
+}
+async function runSetupFlow(_existing) {
+    // ── Language selection (first) ─────────────────────────────
+    console.log('');
+    console.log(chalk.gray(S.CORNER_TL));
+    const langOptions = [
+        { label: 'English', value: 'en' },
+        { label: '日本語', value: 'ja' },
+    ];
+    const langDefault = getLocale() === 'ja' ? 1 : 0;
+    const langIdx = await interactiveSelect(t('setup_language'), langOptions, langDefault);
+    const language = langOptions[langIdx].value;
+    setLocale(language);
+    // ── Title ──────────────────────────────────────────────────
+    console.log(chalk.gray(S.BAR));
+    console.log(chalk.gray(S.BAR) + chalk.cyan.bold(`  ${t('setup_title')}`));
+    console.log(chalk.gray(S.BAR));
+    // ── Step 1: CLI Detection ──────────────────────────────────
+    console.log(chalk.cyan(S.STEP_ACTIVE) + chalk.bold(` ${t('setup_step_detect')}`));
+    const detection = await detectAvailableCLIs();
+    const status = (name, available) => {
+        const icon = available ? chalk.green('✓') : chalk.dim('✗');
+        const label = available ? t('setup_installed') : t('setup_not_installed');
+        return `${chalk.gray(S.BAR)}  ${icon} ${chalk.white(name)}  ${chalk.dim(label)}`;
+    };
+    console.log(status('Claude Code', detection.claude.available));
+    console.log(status('Codex CLI  ', detection.codex.available));
+    console.log(status('Gemini CLI ', detection.gemini.available));
+    const available = getAvailableUnits(detection);
+    if (available.length === 0) {
+        console.log(chalk.gray(S.BAR));
+        console.log(chalk.gray(S.BAR_END) + chalk.red(` ${t('setup_no_cli')}`));
+        console.log(chalk.dim(`  ${t('setup_no_cli_hint')}`));
+        console.log('');
+        return;
+    }
+    console.log(chalk.gray(S.BAR));
+    // ── Step 2: Configuration ──────────────────────────────────
+    const suggestions = suggestConfigurations(detection);
+    let enabledUnits;
+    if (suggestions.length <= 1) {
+        enabledUnits = suggestions[0]?.enabledUnits ?? available;
+        const display = enabledUnits.map(u => UNIT_NAMES[u]).join(' + ');
+        console.log(chalk.cyan(S.STEP_DONE) + chalk.dim(` ${t('setup_select_config')} `) + chalk.white(display));
+    }
+    else {
+        const configOptions = suggestions.map(s => ({
+            label: s.enabledUnits.map(u => UNIT_NAMES[u]).join(' + '),
+            value: String(s.unitCount),
+            hint: s.unitCount === 3 ? t('setup_all_ai')
+                : s.unitCount === 2 ? t('setup_two_ai')
+                    : t('setup_single'),
+            recommended: s.recommended,
+        }));
+        const recIdx = suggestions.findIndex(s => s.recommended);
+        const selected = await interactiveSelect(t('setup_select_config'), configOptions, Math.max(0, recIdx));
+        enabledUnits = suggestions[selected].enabledUnits;
+    }
+    // ── Step 3: Settings ───────────────────────────────────────
+    console.log(chalk.gray(S.BAR));
+    console.log(chalk.gray(S.BAR) + chalk.dim(`  ${t('setup_defaults_ok')}`));
+    console.log(chalk.gray(S.BAR));
+    // Rounds
+    const roundOptions = [
+        { label: '1', value: '1', hint: t('setup_rounds_1') },
+        { label: '2', value: '2', hint: t('setup_rounds_2') },
+        { label: '3', value: '3', hint: t('setup_rounds_3'), recommended: true },
+        { label: '5', value: '5', hint: t('setup_rounds_5') },
+    ];
+    const roundIdx = await interactiveSelect(t('setup_rounds'), roundOptions, 2);
+    const maxRounds = parseInt(roundOptions[roundIdx].value, 10);
+    // Early exit
+    const earlyConsensusExit = await interactiveConfirm(t('setup_early_exit'), true);
+    // Deadlock
+    const deadlockOptions = buildDeadlockOptions(enabledUnits);
+    const deadlockIdx = await interactiveSelect(t('setup_deadlock'), deadlockOptions, 0);
+    const deadlockStrategy = deadlockOptions[deadlockIdx].value;
+    // TUI
+    const tuiEnabled = await interactiveConfirm(t('setup_tui'), true);
+    // File access
+    const fileAccessEnabled = await interactiveConfirm(t('setup_file_access'), false);
+    // ── Save ───────────────────────────────────────────────────
+    console.log(chalk.gray(S.BAR));
+    const config = {
+        enabledUnits,
+        defaultPipeline: {
+            maxRounds,
+            earlyConsensusExit,
+            consensus: { deadlockStrategy: deadlockStrategy },
+        },
+        tui: { enabled: tuiEnabled },
+        fileAccess: { enabled: fileAccessEnabled },
+        language,
+    };
+    await saveUserConfig(config);
+    console.log(chalk.gray(S.BAR_END) + chalk.green(` ${t('setup_saved')} `) + chalk.dim(t('setup_saved_path')));
+    console.log('');
+    console.log(chalk.dim(`  ${t('setup_hint_config')}`));
+    console.log(chalk.dim(`  ${t('setup_hint_reset')}`));
+    console.log('');
+}
+// ── Helpers ──────────────────────────────────────────────────────
+function buildDeadlockOptions(enabledUnits) {
+    const options = [];
+    if (enabledUnits.includes('MELCHIOR')) {
+        options.push({
+            label: t('setup_deadlock_melchior'),
+            value: 'melchior-tiebreak',
+            hint: t('setup_deadlock_melchior_hint'),
+            recommended: true,
+        });
+    }
+    options.push({
+        label: t('setup_deadlock_confidence'),
+        value: 'highest-confidence',
+        hint: t('setup_deadlock_confidence_hint'),
+        recommended: !enabledUnits.includes('MELCHIOR'),
+    });
+    options.push({
+        label: t('setup_deadlock_escalate'),
+        value: 'escalate',
+        hint: t('setup_deadlock_escalate_hint'),
+    });
+    options.push({
+        label: t('setup_deadlock_human'),
+        value: 'human-in-the-loop',
+        hint: t('setup_deadlock_human_hint'),
+    });
+    return options;
+}

package/dist/src/cli/i18n.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Minimal i18n for CLI commands (setup, config, etc.)
+ *
+ * TUI stays Japanese (Eva world-building).
+ * CLI setup/config supports ja/en.
+ */
+export type Locale = 'ja' | 'en';
+export declare function getLocale(): Locale;
+export declare function setLocale(locale: Locale): void;
+/** Detect locale from environment or system settings. */
+export declare function detectLocale(): Locale;
+interface Messages {
+    setup_title: string;
+    setup_step_detect: string;
+    setup_step_config: string;
+    setup_step_settings: string;
+    setup_detecting: string;
+    setup_installed: string;
+    setup_not_installed: string;
+    setup_no_cli: string;
+    setup_no_cli_hint: string;
+    setup_select_config: string;
+    setup_select_config_hint: string;
+    setup_all_ai: string;
+    setup_two_ai: string;
+    setup_single: string;
+    setup_recommended: string;
+    setup_rounds: string;
+    setup_rounds_1: string;
+    setup_rounds_2: string;
+    setup_rounds_3: string;
+    setup_rounds_5: string;
+    setup_early_exit: string;
+    setup_early_exit_hint: string;
+    setup_deadlock: string;
+    setup_deadlock_melchior: string;
+    setup_deadlock_melchior_hint: string;
+    setup_deadlock_confidence: string;
+    setup_deadlock_confidence_hint: string;
+    setup_deadlock_escalate: string;
+    setup_deadlock_escalate_hint: string;
+    setup_deadlock_human: string;
+    setup_deadlock_human_hint: string;
+    setup_tui: string;
+    setup_tui_hint: string;
+    setup_file_access: string;
+    setup_file_access_hint: string;
+    setup_language: string;
+    setup_saved: string;
+    setup_saved_path: string;
+    setup_hint_config: string;
+    setup_hint_reset: string;
+    setup_defaults_ok: string;
+    setup_cancelled: string;
+    yes: string;
+    no: string;
+    config_title: string;
+    config_no_file: string;
+    config_no_file_hint: string;
+    config_file: string;
+    config_units: string;
+    config_max_rounds: string;
+    config_early_exit: string;
+    config_deadlock: string;
+    config_quorum: string;
+    config_phase_timeout: string;
+    config_tui: string;
+    config_sound: string;
+    config_log_level: string;
+    config_output_format: string;
+    config_cache: string;
+    config_file_access: string;
+    config_language: string;
+    config_change_hint: string;
+    config_reset_hint: string;
+    config_set_ok: string;
+    config_set_invalid: string;
+    config_set_usage: string;
+    config_reset_ok: string;
+    config_reset_none: string;
+    config_unknown_action: string;
+    on: string;
+    off: string;
+    nav_hint: string;
+    needs_tty: string;
+}
+/** Get localized message. */
+export declare function t(key: keyof Messages): string;
+export {};