@ashulab/carrier 0.0.0-stage → 0.1.0

package/dist/terminal/dashboard/logs.js

@@ -0,0 +1,85 @@
+import { closeSync, openSync, readSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+// The agent's output is one JSON event per line, in a different shape for each harness. What is worth reading in each:
+// what it said, and what tool it ran. Everything else (init, usage, step bookkeeping) is skipped.
+const brief = (value, max = 60) => {
+    const text = typeof value === 'string' ? value : JSON.stringify(value) ?? '';
+    return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+};
+// Claude's own notices: what it published and which of its background jobs ended. Starts, progress and usage are noise.
+function summarizeNotice(e) {
+    if (e.subtype === 'code_change_published')
+        return `▲ PR #${e.identifier} ${e.action}`;
+    if (e.subtype === 'vcs_state_changed' && e.kind === 'push')
+        return '▲ pushed';
+    if (e.subtype !== 'task_notification')
+        return null;
+    const summary = String(e.summary ?? '');
+    if (e.status === 'failed')
+        return `✗ ${brief(summary, 80)}`;
+    // a sub-agent (one `ship` slice) reports its result as JSON; a finished shell command is already in the log as the line that started it
+    const slice = /"slice":\s*"([^"]+)",\s*"outcome":\s*"([^"]+)"/.exec(summary);
+    return slice ? `✓ slice ${slice[1]} ${slice[2]}` : null;
+}
+export function summarizeLogLine(line) {
+    if (line.trim() === '')
+        return null;
+    let e;
+    try {
+        e = JSON.parse(line);
+    }
+    catch {
+        return line.trim(); // not an event: an error message, say
+    }
+    if (e === null || typeof e !== 'object')
+        return line.trim();
+    // Claude Code (stream-json)
+    if (e.type === 'assistant') {
+        const parts = Array.isArray(e.message?.content) ? e.message.content : [];
+        const out = parts.map((c) => (c?.type === 'text' ? String(c.text).trim() : c?.type === 'tool_use' ? `▸ ${c.name} ${brief(c.input)}` : '')).filter(Boolean);
+        return out.length > 0 ? out.join(' ') : null;
+    }
+    if (e.type === 'result')
+        return `result: ${brief(e.result ?? e.subtype ?? e.status ?? '', 100)}`;
+    if (e.type === 'system')
+        return summarizeNotice(e);
+    // Codex (--json)
+    if (e.item?.type === 'agent_message')
+        return String(e.item.text).trim();
+    if (e.item?.type === 'command_execution' && e.type === 'item.started')
+        return `$ ${brief(e.item.command, 90)}`;
+    // Antigravity (stream-json)
+    if (e.event === 'step_update') {
+        const su = e.step_update ?? {};
+        if (su.tool_name && su.state === 'ACTIVE')
+            return `▸ ${su.tool_name} ${brief(su.tool_info ?? '')}`;
+        return su.state === 'DONE' && su.step_type === 'agent_response' && typeof su.text_delta === 'string' && su.text_delta.trim() ? su.text_delta.trim() : null;
+    }
+    if (e.event === 'result')
+        return `result: ${brief(e.result?.response ?? e.result?.status ?? '', 100)}`;
+    return null;
+}
+/** The last `count` meaningful lines of an execution's output, read from the end of the file (it can be megabytes). */
+export function tailExecution(logs, executionId, count, fileSizeLimit = 256 * 1024) {
+    const path = join(logs, 'executions', executionId, 'stdout.log');
+    let fd;
+    try {
+        fd = openSync(path, 'r');
+    }
+    catch {
+        return []; // nothing written yet
+    }
+    try {
+        const size = statSync(path).size;
+        const start = Math.max(0, size - fileSizeLimit);
+        const buffer = Buffer.alloc(size - start);
+        readSync(fd, buffer, 0, buffer.length, start);
+        const lines = buffer.toString('utf8').split('\n');
+        if (start > 0)
+            lines.shift(); // cut in the middle of a line
+        return lines.flatMap((l) => summarizeLogLine(l) ?? []).slice(-count);
+    }
+    finally {
+        closeSync(fd);
+    }
+}

package/dist/terminal/dashboard/panel.js

@@ -0,0 +1,62 @@
+import { renderDashboard } from './dashboard.js';
+import { renderPanel } from './plain.js';
+// What a person reads as "the state changed": durations tick every second and do not count.
+const stateOf = (e) => [e.status, e.stage, e.round, e.blockers, e.needsHumanReason, e.lastError].join('|');
+/**
+ * Shows the snapshot on `out` every `intervalMs`: redrawn in place with ANSI on a terminal, one plain line
+ * per state change otherwise. No input handling: Ctrl+C is the only way to stop the process.
+ * Returns the stop function.
+ */
+export function startPanel(snapshot, out = process.stdout, intervalMs = 1000, 
+/** What a terminal is shown; the dashboard unless the caller draws its own (with a selection, say). */
+render = (s, columns) => renderDashboard(s, { columns })) {
+    let drawn = 0;
+    const seen = new Map();
+    let queueSeen = '';
+    let finishedSeen = '';
+    // The panel owns the screen, so the cursor is hidden while it runs and always given back, also when the process dies on its own.
+    const hideCursor = '\x1b[?25l';
+    const showCursor = '\x1b[?25h';
+    const restoreOnExit = () => out.write(showCursor);
+    if (out.isTTY)
+        process.once('exit', restoreOnExit);
+    const redraw = (s) => {
+        // Lines wider than the terminal would wrap and break the cursor-up count; the dashboard cuts them itself.
+        const lines = render(s, out.columns);
+        out.write(`${drawn > 0 ? `\x1b[${drawn}A` : hideCursor}${lines.map((l) => `\r\x1b[2K${l}\n`).join('')}\x1b[J`);
+        drawn = lines.length;
+    };
+    const emitChanges = (s) => {
+        const at = new Date(s.now).toISOString();
+        const queue = `${s.slots.busy}/${s.slots.total}|${s.queue.map((q) => `${q.repo}#${q.issue}`).join(',')}`;
+        if (queue !== queueSeen) {
+            queueSeen = queue;
+            out.write(`${at} slots ${s.slots.busy}/${s.slots.total} queue ${s.queue.length}${s.queue.length > 0 ? `: ${s.queue.map((q) => `${q.repo}#${q.issue}`).join(', ')}` : ''}\n`);
+        }
+        for (const e of s.epics) {
+            const key = `${e.repo}#${e.issue}`;
+            if (seen.get(key) === stateOf(e))
+                continue;
+            seen.set(key, stateOf(e));
+            out.write(`${at} ${renderPanel({ ...s, epics: [e], finished: [] }).slice(1).map((l) => l.trim()).join(' | ')}\n`);
+        }
+        // The finished rows when the set changes: their "ago" ticks and does not count.
+        const finished = (s.finished ?? []).map((f) => `${f.repo}#${f.issue}`).join(',');
+        if (finished !== finishedSeen) {
+            finishedSeen = finished;
+            for (const l of renderPanel({ ...s, epics: [] }).slice(1))
+                out.write(`${at} ${l}\n`);
+        }
+    };
+    const tick = () => (out.isTTY ? redraw : emitChanges)(snapshot());
+    tick();
+    const timer = setInterval(tick, intervalMs);
+    const stop = () => {
+        clearInterval(timer);
+        if (out.isTTY) {
+            process.removeListener('exit', restoreOnExit);
+            out.write(showCursor);
+        }
+    };
+    return Object.assign(stop, { redraw: tick });
+}

package/dist/terminal/dashboard/plain.js

@@ -0,0 +1,32 @@
+import { formatDuration } from '../../format/duration.js';
+import { printable } from './printable.js';
+import { finishedSections } from './ui-state.js';
+// The one-line-per-change form for a pipe (a terminal gets the dashboard). Pure: no ANSI.
+export function renderPanel(s) {
+    const { now, slots, queue, epics } = s;
+    const lines = [`carrier  slots ${slots.busy}/${slots.total}  queue ${queue.length}${queue.length > 0 ? `: ${queue.map((q) => `${q.repo}#${q.issue}`).join(', ')}` : ''}`];
+    for (const e of epics) {
+        const parts = [
+            `${e.repo}#${e.issue}`,
+            e.status === 'needs_human' ? 'NEEDS HUMAN' : e.options?.choiceDeadline != null ? `waiting for its choice (starts in ${formatDuration(e.options.choiceDeadline - now)})` : (e.stage ?? 'starting'),
+            ...(e.round === null ? [] : [`round ${e.round}/${e.maxReviews}`]),
+            ...(e.slices && e.slices.total > 0 ? [`slices ${e.slices.done}/${e.slices.total}`] : []),
+            `blockers ${e.blockers}`,
+            `in stage ${formatDuration(now - e.stageSince)}`,
+            e.lastActivityAt === null ? 'no activity' : `activity ${formatDuration(now - e.lastActivityAt)} ago`,
+        ];
+        lines.push(parts.join('  '), `  issue ${e.issueUrl}${e.prUrl ? `  PR ${e.prUrl}` : ''}`);
+        if (e.needsHumanReason)
+            lines.push(`  reason: ${printable(e.needsHumanReason)}`);
+        if (e.lastError)
+            lines.push(`  error: ${printable(e.lastError)}`);
+    }
+    for (const { status, rows, more } of finishedSections(s)) {
+        const kind = status === 'merged' ? 'done' : 'cancelled';
+        for (const f of rows)
+            lines.push(`${kind}  ${f.repo}#${f.issue}${f.prNumber === null ? '' : `  PR #${f.prNumber}`}  ${formatDuration(Math.max(0, now - f.finishedAt))} ago${f.title ? `  ${printable(f.title)}` : ''}${f.cancelReason ? `  reason: ${printable(f.cancelReason)}` : ''}`);
+        if (more > 0)
+            lines.push(`${kind}  +${more} more`);
+    }
+    return lines;
+}

package/dist/terminal/dashboard/printable.js

@@ -0,0 +1,2 @@
+/** The reason and the error come from the agent's own output: no control character (ESC included) may reach the terminal. */
+export const printable = (text) => text.replace(/[\x00-\x1f\x7f-\x9f]/g, ' ');

package/dist/terminal/dashboard/ui-state.js

@@ -0,0 +1,110 @@
+/** How many queued epics the dashboard lists before "… and N more"; selection only reaches what is listed. */
+export const maxListed = 5;
+/** How many finished epics of each kind the panel lists before "+N more"; selection only reaches what is listed. */
+export const maxFinished = 10;
+/** The DONE and CANCELLED sections that have something to show, each cut to `maxFinished` rows with the count of the rest. */
+export function finishedSections(s) {
+    const all = s.finished ?? [];
+    return [['DONE', 'merged'], ['CANCELLED', 'cancelled']]
+        .map(([name, status]) => ({ name, status, all: all.filter((f) => f.status === status) }))
+        .filter((x) => x.all.length > 0)
+        .map(({ name, status, all }) => ({ name, status, rows: all.slice(0, maxFinished), more: Math.max(0, all.length - maxFinished) }));
+}
+const issueUrl = (repo, issue) => `https://github.com/${repo}/issues/${issue}`;
+export function itemsOf(s) {
+    const running = s.epics.filter((e) => e.status === 'running');
+    const needsYou = s.epics.filter((e) => e.status === 'needs_human');
+    return [
+        ...running.map((e) => ({ key: `${e.repo}#${e.issue}`, url: e.prUrl ?? e.issueUrl, executionId: e.executionId })),
+        ...s.queue.slice(0, maxListed).map((q) => ({ key: `${q.repo}#${q.issue}`, url: issueUrl(q.repo, q.issue), executionId: null })),
+        ...needsYou.map((e) => ({ key: `${e.repo}#${e.issue}`, url: e.prUrl ?? e.issueUrl, executionId: e.executionId })),
+        ...[...s.done, ...finishedSections(s).flatMap((x) => x.rows)].map((d) => ({ key: `${d.repo}#${d.issue}`, url: d.prNumber === null ? issueUrl(d.repo, d.issue) : `https://github.com/${d.repo}/pull/${d.prNumber}`, executionId: d.executionId })),
+    ];
+}
+/** An epic that is waiting for its option choice, found by the key of a row. */
+export const waitingEpic = (s, key) => s.epics.find((e) => `${e.repo}#${e.issue}` === key && e.status === 'running' && e.options !== undefined && e.options.choiceDeadline !== null);
+export const initialUi = { selected: null, mode: 'dashboard', toast: null };
+export const toastFor = 3000;
+/** Pure: what a key does to the screen state, and what it asks the program to do. */
+export function onKey(ui, key, s, now, canChoose = false) {
+    const items = itemsOf(s);
+    const say = (text) => ({ ...ui, toast: { text, until: now + toastFor } });
+    const raw = key.sequence === '?' ? '?' : key.name;
+    const name = raw === 'j' ? 'down' : raw === 'k' ? 'up' : raw; // vim keys move too
+    if ((key.ctrl && name === 'c') || name === 'q')
+        return { ui, action: { type: 'quit' } };
+    if (ui.mode === 'choose')
+        return chooseKey(ui, name, s, now);
+    if (name === '?')
+        return { ui: { ...ui, mode: ui.mode === 'help' ? 'dashboard' : 'help' } };
+    if (ui.mode !== 'dashboard') {
+        // Help and logs are one keypress away from the dashboard and take no other keys.
+        return name === 'escape' || (ui.mode === 'logs' && name === 'l') ? { ui: { ...ui, mode: 'dashboard' } } : { ui };
+    }
+    const at = items.findIndex((i) => i.key === ui.selected);
+    const current = at === -1 ? undefined : items[at];
+    switch (name) {
+        case 'down':
+            return { ui: { ...ui, selected: items.length === 0 ? null : items[Math.min(at + 1, items.length - 1)].key } };
+        case 'up':
+            return { ui: { ...ui, selected: items.length === 0 ? null : items[at <= 0 ? 0 : at - 1].key } };
+        case 'return':
+            return current ? { ui: say(`Opening ${current.url.replace('https://github.com/', '')}`), action: { type: 'open', url: current.url } } : { ui: say('Select an epic first (↑/↓)') };
+        case 'l':
+            if (!current)
+                return { ui: say('Select an epic first (↑/↓)') };
+            return current.executionId ? { ui: { ...ui, mode: 'logs' } } : { ui: say('That one has no agent output yet') };
+        case 'r':
+            return { ui: say('Checking GitHub now…'), action: { type: 'poll' } };
+        case 'o': {
+            const waiting = canChoose ? waitingEpic(s, ui.selected) : undefined;
+            if (!waiting?.options || waiting.options.names.length < 2)
+                return { ui };
+            return { ui: { ...ui, mode: 'choose', choice: { role: 'author', author: waiting.options.author ?? waiting.options.names[0], reviewer: waiting.options.reviewer ?? waiting.options.names[0] } } };
+        }
+        case 'a': {
+            const waiting = canChoose ? waitingEpic(s, ui.selected) : undefined;
+            return waiting ? { ui: say(`Starting ${ui.selected} on its defaults`), action: { type: 'choose', repo: waiting.repo, issue: waiting.issue } } : { ui };
+        }
+        case 'p':
+            return s.paused ? { ui: say('Resumed: taking epics again'), action: { type: 'pause', paused: false } } : { ui: say('Paused: no new epics will start'), action: { type: 'pause', paused: true } };
+        default:
+            return { ui };
+    }
+}
+/** The keys of the choice mode: ↑↓ move between the roles, ←→ change the option of the one they are on, enter sends, esc leaves. */
+function chooseKey(ui, name, s, now) {
+    const waiting = waitingEpic(s, ui.selected);
+    const choice = ui.choice;
+    if (!waiting?.options || !choice || name === 'escape')
+        return { ui: { ...ui, mode: 'dashboard', choice: undefined } };
+    const { names } = waiting.options;
+    switch (name) {
+        case 'up':
+        case 'down':
+            return { ui: { ...ui, choice: { ...choice, role: choice.role === 'author' ? 'reviewer' : 'author' } } };
+        case 'left':
+        case 'right': {
+            const at = names.indexOf(choice[choice.role]);
+            const next = names[(at + (name === 'right' ? 1 : names.length - 1)) % names.length];
+            return { ui: { ...ui, choice: { ...choice, [choice.role]: next } } };
+        }
+        case 'return':
+            return { ui: { ...ui, mode: 'dashboard', choice: undefined, toast: { text: `Starting ${ui.selected} on ${choice.author} and ${choice.reviewer}`, until: now + toastFor } }, action: { type: 'choose', repo: waiting.repo, issue: waiting.issue, author: choice.author, reviewer: choice.reviewer } };
+        default:
+            return { ui };
+    }
+}
+/** The state to draw with: a selection that no longer exists moves to the first row, a toast past its time is dropped, logs of nothing go back. */
+export function settle(ui, s, now) {
+    const items = itemsOf(s);
+    const current = items.find((i) => i.key === ui.selected);
+    const gone = (ui.mode === 'logs' && !current?.executionId) || (ui.mode === 'choose' && !waitingEpic(s, ui.selected)); // logs of nothing, or an epic that started meanwhile
+    return {
+        selected: current ? ui.selected : (items[0]?.key ?? null), // something is always selected, so the keys always act on a visible row
+        mode: gone ? 'dashboard' : ui.mode,
+        ...(ui.mode === 'choose' && !gone && { choice: ui.choice }),
+        // The wait ended with the choice still open: the options picked are lost, so say so.
+        toast: gone && ui.mode === 'choose' ? { text: 'Time ran out: started on its defaults', until: now + toastFor } : ui.toast && ui.toast.until > now ? ui.toast : null,
+    };
+}

package/dist/terminal/prompts/clack.js

@@ -0,0 +1,121 @@
+import { styleText } from 'node:util';
+import { autocomplete, autocompleteMultiselect, cancel, confirm, groupMultiselect, intro, isCancel, log, note, outro, select, spinner, text } from '@clack/prompts';
+import { Cancelled } from './types.js';
+const keep = (value) => {
+    if (isCancel(value))
+        throw new Cancelled();
+    return value;
+};
+const checkLine = ({ name, detail }) => (detail ? `${name} — ${detail}` : name);
+const fixLine = (fix) => log.message(styleText('dim', `→ ${fix}`));
+/** One line per check, with its remedy under a failure. */
+export function printCheck(check) {
+    if (check.status === 'ok')
+        log.success(checkLine(check));
+    else if (check.status === 'warn')
+        log.warn(checkLine(check));
+    else
+        log.error(styleText('red', checkLine(check)));
+    if (check.fix)
+        fixLine(check.fix);
+}
+// Past this many options a plain list is a chore to scroll: type to filter instead.
+const longList = 10;
+/**
+ * `compact`: what passes leaves no trace but a final count, only failures are printed (init: nobody needs eight lines
+ * that say everything is fine). Not compact: one line per check (the `doctor` command, which is asked for them).
+ */
+export function makeClackUi({ compact = false } = {}) {
+    // A check that takes a while (a token from Forge, a call to GitHub) shows a spinner until its result arrives.
+    let spin;
+    return {
+        interactive: true,
+        intro: (title) => intro(title),
+        outro: (message) => outro(message),
+        note: (message, title) => note(message, title),
+        warn: (message) => log.warn(message),
+        checkStart: (name) => {
+            // Compact: one spinner for the whole run whose text changes, so the screen does not jump once per check.
+            if (spin === undefined) {
+                spin = spinner();
+                spin.start(name);
+            }
+            else
+                spin.message(name);
+        },
+        check: (check) => {
+            if (spin === undefined)
+                return check.status === 'ok' && compact ? undefined : printCheck(check);
+            if (check.status === 'fail')
+                spin.error(checkLine(check));
+            else if (compact)
+                return; // the spinner goes on to the next check
+            else
+                spin.stop(checkLine(check));
+            spin = undefined;
+            if (check.fix)
+                fixLine(check.fix);
+        },
+        checksEnd: (total, failed) => {
+            if (!compact || spin === undefined)
+                return;
+            spin.stop(failed === 0 ? `${total} checks passed` : `${total - failed} of ${total} checks passed`);
+            spin = undefined;
+        },
+        text: async ({ validate, ...options }) => keep(await text({ ...options, validate: validate && ((value) => validate(value ?? options.defaultValue ?? '')) })) || options.defaultValue || '',
+        select: async (options) => {
+            if (options.options.length > longList)
+                return keep(await autocomplete({ message: options.message, options: options.options, initialValue: options.initialValue, placeholder: 'Type to filter…', maxItems: 8 }));
+            return keep(await select(options));
+        },
+        confirm: async (message) => keep(await confirm({ message })),
+        multiselect: async ({ message, options, initialValues }) => {
+            const groups = Object.values(options);
+            if (groups.length === 1)
+                return keep(await autocompleteMultiselect({ message, options: groups[0], initialValues, required: true, placeholder: 'Type to filter…', maxItems: 8 }));
+            return keep(await groupMultiselect({ message, options, initialValues, required: true, maxItems: 12 }));
+        },
+    };
+}
+/** For `--yes` and for pipes: any question that was not answered by a flag is an error that names it. */
+export const noPromptUi = {
+    ...makeClackUi(),
+    interactive: false,
+    checkStart: () => { },
+    check: (check) => (check.status === 'ok' ? undefined : printCheck(check)), // like the compact one: failures only
+    checksEnd: (total, failed) => {
+        if (failed === 0)
+            log.success(`${total} checks passed`);
+    },
+    text: async ({ message, defaultValue }) => {
+        if (defaultValue !== undefined)
+            return defaultValue;
+        throw new Error(`"${message}" needs an answer and there is no terminal to ask: pass it as a flag (carrier init --help)`);
+    },
+    select: async ({ message, initialValue }) => {
+        if (initialValue !== undefined)
+            return initialValue;
+        throw new Error(`"${message}" needs an answer and there is no terminal to ask: pass it as a flag (carrier init --help)`);
+    },
+    confirm: async () => false,
+    multiselect: async ({ message, initialValues }) => {
+        if (initialValues?.length)
+            return initialValues; // the repo of the current folder
+        throw new Error(`"${message}" needs an answer and there is no terminal to ask: pass it as a flag (carrier init --help)`);
+    },
+};
+/** "Starting…" while the engine comes up, then the line Carrier arrives with. Only on a terminal. */
+export function announceStart({ framed }) {
+    if (!framed)
+        intro('Carrier');
+    const spin = spinner();
+    spin.start('Starting…');
+    return {
+        arrived: () => {
+            spin.stop('Carrier has arrived.');
+            outro(styleText('dim', 'Ctrl+C stops it'));
+        },
+        failed: () => spin.error('Carrier could not start'),
+    };
+}
+export const cancelled = () => cancel('✖  Cancelled');

package/dist/terminal/prompts/types.js

@@ -0,0 +1,3 @@
+/** The user said no (Ctrl+C, Esc, or declined the final question): not an error, the caller exits quietly. */
+export class Cancelled extends Error {
+}

package/dist/terminal/wizard/build-config.js

@@ -0,0 +1,66 @@
+import { localKinds } from '../../harnesses/local.js';
+import { harnessNames } from '../../harnesses/names.js';
+/** `forge:<agent>` or `gh`, the form used by flags and by the prompts' values. */
+export function parseIdentity(text) {
+    if (text === 'gh')
+        return { kind: 'gh' };
+    const agent = /^forge:(.+)$/.exec(text)?.[1];
+    if (agent !== undefined)
+        return { kind: 'forge', agent };
+    throw new Error(`invalid identity "${text}", expected "forge:<agent>" or "gh"`);
+}
+export const identityText = (identity) => (identity.kind === 'gh' ? 'gh' : `forge:${identity.agent}`);
+/** `<harness>:<model>`, the harness being one of `harnessNames`. */
+export function parseHarnessModel(text) {
+    const match = new RegExp(`^(${harnessNames.join('|')}):(.+)$`).exec(text);
+    if (match === null)
+        throw new Error(`invalid agent "${text}", expected "<harness>:<model>" with harness one of ${harnessNames.join(", ")}`);
+    return { harness: match[1], model: match[2] };
+}
+export function parseProvider(text) {
+    const local = localKinds.find((kind) => kind === text);
+    if (local === undefined)
+        throw new Error(`invalid provider "${text}", expected ${localKinds.join(' or ')}`);
+    return local;
+}
+// A forge profile is named after its agent; the user's own login is just "gh".
+const profileName = (identity) => (identity.kind === 'gh' ? 'gh' : identity.agent);
+/** The user config (what goes in the file): only what has no default. The author's profile also acts as orchestrator. */
+export function buildConfig({ repos, author, reviewer, leadReviewer, providers, failover, identities }) {
+    const [a, r] = [profileName(author.identity), profileName(reviewer.identity)];
+    const l = leadReviewer ? profileName(leadReviewer.identity) : undefined;
+    return {
+        repos: repos.map((name) => ({ name })),
+        ...(identities === 'shared' && { identities }), // the default, separate, is not written
+        profiles: {
+            [a]: author.identity,
+            [r]: reviewer.identity,
+            ...(l && leadReviewer ? { [l]: leadReviewer.identity } : {}),
+        },
+        orchestratorProfile: a,
+        providers,
+        ...(failover && { failover }),
+        agents: {
+            author: {
+                profile: a,
+                provider: author.provider,
+                model: author.model,
+                ...(author.persona && { persona: author.persona }),
+            },
+            reviewer: {
+                profile: r,
+                provider: reviewer.provider,
+                model: reviewer.model,
+                ...(reviewer.persona && { persona: reviewer.persona }),
+            },
+            ...(leadReviewer && l ? {
+                leadReviewer: {
+                    profile: l,
+                    provider: leadReviewer.provider,
+                    model: leadReviewer.model,
+                    ...(leadReviewer.persona && { persona: leadReviewer.persona }),
+                },
+            } : {}),
+        },
+    };
+}

package/dist/terminal/wizard/deps.js

@@ -0,0 +1,94 @@
+import { execFileSync, spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { enginePlacesOf } from '../../config/engine-places.js';
+import { repoNamePattern } from '../../config/schema.js';
+import { defaults } from '../../config/load.js';
+import { cliLoggedIn, runDoctor } from '../../doctor/doctor.js';
+import { ghReposArgs, parseRepos } from '../../integrations/available-repos.js';
+import { forgeCwd } from '../../integrations/forge-cwd.js';
+import { GhGitHub } from '../../integrations/github.js';
+import { listLocalModels } from '../../harnesses/local.js';
+import { readForgeAgents } from './forge-registry.js';
+export const realDeps = {
+    which: (command) => spawnSync('which', [command], { stdio: 'ignore' }).status === 0,
+    forgeAgents: () => readForgeAgents(),
+    ghLogin: () => {
+        try {
+            return execFileSync('gh', ['api', 'user', '--jq', '.login'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim() || undefined;
+        }
+        catch {
+            return undefined; // not logged in or no gh: the doctor reports it, here it only means no hint
+        }
+    },
+    listRepos: (page) => {
+        // no config yet at init: the default bounds the call
+        const { repos, hasMore } = parseRepos(execFileSync('gh', ghReposArgs(page), { encoding: 'utf8', timeout: defaults.limits.githubCallTimeoutSeconds * 1000, stdio: ['ignore', 'pipe', 'pipe'] }));
+        return { names: repos.map((repo) => repo.name), hasMore };
+    },
+    originRepo: () => {
+        const url = spawnSync('git', ['remote', 'get-url', 'origin'], { encoding: 'utf8' }).stdout.trim();
+        const repo = /github\.com[:/]([\w.-]+\/[\w.-]+?)(?:\.git)?$/.exec(url)?.[1];
+        return repo !== undefined && repoNamePattern.test(repo) ? repo : undefined;
+    },
+    codexModel: () => {
+        try {
+            return /^model\s*=\s*"([^"]+)"/m.exec(readFileSync(join(process.env.CODEX_HOME ?? join(homedir(), '.codex'), 'config.toml'), 'utf8'))?.[1];
+        }
+        catch {
+            return undefined;
+        }
+    },
+    codexModels: () => {
+        try {
+            const cache = JSON.parse(readFileSync(join(process.env.CODEX_HOME ?? join(homedir(), '.codex'), 'models_cache.json'), 'utf8'));
+            return (cache.models ?? []).flatMap((m) => (m.visibility === 'list' && m.slug ? [{ value: m.slug, label: m.slug, hint: m.description }] : []));
+        }
+        catch {
+            return []; // no cache yet: the model is typed
+        }
+    },
+    agyModels: () => {
+        try {
+            // "Fetching available models..." then `id<TAB>label` per line.
+            const out = execFileSync('agy', ['models'], { encoding: 'utf8', timeout: 20_000, stdio: ['ignore', 'pipe', 'ignore'] });
+            return out.split('\n').flatMap((line) => {
+                const [id, label] = line.split('\t');
+                return id && label ? [{ value: id, label: id, hint: label }] : [];
+            });
+        }
+        catch {
+            return []; // not installed, not logged in or offline: the model is typed
+        }
+    },
+    localModels: (local) => listLocalModels(local),
+    configFolders: (harness) => {
+        const home = homedir();
+        const isFolder = (path) => {
+            try {
+                return statSync(path).isDirectory();
+            }
+            catch {
+                return false; // a dangling link
+            }
+        };
+        return readdirSync(home)
+            .filter((name) => (harness === 'claude' ? name === '.claude' || name.startsWith('.claude-') : name === '.codex') && isFolder(join(home, name)))
+            .sort()
+            .map((name) => join(home, name));
+    },
+    loggedIn: cliLoggedIn,
+    exists: existsSync,
+    write: (path, content) => {
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, content);
+    },
+    doctor: runDoctor,
+    readConfig: (path) => JSON.parse(readFileSync(path, 'utf8')),
+    forgeAdd: () => spawnSync('agent-forge', ['add'], { stdio: 'inherit' }).status === 0,
+    readyEpics: async (config, folder) => {
+        const github = new GhGitHub({ profile: config.profiles[config.orchestratorProfile], cwd: forgeCwd(enginePlacesOf(folder)), timeoutMs: config.limits.githubCallTimeoutSeconds * 1000 });
+        return Object.fromEntries(await Promise.all(config.repos.map(async (repo) => [repo.name, await github.listReadyEpics(repo.name).then((epics) => epics.length, () => undefined)])));
+    },
+};

package/dist/terminal/wizard/flags.js

@@ -0,0 +1 @@
+export {};

package/dist/terminal/wizard/forge-registry.js

@@ -0,0 +1,23 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+/** Same lookup order as Agent Forge: $AGENT_FORGE_CONFIG, the global registry, then ./agents.json. */
+export function forgeRegistryPath(env = process.env, cwd = process.cwd()) {
+    if (env.AGENT_FORGE_CONFIG)
+        return resolve(env.AGENT_FORGE_CONFIG);
+    const global = join(env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'agent-forge', 'agents.json');
+    if (existsSync(global))
+        return global;
+    const local = resolve(cwd, 'agents.json');
+    return existsSync(local) ? local : undefined;
+}
+/** The agents Forge knows about (names only, never keys). Empty when there is no registry; throws when it is unreadable. */
+export function readForgeAgents(path = forgeRegistryPath()) {
+    if (path === undefined || !existsSync(path))
+        return [];
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    const agents = parsed.agents;
+    if (!Array.isArray(agents))
+        return [];
+    return agents.flatMap((agent) => typeof agent?.name === 'string' ? [{ name: agent.name, ...(typeof agent.label === 'string' ? { label: agent.label } : {}) }] : []);
+}

package/dist/terminal/wizard/prior.js

@@ -0,0 +1,20 @@
+import { defaults, loadConfig } from '../../config/load.js';
+import { tilde } from './summary.js';
+export function priorFrom(raw) {
+    const loaded = loadConfig(defaults, raw);
+    if (!loaded.ok)
+        return undefined;
+    const { config } = loaded;
+    const role = (r) => ({ identity: config.profiles[r.profile], provider: r.provider, model: r.model, ...(r.persona && { persona: r.persona }) });
+    // The loader makes a folder absolute; written back with `~` it stays portable.
+    const providers = Object.fromEntries(Object.entries(config.providers).map(([name, p]) => [name, p.configDir ? { ...p, configDir: tilde(p.configDir) } : p]));
+    return {
+        repos: config.repos.map((r) => r.name),
+        identities: config.identities,
+        providers,
+        ...(config.failover && { failover: config.failover }),
+        author: role(config.agents.author),
+        reviewer: role(config.agents.reviewer),
+        ...(config.agents.leadReviewer ? { leadReviewer: role(config.agents.leadReviewer) } : {}),
+    };
+}