@phantomcodes/cli 1.2.5 → 1.2.6

package/README.md

@@ -62,9 +62,11 @@ 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.
+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`. The Phantom CLI keeps backups;
 undo the changes with `phantom setup --restore`.

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.6';

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/screen.mjs

@@ -208,7 +208,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/package.json

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