magi-ai 0.1.0

package/dist/src/cli/i18n.js

@@ -0,0 +1,176 @@
+/**
+ * Minimal i18n for CLI commands (setup, config, etc.)
+ *
+ * TUI stays Japanese (Eva world-building).
+ * CLI setup/config supports ja/en.
+ */
+let currentLocale = 'ja';
+export function getLocale() {
+    return currentLocale;
+}
+export function setLocale(locale) {
+    currentLocale = locale;
+}
+/** Detect locale from environment or system settings. */
+export function detectLocale() {
+    const lang = process.env.LANG ?? process.env.LC_ALL ?? process.env.LANGUAGE ?? '';
+    if (lang.startsWith('ja'))
+        return 'ja';
+    // Default to English for all non-Japanese locales
+    return 'en';
+}
+const ja = {
+    setup_title: 'MAGI System — 初期セットアップ',
+    setup_step_detect: 'AI CLIを検出',
+    setup_step_config: '構成を選択',
+    setup_step_settings: '動作設定',
+    setup_detecting: '利用可能なAI CLIをスキャン中...',
+    setup_installed: 'インストール済み',
+    setup_not_installed: '未インストール',
+    setup_no_cli: 'AI CLIが見つかりませんでした。',
+    setup_no_cli_hint: 'claude, codex, gemini のいずれかをインストールしてください。',
+    setup_select_config: '使用するAIの構成',
+    setup_select_config_hint: '検出されたCLIから構成を選びます',
+    setup_all_ai: '全AIで合議',
+    setup_two_ai: '2体で合議',
+    setup_single: '単体モード',
+    setup_recommended: '推奨',
+    setup_rounds: '最大ラウンド数',
+    setup_rounds_1: '最速 — 1回で終了',
+    setup_rounds_2: 'バランス型',
+    setup_rounds_3: '標準 — しっかり議論',
+    setup_rounds_5: '慎重 — 複雑な問題向け',
+    setup_early_exit: '意見一致で早期終了',
+    setup_early_exit_hint: 'AIの意見が一致したら残りのラウンドをスキップ',
+    setup_deadlock: '意見が割れた時',
+    setup_deadlock_melchior: 'MELCHIOR優先',
+    setup_deadlock_melchior_hint: 'MELCHIORの判断を採用',
+    setup_deadlock_confidence: '確信度で決定',
+    setup_deadlock_confidence_hint: '最も自信のある意見を採用',
+    setup_deadlock_escalate: 'エスカレーション',
+    setup_deadlock_escalate_hint: '決定を保留して報告',
+    setup_deadlock_human: '人間に聞く',
+    setup_deadlock_human_hint: 'ターミナルで判断を委ねる',
+    setup_tui: 'エヴァンゲリオン風UI (TUI)',
+    setup_tui_hint: 'フルスクリーンのアニメーション表示',
+    setup_file_access: 'ファイルアクセス',
+    setup_file_access_hint: 'CLIがプロジェクトファイルを読み取れるようにする',
+    setup_language: '言語',
+    setup_saved: '設定を保存しました',
+    setup_saved_path: '.magi/config.json',
+    setup_hint_config: '設定の確認: /config',
+    setup_hint_reset: '設定の初期化: /config reset',
+    setup_defaults_ok: 'デフォルトのままでOK',
+    setup_cancelled: 'セットアップを中断しました',
+    yes: 'はい',
+    no: 'いいえ',
+    config_title: 'MAGI 設定',
+    config_no_file: '設定ファイルがありません',
+    config_no_file_hint: '/setup で作成できます',
+    config_file: 'ファイル',
+    config_units: '有効なユニット',
+    config_max_rounds: '最大ラウンド数',
+    config_early_exit: '早期合意終了',
+    config_deadlock: 'デッドロック戦略',
+    config_quorum: '定足数',
+    config_phase_timeout: 'フェーズタイムアウト',
+    config_tui: 'TUI',
+    config_sound: 'サウンド',
+    config_log_level: 'ログレベル',
+    config_output_format: '出力形式',
+    config_cache: 'キャッシュ',
+    config_file_access: 'ファイルアクセス',
+    config_language: '言語',
+    config_change_hint: '変更: /config set <項目> <値>',
+    config_reset_hint: '初期化: /config reset',
+    config_set_ok: '設定を変更しました',
+    config_set_invalid: '無効な設定値です',
+    config_set_usage: '使い方: /config set <項目> <値>',
+    config_reset_ok: '設定を初期化しました',
+    config_reset_none: '設定ファイルがまだありません',
+    config_unknown_action: '不明な操作',
+    on: 'ON',
+    off: 'OFF',
+    nav_hint: '↑↓ 移動  Enter 決定',
+    needs_tty: 'インタラクティブターミナルが必要です',
+};
+const en = {
+    setup_title: 'MAGI System — Setup',
+    setup_step_detect: 'Detect AI CLIs',
+    setup_step_config: 'Choose configuration',
+    setup_step_settings: 'Settings',
+    setup_detecting: 'Scanning for available AI CLIs...',
+    setup_installed: 'installed',
+    setup_not_installed: 'not found',
+    setup_no_cli: 'No AI CLIs found.',
+    setup_no_cli_hint: 'Install at least one of: claude, codex, gemini',
+    setup_select_config: 'AI configuration',
+    setup_select_config_hint: 'Choose which AIs to use for deliberation',
+    setup_all_ai: 'All 3 AIs deliberate together',
+    setup_two_ai: '2 AIs deliberate together',
+    setup_single: 'Single AI mode',
+    setup_recommended: 'recommended',
+    setup_rounds: 'Max rounds',
+    setup_rounds_1: 'Fastest — one pass',
+    setup_rounds_2: 'Balanced',
+    setup_rounds_3: 'Standard — thorough deliberation',
+    setup_rounds_5: 'Careful — for complex problems',
+    setup_early_exit: 'Early consensus exit',
+    setup_early_exit_hint: 'Skip remaining rounds when AIs agree',
+    setup_deadlock: 'When AIs disagree',
+    setup_deadlock_melchior: 'MELCHIOR decides',
+    setup_deadlock_melchior_hint: 'Use MELCHIOR\'s judgment as tiebreaker',
+    setup_deadlock_confidence: 'Highest confidence',
+    setup_deadlock_confidence_hint: 'Pick the most confident opinion',
+    setup_deadlock_escalate: 'Escalate',
+    setup_deadlock_escalate_hint: 'Defer the decision',
+    setup_deadlock_human: 'Ask human',
+    setup_deadlock_human_hint: 'Prompt the user in terminal',
+    setup_tui: 'Evangelion-themed UI (TUI)',
+    setup_tui_hint: 'Full-screen animated display',
+    setup_file_access: 'File access',
+    setup_file_access_hint: 'Let CLIs read project files during deliberation',
+    setup_language: 'Language',
+    setup_saved: 'Configuration saved',
+    setup_saved_path: '.magi/config.json',
+    setup_hint_config: 'View config: /config',
+    setup_hint_reset: 'Reset config: /config reset',
+    setup_defaults_ok: 'Defaults are fine',
+    setup_cancelled: 'Setup cancelled',
+    yes: 'Yes',
+    no: 'No',
+    config_title: 'MAGI Configuration',
+    config_no_file: 'No configuration file found',
+    config_no_file_hint: 'Run /setup to create one',
+    config_file: 'File',
+    config_units: 'Enabled units',
+    config_max_rounds: 'Max rounds',
+    config_early_exit: 'Early consensus exit',
+    config_deadlock: 'Deadlock strategy',
+    config_quorum: 'Quorum',
+    config_phase_timeout: 'Phase timeout',
+    config_tui: 'TUI',
+    config_sound: 'Sound',
+    config_log_level: 'Log level',
+    config_output_format: 'Output format',
+    config_cache: 'Cache',
+    config_file_access: 'File access',
+    config_language: 'Language',
+    config_change_hint: 'Change: /config set <key> <value>',
+    config_reset_hint: 'Reset: /config reset',
+    config_set_ok: 'Configuration updated',
+    config_set_invalid: 'Invalid configuration value',
+    config_set_usage: 'Usage: /config set <key> <value>',
+    config_reset_ok: 'Configuration reset to defaults',
+    config_reset_none: 'No configuration file to reset',
+    config_unknown_action: 'Unknown action',
+    on: 'ON',
+    off: 'OFF',
+    nav_hint: '↑↓ move  Enter select',
+    needs_tty: 'Requires an interactive terminal',
+};
+const catalogs = { ja, en };
+/** Get localized message. */
+export function t(key) {
+    return catalogs[currentLocale][key];
+}

package/dist/src/cli/interactive-select.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Arrow-key interactive selector for terminal UI.
+ *
+ * @clack/prompts inspired box-drawing style.
+ * ↑/↓ to navigate, Enter to select, Ctrl+C to cancel.
+ */
+export interface SelectOption {
+    label: string;
+    value: string;
+    hint?: string;
+    recommended?: boolean;
+}
+/** Thrown when user presses Ctrl+C during interactive selection. */
+export declare class UserCancelledError extends Error {
+    constructor();
+}
+/**
+ * Display an interactive selection menu with box-drawing UI.
+ * Returns the selected index.
+ * Throws UserCancelledError if Ctrl+C is pressed.
+ */
+export declare function interactiveSelect(title: string, options: SelectOption[], defaultIndex?: number): Promise<number>;
+/**
+ * Yes/No selection with box-drawing UI.
+ * Throws UserCancelledError if Ctrl+C is pressed.
+ */
+export declare function interactiveConfirm(message: string, defaultYes?: boolean): Promise<boolean>;

package/dist/src/cli/interactive-select.js

@@ -0,0 +1,130 @@
+/**
+ * Arrow-key interactive selector for terminal UI.
+ *
+ * @clack/prompts inspired box-drawing style.
+ * ↑/↓ to navigate, Enter to select, Ctrl+C to cancel.
+ */
+import chalk from 'chalk';
+import { t } from './i18n.js';
+// ── Box-drawing symbols (clack style) ────────────────────────────
+const S = {
+    BAR: '│',
+    BAR_END: '└',
+    BAR_H: '─',
+    CORNER_TL: '┌',
+    RADIO_ON: '●',
+    RADIO_OFF: '○',
+    CHECK: '◼',
+    STEP_ACTIVE: '◆',
+    STEP_DONE: '◇',
+};
+/** Thrown when user presses Ctrl+C during interactive selection. */
+export class UserCancelledError extends Error {
+    constructor() {
+        super('User cancelled');
+        this.name = 'UserCancelledError';
+    }
+}
+/**
+ * Display an interactive selection menu with box-drawing UI.
+ * Returns the selected index.
+ * Throws UserCancelledError if Ctrl+C is pressed.
+ */
+export async function interactiveSelect(title, options, defaultIndex = 0) {
+    if (!process.stdin.isTTY)
+        return defaultIndex;
+    if (options.length === 0)
+        return -1;
+    if (options.length === 1) {
+        printSingleChoice(title, options[0]);
+        return 0;
+    }
+    let cursor = defaultIndex;
+    return new Promise((resolve, reject) => {
+        const wasRaw = process.stdin.isRaw;
+        const cleanup = () => {
+            process.stdin.removeListener('data', onData);
+            try {
+                process.stdin.setRawMode(wasRaw ?? false);
+            }
+            catch { /* ignore */ }
+        };
+        renderMenu(title, options, cursor);
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        const onData = (data) => {
+            try {
+                const key = data.toString();
+                if (key === '\x1b[A' || key === 'k') {
+                    cursor = (cursor - 1 + options.length) % options.length;
+                    clearAndRender(title, options, cursor);
+                }
+                else if (key === '\x1b[B' || key === 'j') {
+                    cursor = (cursor + 1) % options.length;
+                    clearAndRender(title, options, cursor);
+                }
+                else if (key === '\r' || key === '\n') {
+                    cleanup();
+                    clearLines(options.length + 2);
+                    printSelected(title, options[cursor]);
+                    resolve(cursor);
+                }
+                else if (key === '\x03') {
+                    cleanup();
+                    clearLines(options.length + 2);
+                    console.log(chalk.yellow(S.STEP_DONE) + chalk.dim(` ${title} `) + chalk.yellow('cancelled'));
+                    reject(new UserCancelledError());
+                }
+            }
+            catch (err) {
+                cleanup();
+                reject(err);
+            }
+        };
+        process.stdin.on('data', onData);
+    });
+}
+// ── Rendering ────────────────────────────────────────────────────
+function renderMenu(title, options, cursor) {
+    console.log(chalk.cyan(S.STEP_ACTIVE) + chalk.bold(` ${title}`));
+    for (let i = 0; i < options.length; i++) {
+        const opt = options[i];
+        const active = i === cursor;
+        const radio = active ? chalk.cyan(S.RADIO_ON) : chalk.dim(S.RADIO_OFF);
+        const label = active ? chalk.white(opt.label) : chalk.dim(opt.label);
+        const rec = opt.recommended ? chalk.cyan(` (${t('setup_recommended')})`) : '';
+        const hint = opt.hint ? chalk.dim(` ${opt.hint}`) : '';
+        console.log(chalk.gray(S.BAR) + `  ${radio} ${label}${rec}${hint}`);
+    }
+    console.log(chalk.gray(S.BAR_END) + chalk.dim(` ${t('nav_hint')}`));
+}
+function printSelected(title, option) {
+    const rec = option.recommended ? chalk.cyan(` (${t('setup_recommended')})`) : '';
+    console.log(chalk.cyan(S.STEP_DONE) + chalk.dim(` ${title} `) + chalk.white(option.label) + rec);
+}
+function printSingleChoice(title, option) {
+    console.log(chalk.cyan(S.STEP_DONE) + chalk.dim(` ${title} `) + chalk.white(option.label));
+}
+function clearLines(n) {
+    for (let i = 0; i < n; i++) {
+        process.stdout.write('\x1b[1A\x1b[2K');
+    }
+}
+function clearAndRender(title, options, cursor) {
+    clearLines(options.length + 2);
+    renderMenu(title, options, cursor);
+}
+/**
+ * Yes/No selection with box-drawing UI.
+ * Throws UserCancelledError if Ctrl+C is pressed.
+ */
+export async function interactiveConfirm(message, defaultYes = true) {
+    if (!process.stdin.isTTY)
+        return defaultYes;
+    const options = [
+        { label: t('yes'), value: 'yes' },
+        { label: t('no'), value: 'no' },
+    ];
+    const idx = await interactiveSelect(message, options, defaultYes ? 0 : 1);
+    return idx === 0;
+}

package/dist/src/cli/tui-setup.d.ts

@@ -0,0 +1,24 @@
+/**
+ * TUI initialization helper — extracted from deliberate/review/decide commands
+ * to eliminate 3x code duplication in bin/magi.ts.
+ *
+ * Handles:
+ *   1. Non-TUI mode: prints header + starts StreamingProgressReporter
+ *   2. TUI mode + capable terminal: creates and starts MagiTui instance
+ *   3. TUI mode + incapable terminal: graceful fallback to streaming mode
+ */
+import type { MagiEventBus } from '../engine/events.js';
+export interface TuiSetupResult {
+    tuiInstance?: {
+        dispose: () => void;
+        waitForDismiss: () => Promise<void>;
+    };
+    /** True when a StreamingProgressReporter is already subscribed as fallback. */
+    streamingActive?: boolean;
+    /** Dispose function for StreamingProgressReporter (removes all listeners). */
+    disposeStreaming?: () => void;
+}
+export interface TuiSetupOptions {
+    soundEnabled?: boolean;
+}
+export declare function initializeTui(eventBus: MagiEventBus, enableTui: boolean, options?: TuiSetupOptions): Promise<TuiSetupResult>;

package/dist/src/cli/tui-setup.js

@@ -0,0 +1,42 @@
+/**
+ * TUI initialization helper — extracted from deliberate/review/decide commands
+ * to eliminate 3x code duplication in bin/magi.ts.
+ *
+ * Handles:
+ *   1. Non-TUI mode: prints header + starts StreamingProgressReporter
+ *   2. TUI mode + capable terminal: creates and starts MagiTui instance
+ *   3. TUI mode + incapable terminal: graceful fallback to streaming mode
+ */
+import chalk from 'chalk';
+import { StreamingProgressReporter } from '../reporters/streaming.js';
+import { printHeader } from '../reporters/console.js';
+import { setTuiMode } from '../utils/logger.js';
+// ── Main function ───────────────────────────────────────────
+export async function initializeTui(eventBus, enableTui, options = {}) {
+    if (!enableTui) {
+        printHeader();
+        const reporter = new StreamingProgressReporter(eventBus);
+        return { streamingActive: true, disposeStreaming: () => reporter.dispose() };
+    }
+    const { MagiTui, detectCapabilities, tuiCheckFailure } = await import('../tui/index.js');
+    const caps = detectCapabilities();
+    const failure = tuiCheckFailure(caps);
+    if (failure) {
+        console.error(chalk.yellow(`  TUI unavailable: ${failure} — falling back to streaming mode`));
+        printHeader();
+        const reporter = new StreamingProgressReporter(eventBus);
+        return { streamingActive: true, disposeStreaming: () => reporter.dispose() };
+    }
+    const tui = new MagiTui({ eventBus, soundEnabled: options.soundEnabled });
+    await tui.start();
+    setTuiMode(true);
+    return {
+        tuiInstance: {
+            dispose: () => {
+                setTuiMode(false);
+                tui.dispose();
+            },
+            waitForDismiss: () => tui.waitForDismiss(),
+        },
+    };
+}

package/dist/src/config/cli-detector.d.ts

@@ -0,0 +1,37 @@
+/**
+ * CLI auto-detection and configuration suggestion.
+ *
+ * Detects which AI CLIs (claude, codex, gemini) are available
+ * and generates recommended unit configurations.
+ */
+import type { BuiltinMagiUnit } from '../types/core.js';
+export interface CliStatus {
+    available: boolean;
+    version?: string;
+}
+export interface CliDetectionResult {
+    claude: CliStatus;
+    codex: CliStatus;
+    gemini: CliStatus;
+}
+export interface ConfigSuggestion {
+    enabledUnits: BuiltinMagiUnit[];
+    unitCount: number;
+    description: string;
+    recommended: boolean;
+}
+/**
+ * Detect which AI CLIs are installed and available.
+ * Runs all checks in parallel using Promise.allSettled.
+ */
+export declare function detectAvailableCLIs(): Promise<CliDetectionResult>;
+/**
+ * Get the list of available units from detection result.
+ */
+export declare function getAvailableUnits(detection: CliDetectionResult): BuiltinMagiUnit[];
+/**
+ * Generate configuration suggestions based on detected CLIs.
+ * Returns suggestions sorted by unit count (descending), with the
+ * largest available configuration marked as recommended.
+ */
+export declare function suggestConfigurations(detection: CliDetectionResult): ConfigSuggestion[];

package/dist/src/config/cli-detector.js

@@ -0,0 +1,99 @@
+/**
+ * CLI auto-detection and configuration suggestion.
+ *
+ * Detects which AI CLIs (claude, codex, gemini) are available
+ * and generates recommended unit configurations.
+ */
+import { isBinaryAvailable } from '../utils/process.js';
+import { logger } from '../utils/logger.js';
+// ── CLI ↔ Unit mapping ──────────────────────────────────────────
+const CLI_UNIT_MAP = {
+    claude: 'MELCHIOR',
+    codex: 'BALTHASAR',
+    gemini: 'CASPER',
+};
+// ── Detection ───────────────────────────────────────────────────
+/**
+ * Detect which AI CLIs are installed and available.
+ * Runs all checks in parallel using Promise.allSettled.
+ */
+export async function detectAvailableCLIs() {
+    const clis = ['claude', 'codex', 'gemini'];
+    const results = await Promise.allSettled(clis.map(async (cli) => {
+        const available = await isBinaryAvailable(cli);
+        return { cli, available };
+    }));
+    const detection = {
+        claude: { available: false },
+        codex: { available: false },
+        gemini: { available: false },
+    };
+    for (const result of results) {
+        if (result.status === 'fulfilled') {
+            detection[result.value.cli] = { available: result.value.available };
+        }
+        else {
+            logger.debug('CLI detection failed', { error: String(result.reason) });
+        }
+    }
+    return detection;
+}
+/**
+ * Get the list of available units from detection result.
+ */
+export function getAvailableUnits(detection) {
+    const units = [];
+    for (const [cli, status] of Object.entries(detection)) {
+        if (status.available && cli in CLI_UNIT_MAP) {
+            units.push(CLI_UNIT_MAP[cli]);
+        }
+    }
+    return units;
+}
+/**
+ * Generate configuration suggestions based on detected CLIs.
+ * Returns suggestions sorted by unit count (descending), with the
+ * largest available configuration marked as recommended.
+ */
+export function suggestConfigurations(detection) {
+    const available = getAvailableUnits(detection);
+    if (available.length === 0)
+        return [];
+    const suggestions = [];
+    const displayNames = {
+        MELCHIOR: 'MELCHIOR (Claude)',
+        BALTHASAR: 'BALTHASAR (Codex)',
+        CASPER: 'CASPER (Gemini)',
+    };
+    // Full configuration (all available)
+    if (available.length >= 2) {
+        suggestions.push({
+            enabledUnits: [...available],
+            unitCount: available.length,
+            description: `${available.length}体モード (${available.map(u => displayNames[u]).join(' + ')})`,
+            recommended: true,
+        });
+    }
+    // 2-unit combinations (only if 3 are available)
+    if (available.length === 3) {
+        for (let i = 0; i < available.length; i++) {
+            const pair = available.filter((_, idx) => idx !== i);
+            suggestions.push({
+                enabledUnits: pair,
+                unitCount: 2,
+                description: `2体モード (${pair.map(u => displayNames[u]).join(' + ')})`,
+                recommended: false,
+            });
+        }
+    }
+    // Single-unit options
+    for (const unit of available) {
+        suggestions.push({
+            enabledUnits: [unit],
+            unitCount: 1,
+            description: `1体モード (${displayNames[unit]} のみ)`,
+            recommended: available.length === 1,
+        });
+    }
+    return suggestions;
+}

package/dist/src/config/user-config.d.ts

@@ -0,0 +1,81 @@
+/**
+ * User configuration management for .magi/config.json
+ *
+ * Handles loading, saving, validating, and merging user-level
+ * settings with the immutable DEFAULT_CONFIG.
+ */
+import { z } from 'zod/v4';
+import type { MagiConfig } from '../types/config.js';
+export declare const UserConfigSchema: z.ZodObject<{
+    enabledUnits: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        MELCHIOR: "MELCHIOR";
+        BALTHASAR: "BALTHASAR";
+        CASPER: "CASPER";
+    }>>>;
+    adapters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        maxRetries: z.ZodOptional<z.ZodNumber>;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    defaultPipeline: z.ZodOptional<z.ZodObject<{
+        maxRounds: z.ZodOptional<z.ZodNumber>;
+        earlyConsensusExit: z.ZodOptional<z.ZodBoolean>;
+        consensus: z.ZodOptional<z.ZodObject<{
+            deadlockStrategy: z.ZodOptional<z.ZodEnum<{
+                escalate: "escalate";
+                "melchior-tiebreak": "melchior-tiebreak";
+                "highest-confidence": "highest-confidence";
+                "human-in-the-loop": "human-in-the-loop";
+            }>>;
+            quorum: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        phaseTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    logLevel: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        debug: "debug";
+        info: "info";
+        warn: "warn";
+    }>>;
+    outputFormat: z.ZodOptional<z.ZodEnum<{
+        json: "json";
+        console: "console";
+        markdown: "markdown";
+    }>>;
+    tui: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        soundEnabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    cacheEnabled: z.ZodOptional<z.ZodBoolean>;
+    language: z.ZodOptional<z.ZodEnum<{
+        ja: "ja";
+        en: "en";
+    }>>;
+    fileAccess: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        allowedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deniedPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export type UserConfig = z.infer<typeof UserConfigSchema>;
+export declare function getUserConfigPath(workspaceDir?: string): string;
+/**
+ * Load user config from .magi/config.json.
+ * Returns undefined if file does not exist.
+ * Throws on invalid JSON or schema validation failure.
+ */
+export declare function loadUserConfig(workspaceDir?: string): Promise<UserConfig | undefined>;
+/**
+ * Load user config with graceful fallback.
+ * Logs a warning on error and returns undefined instead of throwing.
+ */
+export declare function loadUserConfigSafe(workspaceDir?: string): Promise<UserConfig | undefined>;
+/**
+ * Save user config to .magi/config.json using safePersist (0o600).
+ */
+export declare function saveUserConfig(config: UserConfig, workspaceDir?: string): Promise<void>;
+/**
+ * Merge user config with DEFAULT_CONFIG, producing a full MagiConfig.
+ * The `tui` and `language` fields are stripped (consumed by the CLI layer, not Magi core).
+ */
+export declare function mergeWithDefaults(userConfig: UserConfig): Partial<MagiConfig>;