@phantomcodes/cli 1.2.5 → 1.2.7

package/README.md

@@ -62,11 +62,15 @@ The Phantom CLI detects supported agents, previews the configuration changes, th
 applying them. It connects their model calls to Phantom AI and wires up the saved
 key. Restart your agent, or open a new terminal, to use the connection.
 
-Codex, Claude Code, opencode, Continue, Goose, Aider, GitHub Copilot CLI, Cline
-and Gemini CLI support saved setup. Cursor gets instructions for its settings screen; pi gets
-the agent skill.
-
-Preview without changing files with `phantom setup --dry-run`. The Phantom CLI keeps backups;
+Saved setup covers Claude Code, Codex, opencode, Continue, Goose, Aider, GitHub
+Copilot CLI, Cline, Gemini CLI, Crush, Qwen Code, Kilo Code, Kimi Code, Droid,
+Mistral Vibe and Zed. Cursor, VS Code, JetBrains AI Assistant, Warp and Trae
+keep these settings on their own settings screens, so setup prints the steps;
+pi gets the agent skill.
+
+Preview without changing files with `phantom setup --dry-run`. To leave your
+shell startup file alone, untick "Your shell" in the checklist or pass
+`--no-shell`; setup then prints the lines to add yourself. The Phantom CLI keeps backups;
 undo the changes with `phantom setup --restore`.
 
 ## Connect for one run

package/dist/cli/app.mjs

@@ -6,6 +6,7 @@ import { resolveApiKey } from "../keys/saved.mjs";
 import { hideHints } from "./screens.mjs";
 import { startHeader } from "./start.mjs";
 import { COMMANDS } from "./commands.mjs";
+import { FREE_LINE } from "../core/free.mjs";
 /** The agents the menu can start, and the program each needs on this computer. */
 const AGENTS = [
     { label: 'Start Claude Code', bin: 'claude', run: ['claude'] },
@@ -17,7 +18,7 @@ export function mainMenu(s) {
     const quit = { label: 'Quit', value: { run: [] } };
     if (!s.signedIn) {
         return [
-            { label: 'Set up my coding agents', hint: 'sign in and connect them; phantom-1 is free to start', value: { run: ['setup'] } },
+            { label: 'Set up my coding agents', hint: 'sign in and connect them, free to start', value: { run: ['setup'] } },
             { label: 'Sign in only', hint: 'or save a Phantom key you already have', value: { run: ['login'] } },
             { label: 'Every command', hint: 'pick one to run', value: { open: 'commands' } },
             quit,
@@ -26,7 +27,7 @@ export function mainMenu(s) {
     // Only agents that are installed here, so the menu never offers one that can't start.
     const agents = s.setUp ? AGENTS.filter((a) => s.installed(a.bin)).map((a) => ({ label: a.label, hint: 'on Phantom AI', value: { run: a.run } })) : [];
     return [
-        ...(s.setUp ? [] : [{ label: 'Finish setting up my agents', hint: "you're signed in, but no agent uses Phantom yet", value: { run: ['setup'] } }]),
+        ...(s.setUp ? [] : [{ label: 'Finish setting up my agents', hint: 'no agent uses Phantom yet', value: { run: ['setup'] } }]),
         ...agents,
         { label: 'Balance', hint: 'what this key can spend', value: { run: ['balance'] } },
         { label: 'Spend', hint: 'what you spent, and what phantom-1 saved', value: { run: ['spend'] } },
@@ -105,7 +106,9 @@ export async function runApp(env, pick, write, runCommand, installed = onPath) {
             // A clean screen for each visit to the menu: a title, then where you are.
             write('\x1b[2J\x1b[H' + startHeader(env, color) + '\n');
             const s = state();
-            write(`  ${p.dim(s.signedIn ? (s.setUp ? 'Signed in · your agents use Phantom AI' : 'Signed in · no agent set up yet') : 'Not signed in yet')}\n\n`);
+            write(`  ${p.dim(s.signedIn ? (s.setUp ? 'Signed in · your agents use Phantom AI' : 'Signed in · no agent set up yet') : 'Not signed in yet')}\n`);
+            // Before signing in, the one line that says what free means, whole, since it is why most people came.
+            write(s.signedIn ? '\n' : `  ${p.lime('Free to start:')} ${FREE_LINE}.\n\n`);
             let action = await choose({ ...pick, esc: 'quit' }, 'What would you like to do?', mainMenu(s));
             if (action === null)
                 return 0;

package/dist/cli/commands.mjs

@@ -160,6 +160,8 @@ export const COMMANDS = [
         [--no-browser]              print the sign-in link instead of opening it
         [--dry-run]                 preview the changes without making them
         [--diff]                    show every line each file gains or loses
+        [--no-shell]                leave your shell startup file alone and list
+                                    the lines to add yourself
         [--json]                    print JSON in a terminal too (a pipe always gets JSON)
         [--model <id>]              the model each agent starts on (default ${SETUP_MODEL})
   setup --agent <name>              install the skill for one agent, without asking:

package/dist/cli/run.mjs

@@ -1,7 +1,7 @@
 import { VERSION } from "../core/version.mjs";
 import { nodeTrustWarning } from "../core/node-trust.mjs";
 import { die, NO_KEY } from "../core/errors.mjs";
-import { colorOn } from "../core/style.mjs";
+import { colorOn, fitText } from "../core/style.mjs";
 import { ALIASES, closestCommand, commandFromWords, startScreen } from "./start.mjs";
 import { BackToMenu } from "../core/pick.mjs";
 import { runApp } from "./app.mjs";
@@ -41,7 +41,17 @@ export async function run(argv = process.argv.slice(2), env = process.env, io =
     stderr: (s) => process.stderr.write(s),
     isTTY: Boolean(process.stderr.isTTY),
     stdoutIsTTY: Boolean(process.stdout.isTTY),
+    columns: process.stdout.columns || process.stderr.columns,
 }, node = process.versions.node) {
+    // A line wider than the terminal breaks at a word, under its own column, rather than wherever the edge falls.
+    if (io.columns) {
+        const { columns, stdout, stderr } = io;
+        io = {
+            ...io,
+            ...(io.stdoutIsTTY ? { stdout: (s) => stdout(fitText(s, columns)) } : {}),
+            ...(io.isTTY ? { stderr: (s) => stderr(fitText(s, columns)) } : {}),
+        };
+    }
     const unsafe = nodeTrustWarning(node);
     if (unsafe)
         io.stderr(unsafe);

package/dist/cli/screens.mjs

@@ -100,8 +100,12 @@ export function spendScreen(s, style = {}) {
     if (s.keys.length > 1) {
         lines.push('', ...caption(p, w, 'BY KEY'));
         for (const k of s.keys) {
-            const saved = k.saved_usd ? p.lime(`  saved ${usd(k.saved_usd)}`) : '';
-            lines.push(`  ${k.name.slice(0, LABEL - 1).padEnd(LABEL + BAR + 2)}${usd(k.spent_usd).padStart(8)}  ${p.dim(plural(k.calls, 'call'))}${saved}${k.active ? '' : p.dim('  revoked or rotated')}`);
+            const savedText = k.saved_usd ? `  saved ${usd(k.saved_usd)}` : '';
+            const offText = k.active ? '' : '  revoked or rotated';
+            // The dollars line up with the model rows above, unless that pushes the row past the window's edge.
+            const tail = 8 + 2 + plural(k.calls, 'call').length + savedText.length + offText.length;
+            const pad = Math.max(LABEL, Math.min(LABEL + BAR + 2, widthOf(style) - 2 - tail));
+            lines.push(`  ${k.name.slice(0, LABEL - 1).padEnd(pad)}${usd(k.spent_usd).padStart(8)}  ${p.dim(plural(k.calls, 'call'))}${savedText ? p.lime(savedText) : ''}${offText ? p.dim(offText) : ''}`);
         }
     }
     if (!s.total.calls)
@@ -116,12 +120,12 @@ function keyRows(p, keys) {
     if (!keys.length)
         return [`  ${p.dim('No keys yet.')}`];
     return keys.map((k) => {
-        const limit = k.limit_usd != null ? `limit ${usd(k.limit_usd)}` : k.budget_usd != null ? `${usd(k.budget_usd)} every ${plural(k.period_days ?? 30, 'day')}` : 'no limit';
+        const limit = k.limit_usd != null ? `limit ${usd(k.limit_usd)}` : k.budget_usd != null ? `${usd(k.budget_usd)} per ${plural(k.period_days ?? 30, 'day')}` : 'no limit';
         // A revoked or rotated key gets a hollow mark and the word off at the end, so the columns stay in line.
         const off = k.is_active === false;
         const mark = off ? p.dim('○') : p.lime('●');
         // The id's first 8 characters: enough for --id, which also takes the name.
-        return `  ${mark} ${clip(k.name ?? 'Key', 20).padEnd(21)}${p.dim((k.id ?? '').slice(0, 8).padEnd(10))}${p.dim((k.prefix ?? '').slice(0, 18).padEnd(20))}${usd(k.spent_usd ?? 0).padStart(8)}  ${p.dim(limit)}${off ? `  ${p.dim('off')}` : ''}`;
+        return `  ${mark} ${clip(k.name ?? 'Key', 20).padEnd(21)}${p.dim((k.id ?? '').slice(0, 8).padEnd(9))}${p.dim((k.prefix ?? '').slice(0, 18).padEnd(20))}${usd(k.spent_usd ?? 0).padStart(8)}  ${p.dim(limit)}${off ? `  ${p.dim('off')}` : ''}`;
     });
 }
 /** `phantom workspace`: the shared balance, each key, and the last few charges. */
@@ -154,6 +158,16 @@ export function signedInScreen(saved, style = {}) {
     const where = saved.saved_as === 'default' ? 'Your key is' : `Key "${saved.saved_as}" is`;
     return ['', `  ${p.lime('✓')} ${p.bold('Signed in.')} ${p.dim(`${where} saved in your ${saved.storage}.`)}`, ...next(p, 'Connect your coding agents:', 'phantom setup')].join('\n');
 }
+/** `phantom login` when this computer already has a key: say so, then how to switch or add one. */
+export function alreadySignedInScreen(keyIdShown, style = {}) {
+    const p = paint(style.env ?? {}, Boolean(style.color));
+    return [
+        '',
+        `  ${p.lime('✓')} ${p.bold('You are already signed in on this computer.')}${keyIdShown ? ` ${p.dim(`key ${keyIdShown}`)}` : ''}`,
+        ...next(p, 'Use another workspace: run phantom logout, then', 'phantom login'),
+        ...next(p, 'Add a second key here:', 'phantom login --save <name>'),
+    ].join('\n');
+}
 /** A ✓ line with an optional dim detail, for a change that worked. */
 function done(p, words, detail = '') {
     return `  ${p.lime('✓')} ${words}${detail ? `  ${p.dim(detail)}` : ''}`;

package/dist/cli/start.mjs

@@ -3,6 +3,7 @@
 // day to day. It reads no network, so it prints at once, even offline.
 import { brandHeader } from "../core/brand.mjs";
 import { paint } from "../core/style.mjs";
+import { FREE_LINE } from "../core/free.mjs";
 /** One row: a command in cyan, padded, then what it does. */
 const row = (p, command, about) => `  ${p.cyan(command.padEnd(18))}${about}`;
 /** An uppercase caption over a thin rule, like the site's section labels. */
@@ -15,7 +16,7 @@ export function startScreen(env, color, signedIn) {
     const p = paint(env, color);
     const lines = ['', ...brandHeader(p, color, '')];
     if (!signedIn) {
-        lines.push(...caption(p, 'START HERE'), row(p, 'phantom setup', 'signs you in and connects your coding agents'), `  ${' '.repeat(18)}${p.dim('phantom-1 is free to start: no credit needed')}`, '', `  Then use your agent as usual, or start it with ${p.cyan('phantom claude')}, ${p.cyan('phantom codex')} or ${p.cyan('phantom pi')}.`);
+        lines.push(...caption(p, 'START HERE'), row(p, 'phantom setup', 'signs you in and connects your coding agents'), `  ${' '.repeat(18)}${p.dim(FREE_LINE)}`, '', `  Then use your agent as usual, or start it with ${p.cyan('phantom claude')}, ${p.cyan('phantom codex')} or ${p.cyan('phantom pi')}.`);
     }
     else {
         lines.push(`  ${p.lime('✓')} Signed in.`, '', ...caption(p, 'EVERYDAY'), row(p, 'phantom claude', 'run Claude Code on Phantom AI (also codex, pi)'), row(p, 'phantom balance', 'your credit'), row(p, 'phantom spend', 'what you spent, and what phantom-1 saved'), row(p, 'phantom setup', 'connect more agents, or change how they run'));
@@ -67,7 +68,7 @@ export function startChoices(signedIn, setUp = signedIn) {
     const quit = { label: 'Quit', value: [] };
     if (!signedIn) {
         return [
-            { label: 'Set up my coding agents', hint: 'sign in and connect them (phantom-1 is free to start)', value: ['setup'] },
+            { label: 'Set up my coding agents', hint: 'sign in and connect them, free to start', value: ['setup'] },
             { label: 'Sign in only', hint: 'or save a Phantom key you already have', value: ['login'] },
             { label: 'See every command', value: ['--help'] },
             quit,

package/dist/core/free.mjs

@@ -0,0 +1,9 @@
+// What phantom-1 gives a key for free, said the same way on every screen that mentions it.
+/**
+ * Free phantom-1 requests a workspace gets each UTC day, before it has had $10
+ * of credit. Phantom's own limit is `FREE_ROUTER_CAPS.perDay` in the Phantom
+ * repo's `lib/config.ts`; change both together.
+ */
+export const FREE_REQUESTS_A_DAY = 50;
+/** The free offer in one line short enough for an 80-column terminal. */
+export const FREE_LINE = `phantom-1 runs free models, ${FREE_REQUESTS_A_DAY} requests a day, with no card`;

package/dist/core/style.mjs

@@ -34,3 +34,65 @@ export function paint(env, on) {
 }
 /** `text` without color codes, to measure how wide it prints. */
 export const unstyled = (text) => text.replace(/\x1b\[[0-9;]*m/g, '');
+/**
+ * One line of a screen, fitted to a terminal `columns` wide: a longer line
+ * breaks at spaces, and each piece after the first starts under the text it
+ * continues. That is the second column for a table row or a help entry
+ * (text after a run of two spaces), the words after a mark such as `✓ ` or
+ * `→ `, or else the line's own indent. A word longer than the room, such as
+ * a URL, stays whole. Color codes don't count toward the width.
+ */
+export function fitLine(line, columns) {
+    const seen = unstyled(line);
+    if (seen.length <= columns)
+        return line;
+    const lead = seen.length - seen.trimStart().length;
+    const column = /^(\s*\S.*?\s{2,})\S/.exec(seen)?.[1].length;
+    const mark = /^\s*[✓✗→·!◆?❯] /.exec(seen)?.[0].length;
+    const hang = column !== undefined && column <= columns / 2 ? column : (mark ?? lead);
+    const rows = [];
+    let row = '';
+    let width = 0;
+    // A command stays on one line to copy: `phantom` keeps the word after it, and a flag the word before.
+    const words = [];
+    for (const word of line.split(' ')) {
+        const last = words.length ? unstyled(words[words.length - 1]) : '';
+        if (words.length && word && (/(^|[^\w-])phantom$/.test(last) || /^-{1,2}[a-z]/.test(unstyled(word))))
+            words[words.length - 1] += ' ' + word;
+        else
+            words.push(word);
+    }
+    words.forEach((word, i) => {
+        const w = unstyled(word).length;
+        const blank = unstyled(row).trim() === '';
+        if (i > 0 && !blank && width + 1 + w > columns) {
+            rows.push(row.trimEnd());
+            row = ' '.repeat(hang) + word;
+            width = hang + w;
+        }
+        else if (i > 0 && blank && rows.length) {
+            row += word;
+            width += w;
+        }
+        else {
+            row += (i > 0 ? ' ' : '') + word;
+            width += (i > 0 ? 1 : 0) + w;
+        }
+    });
+    return [...rows, row.trimEnd()].join('\n');
+}
+/** Moves the cursor or redraws: text drawn in place (a menu, a spinner), which must not be wrapped. */
+const DRAWN = /\r|\x1b\[[0-9;?]*[A-HJKSTfhlsu]/;
+/**
+ * Text fitted to `columns` with {@link fitLine}, line by line. JSON (text
+ * that starts with `{` or `[`) and anything drawn in place come back as they
+ * are, since a break there would change what they mean.
+ */
+export function fitText(text, columns) {
+    if (!columns || DRAWN.test(text) || /^\s*[{[]/.test(text))
+        return text;
+    return text
+        .split('\n')
+        .map((l) => fitLine(l, columns))
+        .join('\n');
+}

package/dist/core/version.mjs

@@ -1,2 +1,2 @@
 /** This release of phantom. `npm version` keeps it equal to the version in package.json. */
-export const VERSION = '1.2.5';
+export const VERSION = '1.2.7';

package/dist/plan/command.mjs

@@ -65,7 +65,7 @@ export async function planCommand(input) {
         const pick = pickIo(input);
         if (pick) {
             const offer = (await getPlan(apiKey, baseUrl)).prices?.[subcommand];
-            const what = offer ? `$${offer.usd_per_month} a month, paying for $${offer.week_limit_usd} of model cost a week, for every key in this workspace` : 'for every key in this workspace';
+            const what = offer ? `$${offer.usd_per_month} a month for $${offer.week_limit_usd} of model cost a week, every key` : 'for every key in this workspace';
             const go = await choose(pick, `Start ${subcommand === 'max' ? 'Max' : 'Pro'}?`, [
                 { label: 'Open Stripe to pay', hint: what, value: true },
                 { label: 'Cancel', hint: 'nothing is charged', value: false },

package/dist/setup/agents.mjs

@@ -6,6 +6,13 @@ import { die } from "../core/errors.mjs";
 import { resolveApiKey } from "../keys/saved.mjs";
 import { SETUP_MODEL, agentBaseUrl, readText, configHome, onPath, phantomCommand, offResult, unreadable, SETUP_MARK, SETUP_CONTEXT_WINDOW, } from "./shared.mjs";
 import { jsonObject, jsonEdit, tomlSet, tomlRemoveOurs, yamlSetTop, yamlAddModel, yamlRemoveOurs } from "./editors.mjs";
+/** The most output a model call may ask for, for agents that need a number. */
+const SETUP_OUTPUT_TOKENS = 32_000;
+/** A JSON edit's result, or '' when only `$schema` (or nothing) is left, so `off` deletes a file phantom made. */
+function unlessEmpty(file, after) {
+    const left = jsonObject(file, after);
+    return Object.keys(left).every((k) => k === '$schema') ? '' : after;
+}
 // ── Manual Provider Helper ───────────────────────────────────────────────────
 /** An agent whose model settings live on its own settings screen: setup prints the steps. */
 export function manualProvider(where, steps, note) {
@@ -350,6 +357,274 @@ export function geminiProvider(ctx, off) {
         },
     };
 }
+// ── Crush ────────────────────────────────────────────────────────────────────
+/** Crush's config folder: `$CRUSH_GLOBAL_CONFIG`, else `crush` in the config folder. */
+export function crushDir(env, home) {
+    return env.CRUSH_GLOBAL_CONFIG?.trim() ? env.CRUSH_GLOBAL_CONFIG : path.join(configHome(env, home), 'crush');
+}
+/**
+ * Crush: `crush.json` in Crush's config folder gets a `phantom` provider at
+ * `/coding-agent/v1` whose key is `$PHANTOM_API_KEY`, which Crush expands
+ * when it loads, and phantom-1 as both its large and small model. Crush 0.99
+ * reads this file beside a `crushrc`.
+ */
+export function crushProvider(ctx, off) {
+    const file = path.join(crushDir(ctx.env, ctx.home), 'crush.json');
+    const text = readText(file);
+    const config = jsonObject(file, text);
+    const sizes = ['large', 'small'];
+    if (off) {
+        if (!config.providers?.phantom)
+            return offResult('Crush', file, text, text);
+        const changes = [Object.keys(config.providers).length === 1 ? [['providers'], undefined] : [['providers', 'phantom'], undefined]];
+        const mine = Object.keys(config.models ?? {}).filter((k) => sizes.includes(k) && config.models?.[k]?.provider === 'phantom');
+        if (mine.length && mine.length === Object.keys(config.models ?? {}).length)
+            changes.push([['models'], undefined]);
+        else
+            for (const k of mine)
+                changes.push([['models', k], undefined]);
+        return offResult('Crush', file, text, unlessEmpty(file, jsonEdit(file, text, changes)));
+    }
+    const base = agentBaseUrl(ctx.env, 'coding-agent');
+    const model = ctx.model ?? SETUP_MODEL;
+    const changes = [
+        ...(!text?.trim() ? [[['$schema'], 'https://charm.land/crush.json']] : []),
+        [
+            ['providers', 'phantom'],
+            {
+                name: 'Phantom AI',
+                type: 'openai-compat',
+                base_url: base,
+                api_key: '$PHANTOM_API_KEY',
+                models: [{ id: model, name: model, context_window: SETUP_CONTEXT_WINDOW, default_max_tokens: SETUP_OUTPUT_TOKENS }],
+            },
+        ],
+        ...sizes.map((size) => [['models', size], { provider: 'phantom', model }]),
+    ];
+    return { edits: [{ file, after: jsonEdit(file, text, changes) }], result: { settings: file, on: true, base_url: base, model, warnings: [] } };
+}
+// ── Qwen Code ────────────────────────────────────────────────────────────────
+/** Qwen Code's folder: `$QWEN_HOME`, else `~/.qwen`. */
+export function qwenDir(env, home) {
+    return env.QWEN_HOME?.trim() ? env.QWEN_HOME : path.join(home, '.qwen');
+}
+/**
+ * Qwen Code: `settings.json` in its folder gets a model under
+ * `modelProviders.openai` at `/coding-agent/v1` that reads its key from
+ * PHANTOM_API_KEY (`envKey`), is picked as the model (`model.name`), and the
+ * OpenAI-compatible sign-in (`security.auth.selectedType`), so Qwen Code
+ * starts without asking. Its other models stay.
+ */
+export function qwenProvider(ctx, off) {
+    const file = path.join(qwenDir(ctx.env, ctx.home), 'settings.json');
+    const text = readText(file);
+    const config = jsonObject(file, text);
+    const list = config.modelProviders?.openai ?? [];
+    if (!Array.isArray(list))
+        unreadable(file, 'has modelProviders.openai as something other than a list');
+    const base = agentBaseUrl(ctx.env, 'coding-agent');
+    const ours = (m) => m?.baseUrl === base;
+    const others = list.filter((m) => !ours(m));
+    const mineIds = list.filter(ours).map((m) => m.id);
+    if (off) {
+        if (others.length === list.length)
+            return offResult('Qwen Code', file, text, text);
+        const changes = [];
+        if (others.length)
+            changes.push([['modelProviders', 'openai'], others]);
+        else
+            changes.push(Object.keys(config.modelProviders ?? {}).length === 1 ? [['modelProviders'], undefined] : [['modelProviders', 'openai'], undefined]);
+        if (mineIds.includes(config.model?.name))
+            changes.push(Object.keys(config.model ?? {}).length === 1 ? [['model'], undefined] : [['model', 'name'], undefined]);
+        return offResult('Qwen Code', file, text, unlessEmpty(file, jsonEdit(file, text, changes)));
+    }
+    const model = ctx.model ?? SETUP_MODEL;
+    const entry = { id: model, name: `Phantom AI ${model}`, baseUrl: base, envKey: 'PHANTOM_API_KEY', generationConfig: { contextWindowSize: SETUP_CONTEXT_WINDOW } };
+    const changes = [
+        [['modelProviders', 'openai'], [entry, ...others]],
+        [['security', 'auth', 'selectedType'], 'openai'],
+        [['model', 'name'], model],
+    ];
+    return { edits: [{ file, after: jsonEdit(file, text, changes) }], result: { settings: file, on: true, base_url: base, model, warnings: [] } };
+}
+// ── Kilo Code ────────────────────────────────────────────────────────────────
+/** Kilo Code's config file: `kilo.jsonc` (or `kilo.json`) in `$XDG_CONFIG_HOME/kilo`, else `~/.config/kilo`. */
+export function kiloFile(env, home) {
+    const dir = path.join(configHome(env, home), 'kilo');
+    return existsSync(path.join(dir, 'kilo.jsonc')) ? path.join(dir, 'kilo.jsonc') : path.join(dir, 'kilo.json');
+}
+/**
+ * Kilo Code's CLI, a fork of opencode: its global config gets the same
+ * `phantom` provider opencode does, with the key as `{env:PHANTOM_API_KEY}`,
+ * and `phantom/<model>` as the model. Kilo resolves `{env:...}` only in the
+ * global file, which is the one written here.
+ */
+export function kiloProvider(ctx, off) {
+    const file = kiloFile(ctx.env, ctx.home);
+    const text = readText(file);
+    const config = jsonObject(file, text);
+    if (off) {
+        if (!config.provider?.phantom)
+            return offResult('Kilo Code', file, text, text);
+        const changes = [Object.keys(config.provider).length === 1 ? [['provider'], undefined] : [['provider', 'phantom'], undefined]];
+        if (typeof config.model === 'string' && config.model.startsWith('phantom/'))
+            changes.push([['model'], undefined]);
+        return offResult('Kilo Code', file, text, unlessEmpty(file, jsonEdit(file, text, changes)));
+    }
+    const base = agentBaseUrl(ctx.env, 'coding-agent');
+    const model = ctx.model ?? SETUP_MODEL;
+    const changes = [
+        ...(!text?.trim() ? [[['$schema'], 'https://app.kilo.ai/config.json']] : []),
+        [
+            ['provider', 'phantom'],
+            {
+                npm: '@ai-sdk/openai-compatible',
+                name: 'Phantom AI',
+                options: { baseURL: base, apiKey: '{env:PHANTOM_API_KEY}' },
+                // Kilo turns off compaction for a model without limits.
+                models: { [model]: { name: model, tool_call: true, reasoning: true, limit: { context: SETUP_CONTEXT_WINDOW, output: SETUP_OUTPUT_TOKENS } } },
+            },
+        ],
+        [['model'], `phantom/${model}`],
+    ];
+    return { edits: [{ file, after: jsonEdit(file, text, changes) }], result: { settings: file, on: true, base_url: base, model: `phantom/${model}`, warnings: [] } };
+}
+// ── Kimi Code ────────────────────────────────────────────────────────────────
+/** Kimi Code's folder: `$KIMI_CODE_HOME`, else `~/.kimi-code`. */
+export function kimiDir(env, home) {
+    return env.KIMI_CODE_HOME?.trim() ? env.KIMI_CODE_HOME : path.join(home, '.kimi-code');
+}
+/**
+ * Kimi Code CLI: `config.toml` in its folder gets a `phantom` provider at
+ * `/coding-agent/v1` that reads its key from PHANTOM_API_KEY
+ * (`api_key_env`), a `phantom/<model>` model, and that model as
+ * `default_model`. Each run starts from the file without phantom's lines, so
+ * a new `--model` replaces the old one.
+ */
+export function kimiProvider(ctx, off) {
+    const file = path.join(kimiDir(ctx.env, ctx.home), 'config.toml');
+    const text = readText(file);
+    const before = text === null ? null : tomlRemoveOurs(file, text);
+    if (off)
+        return offResult('Kimi Code', file, text, before);
+    const base = agentBaseUrl(ctx.env, 'coding-agent');
+    const model = ctx.model ?? SETUP_MODEL;
+    const alias = `phantom/${model}`;
+    let t = tomlSet(file, before ?? '', [], 'default_model', JSON.stringify(alias));
+    for (const [k, v] of [['type', '"openai"'], ['base_url', JSON.stringify(base)], ['api_key_env', '"PHANTOM_API_KEY"']])
+        t = tomlSet(file, t, ['providers', 'phantom'], k, v);
+    for (const [k, v] of [['provider', '"phantom"'], ['model', JSON.stringify(model)], ['max_context_size', String(SETUP_CONTEXT_WINDOW)], ['capabilities', '["thinking", "tool_use"]']]) {
+        t = tomlSet(file, t, ['models', alias], k, v);
+    }
+    return { edits: [{ file, after: t }], result: { settings: file, on: true, base_url: base, model: alias, warnings: [] } };
+}
+// ── Droid ────────────────────────────────────────────────────────────────────
+/** The name phantom gives its model in Droid. Droid calls it `custom:Phantom-AI-<n>`. */
+const DROID_NAME = 'Phantom AI';
+/**
+ * Factory's Droid: `~/.factory/settings.json` gets a custom model at
+ * `/coding-agent/v1` (chat completions) with the key as `${PHANTOM_API_KEY}`,
+ * which Droid expands, and that model as `model`. Droid names a custom
+ * model by its place in `customModels`, so phantom's goes last, or stays
+ * where it was, and the user's own keep their names.
+ */
+export function droidProvider(ctx, off) {
+    const file = path.join(ctx.home, '.factory', 'settings.json');
+    const text = readText(file);
+    const config = jsonObject(file, text);
+    const list = config.customModels ?? [];
+    if (!Array.isArray(list))
+        unreadable(file, 'has customModels as something other than a list');
+    const base = agentBaseUrl(ctx.env, 'coding-agent');
+    const at = list.findIndex((m) => m?.baseUrl === base);
+    const mine = (m) => typeof m === 'string' && m.startsWith(`custom:${DROID_NAME.replace(/ /g, '-')}-`);
+    if (off) {
+        if (at === -1)
+            return offResult('Droid', file, text, text);
+        const rest = list.filter((_, i) => i !== at);
+        const changes = [[['customModels'], rest.length ? rest : undefined]];
+        if (mine(config.model))
+            changes.push([['model'], undefined]);
+        return offResult('Droid', file, text, unlessEmpty(file, jsonEdit(file, text, changes)));
+    }
+    const model = ctx.model ?? SETUP_MODEL;
+    const entry = { model, displayName: DROID_NAME, baseUrl: base, apiKey: '${PHANTOM_API_KEY}', provider: 'generic-chat-completion-api', maxOutputTokens: SETUP_OUTPUT_TOKENS };
+    const index = at === -1 ? list.length : at;
+    const next = [...list];
+    next[index] = entry;
+    const id = `custom:${DROID_NAME.replace(/ /g, '-')}-${index}`;
+    const changes = [
+        [['customModels'], next],
+        [['model'], id],
+    ];
+    return { edits: [{ file, after: jsonEdit(file, text, changes) }], result: { settings: file, on: true, base_url: base, model: id, warnings: [] } };
+}
+// ── Mistral Vibe ─────────────────────────────────────────────────────────────
+/**
+ * Mistral Vibe: `~/.vibe/config.toml` gets a `phantom` provider at
+ * `/coding-agent/v1` that reads its key from PHANTOM_API_KEY
+ * (`api_key_env_var`), a model on it, and that model as `active_model`.
+ * Providers and models are lists of tables (`[[providers]]`), so phantom's
+ * go at the end as marked lines, which `--provider off` takes out again.
+ */
+export function vibeProvider(ctx, off) {
+    const file = path.join(ctx.home, '.vibe', 'config.toml');
+    const text = readText(file);
+    const before = text === null ? null : tomlRemoveOurs(file, text);
+    if (off)
+        return offResult('Mistral Vibe', file, text, before);
+    const base = agentBaseUrl(ctx.env, 'coding-agent');
+    const model = ctx.model ?? SETUP_MODEL;
+    const block = [
+        '[[providers]]',
+        'name = "phantom"',
+        `api_base = ${JSON.stringify(base)}`,
+        'api_key_env_var = "PHANTOM_API_KEY"',
+        'backend = "generic"',
+        'api_style = "openai"',
+        '',
+        '[[models]]',
+        `name = ${JSON.stringify(model)}`,
+        'provider = "phantom"',
+        `alias = ${JSON.stringify(model)}`,
+    ].map((l) => (l ? `${l}  ${SETUP_MARK}` : l));
+    const body = (before ?? '').replace(/\s*$/, '');
+    const t = tomlSet(file, `${body ? `${body}\n\n` : ''}${block.join('\n')}\n`, [], 'active_model', JSON.stringify(model));
+    return { edits: [{ file, after: t }], result: { settings: file, on: true, base_url: base, model, warnings: [] } };
+}
+// ── Zed ──────────────────────────────────────────────────────────────────────
+/**
+ * Zed's agent panel: `settings.json` in Zed's config folder gets an OpenAI
+ * compatible provider named `phantom` at `/coding-agent/v1`, and its model
+ * as the agent's default. Zed reads the key for a provider named `phantom`
+ * from PHANTOM_API_KEY by itself, so no key goes in the file.
+ */
+export function zedProvider(ctx, off) {
+    const file = path.join(configHome(ctx.env, ctx.home), 'zed', 'settings.json');
+    const text = readText(file);
+    const config = jsonObject(file, text);
+    if (off) {
+        if (!config.language_models?.openai_compatible?.phantom)
+            return offResult('Zed', file, text, text);
+        const changes = [[['language_models', 'openai_compatible', 'phantom'], undefined]];
+        if (config.agent?.default_model?.provider === 'phantom')
+            changes.push([['agent', 'default_model'], undefined]);
+        return offResult('Zed', file, text, jsonEdit(file, text, changes));
+    }
+    const base = agentBaseUrl(ctx.env, 'coding-agent');
+    const model = ctx.model ?? SETUP_MODEL;
+    const changes = [
+        [
+            ['language_models', 'openai_compatible', 'phantom'],
+            { api_url: base, available_models: [{ name: model, display_name: `Phantom AI ${model}`, max_tokens: SETUP_CONTEXT_WINDOW, capabilities: { tools: true } }] },
+        ],
+        [['agent', 'default_model'], { provider: 'phantom', model }],
+    ];
+    return {
+        edits: [{ file, after: jsonEdit(file, text, changes) }],
+        result: { settings: file, on: true, base_url: base, model, warnings: ['Zed reads PHANTOM_API_KEY from your login shell; quit and reopen Zed'] },
+    };
+}
 // ── Registry ─────────────────────────────────────────────────────────────────
 /**
  * The agents `phantom setup` knows, in the order setup runs them. Adding an agent
@@ -471,6 +746,122 @@ export const SETUP_AGENTS = {
             GEMINI_API_KEY: '$PHANTOM_API_KEY',
         }),
     },
+    /** Crush. */
+    crush: {
+        label: 'Crush',
+        /** ~/.config/crush, or $CRUSH_GLOBAL_CONFIG */
+        home: '.config/crush',
+        detect: (env, home) => existsSync(crushDir(env, home)),
+        /** ~/.agents/skills */
+        skills: '.agents/skills',
+        provider: crushProvider,
+        shellEnv: () => ({}),
+    },
+    /** Qwen Code. */
+    qwen: {
+        label: 'Qwen Code',
+        /** ~/.qwen, or $QWEN_HOME */
+        home: '.qwen',
+        detect: (env, home) => existsSync(qwenDir(env, home)),
+        /** ~/.agents/skills */
+        skills: '.agents/skills',
+        provider: qwenProvider,
+        shellEnv: () => ({}),
+    },
+    /** Kilo Code's CLI. */
+    kilo: {
+        label: 'Kilo Code',
+        /** ~/.config/kilo, or under $XDG_CONFIG_HOME */
+        home: '.config/kilo',
+        detect: (env, home) => existsSync(path.join(configHome(env, home), 'kilo')),
+        /** ~/.agents/skills */
+        skills: '.agents/skills',
+        provider: kiloProvider,
+        shellEnv: () => ({}),
+    },
+    /** Kimi Code CLI. */
+    kimi: {
+        label: 'Kimi Code',
+        /** ~/.kimi-code, or $KIMI_CODE_HOME */
+        home: '.kimi-code',
+        detect: (env, home) => existsSync(kimiDir(env, home)),
+        /** ~/.agents/skills */
+        skills: '.agents/skills',
+        provider: kimiProvider,
+        shellEnv: () => ({}),
+    },
+    /** Factory's Droid. */
+    droid: {
+        label: 'Droid',
+        /** ~/.factory */
+        home: '.factory',
+        /** ~/.factory/skills */
+        skills: '.factory/skills',
+        provider: droidProvider,
+        shellEnv: () => ({}),
+    },
+    /** Mistral Vibe. */
+    vibe: {
+        label: 'Mistral Vibe',
+        /** ~/.vibe */
+        home: '.vibe',
+        provider: vibeProvider,
+        shellEnv: () => ({}),
+    },
+    /** Zed's agent panel. It reads PHANTOM_API_KEY from the login shell. */
+    zed: {
+        label: 'Zed',
+        /** ~/.config/zed, or under $XDG_CONFIG_HOME */
+        home: '.config/zed',
+        detect: (env, home) => existsSync(path.join(configHome(env, home), 'zed')),
+        /** ~/.agents/skills */
+        skills: '.agents/skills',
+        provider: zedProvider,
+        shellEnv: () => ({}),
+    },
+    /** VS Code's chat. Its Custom Endpoint models are added on its Language Models screen. */
+    vscode: {
+        label: 'VS Code',
+        /** ~/.vscode */
+        home: '.vscode',
+        provider: manualProvider('VS Code, Chat: Manage Language Models', (ctx) => [
+            'In VS Code, run Chat: Manage Language Models from the Command Palette, then Add Models, Custom Endpoint.',
+            'Name the group Phantom AI, paste your Phantom AI key (copy it with "Copy my key" in phantom\'s menu, or phantom keys show --copy), and pick Chat Completions.',
+            `In the chatLanguageModels.json file VS Code opens, set the model's id to ${ctx.model ?? SETUP_MODEL}, its url to ${agentBaseUrl(ctx.env, 'coding-agent')}/chat/completions, and toolCalling to true, then save.`,
+        ]),
+    },
+    /** JetBrains AI Assistant, in IntelliJ IDEA, PyCharm and the other JetBrains editors. */
+    jetbrains: {
+        label: 'JetBrains AI Assistant',
+        /** ~/Library/Application Support/JetBrains on macOS, ~/.config/JetBrains elsewhere */
+        home: 'Library/Application Support/JetBrains',
+        detect: (env, home) => existsSync(path.join(home, 'Library', 'Application Support', 'JetBrains')) || existsSync(path.join(configHome(env, home), 'JetBrains')),
+        provider: manualProvider('Settings, Tools, AI Assistant, Providers & API keys', (ctx) => [
+            'In your JetBrains editor, open Settings, then Tools, AI Assistant, Providers & API keys.',
+            `Under OpenAI-compatible, set the URL to ${agentBaseUrl(ctx.env, 'coding-agent')}, paste your Phantom AI key (copy it with "Copy my key" in phantom's menu, or phantom keys show --copy), and turn on Tool calling.`,
+            `Pick ${ctx.model ?? SETUP_MODEL} in the AI Assistant chat.`,
+        ]),
+    },
+    /** Warp. Its custom inference endpoint is set on its settings screen. */
+    warp: {
+        label: 'Warp',
+        /** ~/.warp */
+        home: '.warp',
+        provider: manualProvider('Warp Settings', (ctx) => [
+            'In Warp, open Settings and search for "inference endpoint".',
+            `Set the endpoint to ${agentBaseUrl(ctx.env, 'coding-agent')}, paste your Phantom AI key (copy it with "Copy my key" in phantom's menu, or phantom keys show --copy), and add the model ${ctx.model ?? SETUP_MODEL}.`,
+        ], 'Warp uses a custom endpoint for agents that run on this computer only.'),
+    },
+    /** Trae. Its custom models are added on its settings screen. */
+    trae: {
+        label: 'Trae',
+        /** ~/.trae */
+        home: '.trae',
+        provider: manualProvider('Trae Settings, Models', (ctx) => [
+            'In Trae, open Settings, then Models, Add Model, Custom Model.',
+            `Pick the OpenAI API format, set the request URL to ${agentBaseUrl(ctx.env, 'coding-agent')}, the model id to ${ctx.model ?? SETUP_MODEL}, and paste your Phantom AI key (copy it with "Copy my key" in phantom's menu, or phantom keys show --copy).`,
+        ]),
+    },
 };
 export const SETUP_NAMES = Object.keys(SETUP_AGENTS);
 /** `a, b or c`. */

package/dist/setup/command.mjs

@@ -119,19 +119,25 @@ export async function setupCommand(input) {
         provider: guided || provider === true ? true : provider === 'off' ? 'off' : false,
         model: typeof model === 'string' ? model : undefined,
         guided,
+        shell: !flags['no-shell'],
     };
     const found = planSetup(env, options);
     let plan = found;
     // At a terminal, plain setup asks which of the agents it found to connect (all ticked, Space unticks),
     // then whether to make the changes. Esc on the question goes back to the checklist.
     const pick = guided && !flags['yes'] && !dryRun ? pickIo(input) : null;
-    const ticks = Boolean(pick) && found.agents.length > 1;
+    const ticks = Boolean(pick) && (found.agents.length > 1 || found.files.some((f) => f.agent === 'shell'));
     /** Shows the checklist, or returns false when Esc there means leave. */
+    // The shell file is a row of its own, so it can be left out like an agent.
+    const shellRow = found.files.some((f) => f.agent === 'shell');
     const tick = async () => {
-        const only = await checklist(pick, 'Which agents should use Phantom AI?', found.agents.map((a) => ({ label: SETUP_AGENTS[a.agent].label, hint: a.provider ? 'skill and model settings' : 'skill', value: a.agent, checked: plan.agents.some((p) => p.agent === a.agent) })));
+        const only = await checklist(pick, 'Which agents should use Phantom AI?', [
+            ...found.agents.map((a) => ({ label: SETUP_AGENTS[a.agent].label, hint: a.provider ? 'skill and model settings' : 'skill', value: a.agent, checked: plan.agents.some((p) => p.agent === a.agent) })),
+            ...(shellRow ? [{ label: 'Your shell', hint: 'new terminals get your key; untick to add it yourself', value: 'shell', checked: plan.files.some((f) => f.agent === 'shell') }] : []),
+        ]);
         if (!only)
             return false;
-        plan = planSetup(env, { ...options, only });
+        plan = planSetup(env, { ...options, only: only.filter((a) => a !== 'shell'), shell: shellRow ? only.includes('shell') : options.shell });
         return true;
     };
     /** Esc on setup's first step: back to the menu when it started setup, otherwise stop with nothing changed. */

package/dist/setup/plan.mjs

@@ -109,7 +109,12 @@ export function planSetup(env, opts = {}) {
         }
         agents.push({ agent, skill, ...(result ? { provider: result } : {}) });
     }
-    if (shellOn.size || shellOff.length) {
+    if (shellOn.size && opts.shell === false) {
+        const block = withShellBlock(env, ctx.shellRc, '', shellOn, [], opts.onPath) ?? '';
+        const short = ctx.shellRc.startsWith(home + path.sep) ? '~' + ctx.shellRc.slice(home.length) : ctx.shellRc;
+        notes.push(`Your shell file was left alone. So ${orList([...shellOn.keys()].map((a) => SETUP_AGENTS[a].label))} can find your key, add these lines to ${short}:`, '', ...block.trimEnd().split('\n').map((l) => `  ${l}`));
+    }
+    else if (shellOn.size || shellOff.length) {
         try {
             add('shell', ctx.shellRc, withShellBlock(env, ctx.shellRc, readText(ctx.shellRc), shellOn, shellOff, opts.onPath));
         }

package/dist/setup/screen.mjs

@@ -5,10 +5,11 @@
 // The JSON result (setupCommand without a terminal) never goes through here.
 import os from 'node:os';
 import path from 'node:path';
-import { paint, unstyled } from "../core/style.mjs";
+import { fitText, paint, unstyled } from "../core/style.mjs";
 import { brandHeader } from "../core/brand.mjs";
 import { inApp } from "../cli/screens.mjs";
 import { SETUP_AGENTS } from "./agents.mjs";
+import { FREE_LINE } from "../core/free.mjs";
 /** `text` broken at spaces into lines of at most `width` characters; a single longer word stays whole. */
 export function wrapWords(text, width) {
     const lines = [];
@@ -64,10 +65,12 @@ export function setupScreen(r, opts = {}) {
     // unless that's wider than the window: then rows stay short and unaligned.
     const longest = Math.max(0, ...r.files.map((f) => short(f.file).length));
     const columns = opts.columns ?? process.stdout.columns ?? 100;
-    const fits = width + 4 + 10 + longest + 2 + 8 + 4 <= columns;
+    // The widest "what happens" phrase (`new file, 12 lines`), plus room for "copy kept".
+    const said = Math.max(8, ...r.files.map((f) => change(f).length + (f.backup ? 11 : 0)));
+    const fits = width + 4 + 10 + longest + 2 + said <= columns;
     const pathWidth = fits ? longest : 0;
     // As wide as a file row (name, kind, path, action and a line count), and never wider than the window.
-    const rule = Math.max(20, Math.min(width + 2 + 10 + longest + 2 + 8 + 4, columns - 4));
+    const rule = Math.max(20, Math.min(width + 2 + 10 + longest + 2 + said, columns - 4));
     // After the prompt, a blank line sets the result apart from the answer typed above it.
     const lines = [''];
     const found = r.agents.length;
@@ -134,7 +137,16 @@ export function setupScreen(r, opts = {}) {
             lines.push('');
         if (routes) {
             lines.push(`  ${p.dim('What this does:')} these agents send their model requests to Phantom AI, and phantom-1 picks the model.`);
-            lines.push(`  ${p.dim('Nothing is bought:')} phantom-1 runs free until you add credit.`);
+            lines.push(`  ${p.dim('Free to start:')} ${FREE_LINE}.`);
+            // Claude Code's settings file applies in every folder, so its own login stops being used.
+            if (r.agents.some((a) => a.agent === 'claude' && a.provider?.on)) {
+                lines.push(`  ${p.dim('Claude Code:')} uses Phantom AI in place of your Anthropic login, in every folder. To keep your login, leave Claude Code out and start it with ${p.cyan('phantom claude')} when you want Phantom.`);
+            }
+            const readers = r.agents.filter((a) => a.provider?.on && SETUP_AGENTS[a.agent]?.shellEnv);
+            if (readers.length && r.files.some((f) => f.agent === 'shell')) {
+                lines.push(`  ${p.dim('Your shell:')} new terminals get your key as PHANTOM_API_KEY, for ${readers.map((a) => label(a.agent)).join(', ')}. The file runs ${p.cyan('phantom key show')}; the key itself isn't written in it.`);
+            }
+            lines.push(`  ${p.dim('Undo:')} phantom keeps a copy of each file it changes, and ${p.cyan('phantom setup --restore')} puts them back.`);
         }
         if (skills)
             lines.push(`  ${p.dim('skill:')} a short note that teaches the agent the phantom commands.`);
@@ -153,7 +165,8 @@ export function setupScreen(r, opts = {}) {
         lines.push('', ...nextStep(r, p, opts.columns));
         lines.push('', inApp() ? `  ${p.dim('Undo any time: More, then Undo setup.')}` : `  Undo any time: ${p.cyan('phantom setup --restore')}`);
     }
-    return lines.join('\n');
+    // Long sentences break at a word under their own indent, at the terminal's width.
+    return fitText(lines.join('\n'), columns);
 }
 /** What a file is, in the words the screen uses: its settings (an agent's, or the shell's ~/.zshrc), or its skill. */
 function kind(f) {
@@ -162,22 +175,32 @@ function kind(f) {
     // ~/.zshrc is the shell's own settings file, and the row already says "Your shell".
     return 'settings';
 }
-/** What happens to a file, in one short word. */
-const ACTION = { create: 'new', update: 'update', remove: 'remove' };
+/** `n lines`, or `1 line`. */
+const lineCount = (n) => `${n} line${n === 1 ? '' : 's'}`;
 /**
- * One file under an agent, in columns: what the file is, where it is, what
- * happens to it, and how many lines change. For example
- * `settings  ~/.codex/config.toml  new  +12`.
+ * What happens to a file, in words: `new file, 12 lines`, `adds 3 lines`,
+ * `adds 3, removes 1`, `updated` (a skill) or `deleted`.
  */
-function fileRow(f, p, short, pathWidth) {
-    const action = ACTION[f.action].padEnd(6);
+function change(f) {
     const { added, removed } = counts(f.diff);
-    const change = [added ? p.green(`+${added}`) : '', removed ? p.red(`-${removed}`) : ''].filter(Boolean).join(' ');
+    if (f.action === 'remove')
+        return 'deleted';
+    if (f.action === 'create')
+        return added ? `new file, ${lineCount(added)}` : 'new file';
+    if (!f.diff)
+        return 'updated';
+    return removed ? `adds ${added}, removes ${removed}` : `adds ${lineCount(added)}`;
+}
+/**
+ * One file under an agent, in columns: what the file is, where it is, and
+ * what happens to it. For example `settings  ~/.codex/config.toml  new file, 12 lines`.
+ */
+function fileRow(f, p, short, pathWidth) {
+    const what = change(f);
     return [
         p.dim(kind(f).padEnd(8)),
         short(f.file).padEnd(pathWidth),
-        f.action === 'remove' ? p.red(action) : p.cyan(action),
-        change + (f.backup ? p.dim('  copy kept') : ''),
+        (f.action === 'remove' ? p.red(what) : p.cyan(what)) + (f.backup ? p.dim('  copy kept') : ''),
     ]
         .join('  ')
         .trimEnd();
@@ -208,7 +231,7 @@ function doneSummary(agent, a, files, skipped, p) {
     return files ? 'skill installed.' : p.dim('already set up.');
 }
 /** The command that starts each agent that runs in a terminal. Editors (Cursor, Continue, Cline) are opened, not run. */
-const START = { claude: 'claude', codex: 'codex', pi: 'pi', opencode: 'opencode', goose: 'goose', aider: 'aider', copilot: 'copilot', gemini: 'gemini' };
+const START = { claude: 'claude', codex: 'codex', pi: 'pi', opencode: 'opencode', goose: 'goose', aider: 'aider', copilot: 'copilot', gemini: 'gemini', crush: 'crush', qwen: 'qwen', kilo: 'kilo', kimi: 'kimi', droid: 'droid', vibe: 'vibe' };
 /**
  * The one thing to do after setup, in corner brackets: run the agent. When an
  * agent reads its key from the shell (Codex, Goose and others), the step says

package/dist/spend/command.mjs

@@ -174,7 +174,7 @@ async function lineupPicker(input, pick, show) {
             io.stdout(show(read) + '\n\n');
             const tier = await choose({ ...pick, esc: 'back' }, 'Which tier do you want to change?', [
                 ...LINEUP_TIERS.map((t) => ({ label: t[0].toUpperCase() + t.slice(1), hint: `${TIER_ABOUT[t]} · now ${read.tiers[t].model}`, value: t })),
-                { label: 'Put every tier back to its default', value: 'reset' },
+                { label: 'Reset every tier', hint: 'back to its default', value: 'reset' },
             ], last);
             if (tier === null)
                 return 0;

package/dist/workspace/command.mjs

@@ -12,8 +12,8 @@ import { BackToMenu, Cancelled, askText, cancelKeys, choose, keyboard } from "..
 import { spawnSync } from 'node:child_process';
 import { onPath } from "../setup/shared.mjs";
 import { colorOn, paint } from "../core/style.mjs";
-import { fundScreen, keyChangeScreen, keysScreen, paymentScreen, signedInScreen, workspaceScreen } from "../cli/screens.mjs";
-import { keyPath, listNamedKeys, namedKeyPath, readNamedKey, saveApiKey, saveNamedKey } from "../keys/saved.mjs";
+import { alreadySignedInScreen, fundScreen, keyChangeScreen, keysScreen, paymentScreen, signedInScreen, workspaceScreen } from "../cli/screens.mjs";
+import { keyId, keyPath, listNamedKeys, namedKeyPath, readNamedKey, resolveApiKey, saveApiKey, saveNamedKey } from "../keys/saved.mjs";
 const credentialPath = (env) => path.join(stateDir(env), 'workspace');
 const base = (input) => httpsOnly(input.baseUrl || input.env.PHANTOM_BASE_URL || DEFAULT_BASE_URL).replace(/\/$/, '');
 async function wire(url, method, endpoint, body, token) {
@@ -52,8 +52,12 @@ export async function workspaceLogin(input, opts = {}) {
         die('--save requires a key name.');
     const name = typeof flags.save === 'string' ? flags.save : 'default';
     const target = name === 'default' ? keyPath(env) : namedKeyPath(env, name);
-    if (existsSync(target))
-        die(`Saved key ${name} already exists. Use --save <new-name>; no key was overwritten.`, 'key_exists');
+    if (existsSync(target)) {
+        // Signing in again is a question ("am I signed in?"), so it gets an answer, not an error.
+        if (name === 'default')
+            return alreadySignedIn(input);
+        die(`A key named ${name} is already saved here. Pick another name with --save <name>; nothing was changed.`, 'key_exists');
+    }
     // At a terminal, how to sign in is a choice; --no-browser or a pipe skips it.
     const pick = flags['no-browser'] ? null : pickIo(input);
     let noBrowser = Boolean(flags['no-browser']);
@@ -101,6 +105,17 @@ export async function workspaceLogin(input, opts = {}) {
         cancel?.close();
     }
 }
+/** `phantom login` on a computer that already has a key: which key, and how to use another. Exit 0. */
+function alreadySignedIn(input) {
+    const { env, io } = input;
+    const key = resolveApiKey(env);
+    const result = { signed_in: true, already: true, key_id: key ? keyId(key) : null };
+    if (showsScreen(input))
+        io.stdout(alreadySignedInScreen(result.key_id, { env, color: colorOn(env, io.stdoutIsTTY) }) + '\n');
+    else
+        io.stdout(JSON.stringify(result) + '\n');
+    return 0;
+}
 /** A spinner on one line: `⠋ Waiting for you to approve...` until stopped, then `✓ Approved.` or nothing. */
 function waiting(write, p, words = 'Waiting for you to approve...', doneWords = 'Approved.') {
     const frames = '⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏';
@@ -324,7 +339,7 @@ export async function workspaceCommand(input) {
         }
         if (pick && !method) {
             method = (await choose({ ...pick, esc: 'back' }, 'How do you want to pay?', [
-                { label: 'Card', hint: "on Stripe's page; Stripe's fee is added, and the next screen shows the total", value: 'card' },
+                { label: 'Card', hint: "on Stripe's page, plus Stripe's card fee", value: 'card' },
                 { label: 'USDC', hint: 'from a Solana wallet', value: 'usdc' },
                 { label: 'USDT', hint: 'from a Solana wallet', value: 'usdt' },
                 { label: 'SOL', hint: 'from a Solana wallet', value: 'sol' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phantomcodes/cli",
-  "version": "1.2.5",
+  "version": "1.2.7",
   "description": "AI inference for your coding agents. Route models, control spending, and fund your workspace.",
   "keywords": [
     "phantom",