magi-ai 0.1.0

package/dist/src/repl/boot-animation.js

@@ -0,0 +1,143 @@
+/**
+ * NERV-style boot animation for MAGI REPL.
+ *
+ * Displays a typewriter-style boot sequence (0.8-1.2s total).
+ * Skips on: non-TTY, CI, MAGI_NO_ANIMATION=1, or any keypress.
+ * Does NOT use alt screen — output stays in normal scrollback.
+ */
+import chalk from 'chalk';
+import { EVA_PALETTE } from '../tui/colors.js';
+import { shouldSkipAnimation } from './accessibility.js';
+import { centerVisible, frameLines, getResponsiveBoxWidth, truncateVisible, wrapDisplayText } from './display-utils.js';
+const { frame, scanline, textPrimary } = EVA_PALETTE;
+const GREEN = chalk.rgb(scanline.r, scanline.g, scanline.b);
+const ORANGE = chalk.rgb(frame.r, frame.g, frame.b);
+const TEXT = chalk.rgb(textPrimary.r, textPrimary.g, textPrimary.b);
+const BOOT_LINES = [
+    { text: '  [NERV] REPL link ................. ESTABLISHED', color: 'green', delay: 60 },
+    { text: '  [MAGI] MELCHIOR-1 ............... ONLINE', color: 'green', delay: 40 },
+    { text: '  [MAGI] BALTHASAR-2 .............. ONLINE', color: 'green', delay: 40 },
+    { text: '  [MAGI] CASPER-3 ................. ONLINE', color: 'green', delay: 40 },
+    { text: '  [SYNC] Context window ........... 50,000 chars', color: 'green', delay: 40 },
+    { text: '  [I/O ] Slash commands ........... 15 loaded', color: 'green', delay: 40 },
+    { text: '  [A.T.] Interactive shell ........ ACTIVE', color: 'green', delay: 40 },
+];
+function colorize(text, color) {
+    switch (color) {
+        case 'green': return GREEN(text);
+        case 'orange': return ORANGE.bold(text);
+        case 'text': return TEXT(text);
+    }
+}
+function defaultDelay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function buildReadyBox() {
+    const width = getResponsiveBoxWidth(44, 24);
+    const innerWidth = Math.max(1, width - 4);
+    const title = width >= 32 ? 'M A G I  S Y S T E M' : 'MAGI SYSTEM';
+    return [
+        '',
+        ...frameLines([centerVisible(title, innerWidth), centerVisible('REPL INTERFACE READY', innerWidth)], { width, borderColor: (text) => ORANGE.bold(text) }),
+        '',
+    ];
+}
+function shouldSkip(opts) {
+    if (opts.skipCondition)
+        return true;
+    return shouldSkipAnimation();
+}
+export async function runReplBoot(options) {
+    const { write } = options;
+    const delay = options.delayFn ?? defaultDelay;
+    const readyBox = buildReadyBox();
+    const readyInnerWidth = Math.max(1, getResponsiveBoxWidth(44, 24) - 4);
+    const helpLines = wrapDisplayText('Type a question to deliberate. /help for commands.', readyInnerWidth);
+    if (shouldSkip(options)) {
+        // Print static banner instead
+        write('\n');
+        for (const line of readyBox) {
+            write(line + '\n');
+        }
+        for (const line of helpLines) {
+            write(GREEN(`  ${line}\n`));
+        }
+        write('\n');
+        return;
+    }
+    // Detect keypress to abort animation
+    let aborted = false;
+    let rawModeWasSet = false;
+    const keypressHandler = () => { aborted = true; };
+    // Safety: restore raw mode on unexpected signals.
+    // Only cleans up raw mode — does NOT re-raise signal because
+    // setupGracefulShutdown() already has global handlers for SIGTERM/SIGHUP
+    // and re-raising would cause the global handler to run twice.
+    const cleanupRawMode = () => {
+        if (rawModeWasSet) {
+            try {
+                process.stdin.setRawMode(false);
+            }
+            catch { /* best-effort */ }
+            try {
+                process.stdin.pause();
+            }
+            catch { /* best-effort */ }
+        }
+    };
+    process.once('SIGTERM', cleanupRawMode);
+    process.once('SIGHUP', cleanupRawMode);
+    try {
+        if (process.stdin.isTTY && !process.stdin.isRaw) {
+            try {
+                process.stdin.setRawMode(true);
+                rawModeWasSet = true;
+            }
+            catch {
+                // Can't set raw mode — continue without keypress detection
+            }
+        }
+        if (rawModeWasSet) {
+            process.stdin.once('data', keypressHandler);
+            process.stdin.resume();
+        }
+        write('\n');
+        // Boot lines
+        for (const line of BOOT_LINES) {
+            if (aborted)
+                break;
+            const cols = process.stdout.columns ?? 80;
+            const margin = cols >= 32 ? 4 : 2;
+            const truncated = truncateVisible(line.text, Math.max(8, cols - margin));
+            write(colorize(truncated, line.color) + '\n');
+            await delay(line.delay);
+        }
+        // Ready box with flash
+        if (!aborted) {
+            await delay(120);
+            write('\n');
+            for (const line of readyBox) {
+                write(line + '\n');
+            }
+        }
+        for (const line of helpLines) {
+            write(GREEN(`  ${line}\n`));
+        }
+        write('\n');
+    }
+    finally {
+        // Cleanup: restore raw mode and remove listener
+        process.removeListener('SIGTERM', cleanupRawMode);
+        process.removeListener('SIGHUP', cleanupRawMode);
+        if (rawModeWasSet) {
+            process.stdin.removeListener('data', keypressHandler);
+            try {
+                process.stdin.setRawMode(false);
+            }
+            catch {
+                // Best-effort restore
+            }
+            process.stdin.pause();
+        }
+    }
+}

package/dist/src/repl/completer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Tab completion for MAGI REPL.
+ *
+ * - `/` prefix: slash command name completion
+ * - `/review <path>`: sync file path completion (cwd-restricted, no symlinks)
+ * - `/decide`, `/berserk`: no completion (freeform)
+ * - Other commands: no completion (none)
+ */
+export type ArgKind = 'none' | 'file' | 'freeform';
+export interface CompletableCommand {
+    name: string;
+    aliases?: string[];
+    argKind: ArgKind;
+}
+/** Exported for testing — clear the directory cache. */
+export declare function clearCompleterCache(): void;
+export declare function createCompleter(commands: CompletableCommand[], opts?: {
+    ghostEngine?: {
+        consumeAccepted(): boolean;
+    };
+}): (line: string) => [string[], string];

package/dist/src/repl/completer.js

@@ -0,0 +1,168 @@
+/**
+ * Tab completion for MAGI REPL.
+ *
+ * - `/` prefix: slash command name completion
+ * - `/review <path>`: sync file path completion (cwd-restricted, no symlinks)
+ * - `/decide`, `/berserk`: no completion (freeform)
+ * - Other commands: no completion (none)
+ */
+import { readdirSync, lstatSync, realpathSync } from 'node:fs';
+import { resolve, join, dirname, basename, normalize } from 'node:path';
+const CACHE_TTL_MS = 2_000;
+const CACHE_MAX_SIZE = 5;
+const MAX_CANDIDATES = 50;
+const dirCache = new Map();
+function getCachedDir(dirPath) {
+    const cached = dirCache.get(dirPath);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS)
+        return cached;
+    dirCache.delete(dirPath);
+    return undefined;
+}
+function readDirCached(dirPath) {
+    const cached = getCachedDir(dirPath);
+    if (cached)
+        return cached;
+    try {
+        const names = readdirSync(dirPath);
+        const entries = [];
+        const isDir = [];
+        for (const name of names) {
+            if (name.startsWith('.'))
+                continue; // skip hidden
+            const full = join(dirPath, name);
+            try {
+                const st = lstatSync(full);
+                if (st.isSymbolicLink())
+                    continue; // skip symlinks
+                entries.push(name);
+                isDir.push(st.isDirectory());
+            }
+            catch {
+                // permission error etc — skip
+            }
+        }
+        const entry = { entries, isDir, timestamp: Date.now() };
+        // LRU eviction
+        if (dirCache.size >= CACHE_MAX_SIZE) {
+            const oldest = dirCache.keys().next().value;
+            if (oldest !== undefined)
+                dirCache.delete(oldest);
+        }
+        dirCache.set(dirPath, entry);
+        return entry;
+    }
+    catch {
+        return { entries: [], isDir: [], timestamp: Date.now() };
+    }
+}
+/** Exported for testing — clear the directory cache. */
+export function clearCompleterCache() {
+    dirCache.clear();
+}
+// ── Main completer factory ───────────────────────────────────
+export function createCompleter(commands, opts) {
+    // Build lookup maps
+    const allNames = [];
+    const nameToArgKind = new Map();
+    for (const cmd of commands) {
+        const n = `/${cmd.name}`;
+        allNames.push(n);
+        nameToArgKind.set(cmd.name, cmd.argKind);
+        if (cmd.aliases) {
+            for (const alias of cmd.aliases) {
+                const a = `/${alias}`;
+                if (!allNames.includes(a))
+                    allNames.push(a);
+                nameToArgKind.set(alias, cmd.argKind);
+            }
+        }
+    }
+    return function completeLine(line) {
+        // Suppress completion if ghost text was just accepted via Tab
+        if (opts?.ghostEngine?.consumeAccepted()) {
+            return [[], line];
+        }
+        // Slash command name completion
+        if (line.startsWith('/') && !line.includes(' ')) {
+            const matches = allNames
+                .filter(n => n.startsWith(line))
+                .slice(0, MAX_CANDIDATES);
+            // Append space if single match
+            if (matches.length === 1) {
+                const match = matches[0];
+                const cmd = match.slice(1);
+                const kind = nameToArgKind.get(cmd);
+                matches[0] = kind === 'none' ? match : `${match} `;
+            }
+            return [matches, line];
+        }
+        // After a command with arguments
+        const spaceIdx = line.indexOf(' ');
+        if (spaceIdx > 0 && line.startsWith('/')) {
+            const cmdName = line.slice(1, spaceIdx).toLowerCase();
+            const kind = nameToArgKind.get(cmdName);
+            if (kind === 'file') {
+                const partial = line.slice(spaceIdx + 1);
+                return completeFilePath(partial, line);
+            }
+            // freeform or none — no completion
+        }
+        return [[], line];
+    };
+}
+// ── File path completion ─────────────────────────────────────
+function completeFilePath(partial, fullLine) {
+    // Security: reject null bytes
+    if (partial.includes('\0')) {
+        return [[], fullLine];
+    }
+    // Segment-based path traversal check (allows filenames containing '..' like 'foo..bar.ts')
+    const normalized = normalize(partial);
+    const segments = normalized.split('/');
+    if (segments.some(s => s === '..')) {
+        return [[], fullLine];
+    }
+    const cwd = process.cwd();
+    // Handle trailing slash: list directory contents
+    const dirPart = partial.endsWith('/') ? partial.slice(0, -1) || '.'
+        : partial.includes('/') ? dirname(partial) : '.';
+    const prefix = partial.endsWith('/') ? '' : basename(partial);
+    // Resolve and verify within cwd (follow symlinks to detect escapes)
+    const resolvedDir = resolve(cwd, dirPart);
+    if (!resolvedDir.startsWith(cwd + '/') && resolvedDir !== cwd) {
+        return [[], fullLine]; // outside cwd (logical path)
+    }
+    try {
+        const realDir = realpathSync(resolvedDir);
+        const realCwd = realpathSync(cwd);
+        if (!realDir.startsWith(realCwd + '/') && realDir !== realCwd) {
+            return [[], fullLine]; // outside cwd (physical path via symlink)
+        }
+    }
+    catch {
+        return [[], fullLine]; // can't resolve — reject
+    }
+    const cached = readDirCached(resolvedDir);
+    const completions = [];
+    for (let i = 0; i < cached.entries.length && completions.length < MAX_CANDIDATES; i++) {
+        const name = cached.entries[i];
+        if (!name.startsWith(prefix))
+            continue;
+        const relPath = dirPart === '.' ? name : `${dirPart}/${name}`;
+        if (cached.isDir[i]) {
+            completions.push(`${relPath}/`);
+        }
+        else {
+            completions.push(relPath);
+        }
+    }
+    // Reconstruct full-line completions (command + path)
+    const cmdPrefix = fullLine.slice(0, fullLine.indexOf(' ') + 1);
+    const fullCompletions = completions.map(c => `${cmdPrefix}${c}`);
+    // Single match: append space for files
+    if (fullCompletions.length === 1 && !fullCompletions[0].endsWith('/')) {
+        fullCompletions[0] += ' ';
+    }
+    return [fullCompletions, fullLine];
+}

package/dist/src/repl/context.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ReplContext — accumulates deliberation summaries for follow-up context injection.
+ *
+ * Only summaries are retained (not full results) to avoid token exhaustion
+ * when injected into MagiTask.context (max 200,000 chars).
+ */
+import type { MagiDeliberation } from '../types/core.js';
+import type { ConsensusDecision } from '../types/consensus.js';
+export interface ContextEntry {
+    id: string;
+    title: string;
+    decision: ConsensusDecision;
+    summary: string;
+    timestamp: Date;
+}
+export declare class ReplContext {
+    private entries;
+    private readonly maxEntries;
+    constructor(maxEntries?: number);
+    add(deliberation: MagiDeliberation): void;
+    buildContextString(): string | undefined;
+    getHistory(): readonly ContextEntry[];
+    clear(): void;
+}

package/dist/src/repl/context.js

@@ -0,0 +1,42 @@
+/**
+ * ReplContext — accumulates deliberation summaries for follow-up context injection.
+ *
+ * Only summaries are retained (not full results) to avoid token exhaustion
+ * when injected into MagiTask.context (max 200,000 chars).
+ */
+const MAX_CONTEXT_CHARS = 200_000;
+export class ReplContext {
+    entries = [];
+    maxEntries;
+    constructor(maxEntries = 5) {
+        this.maxEntries = maxEntries;
+    }
+    add(deliberation) {
+        this.entries.push({
+            id: deliberation.id,
+            title: deliberation.task.title,
+            decision: deliberation.consensus.decision,
+            summary: deliberation.consensus.summary ?? '',
+            timestamp: new Date(),
+        });
+        if (this.entries.length > this.maxEntries) {
+            this.entries = this.entries.slice(-this.maxEntries);
+        }
+    }
+    buildContextString() {
+        if (this.entries.length === 0)
+            return undefined;
+        const lines = this.entries.map((e, i) => `[Previous deliberation ${i + 1}] "${e.title}" → ${e.decision}: ${e.summary}`);
+        const result = `Previous deliberation context:\n${lines.join('\n')}`;
+        if (result.length > MAX_CONTEXT_CHARS) {
+            return result.slice(0, MAX_CONTEXT_CHARS) + '\n[...truncated]';
+        }
+        return result;
+    }
+    getHistory() {
+        return [...this.entries];
+    }
+    clear() {
+        this.entries = [];
+    }
+}

package/dist/src/repl/display-utils.d.ts

@@ -0,0 +1,13 @@
+export declare function stripAnsi(text: string): string;
+export declare function visibleWidth(text: string): number;
+export declare function padVisibleRight(text: string, width: number): string;
+export declare function centerVisible(text: string, width: number): string;
+export declare function wrapDisplayText(text: string, maxWidth: number): string[];
+export declare function truncateVisible(text: string, width: number): string;
+export declare function getTerminalColumns(fallback?: number): number;
+export declare function getResponsiveBoxWidth(maxWidth: number, minWidth: number): number;
+export declare function frameLines(lines: string[], options: {
+    width: number;
+    borderColor: (text: string) => string;
+    contentColor?: (text: string) => string;
+}): string[];

package/dist/src/repl/display-utils.js

@@ -0,0 +1,65 @@
+import { charDisplayWidth, stringDisplayWidth, truncateToDisplayWidth } from '../tui/screen-buffer.js';
+const ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+export function stripAnsi(text) {
+    return text.replace(ANSI_RE, '');
+}
+export function visibleWidth(text) {
+    return stringDisplayWidth(stripAnsi(text));
+}
+export function padVisibleRight(text, width) {
+    return text + ' '.repeat(Math.max(0, width - visibleWidth(text)));
+}
+export function centerVisible(text, width) {
+    const contentWidth = visibleWidth(text);
+    const leftPad = Math.max(0, Math.floor((width - contentWidth) / 2));
+    const rightPad = Math.max(0, width - contentWidth - leftPad);
+    return ' '.repeat(leftPad) + text + ' '.repeat(rightPad);
+}
+export function wrapDisplayText(text, maxWidth) {
+    if (maxWidth <= 0)
+        return [];
+    const normalized = text.replace(/\r\n/g, '\n');
+    const lines = [];
+    for (const paragraph of normalized.split('\n')) {
+        if (!paragraph) {
+            lines.push('');
+            continue;
+        }
+        let current = '';
+        let currentWidth = 0;
+        for (const ch of paragraph) {
+            const width = charDisplayWidth(ch.codePointAt(0) ?? 0);
+            if (current && currentWidth + width > maxWidth) {
+                lines.push(current.trimEnd());
+                current = ch === ' ' ? '' : ch;
+                currentWidth = ch === ' ' ? 0 : width;
+                continue;
+            }
+            current += ch;
+            currentWidth += width;
+        }
+        lines.push(current.trimEnd());
+    }
+    return lines.length > 0 ? lines : [''];
+}
+export function truncateVisible(text, width) {
+    return truncateToDisplayWidth(text, Math.max(0, width));
+}
+export function getTerminalColumns(fallback = 80) {
+    return Math.max(16, process.stdout.columns ?? fallback);
+}
+export function getResponsiveBoxWidth(maxWidth, minWidth) {
+    const cols = getTerminalColumns();
+    const margin = cols >= 32 ? 4 : 2;
+    const width = Math.min(maxWidth, cols - margin);
+    return Math.max(Math.min(cols, minWidth), width);
+}
+export function frameLines(lines, options) {
+    const innerWidth = Math.max(1, options.width - 4);
+    const colorize = options.contentColor ?? ((text) => text);
+    return [
+        options.borderColor(`  ╔${'═'.repeat(innerWidth)}╗`),
+        ...lines.map(line => options.borderColor('  ║') + colorize(padVisibleRight(line, innerWidth)) + options.borderColor('║')),
+        options.borderColor(`  ╚${'═'.repeat(innerWidth)}╝`),
+    ];
+}

package/dist/src/repl/event-listener.d.ts

@@ -0,0 +1,18 @@
+/**
+ * EventBus subscription for REPL progress display.
+ *
+ * Active only during deliberation when TUI is NOT running.
+ * Outputs inline progress using EVA_PALETTE colors.
+ * Uses setImmediate batching to avoid prompt corruption.
+ * Does NOT reuse StreamingProgressReporter (no unbind support).
+ */
+import type { MagiEventBus } from '../engine/events.js';
+export interface ReplEventListenerOptions {
+    eventBus: MagiEventBus;
+    write: (s: string) => void;
+    onSyncRateUpdate?: (rates: Record<string, number>) => void;
+}
+export declare function createReplEventListener(options: ReplEventListenerOptions): {
+    subscribe: () => void;
+    unsubscribe: () => void;
+};

package/dist/src/repl/event-listener.js

@@ -0,0 +1,112 @@
+/**
+ * EventBus subscription for REPL progress display.
+ *
+ * Active only during deliberation when TUI is NOT running.
+ * Outputs inline progress using EVA_PALETTE colors.
+ * Uses setImmediate batching to avoid prompt corruption.
+ * Does NOT reuse StreamingProgressReporter (no unbind support).
+ */
+import chalk from 'chalk';
+import { unitChalk, EVA_PALETTE } from '../tui/colors.js';
+import { sanitizeForTerminal } from './terminal-sanitize.js';
+import { voteSymbol } from './accessibility.js';
+const { approve, reject, abstain, frame, warning } = EVA_PALETTE;
+const APPROVE_C = chalk.rgb(approve.r, approve.g, approve.b);
+const REJECT_C = chalk.rgb(reject.r, reject.g, reject.b);
+const ABSTAIN_C = chalk.rgb(abstain.r, abstain.g, abstain.b);
+const FRAME_C = chalk.rgb(frame.r, frame.g, frame.b);
+const WARN_C = chalk.rgb(warning.r, warning.g, warning.b);
+const DIM_C = chalk.rgb(abstain.r, abstain.g, abstain.b);
+export function createReplEventListener(options) {
+    const { eventBus, write, onSyncRateUpdate } = options;
+    // Buffer for setImmediate batching
+    let pendingLines = [];
+    let flushScheduled = false;
+    function queueLine(line) {
+        pendingLines.push(line);
+        if (!flushScheduled) {
+            flushScheduled = true;
+            setImmediate(() => {
+                for (const l of pendingLines) {
+                    write(l + '\n');
+                }
+                pendingLines = [];
+                flushScheduled = false;
+            });
+        }
+    }
+    function voteLabel(vote) {
+        const sym = voteSymbol(vote);
+        switch (vote) {
+            case 'APPROVE': return APPROVE_C(`${sym} APPROVE`);
+            case 'REJECT': return REJECT_C(`${sym} REJECT`);
+            case 'ABSTAIN': return ABSTAIN_C(`${sym} ABSTAIN`);
+            default: return vote;
+        }
+    }
+    // ── Listener functions (stored for cleanup) ────────────────
+    const onUnitStart = (e) => {
+        queueLine(`  ${unitChalk(e.unit)(e.unit)} thinking...`);
+    };
+    const onUnitComplete = (e) => {
+        const conf = e.confidence != null ? ` (${Math.round(e.confidence * 100)}%)` : '';
+        const dur = e.durationMs != null ? DIM_C(` ${(e.durationMs / 1000).toFixed(1)}s`) : '';
+        const vote = e.vote ? voteLabel(e.vote) : 'done';
+        queueLine(`  ${unitChalk(e.unit)(e.unit)}: ${vote}${conf}${dur}`);
+    };
+    const onUnitError = (e) => {
+        queueLine(`  ${unitChalk(e.unit)(e.unit)}: ${WARN_C('ERROR')} ${DIM_C(sanitizeForTerminal(e.error ?? ''))}`);
+    };
+    const onPhaseStart = (e) => {
+        const round = e.roundNumber != null ? ` (round ${e.roundNumber})` : '';
+        queueLine(`  ${FRAME_C(`Phase: ${e.phase}`)}${DIM_C(round)}`);
+    };
+    const onPhaseComplete = (e) => {
+        const dur = e.durationMs != null ? ` (${(e.durationMs / 1000).toFixed(1)}s)` : '';
+        queueLine(`  ${DIM_C(`Phase complete${dur}`)}`);
+    };
+    const onPhaseSkipped = (e) => {
+        queueLine(`  ${APPROVE_C(`Early exit: ${e.reason}`)}`);
+    };
+    const onSyncRate = (e) => {
+        onSyncRateUpdate?.(e.rates);
+    };
+    const onUmbilicalStatus = (e) => {
+        const color = e.newStatus === 'connected' ? APPROVE_C
+            : e.newStatus === 'degraded' ? ABSTAIN_C
+                : WARN_C;
+        queueLine(`  ${unitChalk(e.unit)(e.unit)} cable: ${color(e.newStatus)}`);
+    };
+    const onBerserkActivated = () => {
+        queueLine(`  ${WARN_C.bold('WARNING: BERSERK MODE ACTIVATED')}`);
+    };
+    // ── Subscribe / Unsubscribe ────────────────────────────────
+    function subscribe() {
+        eventBus.on('unit:start', onUnitStart);
+        eventBus.on('unit:complete', onUnitComplete);
+        eventBus.on('unit:error', onUnitError);
+        eventBus.on('phase:start', onPhaseStart);
+        eventBus.on('phase:complete', onPhaseComplete);
+        eventBus.on('phase:skipped', onPhaseSkipped);
+        eventBus.on('syncrate:updated', onSyncRate);
+        eventBus.on('umbilical:status_changed', onUmbilicalStatus);
+        eventBus.on('berserk:activated', onBerserkActivated);
+    }
+    function unsubscribe() {
+        eventBus.off('unit:start', onUnitStart);
+        eventBus.off('unit:complete', onUnitComplete);
+        eventBus.off('unit:error', onUnitError);
+        eventBus.off('phase:start', onPhaseStart);
+        eventBus.off('phase:complete', onPhaseComplete);
+        eventBus.off('phase:skipped', onPhaseSkipped);
+        eventBus.off('syncrate:updated', onSyncRate);
+        eventBus.off('umbilical:status_changed', onUmbilicalStatus);
+        eventBus.off('berserk:activated', onBerserkActivated);
+        // Flush any pending lines
+        for (const l of pendingLines) {
+            write(l + '\n');
+        }
+        pendingLines = [];
+    }
+    return { subscribe, unsubscribe };
+}

package/dist/src/repl/export-formatter.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Deliberation export formatters (JSON / Markdown).
+ *
+ * Pure functions — no side-effects, no chalk, no filesystem.
+ */
+import type { MagiDeliberation } from '../types/core.js';
+export declare function formatDeliberationAsJson(d: MagiDeliberation): string;
+export declare function formatDeliberationAsMarkdown(d: MagiDeliberation): string;