@ashulab/carrier 0.0.0-stage → 0.1.1

package/dist/terminal/wizard/questions/agent.js

@@ -0,0 +1,61 @@
+import { isAbsolute } from 'node:path';
+import { localKinds, localLabel } from '../../../harnesses/local.js';
+import { harnessLabel, localProvidersOf, nativeProvider } from '../../../harnesses/names.js';
+import { tilde } from '../summary.js';
+// Aliases the Claude CLI resolves to the latest model of each family, so they do not go stale like a model id does.
+const claudeModels = [
+    { value: 'sonnet', label: 'sonnet', hint: 'latest Sonnet' },
+    { value: 'opus', label: 'opus', hint: 'latest Opus' },
+    { value: 'fable', label: 'fable', hint: 'latest Fable' },
+];
+const otherModel = '\0other';
+const native = '\0native';
+const inherit = '\0inherit';
+const typedPath = '\0path';
+/** The config folder of a Claude or Codex option: one it found, the environment, or a path. It holds the login, so each is shown with its state. Undefined inherits the environment. */
+export async function askConfigDir(ui, harness, deps, noun = 'option') {
+    const state = (dir) => deps.loggedIn(harness, dir).then((ok) => (ok ? 'logged in' : 'not logged in'), () => 'could not check the login');
+    const found = await Promise.all(deps.configFolders(harness).map(async (dir) => ({ value: dir, label: tilde(dir), hint: await state(dir) })));
+    const choice = await ui.select({
+        message: `Config folder of this ${harnessLabel[harness]} ${noun}`,
+        options: [...found, { value: inherit, label: 'Inherit the environment', hint: `the login Carrier runs in: ${await state()}` }, { value: typedPath, label: 'Type a path…' }],
+        initialValue: inherit,
+    });
+    if (choice === inherit)
+        return undefined;
+    if (choice !== typedPath)
+        return tilde(choice);
+    const typed = await ui.text({ message: `Config folder of this ${harnessLabel[harness]} ${noun} (absolute, or starting with ~/)`, validate: (v) => (isAbsolute(v.trim()) || v.trim().startsWith('~/') ? undefined : 'An absolute path, or one starting with ~/') });
+    return typed.trim();
+}
+/** Ask the model for a role (author or reviewer) on a specific harness. */
+export async function askModel(ui, harness, provider, locals, deps, role, current) {
+    const typed = async (suggestion) => (await ui.text({ message: `Model for the ${role}`, placeholder: suggestion ?? 'model name', defaultValue: suggestion, validate: (v) => (v.trim() ? undefined : 'Required') })).trim();
+    const known = provider ? (locals[provider] ?? []).map((value) => ({ value, label: value })) : harness === 'claude' ? claudeModels : harness === 'codex' ? deps.codexModels() : deps.agyModels();
+    const configured = !provider && harness === 'codex' ? deps.codexModel() : undefined;
+    if (known.length === 0)
+        return typed(current ?? configured);
+    const initial = [current, configured, 'sonnet'].find((m) => m !== undefined && known.some((k) => k.value === m)) ?? known[0].value;
+    const choice = await ui.select({ message: `Model for the ${role}`, options: [...known, { value: otherModel, label: 'Other…', hint: 'type a model id' }], initialValue: initial });
+    return choice === otherModel ? await typed() : choice;
+}
+/** Creates a pure AI provider (harness, configDir, local provider) without a model. */
+export async function askAIProvider(ui, installed, used, locals, deps) {
+    const harness = installed.length === 1 ? installed[0] : await ui.select({ message: 'Which agent CLI runs this provider?', options: installed.map((p) => ({ value: p, label: harnessLabel[p] })), initialValue: installed.find((h) => !used.includes(h)) ?? installed[0] });
+    let provider;
+    const servers = localKinds.filter((kind) => localProvidersOf[harness].includes(kind));
+    if (servers.some((kind) => locals[kind])) {
+        const choice = await ui.select({
+            message: 'Where does this provider run?',
+            options: [
+                { value: native, label: nativeProvider[harness], hint: 'cloud' },
+                ...servers.map((kind) => ({ value: kind, label: `${localLabel[kind]} (local)`, hint: locals[kind] ? `${locals[kind].length} models, runs on this machine` : 'not running: start its server to use it', disabled: !locals[kind] })),
+            ],
+            initialValue: native,
+        });
+        if (choice !== native)
+            provider = servers.find((kind) => kind === choice);
+    }
+    const configDir = harness === 'agy' ? undefined : await askConfigDir(ui, harness, deps, 'provider');
+    return { harness, ...(provider && { provider }), ...(configDir && { configDir }) };
+}

package/dist/terminal/wizard/questions/identities.js

@@ -0,0 +1,28 @@
+const reach = 'Both roles, the reviewer included, act with everything your gh token can do, as you. Their signature in what they publish is what tells them apart.';
+/** Separate identities (a different one per role) or one shared identity, which is the gh login. The first question of the identity step. */
+export async function askIdentities(ui, flags, login, interactive, current = 'separate') {
+    const { identities: flag } = flags;
+    if (flag !== undefined && flag !== 'separate' && flag !== 'shared')
+        throw new Error(`invalid --identities "${flag}", expected separate or shared`);
+    const profiles = flags.authorProfile !== undefined || flags.reviewerProfile !== undefined;
+    if (flag === 'shared' && profiles)
+        throw new Error('--identities shared cannot go with --author-profile or --reviewer-profile: the shared identity is the gh login');
+    for (;;) {
+        // A profile flag already names one identity per role, so there is nothing to ask.
+        const choice = flag ?? (interactive && !profiles ? await ui.select({
+            message: 'GitHub identities: one for each role, or one shared?',
+            options: [
+                { value: 'separate', label: 'One for each role', hint: 'Agent Forge bots, or your gh login for one of them' },
+                { value: 'shared', label: 'One shared identity', hint: 'your gh login for both, when you cannot get a second one' },
+            ],
+            initialValue: current,
+        }) : 'separate');
+        if (choice === 'separate')
+            return choice;
+        if (login === undefined)
+            throw new Error('A shared identity is your gh login, and gh is not logged in. Run: gh auth login');
+        ui.note(reach, 'Shared identity');
+        if (flag !== undefined || (await ui.confirm('Use your gh login for both roles?')))
+            return choice; // the flag is the consent
+    }
+}

package/dist/terminal/wizard/questions/identity.js

@@ -0,0 +1,30 @@
+import { identityText, parseIdentity } from '../build-config.js';
+const addBot = '\0add';
+/** Which GitHub identity a role acts as: a Forge bot or the person's own gh login (never the same for both roles). */
+export async function askIdentity(ui, role, forge, readForge, login, taken, deps, interactive, current) {
+    for (;;) {
+        const options = [
+            ...forge.agents.map((a) => ({ value: `forge:${a.name}`, label: a.name, hint: a.label && a.label !== a.name ? a.label : 'Agent Forge bot' })),
+            { value: 'gh', label: 'My own gh login', hint: login },
+        ].filter((o) => !taken.some((t) => identityText(t) === o.value));
+        const canAdd = interactive && deps.which('agent-forge');
+        if (options.length === 0 && !canAdd) {
+            throw new Error('Identities need to differ and there is nothing left to pick. Add a bot with "agent-forge add" (https://github.com/AshuLab/agent-forge) and run this again.');
+        }
+        if (options.length === 1 && !canAdd) {
+            ui.note(`${options[0].label}${options[0].hint ? ` (${options[0].hint})` : ''} — the only identity left`, `GitHub identity for the ${role}`);
+            return parseIdentity(options[0].value);
+        }
+        const initialValue = options.find((o) => current && o.value === identityText(current))?.value ?? options[0]?.value;
+        const picked = await ui.select({
+            message: `GitHub identity for the ${role}`,
+            options: canAdd ? [...options, { value: addBot, label: 'Add a new Agent Forge bot…', hint: 'runs: agent-forge add' }] : options,
+            initialValue,
+        });
+        if (picked !== addBot)
+            return parseIdentity(picked);
+        if (!deps.forgeAdd())
+            ui.warn('agent-forge add did not finish; nothing was added.');
+        readForge(); // the new bot, if any, is in the list the next time around
+    }
+}

package/dist/terminal/wizard/questions/options.js

@@ -0,0 +1,93 @@
+import { basename } from 'node:path';
+import { optionNamePattern } from '../../../config/schema.js';
+import { parseHarnessModel, parseProvider } from '../build-config.js';
+import { providerLine } from '../summary.js';
+import { askAIProvider } from './agent.js';
+const uniqueName = (items, base) => {
+    let name = base;
+    for (let n = 2; name in items; n += 1)
+        name = `${base}-${n}`;
+    return name;
+};
+/** Turn a user-typed name into a valid option code: lowercase, hyphens instead of spaces/symbols, no leading/trailing hyphens. */
+export function normalizeOptionName(raw) {
+    return raw
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 40)
+        .replace(/-+$/, '');
+}
+export function suggestProviderName(providers, provider) {
+    const folder = (provider.configDir ? basename(provider.configDir) : '').replace(/^\.+/, '');
+    const raw = folder === '' ? provider.harness : folder.startsWith(provider.harness) ? folder : `${provider.harness}-${folder}`;
+    const slug = normalizeOptionName(raw).slice(0, 30);
+    return uniqueName(providers, optionNamePattern.test(slug) ? slug : provider.harness);
+}
+/** Pure AI providers section: CLI, config folder, and local provider. No models. */
+export async function askProviders(ui, start, installed, locals, deps) {
+    const there = Object.entries(start).map(([name, provider]) => `${name}: ${providerLine(provider)}`);
+    ui.note(['Your AI accounts and local model servers (Claude Code, Codex, Antigravity). Each role will pick one.', ...(there.length > 0 ? ['', 'Already there:', ...there] : [])].join('\n'), 'AI Providers');
+    let providers = start;
+    while (Object.keys(providers).length === 0 || (await ui.confirm('Add another AI provider?'))) {
+        const provider = await askAIProvider(ui, installed, Object.values(providers).map((p) => p.harness), locals, deps);
+        const raw = await ui.text({
+            message: 'Name of this provider',
+            defaultValue: suggestProviderName(providers, provider),
+            validate: (v) => {
+                const slug = normalizeOptionName(v);
+                if (!optionNamePattern.test(slug))
+                    return 'A name starting with a letter: letters, digits and hyphens, up to 40 characters';
+                if (slug in providers)
+                    return 'Another provider has this name';
+                return undefined;
+            },
+        });
+        const name = normalizeOptionName(raw);
+        providers = { ...providers, [name]: provider };
+    }
+    return providers;
+}
+export async function askRoleProvider(ui, role, providers, current, other) {
+    const names = Object.keys(providers);
+    if (names.length === 1)
+        return names[0];
+    return ui.select({
+        message: `Which AI provider runs the ${role}?`,
+        options: names.map((name) => ({ value: name, label: name, hint: providerLine(providers[name]) })),
+        initialValue: [current, names.find((name) => name !== other)].find((name) => name !== undefined && name in providers) ?? names[0],
+    });
+}
+/** The provider and model a `--author` or `--reviewer` flag declares: reuses an existing matching provider, or adds a new one. */
+export function declareFlaggedProvider(providers, role, flag, providerFlag) {
+    const { harness, model } = parseHarnessModel(flag);
+    const localProvider = providerFlag ? parseProvider(providerFlag) : undefined;
+    const existing = Object.keys(providers).find((name) => providers[name].harness === harness && providers[name].provider === localProvider);
+    if (existing !== undefined)
+        return { providers, providerName: existing, model };
+    const name = uniqueName(providers, harness in providers ? `${harness}-${role}` : harness);
+    return { providers: { ...providers, [name]: { harness, ...(localProvider && { provider: localProvider }) } }, providerName: name, model };
+}
+const done = '\0done';
+/** With two or more providers: whether to move a role to another provider when its credits run out or errors occur, and in which order. */
+export async function askFailover(ui, providers) {
+    const names = Object.keys(providers);
+    if (names.length < 2 || !(await ui.confirm('Turn failover on? A role that runs out of credits then moves to the next provider you list, so its code can reach another provider.')))
+        return undefined;
+    const order = [];
+    while (order.length < names.length) {
+        const pick = await ui.select({
+            message: `Failover order: which provider goes ${order.length === 0 ? 'first' : 'next'}?`,
+            options: [
+                ...names.filter((name) => !order.includes(name)).map((name) => ({ value: name, label: name, hint: providerLine(providers[name]) })),
+                ...(order.length > 0 ? [{ value: done, label: 'That is all' }] : []),
+            ],
+        });
+        if (pick === done)
+            break;
+        order.push(pick);
+    }
+    return { enabled: true, triggers: ['usage_limit', 'rate_limit', 'service_down'], default: order };
+}

package/dist/terminal/wizard/questions/out.js

@@ -0,0 +1,16 @@
+import { tilde } from '../summary.js';
+const otherPath = '\0path';
+/** Where the config goes: the global file, or a path typed. */
+export async function askOut(ui, fallback) {
+    const choice = await ui.select({
+        message: 'Where should the config be saved?',
+        options: [
+            { value: fallback, label: tilde(fallback), hint: 'global: "carrier" finds it without --config' },
+            { value: otherPath, label: 'Somewhere else…', hint: 'then use --config to point at it' },
+        ],
+        initialValue: fallback,
+    });
+    if (choice !== otherPath)
+        return choice;
+    return ui.text({ message: 'Path of the config file', placeholder: 'carrier.config.json', defaultValue: 'carrier.config.json' });
+}

package/dist/terminal/wizard/questions/persona.js

@@ -0,0 +1,47 @@
+import { persona } from '../../../config/schema.js';
+/** The persona of a role: first a choice (default, or set one; when editing, keep the current), so skipping reads as an answer; then a name and a prompt, each skippable by leaving it empty; when editing, empty keeps the current value and `-` clears it. The limits are the schema's. A flag answers ahead of time and, outside the limits, is an error naming it. */
+export async function askPersona(ui, role, given, interactive, current) {
+    const roleName = role.split(' ').map((w) => `${w[0].toUpperCase()}${w.slice(1)}`).join(' ');
+    const flagPrefix = role.replace(/\s+/g, '-');
+    const field = async (key, flag) => {
+        const refusal = (value) => {
+            const parsed = persona.shape[key].safeParse(value);
+            return parsed.success ? undefined : parsed.error.issues[0]?.message;
+        };
+        if (flag !== undefined) {
+            const problem = refusal(flag);
+            if (problem !== undefined)
+                throw new Error(`--${flagPrefix}-persona-${key}: ${problem}`);
+            return flag.trim();
+        }
+        if (!interactive)
+            return undefined;
+        const kept = current?.[key];
+        const answer = await ui.text({
+            message: `${roleName} persona: ${key === 'name' ? 'give it a name' : 'describe how it behaves'}`,
+            placeholder: `${key === 'name' ? 'a short name, e.g. Rex' : 'who it is and how it works'}; ${kept ? 'Enter keeps it, - clears it' : 'Enter to skip'}`,
+            defaultValue: kept ?? '',
+            validate: (value) => (value.trim() === '' ? undefined : value.trim() === '-' ? (kept ? undefined : 'empty to skip') : refusal(value)),
+        });
+        return answer.trim() === '-' && kept ? undefined : answer.trim() || undefined;
+    };
+    if (interactive && given.name === undefined && given.prompt === undefined) {
+        const summary = current && [current.name, current.prompt && (current.prompt.length > 40 ? `${current.prompt.slice(0, 39)}…` : current.prompt)].filter(Boolean).join(' · ');
+        const choice = await ui.select({
+            message: `${roleName} persona`,
+            options: [
+                ...(current ? [{ value: 'keep', label: 'Keep the current one', hint: summary }] : []),
+                { value: 'default', label: current ? 'Remove it' : 'Default', hint: 'no name, no extra instructions' },
+                { value: 'set', label: current ? 'Edit it' : 'Give it a name and a way of behaving' },
+            ],
+            initialValue: current ? 'keep' : 'default',
+        });
+        if (choice === 'keep')
+            return current;
+        if (choice === 'default')
+            return undefined;
+    }
+    const name = await field('name', given.name);
+    const prompt = await field('prompt', given.prompt);
+    return name || prompt ? { ...(name && { name }), ...(prompt && { prompt }) } : undefined;
+}

package/dist/terminal/wizard/questions/repos.js

@@ -0,0 +1,61 @@
+import { repoNamePattern } from '../../../config/schema.js';
+const otherRepo = '\0other';
+const loadMore = '\0more';
+/** The repos to watch: picked from the ones the gh login can push to (grouped by owner), or typed. */
+export async function askRepos(ui, deps, current) {
+    const origin = deps.originRepo();
+    const suggested = current?.join(', ') ?? origin;
+    let listed = [];
+    let hasMore = false;
+    try {
+        ({ names: listed, hasMore } = deps.listRepos(1));
+    }
+    catch (error) {
+        ui.warn(`Could not list your repos (${error instanceof Error ? error.message.split('\n')[0] : String(error)}); type them instead.`);
+    }
+    const typed = async (message) => {
+        const answer = await ui.text({
+            message,
+            placeholder: suggested ?? 'AshuLab/my-repo',
+            defaultValue: suggested,
+            validate: (value) => (value.split(',').every((n) => repoNamePattern.test(n.trim())) ? undefined : 'Each repo must be owner/name'),
+        });
+        return answer.split(',').map((s) => s.trim());
+    };
+    // a first page emptied by the filter still has later pages while hasMore holds
+    if (listed.length === 0 && !hasMore)
+        return typed('Repos to watch (owner/name, comma separated)');
+    // What the config already has, or else the folder you are in, goes first and marked, even when it is not among the recent ones; one section per owner.
+    const first = current ?? (origin === undefined ? [] : [origin]);
+    const other = { value: otherRepo, label: 'Other…', hint: 'type owner/name' };
+    let page = 1;
+    let ticked = first;
+    let picked;
+    for (;;) {
+        const names = [...first, ...listed.filter((n) => !first.includes(n))];
+        const owners = [...new Set(names.map((n) => n.split('/')[0]))];
+        const tail = hasMore ? [{ value: loadMore, label: 'Load more…', hint: 'the next repos' }, other] : [other];
+        const groups = Object.fromEntries(owners.map((owner) => [owner, names.filter((n) => n.startsWith(`${owner}/`)).map((value) => ({ value, label: owners.length > 1 ? value.slice(owner.length + 1) : value }))]));
+        if (owners.length === 1)
+            groups[owners[0]].push(...tail);
+        else
+            groups.Other = tail;
+        picked = await ui.multiselect({ message: 'Repos to watch', options: groups, initialValues: ticked });
+        if (!picked.includes(loadMore))
+            break;
+        ticked = picked.filter((n) => n !== loadMore);
+        try {
+            const next = deps.listRepos(page + 1);
+            page += 1;
+            hasMore = next.hasMore;
+            listed = [...listed, ...next.names.filter((n) => !listed.includes(n))];
+        }
+        catch (error) {
+            ui.warn(`Could not load more repos (${error instanceof Error ? error.message.split('\n')[0] : String(error)}); going on with the ones loaded.`);
+            hasMore = false;
+        }
+    }
+    const chosen = picked.filter((n) => n !== otherRepo);
+    const extra = picked.includes(otherRepo) ? await typed('Other repos (owner/name, comma separated)') : [];
+    return [...new Set([...chosen, ...extra])];
+}

package/dist/terminal/wizard/summary.js

@@ -0,0 +1,31 @@
+import { homedir } from 'node:os';
+import { harnessLabel } from '../../harnesses/names.js';
+import { localLabel } from '../../harnesses/local.js';
+/** `~` for the home folder, for what is shown to a person. */
+export const tilde = (path) => (path.startsWith(`${homedir()}/`) ? `~${path.slice(homedir().length)}` : path);
+/** What an AI provider runs: the CLI, where a local one is served and the config folder when it has one. */
+export const providerLine = (p) => [harnessLabel[p.harness], ...(p.provider ? [`${localLabel[p.provider]} (local)`] : []), ...(p.configDir ? [tilde(p.configDir)] : [])].join(' · ');
+const personaLine = ({ persona }) => (persona ? [`${persona.name ?? '(no name)'}${persona.prompt ? ` · ${persona.prompt.length > 60 ? `${persona.prompt.slice(0, 59)}…` : persona.prompt}` : ''}`] : []);
+const roleLine = (r, providers) => {
+    const p = providers[r.provider];
+    const pDesc = p ? `${r.provider} (${providerLine(p)})` : r.provider;
+    return [`${r.identity.kind === 'gh' ? 'your gh login' : r.identity.agent} · ${pDesc} · ${r.model}`, ...personaLine(r).map((item) => `\n          persona: ${item}`)].join('');
+};
+/** What is about to be written, in one box. */
+export const summary = (repos, author, reviewer, providers, failover, out, identities = 'separate', leadReviewer) => [
+    `Repos       ${repos.join(', ')}`,
+    ...(identities === 'shared' ? ['Identity    shared: both roles act as your gh login'] : []),
+    `Providers   ${Object.keys(providers).join(', ')}`,
+    `Author      ${roleLine(author, providers)}`,
+    `Reviewer    ${roleLine(reviewer, providers)}`,
+    ...(leadReviewer ? [`Lead Rev    ${roleLine(leadReviewer, providers)}`] : []),
+    ...(failover?.enabled
+        ? [
+            `Failover    ${[
+                ...(failover.default?.length ? [failover.roles ? `default: ${failover.default.join(' → ')}` : failover.default.join(' → ')] : []),
+                ...(failover.roles ? Object.entries(failover.roles).filter(([_, list]) => list && list.length > 0).map(([role, list]) => `${role}: ${list.join(' → ')}`) : []),
+            ].join(' · ')}`,
+        ]
+        : []),
+    `Saved to    ${tilde(out)}`,
+].join('\n');

package/dist/terminal/wizard/testing.js

@@ -0,0 +1,106 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterAll } from 'vitest';
+// What the init tests share: a scripted terminal, a machine with fakes in every seam, and a folder to write into.
+/** A temporary folder, removed when the test file is done. */
+export function useTempDir() {
+    const dir = mkdtempSync(join(tmpdir(), 'carrier-init-'));
+    afterAll(() => rmSync(dir, { recursive: true, force: true }));
+    return dir;
+}
+/** A role of a written config with the provider it points at spread in, to assert on harness, model and provider. */
+export function roleOf(written, role) {
+    const config = JSON.parse(written);
+    const agent = config.agents[role];
+    const provider = config.providers?.[agent.provider];
+    return {
+        profile: agent.profile,
+        harness: provider?.harness,
+        model: agent.model,
+        ...(provider?.provider && { provider: provider.provider }),
+        ...(provider?.configDir && { configDir: provider.configDir }),
+        ...(agent.persona && { persona: agent.persona }),
+    };
+}
+export const quietUi = (scripted = {}) => {
+    const lists = {};
+    const values = {};
+    for (const [k, v] of Object.entries(scripted)) {
+        if (Array.isArray(v))
+            lists[k] = [...v];
+        else
+            values[k] = v;
+    }
+    const take = (k) => {
+        if (lists[k] && lists[k].length > 0)
+            return lists[k].shift();
+        return values[k];
+    };
+    const getAnswer = (message) => take(message);
+    const asked = [];
+    const listed = [];
+    const ui = {
+        interactive: true,
+        checkStart: () => { },
+        checksEnd: (total, failed) => void asked.push(`checks:${total}/${failed}`),
+        intro: () => { },
+        outro: (m) => asked.push(`outro:${m}`),
+        note: () => { },
+        warn: (m) => asked.push(`warn:${m}`),
+        check: () => { },
+        text: async ({ message, defaultValue }) => {
+            asked.push(message);
+            const answer = getAnswer(message);
+            if (typeof answer === 'string')
+                return answer;
+            if (defaultValue !== undefined)
+                return defaultValue;
+            throw new Error(`unexpected question: ${message}`);
+        },
+        select: async ({ message, options, initialValue }) => {
+            asked.push(message);
+            const answer = getAnswer(message);
+            return (typeof answer === 'string' ? answer : (initialValue ?? options[0].value));
+        },
+        confirm: async (message) => {
+            asked.push(message);
+            const answer = getAnswer(message);
+            return typeof answer === 'boolean' ? answer : message === 'Save it?'; // the final recap is accepted unless a test declines it
+        },
+        multiselect: async ({ message, options, initialValues }) => {
+            asked.push(message);
+            const answer = getAnswer(message);
+            listed.push(Object.entries(options).map(([group, items]) => `${group}:${items.map((o) => o.label).join(',')}`));
+            return typeof answer === 'string' ? answer.split(',') : (initialValues ?? []);
+        },
+    };
+    return { ui, asked, listed };
+};
+/** Adds a second provider (the machine's other CLI, on its defaults) to the first, then stops: Claude and Codex. */
+export const twoOptions = { 'Add another AI provider?': [true, false] };
+export const okCheck = { name: 'x', status: 'ok' };
+export const fakeDeps = (over = {}) => {
+    const written = {};
+    const deps = {
+        which: () => true,
+        forgeAgents: () => [{ name: 'artanis-agent', label: 'Artanis' }, { name: 'tassadar-agent' }],
+        ghLogin: () => 'diego',
+        listRepos: () => ({ names: [], hasMore: false }),
+        originRepo: () => 'AshuLab/carrier',
+        codexModel: () => 'gpt-test',
+        codexModels: () => [],
+        agyModels: () => [],
+        localModels: async () => Promise.reject(new Error('not running')),
+        configFolders: () => [],
+        loggedIn: async () => true,
+        exists: () => false,
+        write: (path, content) => (written[path] = content),
+        doctor: async () => [okCheck],
+        readConfig: () => ({}),
+        forgeAdd: () => false,
+        readyEpics: async () => ({}),
+        ...over,
+    };
+    return { deps, written };
+};