magi-ai 0.1.0

package/dist/src/repl/multiline-input.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Multiline input support for MAGI REPL.
+ *
+ * Two modes:
+ * 1. `/paste` command: opens a collector that reads lines until "." on its own line.
+ * 2. Trailing backslash (`\`): lightweight continuation for 2-3 line inputs.
+ */
+/** Maximum number of lines in a multiline buffer (DoS prevention). */
+export declare const MAX_MULTILINE_LINES = 10000;
+/** Maximum number of continuation lines (trailing backslash). */
+export declare const MAX_CONTINUATION_LINES = 100;
+export type MultilineResult = {
+    status: 'collecting';
+} | {
+    status: 'complete';
+    text: string;
+} | {
+    status: 'aborted';
+};
+export interface MultilineCollector {
+    /** Feed a line to the collector. Returns the current state. */
+    feed(line: string): MultilineResult;
+    /** Get the current buffer (read-only). */
+    getBuffer(): readonly string[];
+    /** Reset the collector for reuse. */
+    reset(): void;
+}
+/**
+ * Create a multiline collector for `/paste` mode.
+ *
+ * - Single "." line → complete (join all previous lines)
+ * - "/abort" → aborted
+ * - Anything else → collecting
+ */
+export declare function createMultilineCollector(): MultilineCollector;
+/**
+ * Whether a line ends with a single backslash (continuation marker).
+ * Double backslash `\\` at end is an escaped backslash, not continuation.
+ */
+export declare function isContinuationLine(line: string): boolean;
+/**
+ * Join continuation lines: strip trailing backslash from each line
+ * except the last, then join with newline.
+ */
+export declare function joinContinuationLines(lines: string[]): string;

package/dist/src/repl/multiline-input.js

@@ -0,0 +1,78 @@
+/**
+ * Multiline input support for MAGI REPL.
+ *
+ * Two modes:
+ * 1. `/paste` command: opens a collector that reads lines until "." on its own line.
+ * 2. Trailing backslash (`\`): lightweight continuation for 2-3 line inputs.
+ */
+/** Maximum number of lines in a multiline buffer (DoS prevention). */
+export const MAX_MULTILINE_LINES = 10_000;
+/** Maximum number of continuation lines (trailing backslash). */
+export const MAX_CONTINUATION_LINES = 100;
+/**
+ * Create a multiline collector for `/paste` mode.
+ *
+ * - Single "." line → complete (join all previous lines)
+ * - "/abort" → aborted
+ * - Anything else → collecting
+ */
+export function createMultilineCollector() {
+    let buffer = [];
+    return {
+        feed(line) {
+            const trimmed = line.trim();
+            if (trimmed === '/abort') {
+                buffer = [];
+                return { status: 'aborted' };
+            }
+            if (trimmed === '.') {
+                const text = buffer.join('\n');
+                buffer = [];
+                return { status: 'complete', text };
+            }
+            if (buffer.length >= MAX_MULTILINE_LINES) {
+                buffer = [];
+                return { status: 'aborted' };
+            }
+            buffer.push(line);
+            return { status: 'collecting' };
+        },
+        getBuffer() {
+            return buffer;
+        },
+        reset() {
+            buffer = [];
+        },
+    };
+}
+/**
+ * Whether a line ends with a single backslash (continuation marker).
+ * Double backslash `\\` at end is an escaped backslash, not continuation.
+ */
+export function isContinuationLine(line) {
+    const trimmed = line.trimEnd();
+    if (!trimmed.endsWith('\\'))
+        return false;
+    // Count trailing backslashes
+    let count = 0;
+    for (let i = trimmed.length - 1; i >= 0 && trimmed[i] === '\\'; i--) {
+        count++;
+    }
+    // Odd number of trailing backslashes → continuation
+    return count % 2 === 1;
+}
+/**
+ * Join continuation lines: strip trailing backslash from each line
+ * except the last, then join with newline.
+ */
+export function joinContinuationLines(lines) {
+    return lines
+        .map((line, i) => {
+        if (i < lines.length - 1) {
+            // Remove the trailing continuation backslash
+            return line.trimEnd().replace(/\\$/, '');
+        }
+        return line;
+    })
+        .join('\n');
+}

package/dist/src/repl/prompt-builder.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Dynamic prompt builder for MAGI REPL.
+ *
+ * Renders session state into the prompt string:
+ *   MAGI[01|NORM|3/3|CTX:2]>
+ *   MAGI[02|BER|3/3|CTX:3]>   (BERSERK — deep red)
+ *   MAGI[03|NORM|2/3|CTX:1|!]> (error indicator)
+ */
+export interface SessionState {
+    deliberationCount: number;
+    berserkActive: boolean;
+    onlineUnits: number;
+    totalUnits: number;
+    contextEntryCount: number;
+    hasError: boolean;
+    backgroundJobCount: number;
+}
+export declare const DEFAULT_SESSION_STATE: SessionState;
+export declare function buildPrompt(state: SessionState): string;

package/dist/src/repl/prompt-builder.js

@@ -0,0 +1,36 @@
+/**
+ * Dynamic prompt builder for MAGI REPL.
+ *
+ * Renders session state into the prompt string:
+ *   MAGI[01|NORM|3/3|CTX:2]>
+ *   MAGI[02|BER|3/3|CTX:3]>   (BERSERK — deep red)
+ *   MAGI[03|NORM|2/3|CTX:1|!]> (error indicator)
+ */
+import chalk from 'chalk';
+import { EVA_PALETTE } from '../tui/colors.js';
+const { frame, abstain, melchior } = EVA_PALETTE;
+const FRAME_CHALK = chalk.rgb(frame.r, frame.g, frame.b);
+const DIM_CHALK = chalk.rgb(abstain.r, abstain.g, abstain.b);
+const BERSERK_CHALK = chalk.rgb(melchior.r, melchior.g, melchior.b);
+export const DEFAULT_SESSION_STATE = {
+    deliberationCount: 0,
+    berserkActive: false,
+    onlineUnits: 3,
+    totalUnits: 3,
+    contextEntryCount: 0,
+    hasError: false,
+    backgroundJobCount: 0,
+};
+export function buildPrompt(state) {
+    const count = String(state.deliberationCount).padStart(2, '0');
+    const mode = state.berserkActive ? 'BER' : 'NORM';
+    const units = `${state.onlineUnits}/${state.totalUnits}`;
+    const ctx = `CTX:${state.contextEntryCount}`;
+    const jobFlag = state.backgroundJobCount > 0 ? `|J:${state.backgroundJobCount}` : '';
+    const errorFlag = state.hasError ? '|!' : '';
+    const info = `${count}|${mode}|${units}|${ctx}${jobFlag}${errorFlag}`;
+    if (state.berserkActive) {
+        return BERSERK_CHALK.bold('MAGI') + BERSERK_CHALK(`[${info}]`) + BERSERK_CHALK('> ');
+    }
+    return FRAME_CHALK.bold('MAGI') + DIM_CHALK(`[${info}]`) + DIM_CHALK('> ');
+}

package/dist/src/repl/repl-state.d.ts

@@ -0,0 +1,5 @@
+/**
+ * REPL state machine — enforces valid state transitions.
+ */
+export type ReplState = 'INIT' | 'READY' | 'READING_INPUT' | 'MULTILINE_COLLECTING' | 'DISPATCHING' | 'CONFIRMING' | 'DELIBERATING' | 'SHOWING_RESULT' | 'DISPOSING';
+export declare function assertTransition(from: ReplState, to: ReplState): void;

package/dist/src/repl/repl-state.js

@@ -0,0 +1,19 @@
+/**
+ * REPL state machine — enforces valid state transitions.
+ */
+const VALID_TRANSITIONS = {
+    INIT: ['READY', 'DISPOSING'],
+    READY: ['READING_INPUT', 'DELIBERATING', 'DISPOSING'],
+    READING_INPUT: ['DISPATCHING', 'MULTILINE_COLLECTING', 'READY', 'DISPOSING'],
+    MULTILINE_COLLECTING: ['DISPATCHING', 'READING_INPUT', 'DISPOSING'],
+    DISPATCHING: ['DELIBERATING', 'CONFIRMING', 'MULTILINE_COLLECTING', 'READING_INPUT', 'READY', 'DISPOSING'],
+    CONFIRMING: ['DISPATCHING', 'READING_INPUT', 'READY', 'DISPOSING'],
+    DELIBERATING: ['SHOWING_RESULT', 'READY', 'DISPOSING'],
+    SHOWING_RESULT: ['READY', 'DISPOSING'],
+    DISPOSING: [],
+};
+export function assertTransition(from, to) {
+    if (!VALID_TRANSITIONS[from].includes(to)) {
+        throw new Error(`Invalid REPL state transition: ${from} → ${to}`);
+    }
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Rich result display for MAGI REPL.
+ *
+ * Renders a box-drawn CONSENSUS summary with per-unit vote bars,
+ * key points, dissent, and EVA_PALETTE colors.
+ */
+import type { MagiDeliberation } from '../types/core.js';
+export declare function formatResultDisplay(result: MagiDeliberation): string;

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

@@ -0,0 +1,195 @@
+/**
+ * Rich result display for MAGI REPL.
+ *
+ * Renders a box-drawn CONSENSUS summary with per-unit vote bars,
+ * key points, dissent, and EVA_PALETTE colors.
+ */
+import chalk from 'chalk';
+import { EVA_PALETTE, unitChalk } from '../tui/colors.js';
+import { stringDisplayWidth } from '../tui/screen-buffer.js';
+import { isUnanimous, getMajorityVote } from '../types/consensus.js';
+import { sanitizeForTerminal } from './terminal-sanitize.js';
+import { voteSymbol } from './accessibility.js';
+import { getResponsiveBoxWidth, padVisibleRight, truncateVisible, visibleWidth, wrapDisplayText, } from './display-utils.js';
+const { frame, approve, reject, abstain } = EVA_PALETTE;
+const FRAME = chalk.rgb(frame.r, frame.g, frame.b);
+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 DIM = chalk.rgb(abstain.r, abstain.g, abstain.b);
+const BAR_WIDTH = 10;
+const FILLED = '█';
+const EMPTY = '░';
+// ── Helpers ──────────────────────────────────────────────────
+function confidenceBar(confidence, vote) {
+    const filled = Math.round(confidence * BAR_WIDTH);
+    const empty = BAR_WIDTH - filled;
+    const bar = FILLED.repeat(filled) + EMPTY.repeat(empty);
+    const pct = `${Math.round(confidence * 100)}%`;
+    const color = vote === 'APPROVE' ? APPROVE_C
+        : vote === 'REJECT' ? REJECT_C
+            : ABSTAIN_C;
+    return color(bar) + DIM(` ${pct}`);
+}
+function confidenceBarWidth(confidence) {
+    const pct = `${Math.round(confidence * 100)}%`;
+    return BAR_WIDTH + 1 + stringDisplayWidth(pct);
+}
+function verdictLabel(decision) {
+    if (decision.startsWith('UNANIMOUS_APPROVE') || decision === 'MAJORITY_APPROVE') {
+        return '可 決';
+    }
+    if (decision.startsWith('UNANIMOUS_REJECT') || decision === 'MAJORITY_REJECT') {
+        return '否 決';
+    }
+    return '保 留';
+}
+function padRight(text, width) {
+    const displayWidth = stringDisplayWidth(text);
+    const padding = Math.max(0, width - displayWidth);
+    return text + ' '.repeat(padding);
+}
+function frameLine(content, innerWidth) {
+    return FRAME('  ║  ') + padVisibleRight(content, innerWidth) + FRAME('  ║');
+}
+function renderWrappedBlock(prefix, text, innerWidth, color = DIM) {
+    const prefixWidth = stringDisplayWidth(prefix);
+    const wrapped = wrapDisplayText(text, Math.max(1, innerWidth - prefixWidth));
+    return wrapped.map((line, index) => frameLine(color(`${index === 0 ? prefix : ' '.repeat(prefixWidth)}${line}`), innerWidth));
+}
+function renderOpinionLine(unit, vote, conf, innerWidth) {
+    const sym = voteSymbol(vote);
+    if (innerWidth >= 38) {
+        const unitLabel = unitChalk(unit)(padRight(unit, 12));
+        const voteLabel = vote === 'APPROVE' ? APPROVE_C(padRight(`${sym} APPROVE`, 11))
+            : vote === 'REJECT' ? REJECT_C(padRight(`${sym} REJECT`, 11))
+                : ABSTAIN_C(padRight(`${sym} ABSTAIN`, 11));
+        const bar = confidenceBar(conf, vote);
+        const spare = Math.max(1, innerWidth - 12 - 11 - confidenceBarWidth(conf));
+        return [frameLine(unitLabel + voteLabel + bar + ' '.repeat(spare), innerWidth)];
+    }
+    const compactVote = vote === 'APPROVE' ? APPROVE_C(`${sym} APPROVE`)
+        : vote === 'REJECT' ? REJECT_C(`${sym} REJECT`)
+            : ABSTAIN_C(`${sym} ABSTAIN`);
+    return [
+        frameLine(unitChalk(unit)(truncateVisible(unit, Math.max(1, innerWidth - visibleWidth(compactVote) - 1))) + ' ' + compactVote, innerWidth),
+        frameLine(confidenceBar(conf, vote), innerWidth),
+    ];
+}
+function renderHeader(decision, confidence, innerWidth) {
+    const confPct = `CONF ${Math.round(confidence * 100)}%`;
+    const verdict = verdictLabel(decision);
+    if (innerWidth >= 32) {
+        const headerRight = isUnanimous(decision) ? `${verdict}  ${confPct}` : confPct;
+        const decisionLabel = truncateVisible(`MAGI DECISION: ${decision}`, Math.max(1, innerWidth - stringDisplayWidth(headerRight) - 1));
+        const headerPadding = Math.max(1, innerWidth - stringDisplayWidth(decisionLabel) - stringDisplayWidth(headerRight));
+        return [frameLine(chalk.bold(decisionLabel) + ' '.repeat(headerPadding) + DIM(headerRight), innerWidth)];
+    }
+    return [
+        frameLine(chalk.bold(truncateVisible(`MAGI ${decision}`, innerWidth)), innerWidth),
+        frameLine(DIM(isUnanimous(decision) ? `${verdict}  ${confPct}` : confPct), innerWidth),
+    ];
+}
+// ── Main export ──────────────────────────────────────────────
+export function formatResultDisplay(result) {
+    const totalWidth = getResponsiveBoxWidth(80, 24);
+    const innerWidth = totalWidth - 8; // "  ║  " + content + "  ║"
+    const { consensus, rounds, totalDurationMs } = result;
+    const { decision, confidence, summary } = consensus;
+    const lines = [];
+    // ── Top border
+    lines.push(FRAME(`  ╔${'═'.repeat(totalWidth - 4)}╗`));
+    // ── Decision header
+    lines.push(...renderHeader(decision, confidence, innerWidth));
+    // ── Separator
+    lines.push(FRAME(`  ╠${'═'.repeat(totalWidth - 4)}╣`));
+    // ── Duration + rounds
+    const durSec = (totalDurationMs / 1000).toFixed(1);
+    const durLine = `Duration: ${durSec}s    Rounds: ${rounds.length}`;
+    for (const line of wrapDisplayText(durLine, innerWidth)) {
+        lines.push(frameLine(DIM(line), innerWidth));
+    }
+    // ── Thin separator
+    lines.push(FRAME(`  ╠${'─'.repeat(totalWidth - 4)}╣`));
+    // ── Per-unit votes (from last round)
+    const lastRound = rounds[rounds.length - 1];
+    if (lastRound?.opinions) {
+        for (const op of lastRound.opinions) {
+            lines.push(...renderOpinionLine(op.unit, op.vote, op.confidence ?? 0, innerWidth));
+        }
+    }
+    // ── Thin separator
+    lines.push(FRAME(`  ╠${'─'.repeat(totalWidth - 4)}╣`));
+    // ── Summary
+    if (summary) {
+        lines.push(...renderWrappedBlock('Summary: ', sanitizeForTerminal(summary), innerWidth));
+    }
+    // ── Key points (deduplicated, max 3)
+    const keyPoints = extractKeyPoints(result);
+    if (keyPoints.length > 0) {
+        lines.push(frameLine(DIM(padRight('Key Points:', innerWidth)), innerWidth));
+        for (const kp of keyPoints) {
+            lines.push(...renderWrappedBlock('⬢ ', sanitizeForTerminal(kp), innerWidth));
+        }
+    }
+    // ── Dissent
+    const dissent = extractDissent(result);
+    if (dissent) {
+        lines.push(FRAME(`  ╠${'─'.repeat(totalWidth - 4)}╣`));
+        lines.push(frameLine(DIM(padRight(`Dissent (${dissent.unit}):`, innerWidth)), innerWidth));
+        lines.push(...renderWrappedBlock('', sanitizeForTerminal(dissent.text), innerWidth));
+    }
+    // ── DEADLOCK resolution
+    if (decision === 'DEADLOCK' && consensus.method) {
+        lines.push(FRAME(`  ╠${'─'.repeat(totalWidth - 4)}╣`));
+        lines.push(...renderWrappedBlock('Resolution: ', String(consensus.method), innerWidth));
+    }
+    // ── Bottom border with verdict
+    if (isUnanimous(decision)) {
+        const vl = verdictLabel(decision);
+        const bottomInner = `── ${vl} ──`;
+        const bottomPad = Math.max(0, totalWidth - 4 - stringDisplayWidth(bottomInner));
+        const leftPad = Math.floor(bottomPad / 2);
+        const rightPad = bottomPad - leftPad;
+        lines.push(FRAME(`  ╚${'═'.repeat(leftPad)}`) + FRAME.bold(bottomInner) + FRAME(`${'═'.repeat(rightPad)}╝`));
+    }
+    else {
+        lines.push(FRAME(`  ╚${'═'.repeat(totalWidth - 4)}╝`));
+    }
+    return '\n' + lines.join('\n') + '\n';
+}
+// ── Key point extraction ─────────────────────────────────────
+function extractKeyPoints(result) {
+    const lastRound = result.rounds[result.rounds.length - 1];
+    if (!lastRound?.opinions)
+        return [];
+    const seen = new Set();
+    const points = [];
+    for (const op of lastRound.opinions) {
+        if (!op.keyPoints)
+            continue;
+        for (const kp of op.keyPoints) {
+            const normalized = kp.trim().toLowerCase();
+            if (normalized && !seen.has(normalized)) {
+                seen.add(normalized);
+                points.push(kp.trim());
+                if (points.length >= 3)
+                    return points;
+            }
+        }
+    }
+    return points;
+}
+// ── Dissent extraction ───────────────────────────────────────
+function extractDissent(result) {
+    const majorityVote = getMajorityVote(result.consensus.decision);
+    const lastRound = result.rounds[result.rounds.length - 1];
+    if (!lastRound?.opinions)
+        return undefined;
+    for (const op of lastRound.opinions) {
+        if (op.vote !== majorityVote && op.reasoning) {
+            return { unit: op.unit, text: op.reasoning.split('\n')[0] ?? '' };
+        }
+    }
+    return undefined;
+}

package/dist/src/repl/session-stats.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Session statistics tracking for MAGI REPL.
+ *
+ * Tracks inputs, commands, deliberations, and decisions across a session.
+ * Displays a box-drawn summary on /quit if any deliberation was run.
+ */
+import type { ConsensusDecision } from '../types/consensus.js';
+export interface SessionStats {
+    sessionStartedAt: number;
+    totalInputCount: number;
+    slashCommandCount: number;
+    deliberationCount: number;
+    berserkCount: number;
+    approveCount: number;
+    rejectCount: number;
+    deadlockCount: number;
+    totalDurationMs: number;
+    longestDurationMs: number;
+    estimatedTokens: number;
+    contextEntriesUsed: number;
+}
+export declare function createSessionStats(): SessionStats;
+export declare function recordInput(stats: SessionStats): void;
+export declare function recordSlashCommand(stats: SessionStats): void;
+export declare function recordDeliberation(stats: SessionStats, decision: ConsensusDecision, durationMs: number, tokens: number, berserk: boolean): void;
+export declare function formatSessionSummary(stats: SessionStats): string;

package/dist/src/repl/session-stats.js

@@ -0,0 +1,119 @@
+/**
+ * Session statistics tracking for MAGI REPL.
+ *
+ * Tracks inputs, commands, deliberations, and decisions across a session.
+ * Displays a box-drawn summary on /quit if any deliberation was run.
+ */
+import chalk from 'chalk';
+import { EVA_PALETTE } from '../tui/colors.js';
+import { isApproval, isRejection } from '../types/consensus.js';
+import { centerVisible, getResponsiveBoxWidth, padVisibleRight, visibleWidth, wrapDisplayText } from './display-utils.js';
+const { frame, abstain, textPrimary } = 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(textPrimary.r, textPrimary.g, textPrimary.b);
+export function createSessionStats() {
+    return {
+        sessionStartedAt: Date.now(),
+        totalInputCount: 0,
+        slashCommandCount: 0,
+        deliberationCount: 0,
+        berserkCount: 0,
+        approveCount: 0,
+        rejectCount: 0,
+        deadlockCount: 0,
+        totalDurationMs: 0,
+        longestDurationMs: 0,
+        estimatedTokens: 0,
+        contextEntriesUsed: 0,
+    };
+}
+export function recordInput(stats) {
+    stats.totalInputCount++;
+}
+export function recordSlashCommand(stats) {
+    stats.slashCommandCount++;
+}
+export function recordDeliberation(stats, decision, durationMs, tokens, berserk) {
+    stats.deliberationCount++;
+    stats.totalDurationMs += durationMs;
+    stats.longestDurationMs = Math.max(stats.longestDurationMs, durationMs);
+    stats.estimatedTokens += tokens;
+    if (berserk)
+        stats.berserkCount++;
+    if (isApproval(decision)) {
+        stats.approveCount++;
+    }
+    else if (isRejection(decision)) {
+        stats.rejectCount++;
+    }
+    else {
+        stats.deadlockCount++;
+    }
+}
+function formatDuration(ms) {
+    const totalSec = Math.floor(ms / 1000);
+    const min = Math.floor(totalSec / 60);
+    const sec = totalSec % 60;
+    return `${String(min).padStart(2, '0')}:${String(sec).padStart(2, '0')}`;
+}
+function formatSeconds(ms) {
+    return `${(ms / 1000).toFixed(1)}s`;
+}
+function formatMetricLines(label, value, width) {
+    const labelWidth = visibleWidth(label);
+    const valueWidth = visibleWidth(value);
+    if (width >= 24 && labelWidth + valueWidth + 1 <= width) {
+        return [padVisibleRight(label, width - valueWidth) + value];
+    }
+    return wrapDisplayText(`${label}: ${value}`, width);
+}
+export function formatSessionSummary(stats) {
+    if (stats.deliberationCount === 0)
+        return '';
+    const elapsed = Date.now() - stats.sessionStartedAt;
+    const avgDur = stats.deliberationCount > 0
+        ? formatSeconds(stats.totalDurationMs / stats.deliberationCount)
+        : '0.0s';
+    const berserkSuffix = stats.berserkCount > 0 ? ` (${stats.berserkCount} BERSERK)` : '';
+    const inputSuffix = stats.slashCommandCount > 0 ? ` (${stats.slashCommandCount} commands)` : '';
+    // Decision breakdown: ✓2A / ✗1R / ⚠1D
+    const parts = [];
+    if (stats.approveCount > 0)
+        parts.push(`✓${stats.approveCount}A`);
+    if (stats.rejectCount > 0)
+        parts.push(`✗${stats.rejectCount}R`);
+    if (stats.deadlockCount > 0)
+        parts.push(`⚠${stats.deadlockCount}D`);
+    const decisionLine = parts.join(' / ') || '―';
+    const width = getResponsiveBoxWidth(43, 24);
+    const innerWidth = Math.max(1, width - 4);
+    const bodyLines = [
+        ...formatMetricLines('Duration', formatDuration(elapsed), innerWidth),
+        ...formatMetricLines('Inputs', `${stats.totalInputCount}${inputSuffix}`, innerWidth),
+        '',
+        ...formatMetricLines('Deliberations', `${stats.deliberationCount}${berserkSuffix}`, innerWidth),
+        ...formatMetricLines('Decisions', decisionLine, innerWidth),
+        ...formatMetricLines('Avg Duration', avgDur, innerWidth),
+        ...formatMetricLines('Longest', formatSeconds(stats.longestDurationMs), innerWidth),
+        '',
+        ...formatMetricLines('Est. Tokens', `~${stats.estimatedTokens.toLocaleString('en-US')}`, innerWidth),
+        ...formatMetricLines('Context', `${stats.contextEntriesUsed} entries`, innerWidth),
+    ];
+    const lines = [
+        '',
+        FRAME_C(`  ╔${'═'.repeat(innerWidth)}╗`),
+        FRAME_C('  ║') + TEXT_C(centerVisible('SESSION SUMMARY', innerWidth)) + FRAME_C('║'),
+        FRAME_C(`  ╠${'═'.repeat(innerWidth)}╣`),
+        ...bodyLines.map((line, index) => {
+            if (line === '') {
+                return FRAME_C(`  ╠${'─'.repeat(innerWidth)}╣`);
+            }
+            const tone = index <= 1 ? DIM_C : DIM_C;
+            return FRAME_C('  ║') + tone(padVisibleRight(line, innerWidth)) + FRAME_C('║');
+        }),
+        FRAME_C(`  ╚${'═'.repeat(innerWidth)}╝`),
+        '',
+    ];
+    return lines.join('\n');
+}

package/dist/src/repl/slash-commands.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 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 type { Magi } from '../index.js';
+import type { ReplContext } from './context.js';
+import type { TaskType, TaskArtifact } from '../types/core.js';
+export interface DeliberationRequest {
+    task: {
+        type: TaskType;
+        title: string;
+        description: string;
+        artifacts?: TaskArtifact[];
+        context?: string;
+    };
+    berserk?: boolean;
+}
+export interface ConfirmationRequest {
+    description: string;
+    execute: () => Promise<SlashCommandResult>;
+    requiredInput?: string;
+    timeoutMs?: number;
+}
+export interface BackgroundJobRequest {
+    name: string;
+    run: (signal: AbortSignal) => Promise<void>;
+    onEvent?: (message: string) => void;
+}
+export interface WatchCommandRequest {
+    command: 'start' | 'stop' | 'status';
+    pollIntervalMs?: number;
+}
+export interface SlashCommandResult {
+    deliberation?: DeliberationRequest;
+    output?: string;
+    action?: 'quit' | 'clear' | 'reset' | 'toggle-sound' | 'paste' | 'export' | 'jobs';
+    confirm?: ConfirmationRequest;
+    background?: BackgroundJobRequest;
+    watch?: WatchCommandRequest;
+    /** Callback that needs exclusive stdin access (e.g. raw mode menus).
+     *  REPL will pause readline, run the callback, then resume. */
+    interactive?: () => Promise<void>;
+}
+export type ArgKind = 'none' | 'file' | 'freeform';
+export interface SlashCommand {
+    description: string;
+    usage: string;
+    argKind: ArgKind;
+    aliases?: string[];
+    execute(args: string, magi: Magi, context: ReplContext): Promise<SlashCommandResult>;
+}
+export declare function parseInput(input: string): {
+    isSlash: boolean;
+    command: string;
+    args: string;
+};
+export declare function suggestCommand(input: string, commands: Iterable<string>): string | undefined;
+export declare function createSlashCommands(): Map<string, SlashCommand>;