aiki-cli 0.2.0

package/dist/cli/index.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+// aiki CLI entrypoint. Subcommands: doctor / providers / run / show / resolve / config.
+// Bare `aiki` mounts the interactive TUI (T8), honoring .aiki/config.json (T9).
+import { Command } from 'commander';
+import { doctor } from './doctor.js';
+import { providers } from './providers.js';
+import { runCommand } from './run.js';
+import { show } from './show.js';
+import { resolve } from './resolve.js';
+import { resumeCommand } from './resume.js';
+import { sessionsCommand } from './sessions.js';
+import { config } from './config.js';
+import { modelsCommand } from './models.js';
+import { benchCommand } from './bench.js';
+import { ConfigError, loadLayeredConfig } from '../config/config.js';
+import { resolveRunsRoot } from '../storage/paths.js';
+import { startTui } from '../tui/index.js';
+export const VERSION = '0.2.0';
+const program = new Command();
+/** commander collector for a repeatable option. */
+const collect = (v, acc) => {
+    acc.push(v);
+    return acc;
+};
+program
+    .name('aiki')
+    .description('Local multi-model orchestration — coordinate your installed AI CLIs.')
+    .version(VERSION);
+program
+    .command('doctor')
+    .description('Detect providers + probe flags + smoke test; print status table. Exit 0 iff ≥2 ready.')
+    .option('--no-smoke', 'skip the live smoke test (detection + probe only; no model calls)')
+    .option('--fresh', 'bypass the 6h smoke cache and re-run the smoke test')
+    .action(async (opts) => {
+    process.exit(await doctor({ smoke: opts.smoke, fresh: opts.fresh }));
+});
+program
+    .command('providers')
+    .description('Machine-readable provider status: resolved capability profiles (§7.4). No model calls.')
+    .option('--json', 'print the resolved capability profiles as JSON')
+    .action(async (opts) => {
+    process.exit(await providers({ json: opts.json }));
+});
+program
+    .command('run')
+    .description('Headless run of a workflow (§5). idea-refinement: text/file. code-review: git diff or --diff.')
+    .argument('<workflow>', 'workflow id: idea-refinement | code-review')
+    .argument('[input]', 'idea-refinement: inline text or a path to a .md file')
+    .option('--budget <n>', 'max provider calls for this run (default 12)', (v) => parseInt(v, 10))
+    .option('--base <ref>', 'code-review: base git ref to diff from (default: detected default branch)')
+    .option('--head <ref>', 'code-review: head git ref to diff to (default HEAD)')
+    .option('--diff <file>', 'code-review: review a patch file instead of computing a git diff')
+    .option('--cheap', 'code-review: Gemini+Codex review, Claude judges only disputes (~⅓ the Opus; experimental)')
+    .option('--yes', 'skip the run-cost confirmation prompt')
+    .action(async (workflow, input, opts) => {
+    process.exit(await runCommand(workflow, input, { budget: opts.budget, base: opts.base, head: opts.head, diff: opts.diff, cheap: opts.cheap, yes: opts.yes }));
+});
+program
+    .command('show')
+    .description('Print a stored run\'s final report; --raw lists artifact files. No id → latest run.')
+    .argument('[run-id]', 'run id or a unique suffix/substring (omit for the most recent run)')
+    .option('--raw', 'list the run\'s artifact files instead of the report')
+    .option('--html', 'write a self-contained council-view HTML file and print its path')
+    .option('--open', 'with --html, open the generated file in the default browser')
+    .action(async (runId, opts) => {
+    process.exit(await show(runId, { raw: opts.raw, html: opts.html, open: opts.open, root: await resolveRunsRoot() }));
+});
+program
+    .command('resolve')
+    .description('Annotate a run\'s adjudicated disputes → .aiki/feedback.jsonl (§127). No id → latest run.')
+    .argument('[run-id]', 'run id or a unique suffix/substring (omit for the most recent run)')
+    .option('--verdict <id=verdict>', 'non-interactive verdict, repeatable: <item-id>=<correct|incorrect|unsure>', collect, [])
+    .action(async (runId, opts) => {
+    process.exit(await resolve(runId, { verdict: opts.verdict, root: await resolveRunsRoot() }));
+});
+program
+    .command('sessions')
+    .description('List runs from the global registry (~/.aiki/sessions.jsonl), newest first.')
+    .option('--json', 'print the registry as JSON')
+    .action(async (opts) => {
+    process.exit(await sessionsCommand({ json: opts.json }));
+});
+program
+    .command('resume')
+    .description('Continue a killed/timed-out run from where it stopped (replays completed calls; §V6.3).')
+    .argument('[run-id]', 'run id or a unique suffix/substring (see `aiki sessions`)')
+    .action(async (runId) => {
+    process.exit(await resumeCommand(runId, { root: await resolveRunsRoot() }));
+});
+program
+    .command('bench')
+    .description('Run benchmark arms A–D on a task set; writes bench/results/*.json + summary table (§17).')
+    .argument('<workflow>', 'workflow id (v1: code-review)')
+    .option('--arms <list>', 'comma-separated arms to run', 'A,B,C,D')
+    .option('--set <name>', 'task set: build | holdout', 'build')
+    .option('--resume', 'continue the latest results file: keep already-scored case×arm pairs, retry the rest')
+    .option('--yes', 'actually run; without it, print the pre-run Opus-call estimate and exit')
+    .action(async (workflow, opts) => {
+    process.exit(await benchCommand(workflow, { arms: opts.arms, set: opts.set, resume: opts.resume, yes: opts.yes }));
+});
+program
+    .command('models')
+    .description('Show configurable models per provider (lists via the CLI where supported) + your current pins.')
+    .action(async () => {
+    process.exit(await modelsCommand());
+});
+program
+    .command('config')
+    .description('Print the effective config; --edit opens .aiki/config.json (§128).')
+    .option('--edit', 'open .aiki/config.json in $VISUAL/$EDITOR (created if missing)')
+    .action(async (opts) => {
+    process.exit(await config({ edit: opts.edit }));
+});
+// Bare `aiki` (no subcommand) → interactive TUI, honoring layered config (roles/budget/models).
+program.action(async () => {
+    let cfg;
+    try {
+        cfg = await loadLayeredConfig();
+    }
+    catch (e) {
+        if (e instanceof ConfigError) {
+            process.stderr.write(`${e.message}\n`);
+            process.exit(1);
+        }
+        throw e;
+    }
+    startTui({ roleOverrides: cfg.roles, budget: cfg.budget, runsRoot: await resolveRunsRoot(), providerModels: cfg.models, version: VERSION });
+});
+program.parseAsync(process.argv);

package/dist/cli/models.js

@@ -0,0 +1,51 @@
+// `aiki models` (V8) — show which model each provider can run and your current per-provider pins.
+// Only agy exposes a `models` command (verified 2026-07-06, docs/PROVIDER_NOTES.md); claude/codex take
+// any id via `--model` but don't enumerate, so we say "type any id". Listing is free (no inference).
+import { execFile } from 'node:child_process';
+import { PROVIDER_IDS, DISPLAY_NAME } from '../providers/types.js';
+import { detect } from '../providers/detect.js';
+import { loadLayeredConfig } from '../config/config.js';
+import { homeAikiRoot } from '../storage/paths.js';
+/** Models the CLI can enumerate, or null if it has no list command. `agy models` blocks on stdin without
+ *  a TTY (the known agy trap — see PROVIDER_NOTES), so we close the child's stdin. */
+function listModels(id) {
+    if (id !== 'agy')
+        return Promise.resolve(null); // only agy has a `models` subcommand
+    return new Promise((resolve) => {
+        const child = execFile('agy', ['models'], { timeout: 20_000, maxBuffer: 1 << 20 }, (err, stdout) => {
+            if (err)
+                return resolve(null);
+            resolve(stdout.split('\n').map((l) => l.trim()).filter(Boolean));
+        });
+        child.stdin?.end();
+    });
+}
+/** Build the `aiki models` report as a string (so the TUI can render it too, not just stdout). */
+export async function formatModels() {
+    const cfg = await loadLayeredConfig();
+    const models = cfg.models ?? {};
+    const out = ['Models — aiki passes your choice to each CLI as `--model <id>`.', ''];
+    for (const id of PROVIDER_IDS) {
+        const det = await detect(id);
+        const pinned = models[id];
+        const current = pinned ? `pinned: ${pinned}` : 'CLI default';
+        if (det.status !== 'READY') {
+            out.push(`${DISPLAY_NAME[id]} (${id}) — not installed`, '');
+            continue;
+        }
+        out.push(`${DISPLAY_NAME[id]} (${id}) · ${current}`);
+        const list = await listModels(id);
+        if (list && list.length)
+            list.forEach((m) => out.push(`    ${m}`));
+        else
+            out.push("    (this CLI doesn't list models — set any id it accepts)");
+        out.push('');
+    }
+    out.push('Set a model in .aiki/config.json (this project) or ' + homeAikiRoot() + '/config.json (global):');
+    out.push('  { "models": { "agy": "Gemini 3.1 Pro (High)", "claude": "opus", "codex": "gpt-5-codex" } }');
+    return out.join('\n');
+}
+export async function modelsCommand() {
+    process.stdout.write(`${await formatModels()}\n`);
+    return 0;
+}

package/dist/cli/providers.js

@@ -0,0 +1,31 @@
+import { resolveProfiles } from '../providers/profiles.js';
+/**
+ * `aiki providers` (§5) — machine-readable provider status. `--json` prints the capability
+ * profiles actually resolved on this machine; bare prints a compact human summary. Detection +
+ * flag probe only, no model calls (§8). Exit 0 always (informational).
+ */
+export async function providers(opts = {}) {
+    const resolved = await resolveProfiles();
+    if (opts.json) {
+        process.stdout.write(JSON.stringify(resolved, null, 2) + '\n');
+        return 0;
+    }
+    process.stdout.write(renderHuman(resolved) + '\n');
+    return 0;
+}
+const pad = (s, w) => s.padEnd(w);
+function renderHuman(rows) {
+    const out = ['', '  aiki providers — resolved capability profiles (no smoke)', ''];
+    out.push(`  ${pad('PROVIDER', 10)}${pad('VERSION', 11)}${pad('INSTALLED', 11)}${pad('JSON', 6)}${pad('READ-ONLY', 11)}CAPABILITY (reason/codeNav/json/ctx)`);
+    out.push(`  ${'─'.repeat(88)}`);
+    for (const r of rows) {
+        const c = r.capability;
+        const cap = `${c.reasoning}/${c.codeNav}/${c.jsonReliability}/${c.contextExplore}  ${c.cost}`;
+        const json = r.flags ? (r.flags.jsonOutput ? 'yes' : 'no') : '—';
+        const ro = r.flags ? r.flags.readOnlyFlag : '—';
+        out.push(`  ${pad(r.displayName, 10)}${pad(r.version ?? '—', 11)}${pad(r.installed ? 'yes' : 'no', 11)}${pad(json, 6)}${pad(ro, 11)}${cap}`);
+    }
+    out.push('');
+    out.push('  Use --json for the machine-readable form.');
+    return out.join('\n');
+}

package/dist/cli/resolve.js

@@ -0,0 +1,159 @@
+// `aiki resolve <run-id>` (§5/§127) — the human review gate. Records a verdict on each of a run's
+// annotatable items → appends `.aiki/feedback.jsonl`. Workflow-aware (T11):
+//   idea-refinement → the judge's adjudicated contradictions, verdict correct/incorrect/unsure;
+//   code-review     → the report's kept findings, verdict fixed/wontfix/false-positive (false-positive
+//                     labels feed the bench PRECISION metric).
+// Two entry paths: an interactive readline loop (needs a TTY) and non-interactive `--verdict <id>=<v>`
+// (repeatable, used by tests/automation). Both funnel through the pure core in storage/feedback.ts.
+import { createInterface } from 'node:readline';
+import { scoreFindings } from '../orchestration/stages/cr-report.js';
+import { readJsonArtifact, resolveRunId, runDir } from '../storage/runs-read.js';
+import { appendFeedback, buildFeedbackEntries, FeedbackError, parseVerdictFlags, VERDICT_VOCAB } from '../storage/feedback.js';
+/** Build the annotatable list for an idea-refinement run (adjudicated contradictions). */
+function ideaItems(judge, map) {
+    return judge.adjudications.map((a) => {
+        const c = map?.contradictions.find((x) => x.id === a.id);
+        const dispute = c?.attacks[0]?.argument ?? '';
+        return { id: a.id, ruling: a.ruling, label: `[${a.ruling}] ${dispute || a.reasoning}` };
+    });
+}
+/** Build the annotatable list for a code-review run (kept findings from the report). */
+function reviewItems(map, judge) {
+    return scoreFindings(map, judge)
+        .filter((s) => s.disposition === 'kept')
+        .map((s) => ({
+        id: s.finding.id,
+        ruling: `${s.finding.severity}/${s.finding.category}/${s.confidence}`,
+        label: `[${s.finding.severity} ${s.confidence}] ${s.finding.file}:${s.finding.line_start}-${s.finding.line_end} — ${s.finding.claim}`,
+    }));
+}
+function ask(rl, q) {
+    return new Promise((res) => rl.question(q, (a) => res(a.trim())));
+}
+/** Interactive annotation loop. `keys` maps a single-char shortcut to a verdict. */
+async function interactiveAnnotate(items, keys) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const verdicts = new Map();
+    const legend = Object.entries(keys).map(([k, v]) => `[${k}]${v.slice(1)}`).join(' / ');
+    process.stdout.write(`\n  ${items.length} item(s). For each: ${legend} / [s]kip / [q]uit\n`);
+    try {
+        for (const item of items) {
+            process.stdout.write(`\n  ${item.id}  ${item.label}\n`);
+            const key = (await ask(rl, `    verdict? `)).toLowerCase();
+            if (key === 'q')
+                break;
+            if (key === 's' || key === '')
+                continue;
+            const verdict = keys[key];
+            if (!verdict) {
+                process.stdout.write(`    ? unrecognized "${key}" — skipping\n`);
+                continue;
+            }
+            const note = await ask(rl, `    note (enter to skip): `);
+            verdicts.set(item.id, { verdict, ...(note ? { note } : {}) });
+        }
+    }
+    finally {
+        rl.close();
+    }
+    return verdicts;
+}
+/** First-letter shortcut map for a workflow's vocab (correct→c, false-positive→f... unique-first-letter). */
+function shortcutKeys(vocab) {
+    const keys = {};
+    for (const v of vocab) {
+        let k = v[0];
+        let i = 1;
+        while (keys[k] && i < v.length)
+            k = v[i++];
+        keys[k] = v;
+    }
+    return keys;
+}
+export async function resolve(runArg, opts = {}) {
+    const root = opts.root ?? '.aiki';
+    const match = await resolveRunId(runArg, root);
+    if (!match.ok) {
+        if (match.kind === 'none')
+            process.stderr.write('no runs found under .aiki/runs/\n');
+        else if (match.kind === 'no-match')
+            process.stderr.write(`no run matches "${match.arg}". Omit the id for the most recent run.\n`);
+        else
+            process.stderr.write(`"${match.arg}" is ambiguous — matches:\n${match.candidates.map((c) => `  ${c}`).join('\n')}\n`);
+        return 1;
+    }
+    const dir = runDir(match.runId, root);
+    const meta = await readJsonArtifact(dir, 'meta.json');
+    const workflow = meta?.workflow ?? 'idea-refinement';
+    const judge = await readJsonArtifact(dir, '09-judge-report.json');
+    let items;
+    let itemType;
+    if (workflow === 'code-review') {
+        const map = await readJsonArtifact(dir, '07-review-map.json');
+        if (map && judge) {
+            items = reviewItems(map, judge);
+        }
+        else {
+            // Single-call bench arms (A/B) write no review-map — annotate the harness-persisted
+            // scored findings instead (raw/bench-findings.json, the precision denominator).
+            const bench = await readJsonArtifact(dir, 'raw/bench-findings.json');
+            if (!bench || bench.length === 0) {
+                process.stdout.write(`  run ${match.runId} has no findings to annotate.\n`);
+                return 0;
+            }
+            items = bench.map((f) => ({
+                id: f.id,
+                ruling: `${f.severity}/${f.category}/BENCH`,
+                label: `[${f.severity}] ${f.file}:${f.line_start}-${f.line_end} — ${f.claim}`,
+            }));
+        }
+        itemType = 'finding';
+    }
+    else {
+        if (!judge || judge.adjudications.length === 0) {
+            process.stdout.write(`  run ${match.runId} has no adjudicated disputes to annotate.\n`);
+            return 0;
+        }
+        const map = await readJsonArtifact(dir, '07-disagreement-map.json');
+        items = ideaItems(judge, map);
+        itemType = 'adjudication';
+    }
+    if (items.length === 0) {
+        process.stdout.write(`  run ${match.runId} has no items to annotate.\n`);
+        return 0;
+    }
+    const vocab = VERDICT_VOCAB[workflow];
+    let verdicts;
+    if (opts.verdict?.length) {
+        try {
+            verdicts = parseVerdictFlags(opts.verdict, vocab);
+        }
+        catch (e) {
+            process.stderr.write(`${e instanceof Error ? e.message : String(e)}\n`);
+            return 1;
+        }
+    }
+    else if (!process.stdin.isTTY) {
+        process.stderr.write(`resolve is interactive — in a non-interactive shell pass --verdict <id>=<${vocab.join('|')}>\n`);
+        return 1;
+    }
+    else {
+        verdicts = await interactiveAnnotate(items, shortcutKeys(vocab));
+    }
+    const annItems = items.map((i) => ({ id: i.id, ruling: i.ruling }));
+    let entries;
+    try {
+        entries = buildFeedbackEntries(match.runId, workflow, annItems, verdicts, new Date(), itemType);
+    }
+    catch (e) {
+        process.stderr.write(`${e instanceof FeedbackError ? e.message : String(e)}\n`);
+        return 1;
+    }
+    if (entries.length === 0) {
+        process.stdout.write('  no verdicts recorded.\n');
+        return 0;
+    }
+    const path = await appendFeedback(entries);
+    process.stdout.write(`  ✔ recorded ${entries.length} verdict(s) → ${path}\n`);
+    return 0;
+}

package/dist/cli/resume.js

@@ -0,0 +1,94 @@
+// `aiki resume <session-id>` (V6.3) — continue a killed/timed-out run from where it stopped, without
+// re-spending the calls that already succeeded. It re-runs the pipeline into a FRESH run, replaying every
+// completed (provider, prompt) from the old run's raw/ outputs; only the failed stage onward hits a model.
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { run as runEngine } from '../orchestration/engine.js';
+import { ConfigError, loadLayeredConfig } from '../config/config.js';
+import { resolveRunsRoot } from '../storage/paths.js';
+import { buildReplayCache } from '../storage/replay.js';
+import { findSession } from '../storage/sessions.js';
+import { readJsonArtifact, resolveRunId, runDir } from '../storage/runs-read.js';
+export async function resumeCommand(runArg, opts = {}) {
+    if (!runArg) {
+        process.stderr.write('usage: aiki resume <session-id>   (see `aiki sessions`)\n');
+        return 1;
+    }
+    const root = opts.root ?? '.aiki';
+    // Locate the run: prefer the global registry (finds it across locations), else the current root.
+    let oldId;
+    let oldDir;
+    let workflow;
+    let cwd;
+    const sess = await findSession(runArg);
+    if (sess && 'ambiguous' in sess) {
+        process.stderr.write(`"${runArg}" is ambiguous — matches:\n${sess.ambiguous.map((c) => `  ${c}`).join('\n')}\n`);
+        return 1;
+    }
+    if (sess) {
+        oldId = sess.id;
+        workflow = sess.workflow;
+        oldDir = join(sess.runsRoot, 'runs', sess.id);
+        cwd = sess.cwd;
+    }
+    else {
+        const match = await resolveRunId(runArg, root);
+        if (!match.ok) {
+            process.stderr.write(`no run matches "${runArg}" (checked the session registry and ${root}/runs).\n`);
+            return 1;
+        }
+        oldId = match.runId;
+        oldDir = runDir(match.runId, root);
+        const meta = await readJsonArtifact(oldDir, 'meta.json');
+        if (!meta) {
+            process.stderr.write(`cannot read meta.json for ${oldId} — nothing to resume.\n`);
+            return 1;
+        }
+        workflow = meta.workflow;
+    }
+    // Recover the original input the run was started with.
+    const inputFile = workflow === 'code-review' ? 'diff.patch' : 'idea.md';
+    let input;
+    try {
+        input = await readFile(join(oldDir, 'inputs', inputFile), 'utf8');
+    }
+    catch {
+        process.stderr.write(`cannot recover the input (inputs/${inputFile}) for ${oldId} — nothing to resume.\n`);
+        return 1;
+    }
+    const replay = await buildReplayCache(oldDir);
+    if (replay.size === 0) {
+        process.stderr.write(`no completed calls found for ${oldId} — start a fresh run instead.\n`);
+        return 1;
+    }
+    let cfg;
+    try {
+        cfg = await loadLayeredConfig();
+    }
+    catch (e) {
+        if (e instanceof ConfigError) {
+            process.stderr.write(`${e.message}\n`);
+            return 1;
+        }
+        throw e;
+    }
+    process.stdout.write(`  resuming ${oldId} (${workflow}) — replaying ${replay.size} completed call(s); only the rest will hit a model.\n`);
+    const outcome = await runEngine(workflow, input, {
+        budget: cfg.budget,
+        deadlineMs: cfg.deadlineMs,
+        roleOverrides: cfg.roles,
+        cwd: workflow === 'code-review' ? cwd : undefined, // code-review reviewers run at the repo root
+        runsRoot: await resolveRunsRoot(),
+        replay,
+        resumedFrom: oldId,
+        providerModels: cfg.models,
+    });
+    if (outcome.ok) {
+        process.stdout.write(`\n  ✔ resumed run ${outcome.runId} complete — ${outcome.callCount} new provider call(s)\n  artifacts: ${outcome.dir}\n\n`);
+        return 0;
+    }
+    process.stderr.write(`\n  ✖ resumed run ${outcome.runId} failed [${outcome.error?.code}]: ${outcome.error?.message}\n` +
+        (outcome.dir ? `  partial artifacts: ${outcome.dir} — you can \`aiki resume ${outcome.runId}\` again\n` : '') +
+        '\n');
+    return 1;
+}

package/dist/cli/run.js

@@ -0,0 +1,155 @@
+// `aiki run <workflow> [input]` (§5) — headless run. idea-refinement takes inline text or a file path;
+// code-review computes a git diff from --base/--head (or reads --diff) and reviews it at the repo root.
+import { readFile } from 'node:fs/promises';
+import { createInterface } from 'node:readline';
+import { run as runEngine } from '../orchestration/engine.js';
+import { ConfigError, loadLayeredConfig } from '../config/config.js';
+import { computeDiff, detectDefaultBranch, GitError, repoToplevel } from '../orchestration/git.js';
+import { resolveRunsRoot } from '../storage/paths.js';
+import { openCouncilHtml } from '../council/open.js';
+const WORKFLOWS = ['idea-refinement', 'code-review'];
+/** Rough provider-call estimate for the run-cost preview (V5). Approximate — the real count varies with
+ *  §14 repairs, cross-exam skips, and quorum. `opus` = the Claude/Opus subset (the metered-cost driver). */
+export function estimateRun(workflow, opts = {}) {
+    if (workflow === 'code-review')
+        return { calls: 5, opus: opts.cheap ? 1 : 2 };
+    return { calls: 12, opus: 4 }; // idea-refinement (S0/S1/S3 on agy; S2 has claude; S7 + S9 + S9b run on the claude judge)
+}
+/** Thin y/N prompt (default yes). Only used on an interactive TTY. */
+function confirm(question) {
+    return new Promise((resolve) => {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(question, (a) => {
+            rl.close();
+            resolve(!/^n/i.test(a.trim()));
+        });
+    });
+}
+/** Resolve an idea-refinement input: an existing file path → its contents, else the arg as inline text. */
+async function resolveInput(arg) {
+    if (!arg)
+        return null;
+    try {
+        return await readFile(arg, 'utf8'); // path
+    }
+    catch {
+        return arg; // inline text
+    }
+}
+/** Build the code-review input: the unified diff + the repo-root cwd reviewers run in (§12.2). Returns
+ *  a `done` code for the non-run outcomes (no changes / usage / git error) so the caller can exit. */
+async function resolveCodeReview(opts) {
+    const repoRoot = await repoToplevel(process.cwd());
+    let diff;
+    if (opts.diff) {
+        try {
+            diff = await readFile(opts.diff, 'utf8');
+        }
+        catch {
+            process.stderr.write(`cannot read --diff file "${opts.diff}"\n`);
+            return { done: 1 };
+        }
+    }
+    else {
+        if (!repoRoot) {
+            process.stderr.write('not inside a git repository — pass --diff <file> instead\n');
+            return { done: 1 };
+        }
+        const base = opts.base ?? await detectDefaultBranch(repoRoot);
+        if (!base) {
+            process.stderr.write('cannot detect default branch — pass --base <ref>, or --diff <file>\n');
+            return { done: 1 };
+        }
+        try {
+            diff = await computeDiff(base, opts.head ?? 'HEAD', repoRoot);
+        }
+        catch (e) {
+            process.stderr.write(`${e instanceof GitError ? e.message : String(e)}\n`);
+            return { done: 1 };
+        }
+    }
+    if (!diff.trim()) {
+        process.stdout.write('  no changes to review.\n');
+        return { done: 0 };
+    }
+    return { text: diff, cwd: repoRoot ?? process.cwd() };
+}
+export async function runCommand(workflow, input, opts = {}) {
+    if (!WORKFLOWS.includes(workflow)) {
+        process.stderr.write(`unknown workflow "${workflow}". Available: ${WORKFLOWS.join(', ')}\n`);
+        return 1;
+    }
+    let text;
+    let cwd;
+    if (workflow === 'code-review') {
+        const r = await resolveCodeReview(opts);
+        if ('done' in r)
+            return r.done;
+        ({ text, cwd } = r);
+    }
+    else {
+        const resolved = await resolveInput(input);
+        if (!resolved || !resolved.trim()) {
+            process.stderr.write(`no input. Usage: aiki run ${workflow} "<text>"  |  aiki run ${workflow} ./file.md\n`);
+            return 1;
+        }
+        text = resolved;
+    }
+    // Precedence (§10/T9): --budget flag > config.budget > built-in default. roles/deadline/models are
+    // config-only (layered: global ~/.aiki base, project .aiki override).
+    let cfg;
+    try {
+        cfg = await loadLayeredConfig();
+    }
+    catch (e) {
+        if (e instanceof ConfigError) {
+            process.stderr.write(`${e.message}\n`);
+            return 1;
+        }
+        throw e;
+    }
+    // --cheap = bench Arm E's Opus-thrift role swap (agy+codex reviewers, claude judge). code-review only;
+    // takes precedence over config roles for those two seats. Experimental — see BENCHMARK.md amendment E1.
+    let roleOverrides = cfg.roles;
+    if (opts.cheap) {
+        if (workflow === 'code-review')
+            roleOverrides = { ...cfg.roles, s4: ['agy', 'codex'], judge: 'claude' };
+        else
+            process.stderr.write('--cheap only applies to code-review; ignoring for this workflow.\n');
+    }
+    // Run-cost preview (V5): show the estimate; confirm interactively unless --yes or non-interactive.
+    const est = estimateRun(workflow, { cheap: opts.cheap });
+    const note = `  ≈${est.calls} provider call(s), ~${est.opus} on Claude/Opus (the metered part).`;
+    if (!opts.yes && process.stdin.isTTY && process.stdout.isTTY) {
+        if (!(await confirm(`${note}\n  Continue? [Y/n] `))) {
+            process.stdout.write('  cancelled.\n');
+            return 0;
+        }
+    }
+    else {
+        process.stdout.write(`${note}\n`);
+    }
+    const outcome = await runEngine(workflow, text, {
+        budget: opts.budget ?? cfg.budget,
+        deadlineMs: cfg.deadlineMs,
+        roleOverrides,
+        cwd, // code-review: repo root; idea-refinement: undefined → run dir
+        runsRoot: await resolveRunsRoot(), // hybrid: repo .aiki when in a repo, else ~/.aiki
+        providerModels: cfg.models, // V8: per-provider model → CLI --model
+    });
+    if (outcome.ok) {
+        process.stdout.write(`\n  ✔ run ${outcome.runId} complete — ${outcome.callCount} provider call(s)\n  artifacts: ${outcome.dir}\n`);
+        // Auto-open the readable report in the browser (interactive terminals only; skipped in pipes/CI).
+        if (process.stdout.isTTY) {
+            const html = await openCouncilHtml(outcome.runId, outcome.dir);
+            if (html)
+                process.stdout.write(`  report: ${html} — opening in your browser…\n`);
+        }
+        process.stdout.write('\n');
+        return 0;
+    }
+    process.stderr.write(`\n  ✖ run ${outcome.runId} failed [${outcome.error?.code}]: ${outcome.error?.message}\n` +
+        (outcome.dir ? `  partial artifacts: ${outcome.dir}\n` : '') +
+        '\n');
+    return 1;
+}

package/dist/cli/sessions.js

@@ -0,0 +1,35 @@
+// `aiki sessions` (V6.3) — list runs from the global registry (~/.aiki/sessions.jsonl), newest first,
+// across every location aiki was launched from. Failed/aborted ones are resumable via `aiki resume <id>`.
+import { readSessions } from '../storage/sessions.js';
+const MARK = { running: '●', ok: '✔', failed: '✖', aborted: '⊘' };
+function ago(iso) {
+    const ms = Date.now() - Date.parse(iso);
+    if (Number.isNaN(ms))
+        return iso;
+    const m = Math.floor(ms / 60000);
+    if (m < 1)
+        return 'just now';
+    if (m < 60)
+        return `${m}m ago`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h ago`;
+    return `${Math.floor(h / 24)}d ago`;
+}
+export async function sessionsCommand(opts = {}) {
+    const all = await readSessions();
+    if (opts.json) {
+        process.stdout.write(`${JSON.stringify(all, null, 2)}\n`);
+        return 0;
+    }
+    if (all.length === 0) {
+        process.stdout.write('no sessions yet — run `aiki` or `aiki run <workflow> …` first.\n');
+        return 0;
+    }
+    const lines = all.slice(0, 30).map((s) => {
+        const resumable = s.status === 'failed' || s.status === 'aborted';
+        return `  ${MARK[s.status]} ${s.id}  ${s.workflow.padEnd(16)} ${ago(s.startedAt).padStart(9)}${resumable ? '   ← aiki resume ' + s.id : ''}`;
+    });
+    process.stdout.write(`${lines.join('\n')}\n`);
+    return 0;
+}