aiki-cli 0.2.0

package/dist/tui/app.js

@@ -0,0 +1,444 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+// The Ink app (T8, §11 screens). Thin/dumb rendering over the pure logic in timeline.ts + format.ts;
+// all the engine work goes through the standard primitives (setupProviders → resolveRoles → RunCtx →
+// executeRun) with an `events` object wired to React state. Ctrl+C aborts via an AbortController.
+import { useEffect, useRef, useState } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import TextInput from 'ink-text-input';
+import { readFile } from 'node:fs/promises';
+import { basename, dirname, join, resolve } from 'node:path';
+import { DISPLAY_NAME } from '../providers/types.js';
+import { RunCtx, DEFAULT_BUDGET, makeRunId, resolveRoles, setupProviders, } from '../orchestration/context.js';
+import { executeRun } from '../orchestration/engine.js';
+import { RunWriter } from '../storage/runs.js';
+import { recordSession, updateSessionStatus, readSessions, findSession } from '../storage/sessions.js';
+import { buildReplayCache } from '../storage/replay.js';
+import { loadLayeredConfig, effectiveConfig } from '../config/config.js';
+import { formatModels } from '../cli/models.js';
+import { IDEA_STAGES, runIdeaRefinement } from '../workflows/idea-refinement.js';
+import { CR_STAGES, runCodeReview } from '../workflows/code-review.js';
+import { computeDiff, computeWorkingTreeDiff, detectRepoStatus } from '../orchestration/git.js';
+import { loadCouncilView } from '../council/view.js';
+import { openCouncilHtml } from '../council/open.js';
+import { GLYPH, displayNames, elapsedLabel, initTimeline, markEnd, markStart, progressBar, runningPhrase, totalElapsed } from './timeline.js';
+import { formatCompletion, formatError } from './format.js';
+import { COMMANDS, PRODUCT_LINE, filterCommands, parseCommand, routeInput, scopeRedirect, suggestCommand } from './smart-entry.js';
+async function loadCompletion(dir) {
+    try {
+        const [judge, map] = await Promise.all([
+            readFile(join(dir, '09-judge-report.json'), 'utf8').then((s) => JSON.parse(s)),
+            readFile(join(dir, '07-disagreement-map.json'), 'utf8').then((s) => JSON.parse(s)),
+        ]);
+        return formatCompletion(dir, judge, map);
+    }
+    catch {
+        return null;
+    }
+}
+export function App(props) {
+    const { roleOverrides, budget: budgetOverride, runsRoot, providerModels, version } = props;
+    const { exit } = useApp();
+    const [phase, setPhase] = useState('detecting');
+    const [workflow, setWorkflow] = useState('idea-refinement');
+    const [handles, setHandles] = useState([]);
+    const [repo, setRepo] = useState(null);
+    const [idea, setIdea] = useState('');
+    const [routerMessage, setRouterMessage] = useState('');
+    const [rows, setRows] = useState([]);
+    const [now, setNow] = useState(Date.now());
+    const [budget, setBudget] = useState(0);
+    const [dir, setDir] = useState('');
+    const [grill, setGrill] = useState(null);
+    const [grillTyping, setGrillTyping] = useState(false);
+    const [grillText, setGrillText] = useState('');
+    const [clarify, setClarify] = useState(null);
+    const [clarifyTyping, setClarifyTyping] = useState(false); // "type your own" sub-mode
+    const [clarifyText, setClarifyText] = useState('');
+    const [panel, setPanel] = useState(null); // V9: /sessions /models /config /help output
+    const [sel, setSel] = useState(0); // V10: command-palette highlight index
+    // V10: TextInput only puts the cursor at the end on MOUNT (ink-text-input keeps the old offset on an
+    // external value change). Bumping this key remounts it after a Tab-complete so typing continues at the end.
+    const [inputEpoch, setInputEpoch] = useState(0);
+    const [pendingIdea, setPendingIdea] = useState(null); // V10: confirm gate before a paid run
+    const [completion, setCompletion] = useState(null);
+    const [councilView, setCouncilView] = useState(null);
+    const [errorView, setErrorView] = useState(null);
+    const [aborted, setAborted] = useState(false);
+    const abortRef = useRef(null);
+    const ctxRef = useRef(null);
+    // Detect providers + repo context once, up front.
+    useEffect(() => {
+        let alive = true;
+        void Promise.all([setupProviders(providerModels), detectRepoStatus(process.cwd())]).then(([hs, repoStatus]) => {
+            if (!alive)
+                return;
+            setRepo(repoStatus);
+            if (hs.length < 2) {
+                setErrorView(formatError('QUORUM'));
+                setPhase('finished');
+                return;
+            }
+            setHandles(hs);
+            setPhase('input');
+        });
+        return () => {
+            alive = false;
+        };
+    }, []);
+    // Live clock for elapsed labels while running.
+    useEffect(() => {
+        if (phase !== 'running' && phase !== 'grill' && phase !== 'clarify')
+            return;
+        const t = setInterval(() => setNow(Date.now()), 500);
+        return () => clearInterval(t);
+    }, [phase]);
+    // V10 command palette: matches for what's being typed (only on the input screen, not mid-confirm).
+    const paletteMatches = phase === 'input' && pendingIdea === null ? filterCommands(idea) : [];
+    const selIdx = Math.min(sel, Math.max(paletteMatches.length - 1, 0));
+    const fallbackGrillAnswers = (brief) => brief.questions.map((q) => ({ question_id: q.id, answer: 'Use best judgment from the supplied prompt.', source: 'default' }));
+    const submitGrillAnswer = (answer, source) => {
+        if (!grill)
+            return;
+        const q = grill.brief.questions[grill.index];
+        if (!q)
+            return;
+        const next = [...grill.answers, { question_id: q.id, answer: answer.trim(), source }];
+        setGrillTyping(false);
+        setGrillText('');
+        if (next.length >= grill.brief.questions.length) {
+            const resolveGrill = grill.resolve;
+            setGrill(null);
+            setPhase('running');
+            resolveGrill(next);
+            return;
+        }
+        setGrill({ ...grill, index: grill.index + 1, answers: next });
+    };
+    useInput((input, key) => {
+        if (key.ctrl && input === 'c') {
+            abortRef.current?.abort();
+            if (grill) {
+                grill.resolve(fallbackGrillAnswers(grill.brief)); // unblock S0 so the run reaches its abort guard
+                setGrill(null);
+                setGrillTyping(false);
+                setGrillText('');
+            }
+            if (clarify)
+                clarify.resolve({ kind: 'pick', index: 0 }); // unblock S2 so the run reaches its abort guard
+            if (phase === 'detecting' || phase === 'input' || phase === 'finished')
+                exit();
+            return;
+        }
+        // V10 confirm gate: the TextInput is unmounted while pending, so Enter/Esc arrive here only.
+        if (phase === 'input' && pendingIdea !== null) {
+            if (key.return) {
+                const text = pendingIdea;
+                setPendingIdea(null);
+                startIdea(text);
+            }
+            else if (key.escape) {
+                setPendingIdea(null);
+                setRouterMessage('cancelled — nothing was run.');
+            }
+            return;
+        }
+        // V10: Esc on the home screen clears everything typed/shown — universal "get me out" key.
+        if (phase === 'input' && key.escape) {
+            setIdea('');
+            setPanel(null);
+            setRouterMessage('');
+            setSel(0);
+            return;
+        }
+        // V10 palette keys: ↑/↓ move the highlight, Tab completes into the box. (Enter submits via TextInput.)
+        if (phase === 'input' && paletteMatches.length > 0) {
+            if (key.upArrow)
+                return void setSel((selIdx - 1 + paletteMatches.length) % paletteMatches.length);
+            if (key.downArrow)
+                return void setSel((selIdx + 1) % paletteMatches.length);
+            if (key.tab) {
+                setIdea(`/${paletteMatches[selIdx].name} `);
+                setSel(0);
+                setInputEpoch((e) => e + 1); // remount the input → cursor lands after "/command " ready to type
+                return;
+            }
+        }
+        // S0 grill key handling — the "type your own" sub-mode lets TextInput capture keys instead.
+        if (phase === 'grill' && grill && !grillTyping) {
+            const q = grill.brief.questions[grill.index];
+            if (!q)
+                return;
+            const n = Number.parseInt(input, 10);
+            const N = q.suggested_answers.length;
+            if (!Number.isNaN(n)) {
+                if (n >= 1 && n <= N)
+                    submitGrillAnswer(q.suggested_answers[n - 1], 'suggested');
+                else if (n === N + 1)
+                    setGrillTyping(true);
+                else if (n === N + 2)
+                    submitGrillAnswer('Use best judgment from the supplied prompt.', 'default');
+            }
+            return;
+        }
+        // Clarify key handling — the "type your own" sub-mode lets TextInput capture keys instead.
+        if (phase === 'clarify' && clarify && !clarifyTyping) {
+            const n = Number.parseInt(input, 10);
+            const N = clarify.options.length;
+            if (!Number.isNaN(n)) {
+                if (n >= 1 && n <= N)
+                    clarify.resolve({ kind: 'pick', index: n - 1 });
+                else if (n === N + 1)
+                    clarify.resolve({ kind: 'both' });
+                else if (n === N + 2)
+                    setClarifyTyping(true);
+            }
+            return;
+        }
+        if (phase === 'finished')
+            exit();
+    });
+    const startRun = (wf, text, cwd, runner, stages, replay) => {
+        const trimmed = text.trim();
+        if (!trimmed)
+            return;
+        setPanel(null);
+        const available = handles.map((h) => h.id);
+        const rs = resolveRoles(wf, available, roleOverrides);
+        const runId = makeRunId(wf);
+        const writer = new RunWriter(runId, runsRoot);
+        const controller = new AbortController();
+        abortRef.current = controller;
+        const events = {
+            onStageStart: (id) => setRows((r) => markStart(r, id, Date.now())),
+            onStageEnd: (id, st) => setRows((r) => markEnd(r, id, st, Date.now())),
+            grill: (brief) => new Promise((res) => {
+                setGrill({
+                    brief,
+                    index: 0,
+                    answers: [],
+                    resolve: (answers) => {
+                        setGrill(null);
+                        setGrillTyping(false);
+                        setGrillText('');
+                        setPhase('running');
+                        res(answers);
+                    },
+                });
+                setPhase('grill');
+            }),
+            clarify: (question, options) => new Promise((res) => {
+                setClarify({
+                    question,
+                    options,
+                    resolve: (c) => {
+                        setClarify(null);
+                        setClarifyTyping(false);
+                        setClarifyText('');
+                        setPhase('running');
+                        res(c);
+                    },
+                });
+                setPhase('clarify');
+            }),
+        };
+        const ctx = new RunCtx({ runId, workflow: wf, handles, roles: rs, writer, cwd: cwd ?? writer.dir, budget: budgetOverride, signal: controller.signal, events, replay });
+        ctxRef.current = ctx;
+        setWorkflow(wf);
+        setRows(initTimeline(stages, rs, available));
+        setBudget(ctx.budget.limit);
+        setDir(writer.dir);
+        setCompletion(null);
+        setCouncilView(null);
+        setErrorView(null);
+        setRouterMessage('');
+        setPhase('running');
+        void recordSession({ id: runId, workflow: wf, cwd: cwd ?? writer.dir, runsRoot: resolve(dirname(dirname(writer.dir))), startedAt: new Date().toISOString(), status: 'running' });
+        void executeRun(ctx, trimmed, runner).then(async (o) => {
+            const wasAborted = ctx.aborted;
+            setAborted(wasAborted);
+            void updateSessionStatus(o.runId, wasAborted ? 'aborted' : o.ok ? 'ok' : 'failed');
+            if (o.ok) {
+                setCouncilView(await loadCouncilView(o.runId, o.dir));
+                setCompletion(wf === 'idea-refinement' ? await loadCompletion(o.dir) : null);
+                void openCouncilHtml(o.runId, o.dir); // auto-open the readable report in the browser
+            }
+            else if (!wasAborted)
+                setErrorView(formatError(o.error?.code ?? 'CRASH', o.dir || undefined));
+            setPhase('finished');
+        });
+    };
+    const startIdea = (text) => startRun('idea-refinement', text, null, runIdeaRefinement, IDEA_STAGES);
+    const startCodeReview = async (action) => {
+        if (!repo || !repo.defaultBranch) {
+            setRouterMessage('code review needs a git repo with a detectable default branch');
+            return;
+        }
+        try {
+            const diff = action === 'review-working-tree'
+                ? await computeWorkingTreeDiff(repo.defaultBranch, repo.root)
+                : await computeDiff(repo.defaultBranch, 'HEAD', repo.root);
+            if (!diff.trim()) {
+                setRouterMessage('no changes to review');
+                return;
+            }
+            startRun('code-review', diff, repo.root, runCodeReview, CR_STAGES);
+        }
+        catch (e) {
+            setRouterMessage(e instanceof Error ? e.message : String(e));
+        }
+    };
+    const sessionsPanel = async (lead) => {
+        const all = (await readSessions()).slice(0, 12);
+        if (!all.length)
+            return 'no sessions yet.';
+        const mark = { running: '●', ok: '✔', failed: '✖', aborted: '⊘' };
+        const rows = all.map((s) => `  ${mark[s.status]} ${s.id}  ${s.workflow}${s.status === 'failed' || s.status === 'aborted' ? '   /resume ' + s.id : ''}`);
+        return [lead ?? 'Recent sessions:', ...rows].join('\n');
+    };
+    const configPanel = async () => {
+        try {
+            return 'Effective config:\n' + JSON.stringify(effectiveConfig(await loadLayeredConfig()), null, 2);
+        }
+        catch (e) {
+            return e instanceof Error ? e.message : String(e);
+        }
+    };
+    const helpPanel = () => [
+        'aiki — a local council of your installed AI CLIs (Claude, Codex, Gemini).',
+        'It stress-tests ideas and reviews code by making the models cross-examine',
+        'each other; a judge settles disputes. Artifacts land in .aiki/runs/.',
+        '',
+        'Commands:',
+        ...COMMANDS.map((c) => `  ${c.usage.padEnd(20)} ${c.help}`),
+        '',
+        'Examples:',
+        '  /idea a fridge-to-recipe app for students',
+        '  /review --branch          review this branch vs the default branch',
+        '  /resume 20260707-1645     continue a stopped run (finished calls replay free)',
+        '',
+        'Plain text works too — it routes to the idea flow, with a confirm step',
+        'so nothing spends model calls until you say so.',
+    ].join('\n');
+    const resumeInTui = async (idArg) => {
+        if (!idArg)
+            return void setPanel(await sessionsPanel('Resume which? type /resume <id>'));
+        const sess = await findSession(idArg);
+        if (!sess)
+            return void setRouterMessage(`no session matches "${idArg}" — see /sessions`);
+        if ('ambiguous' in sess)
+            return void setRouterMessage(`"${idArg}" is ambiguous: ${sess.ambiguous.join(', ')}`);
+        const wf = sess.workflow;
+        const oldDir = join(sess.runsRoot, 'runs', sess.id);
+        let input;
+        try {
+            input = await readFile(join(oldDir, 'inputs', wf === 'code-review' ? 'diff.patch' : 'idea.md'), 'utf8');
+        }
+        catch {
+            return void setRouterMessage(`can't recover the input for ${sess.id} — nothing to resume`);
+        }
+        const replay = await buildReplayCache(oldDir);
+        if (replay.size === 0)
+            return void setRouterMessage(`no completed calls for ${sess.id} — start fresh`);
+        const [runner, stages] = wf === 'code-review' ? [runCodeReview, CR_STAGES] : [runIdeaRefinement, IDEA_STAGES];
+        startRun(wf, input, wf === 'code-review' ? sess.cwd : null, runner, stages, replay);
+    };
+    const runCommand = async (p) => {
+        setRouterMessage('');
+        setPanel(null);
+        switch (p.cmd) {
+            case 'idea':
+                if (p.rest)
+                    startIdea(p.rest);
+                else
+                    setRouterMessage('type your idea after the command, e.g.  /idea a fridge-to-recipe app');
+                return;
+            case 'review':
+                void startCodeReview(p.args.includes('--branch') || p.args.includes('-b') ? 'review-branch' : 'review-working-tree');
+                return;
+            case 'resume':
+                void resumeInTui(p.args[0]);
+                return;
+            case 'sessions':
+                setPanel('loading…');
+                setPanel(await sessionsPanel());
+                return;
+            case 'models':
+                setPanel('loading models…');
+                setPanel(await formatModels());
+                return;
+            case 'config':
+                setPanel(await configPanel());
+                return;
+            case 'help':
+            case '':
+                setPanel(helpPanel());
+                return;
+            default: {
+                const near = suggestCommand(p.cmd);
+                setRouterMessage(`unknown command /${p.cmd}${near ? ` — did you mean /${near}?` : ' — type /help'}`);
+            }
+        }
+    };
+    const submitInput = (text) => {
+        const parsed = parseCommand(text);
+        if (parsed) {
+            // V10: Enter with the palette open runs the HIGHLIGHTED command when the typed word isn't
+            // itself a known command (so "/mo" ⏎ runs /models; "/review" ⏎ still runs review exactly).
+            const known = COMMANDS.some((c) => c.name === parsed.cmd);
+            setIdea('');
+            setSel(0);
+            if (!known && !parsed.rest && paletteMatches.length > 0) {
+                void runCommand({ cmd: paletteMatches[selIdx].name, rest: '', args: [] });
+                return;
+            }
+            void runCommand(parsed);
+            return;
+        }
+        setPanel(null);
+        // V10.2: "explore my codebase / brainstorm features" → a scope-explaining redirect, BEFORE we would
+        // otherwise mis-route it into a full (paid) idea-refinement run on the request sentence.
+        const redirect = scopeRedirect(text);
+        if (redirect) {
+            setIdea('');
+            setRouterMessage(redirect);
+            return;
+        }
+        const route = routeInput(text);
+        if (route === 'question') {
+            setIdea('');
+            setRouterMessage(`${PRODUCT_LINE} Type /idea if you meant an idea.`);
+            return;
+        }
+        if (route === 'code-review') {
+            setIdea('');
+            setRouterMessage(repo ? 'That looks code-related. Type /review (working tree) or /review --branch.' : 'That looks code-related. Open aiki inside a git repo, then /review.');
+            return;
+        }
+        // V10 confirm gate: plain text never starts a paid run directly — show what will happen first.
+        setIdea('');
+        setRouterMessage('');
+        setPendingIdea(text);
+    };
+    // ── render ────────────────────────────────────────────────────────────────
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, color: "cyan", children: "aiki" }), version ? _jsxs(Text, { dimColor: true, children: [" v", version] }) : null, _jsxs(Text, { dimColor: true, children: [" \u00B7 ", phase === 'input' ? 'local model council — ideas & code review' : workflow] })] }), phase === 'detecting' && (_jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) }), ' ', "detecting providers\u2026"] })), (phase === 'input' || phase === 'running' || phase === 'grill' || phase === 'clarify' || phase === 'finished') && handles.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [repo && (_jsxs(Text, { children: ["repo: ", repo.name, " \u2014 ", repo.changedFiles, " changed files vs ", repo.defaultBranch ?? 'unknown default branch'] })), _jsxs(Text, { children: [handles.map((h, i) => (_jsxs(Text, { children: [i > 0 ? _jsx(Text, { dimColor: true, children: " \u00B7 " }) : null, _jsx(Text, { color: "green", children: "\u2714" }), " ", DISPLAY_NAME[h.id], h.version ? _jsxs(Text, { dimColor: true, children: [" ", h.version] }) : null] }, h.id))), _jsx(Text, { dimColor: true, children: " \u2014 council ready" })] })] })), phase === 'input' && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: "/idea " }), _jsx(Text, { dimColor: true, children: '<text>' }), '   stress-test an idea'] }), _jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: "/review " }), _jsx(Text, { dimColor: true, children: "[--branch]" }), '  review your changes', repo ? '' : _jsx(Text, { dimColor: true, children: "  (needs a git repo)" })] }), _jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: "/resume " }), _jsx(Text, { dimColor: true, children: '<id>' }), '   continue a stopped run  ·  ', _jsx(Text, { color: "cyan", children: "/sessions" }), '  ', _jsx(Text, { color: "cyan", children: "/models" }), '  ', _jsx(Text, { color: "cyan", children: "/config" }), '  ', _jsx(Text, { color: "cyan", children: "/help" })] })] }), pendingIdea !== null ? (
+                    /* V10 confirm gate — nothing spends model calls until Enter. */
+                    _jsxs(Box, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [_jsx(Text, { children: "Run the idea council on:" }), _jsxs(Text, { color: "cyan", children: ["  \u201C", pendingIdea.length > 100 ? `${pendingIdea.slice(0, 97)}…` : pendingIdea, "\u201D"] }), _jsxs(Text, { dimColor: true, children: ["  12-stage pipeline \u00B7 up to ", budgetOverride ?? DEFAULT_BUDGET, " model calls \u00B7 Ctrl+C aborts mid-run"] }), _jsxs(Text, { children: [_jsx(Text, { color: "green", children: "enter" }), " run  \u00B7  ", _jsx(Text, { color: "yellow", children: "esc" }), " cancel"] })] })) : (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: "Type a command, or just describe your idea and press Enter:" }), _jsxs(Box, { borderStyle: "round", paddingX: 1, children: [_jsx(Text, { children: "\u25B8 " }), _jsx(TextInput, { value: idea, onChange: (v) => setIdea(v.replace(/\s*[\r\n]+\s*/g, ' ').replace(/\t/g, '')), onSubmit: submitInput }, inputEpoch)] })] })), paletteMatches.length > 0 && (
+                    /* V10 live command palette — filtered as you type; ↑↓ move, Tab completes, Enter runs. */
+                    _jsxs(Box, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [paletteMatches.map((m, i) => (_jsxs(Text, { children: [_jsxs(Text, { color: i === selIdx ? 'cyan' : undefined, bold: i === selIdx, children: [i === selIdx ? '▸ ' : '  ', "/", m.name] }), _jsx(Text, { dimColor: true, children: `  ${m.usage.replace(`/${m.name}`, '').trim().padEnd(10)}  ${m.help}` })] }, m.name))), _jsx(Text, { dimColor: true, children: "\u2191\u2193 select \u00B7 tab complete \u00B7 enter run" })] })), routerMessage ? _jsx(Text, { color: "yellow", children: routerMessage }) : null, panel ? (_jsx(Box, { flexDirection: "column", marginTop: 1, borderStyle: "round", paddingX: 1, children: panel.split('\n').map((l, i) => (_jsx(Text, { children: l }, i))) })) : (_jsx(Text, { dimColor: true, children: "new here? /help explains how aiki works \u00B7 long idea? `aiki run idea-refinement ./idea.md`" }))] })), (phase === 'running' || phase === 'grill' || phase === 'clarify' || phase === 'finished') && rows.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [rows.map((r) => {
+                        const color = r.status === 'done' ? 'green' : r.status === 'failed' ? 'red' : r.status === 'running' ? 'yellow' : 'gray';
+                        return (_jsxs(Text, { children: [r.status === 'running' ? (_jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) })) : (_jsx(Text, { color: color, children: GLYPH[r.status] })), ' ', r.id.padEnd(3), " ", r.label.padEnd(24), _jsx(Text, { dimColor: true, children: displayNames(r.providers) || '—' }), " ", '  ', elapsedLabel(r, now)] }, r.id));
+                    }), phase === 'running' &&
+                        (() => {
+                            const running = rows.find((r) => r.status === 'running');
+                            const p = progressBar(rows);
+                            const secs = running?.startedAt !== undefined ? Math.floor((now - running.startedAt) / 1000) : 0;
+                            return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: p.bar }), _jsxs(Text, { dimColor: true, children: [" ", p.done, "/", p.total] }), running ? _jsxs(Text, { color: "yellow", children: ["  ", runningPhrase(running.id, secs), "\u2026"] }) : null] }), _jsxs(Text, { dimColor: true, children: ["calls used ", ctxRef.current?.calls.length ?? 0, "/", budget, " \u00B7 Ctrl+C aborts (artifacts kept)"] })] }));
+                        })()] })), phase === 'grill' && grill &&
+                (() => {
+                    const q = grill.brief.questions[grill.index];
+                    if (!q)
+                        return null;
+                    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, borderStyle: "round", paddingX: 1, children: [_jsxs(Text, { bold: true, children: ["Intent preflight ", grill.index + 1, "/", grill.brief.questions.length] }), _jsx(Text, { children: q.question }), _jsx(Text, { dimColor: true, children: q.why_it_matters }), q.suggested_answers.map((o, i) => (_jsxs(Text, { children: ['  ', _jsx(Text, { color: "cyan", children: i + 1 }), ". ", o] }, i))), _jsxs(Text, { children: ['  ', _jsx(Text, { color: "cyan", children: q.suggested_answers.length + 1 }), ". other - type your own"] }), _jsxs(Text, { children: ['  ', _jsx(Text, { color: "cyan", children: q.suggested_answers.length + 2 }), ". skip - use best judgment"] }), grillTyping ? (_jsxs(Box, { borderStyle: "round", paddingX: 1, marginTop: 1, children: [_jsx(Text, { children: "\u25B8 " }), _jsx(TextInput, { value: grillText, onChange: (v) => setGrillText(v.replace(/\s*[\r\n]+\s*/g, ' ')), onSubmit: () => grillText.trim() && submitGrillAnswer(grillText, 'user') })] })) : (_jsxs(Text, { dimColor: true, children: ["press 1-", q.suggested_answers.length + 2, " to choose"] }))] }));
+                })(), phase === 'clarify' && clarify && (_jsxs(Box, { flexDirection: "column", marginTop: 1, borderStyle: "round", paddingX: 1, children: [_jsx(Text, { bold: true, children: clarify.question }), clarify.options.map((o, i) => (_jsxs(Text, { children: ['  ', _jsx(Text, { color: "cyan", children: i + 1 }), ". ", o] }, i))), _jsxs(Text, { children: ['  ', _jsx(Text, { color: "cyan", children: clarify.options.length + 1 }), ". ", clarify.options.length === 2 ? 'both readings — combine them' : 'all readings — combine them'] }), _jsxs(Text, { children: ['  ', _jsx(Text, { color: "cyan", children: clarify.options.length + 2 }), ". other \u2014 type your own"] }), clarifyTyping ? (_jsxs(Box, { borderStyle: "round", paddingX: 1, marginTop: 1, children: [_jsx(Text, { children: "\u25B8 " }), _jsx(TextInput, { value: clarifyText, onChange: (v) => setClarifyText(v.replace(/\s*[\r\n]+\s*/g, ' ')), onSubmit: () => clarifyText.trim() && clarify.resolve({ kind: 'text', text: clarifyText }) })] })) : (_jsxs(Text, { dimColor: true, children: ["press 1\u2013", clarify.options.length + 2, " to choose"] }))] })), phase === 'finished' && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [aborted && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "yellow", children: ["\u2298 Run aborted \u2014 partial artifacts at ", dir] }), _jsxs(Text, { dimColor: true, children: ["  finished calls replay free: aiki resume ", basename(dir)] })] })), !aborted && errorView && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "red", paddingX: 1, children: [_jsxs(Text, { color: "red", bold: true, children: ["\u2716 Run failed [", errorView.code, "]"] }), _jsx(Text, { children: errorView.fix }), errorView.partialDir ? _jsxs(Text, { dimColor: true, children: ["partial artifacts: ", errorView.partialDir] }) : null] })), !aborted && !errorView && councilView && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { color: "green", bold: true, children: "\u2714 Run complete" }), totalElapsed(rows) ? _jsxs(Text, { dimColor: true, children: [" \u00B7 council adjourned in ", totalElapsed(rows)] }) : null] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Verdict" }), _jsx(Text, { children: councilView.verdict }), _jsxs(Text, { dimColor: true, children: [councilView.calls, " \u00B7 ", councilView.stats.join(' · ')] })] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Providers" }), councilView.columns.map((c) => (_jsxs(Text, { children: [c.title, ": ", c.lines[0] ?? 'no role output recorded'] }, c.provider)))] }), councilView.rows.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Council map" }), councilView.rows.slice(0, 5).map((r, i) => (_jsxs(Text, { children: [r.kind.toUpperCase(), " \u00B7 ", r.title, r.ruling ? ` · judge: ${r.ruling}` : ''] }, i)))] })), _jsxs(Text, { dimColor: true, children: ['\n', "report: ", dir, "/final-report.md"] }), _jsxs(Text, { dimColor: true, children: ["report opened in your browser \u00B7 reopen: aiki show ", councilView.runId, " --html --open"] })] })), !aborted && !errorView && !councilView && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { color: "green", bold: true, children: "\u2714 Run complete" }), totalElapsed(rows) ? _jsxs(Text, { dimColor: true, children: [" \u00B7 council adjourned in ", totalElapsed(rows)] }) : null] }), completion ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Verdict" }), _jsx(Text, { children: completion.verdict }), completion.disagreements.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Top disagreements" }), completion.disagreements.map((d, i) => (_jsxs(Text, { children: ['  ', d] }, i)))] })), _jsxs(Text, { dimColor: true, children: ['\n', "report: ", completion.reportPath] })] })) : (_jsxs(Text, { dimColor: true, children: ["artifacts: ", dir] }))] })), _jsxs(Text, { dimColor: true, children: ['\n', "press any key to exit"] })] }))] }));
+}

package/dist/tui/format.js

@@ -0,0 +1,27 @@
+// Pure formatters for the completion + error screens (T8, §4.3, §471). No Ink — unit-tested directly.
+/** Completion summary (§4.3): verdict + the top-N contradictions with their adjudication ruling. */
+export function formatCompletion(dir, judge, map, topN = 3) {
+    const ruling = new Map(judge.adjudications.map((a) => [a.id, a.ruling]));
+    const disagreements = map.contradictions.slice(0, topN).map((d) => {
+        const r = ruling.get(d.id) ?? 'UNRESOLVED';
+        const arg = d.attacks[0]?.argument ?? '';
+        return `${d.id} → ${r}: ${arg}`;
+    });
+    return { verdict: judge.verdict, disagreements, reportPath: `${dir}/final-report.md`, rawPath: `${dir}/raw/` };
+}
+/** Actionable fix line per classified error (§471 error panel). */
+const FIX = {
+    AUTH: "provider needs login — run it once in a terminal (e.g. `claude`)",
+    QUOTA: 'provider quota / rate limit hit — wait, or switch the role to another provider',
+    NOT_FOUND: 'provider binary not on PATH — run `aiki doctor`',
+    TIMEOUT: 'a provider call exceeded its timeout',
+    BAD_OUTPUT: 'a provider returned unparseable output even after the repair retry',
+    CRASH: 'a provider process exited abnormally',
+    QUORUM: 'need ≥2 providers ready — run `aiki doctor`',
+    BUDGET: 'call budget exhausted — raise it with `--budget <n>`',
+    DEADLINE: 'run exceeded its wall-clock deadline',
+    ABORT: 'run aborted',
+};
+export function formatError(code, partialDir) {
+    return { code, fix: FIX[code] ?? 'see the run logs under .aiki/', ...(partialDir ? { partialDir } : {}) };
+}

package/dist/tui/index.js

@@ -0,0 +1,8 @@
+// TUI entry (T8). `render` with exitOnCtrlC:false — the app handles Ctrl+C itself (graceful abort).
+// Config (role pins / budget from .aiki/config.json, T9) is loaded by the CLI entry and passed in here.
+import React from 'react';
+import { render } from 'ink';
+import { App } from './app.js';
+export function startTui(opts = {}) {
+    render(React.createElement(App, opts), { exitOnCtrlC: false });
+}

package/dist/tui/smart-entry.js

@@ -0,0 +1,106 @@
+export const PRODUCT_LINE = 'aiki stress-tests ideas and reviews code; for general questions use a single model — a council adds cost, not accuracy, when there is one right answer.';
+const QUESTION_START = /^(what|why|how|who|when|where|is|are|can|could|should|would|do|does|did|will)\b/i;
+const CODE_MARKER = /(diff --git|^@@|\+\+\+ b\/|--- a\/|```|[A-Za-z0-9_-]+\/[A-Za-z0-9_./-]+\.(ts|tsx|js|jsx|py|go|rs|java|rb|php|css|html|md)\b|\b(function|const|let|class|import|export)\b|[{};])/m;
+// ── Scope redirect (V10.2) — catch "explore my whole codebase / brainstorm features for me" asks and
+// point them at the right door, instead of silently stress-testing the request sentence as an "idea".
+// aiki reviews a DIFF and vets a STATED idea; it does not roam a repo (§3/§22). Pure + deterministic. ──
+// "go through / analyze / review MY|THIS|THE code|codebase|repo|project|files"
+const CODEBASE_SCAN = /\b(go through|read|scan|analy[sz]e|explore|look (?:at|through|into)|review|audit|inspect|check)\b[^.?!]*\b(my|this|the|our|these)\s+(code|code ?base|repo|repository|project|files|source)\b/i;
+// "what|which ... features|improvements|improve|add|build" (interrogative — genuine ideas don't lead with it)
+const BRAINSTORM = /\b(what|which)\b[^.?!]{0,60}\b(features?|improvements?|improve|add|build)\b/i;
+export const SCOPE_REDIRECT_MSG = 'aiki reviews your *changes*, not a whole codebase, and vets a *specific* idea rather than brainstorming for you. Try /review for your current changes, or /idea "<one concrete idea>" to stress-test a specific one.';
+/** A helpful scope message if the text is a codebase-exploration / feature-brainstorm ask, else null. */
+export function scopeRedirect(text) {
+    const t = text.trim();
+    if (!t)
+        return null;
+    return CODEBASE_SCAN.test(t) || BRAINSTORM.test(t) ? SCOPE_REDIRECT_MSG : null;
+}
+export function routeInput(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return 'idea';
+    const codeLike = CODE_MARKER.test(trimmed);
+    if (codeLike)
+        return 'code-review';
+    const words = trimmed.split(/\s+/).filter(Boolean).length;
+    if (words <= 18 && (trimmed.endsWith('?') || QUESTION_START.test(trimmed)))
+        return 'question';
+    return 'idea';
+}
+/** The home-screen command list (also drives `/help`). */
+export const COMMANDS = [
+    { name: 'idea', usage: '/idea <text>', help: 'stress-test an idea with the council' },
+    { name: 'review', usage: '/review [--branch]', help: 'review your working-tree changes (or the branch)' },
+    { name: 'resume', usage: '/resume <id>', help: 'continue a killed/timed-out run (replays finished work)' },
+    { name: 'sessions', usage: '/sessions', help: 'list past runs (newest first)' },
+    { name: 'models', usage: '/models', help: 'show/choose the model each provider uses' },
+    { name: 'config', usage: '/config', help: 'show the effective config' },
+    { name: 'help', usage: '/help', help: 'this list' },
+];
+/** Live palette filter (V10): while the user is typing the command word (input starts with "/",
+ *  no space yet), return the commands it matches — prefix matches first, then substring matches
+ *  (so "/mo" and "/dels" both find models). Bare "/" lists everything. Pure + deterministic. */
+export function filterCommands(input) {
+    const t = input.trimStart();
+    if (!t.startsWith('/') || /\s/.test(t))
+        return [];
+    const q = t.slice(1).toLowerCase();
+    const prefix = COMMANDS.filter((c) => c.name.startsWith(q));
+    const substr = COMMANDS.filter((c) => !c.name.startsWith(q) && c.name.includes(q));
+    return [...prefix, ...substr];
+}
+function editDistance(a, b) {
+    const dp = Array.from({ length: a.length + 1 }, (_, i) => {
+        const row = new Array(b.length + 1).fill(0);
+        row[0] = i;
+        return row;
+    });
+    for (let j = 0; j <= b.length; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= a.length; i++)
+        for (let j = 1; j <= b.length; j++)
+            dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    return dp[a.length][b.length];
+}
+/** Near-miss recovery (V10): the closest command to an unknown one (≤2 edits, e.g. /model → /models),
+ *  falling back to a substring match; null when nothing is plausibly meant. */
+export function suggestCommand(cmd) {
+    const q = cmd.toLowerCase();
+    let best = null;
+    let bestD = 3; // accept distance ≤ 2
+    for (const c of COMMANDS) {
+        const d = editDistance(q, c.name);
+        if (d < bestD) {
+            bestD = d;
+            best = c.name;
+        }
+    }
+    if (best)
+        return best;
+    const sub = COMMANDS.find((c) => c.name.includes(q) || q.includes(c.name));
+    return sub ? sub.name : null;
+}
+/** Parse a slash command like "/review --branch" or "/idea build X". Returns null for non-slash input
+ *  (which then goes through `routeInput`). Pure + deterministic. */
+export function parseCommand(input) {
+    const t = input.trim();
+    if (!t.startsWith('/'))
+        return null;
+    const body = t.slice(1);
+    const sp = body.search(/\s/);
+    const cmd = (sp === -1 ? body : body.slice(0, sp)).toLowerCase();
+    const rest = sp === -1 ? '' : body.slice(sp + 1).trim();
+    return { cmd, rest, args: rest ? rest.split(/\s+/) : [] };
+}
+export function quickActionReducer(key, hasRepo) {
+    const k = key.toLowerCase();
+    if (k === 'i')
+        return { action: 'idea' };
+    if (k === 'r' || k === 'b') {
+        if (!hasRepo)
+            return { action: null, message: 'not inside a git repo' };
+        return { action: k === 'r' ? 'review-working-tree' : 'review-branch' };
+    }
+    return { action: null };
+}