@getforgeai/cli 0.1.0-beta.5 → 0.1.0-beta.7

package/dist/cli.js

@@ -13,7 +13,7 @@ import { orgUnlinkAction } from "./commands/org-unlink.js";
 import { journalListAction } from "./commands/journal-list.js";
 import { journalClearAction } from "./commands/journal-clear.js";
 import { journalStatusAction } from "./commands/journal-status.js";
-import { configSetAgentTypeAction, configSetAgentSlotsAction, configSetOpenerAction, configGetAction, } from "./commands/config-set.js";
+import { configSetAgentTypeAction, configSetAgentSlotsAction, configSetModelsAction, configSetOpenerAction, configGetAction, } from "./commands/config-set.js";
 import { mcpServeAction } from "./commands/mcp-serve.js";
 import { releaseOpenAction } from "./commands/release-open.js";
 import { sessionRespondAction } from "./commands/session-respond.js";
@@ -21,6 +21,7 @@ import { taskOpenAction } from "./commands/task-open.js";
 import { workflowOpenAction } from "./commands/workflow-open.js";
 import { vmInitAction, vmStatusAction, vmCleanupAction, vmStopAllAction, setupClaudeTokenAction, } from "./commands/vm.js";
 import { setupCodexAuthAction, setupKiloAuthAction, setupOpenCodeAuthAction, } from "./commands/auth-setup-agent.js";
+import { modelsListAction } from "./commands/models-list.js";
 const program = new Command();
 program
     .name("forge")
@@ -119,6 +120,10 @@ journalCmd
     .command("status")
     .description("Show sync status: last sync time, pending events, cursor")
     .action(() => journalStatusAction());
+program
+    .command("models [engine]")
+    .description("Show the models declared on this device and the models available for an engine (defaults to the configured agent type)")
+    .action((engine) => modelsListAction(engine));
 const configCmd = program
     .command("config")
     .description("Manage CLI configuration");
@@ -129,6 +134,10 @@ configSetCmd
     .command("agent-type <value>")
     .description("Set agent type (CLAUDE_CODE, CODEX, OPENCODE or KILO)")
     .action((value) => configSetAgentTypeAction(value));
+configSetCmd
+    .command("models <engineOrModels> [models]")
+    .description("Declare the usable models, comma-separated (first = default); 'none' clears. Engine optional — defaults to the configured agent type")
+    .action((engineOrModels, models) => configSetModelsAction(engineOrModels, models));
 configSetCmd
     .command("agent-slots <value>")
     .description("Set agent slots (1-20)")

package/dist/commands/config-set.d.ts

@@ -1,4 +1,10 @@
 export declare function configSetAgentTypeAction(value: string): Promise<void>;
+/**
+ * forge config set models <engine> <m1,m2,...>
+ * Declares the models usable on this device for an engine (first = default).
+ * "none" clears the engine's list. Refused when the org locked the list.
+ */
+export declare function configSetModelsAction(engineOrModels: string, maybeModels?: string): Promise<void>;
 export declare function configSetAgentSlotsAction(value: string): Promise<void>;
 export declare function configSetOpenerAction(value: string): void;
 export declare function configGetAction(): void;

package/dist/commands/config-set.js

@@ -24,6 +24,78 @@ export async function configSetAgentTypeAction(value) {
         console.log(chalk.dim(`Make sure credentials are configured: ${hint}`));
     }
 }
+/**
+ * forge config set models <engine> <m1,m2,...>
+ * Declares the models usable on this device for an engine (first = default).
+ * "none" clears the engine's list. Refused when the org locked the list.
+ */
+export async function configSetModelsAction(engineOrModels, maybeModels) {
+    const config = getConfig();
+    // Engine is optional: `forge config set models sonnet,haiku` applies to the
+    // configured agent type; an explicit engine targets another engine's list.
+    let upper;
+    let value;
+    if (maybeModels === undefined) {
+        if (isAgentType(engineOrModels.toUpperCase())) {
+            console.error(chalk.red(`Missing model list. Usage: forge config set models ${engineOrModels.toUpperCase()} <m1,m2,...>`));
+            process.exitCode = 1;
+            return;
+        }
+        upper = (config.agentType ?? "CLAUDE_CODE").toUpperCase();
+        value = engineOrModels;
+    }
+    else {
+        upper = engineOrModels.toUpperCase();
+        value = maybeModels;
+        if (!isAgentType(upper)) {
+            console.error(chalk.red(`Invalid engine "${engineOrModels}". Allowed: ${AGENT_TYPE.join(", ")}`));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    if (!isAgentType(upper)) {
+        console.error(chalk.red(`Configured agent type "${upper}" is not a valid engine.`));
+        process.exitCode = 1;
+        return;
+    }
+    const lockedByOrgs = config.modelsLockedByOrgs ?? [];
+    if (lockedByOrgs.length > 0) {
+        console.error(chalk.red(`The model list is locked by organization(s): ${lockedByOrgs.join(", ")} — edit it from their cockpit (Settings → CLI Devices).`));
+        process.exitCode = 1;
+        return;
+    }
+    const models = value.trim().toLowerCase() === "none"
+        ? []
+        : value
+            .split(",")
+            .map((m) => m.trim())
+            .filter(Boolean);
+    // Mirror the server-side AvailableModelsSchema bounds so an invalid list
+    // fails HERE instead of turning every register POST/PATCH into a 400.
+    if (models.length > 20) {
+        console.error(chalk.red("Too many models — 20 maximum per engine."));
+        process.exitCode = 1;
+        return;
+    }
+    const tooLong = models.find((m) => m.length > 120);
+    if (tooLong) {
+        console.error(chalk.red(`Model id too long (120 chars max): "${tooLong.slice(0, 40)}..."`));
+        process.exitCode = 1;
+        return;
+    }
+    const availableModels = { ...(config.availableModels ?? {}) };
+    if (models.length === 0) {
+        delete availableModels[upper];
+    }
+    else {
+        availableModels[upper] = models;
+    }
+    setConfig({ availableModels });
+    const applied = await tryReRegister();
+    console.log(chalk.green(models.length === 0
+        ? `Model list cleared for ${upper}. ${applied ? "(Applied immediately)" : "(Will apply on next connect)"}`
+        : `Models for ${upper}: ${models.join(", ")} (default: ${models[0]}). ${applied ? "(Applied immediately)" : "(Will apply on next connect)"}`));
+}
 export async function configSetAgentSlotsAction(value) {
     const num = Number.parseInt(value, 10);
     if (Number.isNaN(num) || num < 1 || num > 20) {
@@ -55,6 +127,17 @@ export function configGetAction() {
     if (config.agentType === "KILO") {
         console.log(`  Kilo model:  ${config.kiloModel ?? "(Kilo default)"}`);
     }
+    const declared = config.availableModels ?? {};
+    const declaredEntries = Object.entries(declared).filter(([, models]) => models.length > 0);
+    if (declaredEntries.length > 0) {
+        const lockNote = (config.modelsLockedByOrgs ?? []).length > 0
+            ? ` (locked by: ${(config.modelsLockedByOrgs ?? []).join(", ")})`
+            : "";
+        console.log(`  Declared models:${lockNote}`);
+        for (const [engine, models] of declaredEntries) {
+            console.log(`    ${engine}: ${models.join(", ")}`);
+        }
+    }
     console.log(`  Agent slots: ${config.agentSlots ?? 5}`);
     console.log(`  Opener:      ${config.opener ?? "terminal"}`);
     console.log(`  Server URL:  ${config.serverUrl}`);

package/dist/commands/models-list.d.ts

@@ -0,0 +1,7 @@
+/**
+ * forge models [engine] — show the models declared on this device and the
+ * models available for the engine (live catalog for OpenCode/Kilo, curated
+ * suggestions for Claude Code/Codex).
+ */
+export declare function modelsListAction(engineArg?: string): Promise<void>;
+//# sourceMappingURL=models-list.d.ts.map

package/dist/commands/models-list.js

@@ -0,0 +1,57 @@
+/**
+ * forge models [engine] — show the models declared on this device and the
+ * models available for the engine (live catalog for OpenCode/Kilo, curated
+ * suggestions for Claude Code/Codex).
+ */
+import chalk from "chalk";
+import { AGENT_TYPE, KNOWN_MODEL_SUGGESTIONS, LIVE_CATALOG_ENGINES, isAgentType, } from "@getforgeai/protocol";
+import { getConfig } from "../config/config-manager.js";
+import { fetchEngineModelCatalog } from "../lib/model-catalog.js";
+import { resolveAgentType } from "../orchestrator/agent-profiles.js";
+export async function modelsListAction(engineArg) {
+    const config = getConfig();
+    const engine = engineArg
+        ? engineArg.toUpperCase()
+        : resolveAgentType(config.agentType);
+    if (!isAgentType(engine)) {
+        console.error(chalk.red(`Invalid engine "${engineArg}". Allowed: ${AGENT_TYPE.join(", ")}`));
+        process.exitCode = 1;
+        return;
+    }
+    const declared = config.availableModels?.[engine] ?? [];
+    const lockedBy = config.modelsLockedByOrgs ?? [];
+    const locked = lockedBy.length > 0;
+    const lockNote = locked
+        ? chalk.yellow(` (locked by: ${lockedBy.join(", ")})`)
+        : "";
+    console.log(chalk.bold(`Models — ${engine}`));
+    if (declared.length > 0) {
+        console.log(`  Declared on this device${lockNote}:`);
+        declared.forEach((m, i) => {
+            console.log(`    ${m}${i === 0 ? chalk.dim(" (default)") : ""}`);
+        });
+    }
+    else {
+        console.log(chalk.dim("  No models declared on this device — any demanded model makes it ineligible only if a list exists; declare one to advertise what your subscription can run.") + lockNote);
+    }
+    const live = LIVE_CATALOG_ENGINES.includes(engine);
+    console.log(live
+        ? chalk.dim(`  Listing available models via the ${engine} engine...`)
+        : chalk.dim("  Known models (curated — no headless listing for this engine):"));
+    const catalog = await fetchEngineModelCatalog(engine);
+    if (catalog.error) {
+        console.error(chalk.yellow(`  ${catalog.error}`));
+    }
+    if (catalog.models.length > 0) {
+        const suggestions = KNOWN_MODEL_SUGGESTIONS[engine];
+        for (const model of catalog.models) {
+            const note = suggestions?.find((s) => s.id === model)?.note;
+            const mark = declared.includes(model) ? chalk.green("✓ ") : "  ";
+            console.log(`  ${mark}${model}${note ? chalk.dim(` — ${note}`) : ""}`);
+        }
+    }
+    console.log(chalk.dim(locked
+        ? "\nModel lists on this device are locked by your organization — manage them from the cockpit."
+        : `\nDeclare with: forge config set models ${engine} <model1,model2,...> (first = default)`));
+}
+//# sourceMappingURL=models-list.js.map

package/dist/config/config-manager.d.ts

@@ -15,6 +15,19 @@ export type CliConfig = {
     opencodeModel?: string;
     /** Kilo model, e.g. "kilo/anthropic/claude-sonnet-4.5" (used when agentType is KILO). */
     kiloModel?: string;
+    /**
+     * Models the device owner declares usable, per engine. Advertised to the
+     * cockpit at registration; first entry = this device's default model for
+     * the engine. Server-owned (read-only here) when modelsLockedByServer.
+     */
+    availableModels?: Record<string, string[]>;
+    /**
+     * Slugs of the organizations that locked this device's model list from the
+     * cockpit. Enforcement is server-side per org (locked orgs ignore CLI-sent
+     * lists); locally this only gates `forge config set models` with a clear
+     * message. Per-org because one machine can serve several orgs.
+     */
+    modelsLockedByOrgs?: string[];
     agentSlots?: number;
     opener?: Opener;
     lastSyncCursor?: string;

package/dist/config/config-manager.js

@@ -53,6 +53,19 @@ export function clearSessionConfig() {
     if (config.agentSlots !== undefined) {
         cleaned.agentSlots = config.agentSlots;
     }
+    // Machine-level agent model settings survive logout too
+    if (config.opencodeModel !== undefined) {
+        cleaned.opencodeModel = config.opencodeModel;
+    }
+    if (config.kiloModel !== undefined) {
+        cleaned.kiloModel = config.kiloModel;
+    }
+    if (config.availableModels !== undefined) {
+        cleaned.availableModels = config.availableModels;
+    }
+    if (config.modelsLockedByOrgs !== undefined) {
+        cleaned.modelsLockedByOrgs = config.modelsLockedByOrgs;
+    }
     if (config.vmCpus !== undefined) {
         cleaned.vmCpus = config.vmCpus;
     }

package/dist/lib/connection-manager.js

@@ -219,6 +219,16 @@ export function establishConnections(ctx, append = false) {
         registerWorkflowStepDispatchHandler(client.socket, org.orgId, spawnerCtx);
         // Register workflow agent dismiss handler (Story 6b-10)
         registerWorkflowAgentDismissHandler(client.socket, spawnerCtx);
+        // Cockpit-initiated model catalog listing ("Fetch from device"): run the
+        // engine's own listing (OpenCode/Kilo) or answer curated suggestions.
+        client.socket.on("models:catalog:request", (payload, callback) => {
+            void (async () => {
+                const { answerCatalogRequest } = await import("./model-catalog.js");
+                callback(await answerCatalogRequest(payload));
+            })().catch(() => {
+                callback({ models: [], error: "Catalog fetch failed" });
+            });
+        });
         // Listen for server-pushed config updates (e.g., admin changed agentSlots
         // or the agent engine in the Cloud UI)
         client.socket.on("cli:config:updated", (payload) => {
@@ -235,6 +245,23 @@ export function establishConnections(ctx, append = false) {
                     console.log(chalk.green(`${prefix(org.orgSlug)}Agent type updated by server: ${previousType} → ${payload.agentType}`));
                 }
             }
+            // Server-pushed model governance (cockpit list edits + lock). The lock
+            // is tracked per org; the local availableModels stays the owner's
+            // declaration (a locked org enforces its own list server-side).
+            if (payload.modelsLocked !== undefined) {
+                const lockedByOrgs = new Set(getConfig().modelsLockedByOrgs ?? []);
+                if (payload.modelsLocked) {
+                    lockedByOrgs.add(org.orgSlug);
+                }
+                else {
+                    lockedByOrgs.delete(org.orgSlug);
+                }
+                setConfig({ modelsLockedByOrgs: Array.from(lockedByOrgs) });
+            }
+            if (payload.availableModels !== undefined ||
+                payload.modelsLocked !== undefined) {
+                console.log(chalk.green(`${prefix(org.orgSlug)}Model governance updated by this organization${payload.modelsLocked ? " (list locked — its cockpit owns it there)" : ""}`));
+            }
             if (payload.agentSlots != null && payload.agentSlots !== ctx.agentSlots) {
                 const previous = ctx.agentSlots;
                 ctx.agentSlots = payload.agentSlots;
@@ -281,8 +308,29 @@ export function establishConnections(ctx, append = false) {
                     name: ctx.cliName,
                     agentType: ctx.agentType,
                     agentSlots: ctx.agentSlots,
+                    availableModels: getConfig().availableModels,
                 });
                 console.log(chalk.green(`${prefix(org.orgSlug)}CLI registered as "${ctx.cliName}"`));
+                // Lock state is tracked PER ORG (one machine can serve several orgs;
+                // org B must not clear org A's lock, and org A's restricted list must
+                // not overwrite the owner's local declaration — enforcement is
+                // server-side per org: a locked org ignores CLI-sent lists anyway).
+                {
+                    const lockedByOrgs = new Set(getConfig().modelsLockedByOrgs ?? []);
+                    const wasLocked = lockedByOrgs.has(org.orgSlug);
+                    if (device.modelsLocked) {
+                        lockedByOrgs.add(org.orgSlug);
+                    }
+                    else {
+                        lockedByOrgs.delete(org.orgSlug);
+                    }
+                    if (wasLocked !== Boolean(device.modelsLocked)) {
+                        setConfig({ modelsLockedByOrgs: Array.from(lockedByOrgs) });
+                        if (device.modelsLocked) {
+                            console.log(chalk.dim(`${prefix(org.orgSlug)}Model list is locked by this organization — its cockpit owns the list there`));
+                        }
+                    }
+                }
                 // The server is source of truth for agentType after first registration
                 // (a cockpit edit made while this CLI was offline must survive the
                 // reconnect). Adopt the returned value.

package/dist/lib/daemon-entry.js

@@ -179,6 +179,7 @@ async function handleReRegisterCommand() {
                 name: ctx.cliName,
                 agentType: ctx.agentType,
                 agentSlots: ctx.agentSlots,
+                availableModels: (await import("../config/config-manager.js")).getConfig().availableModels,
             });
         }
         catch {

package/dist/lib/model-catalog.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Model catalog discovery per engine.
+ *
+ * OpenCode and Kilo can list their real catalogs (`opencode models`,
+ * `kilo models`) — we run that inside the agent Docker image with the stored
+ * credentials, in a throwaway container. Claude Code and Codex have no
+ * headless listing; they answer from the curated KNOWN_MODEL_SUGGESTIONS.
+ *
+ * Used by `forge models` and by the cockpit's "Fetch from device" button
+ * (models:catalog:request socket event, answered via answerCatalogRequest).
+ */
+import type { AgentType } from "@getforgeai/protocol";
+export type ModelCatalogResult = {
+    models: string[];
+    /** "curated" = static suggestions; "live" = listed by the engine itself. */
+    source: "curated" | "live";
+    error?: string;
+};
+/** Strip ANSI escapes and keep plausible model-id lines. Exported for tests. */
+export declare function parseCatalogOutput(raw: string): string[];
+/**
+ * Fetch the model catalog for an engine: live from the engine when it
+ * supports listing, curated suggestions otherwise.
+ */
+export declare function fetchEngineModelCatalog(engine: AgentType): Promise<ModelCatalogResult>;
+/**
+ * Answer a cockpit models:catalog:request payload. Never throws — every
+ * failure maps to a resolved value so the socket ack callback always fires.
+ */
+export declare function answerCatalogRequest(payload: unknown): Promise<{
+    models: string[];
+    error?: string;
+}>;
+//# sourceMappingURL=model-catalog.d.ts.map

package/dist/lib/model-catalog.js

@@ -0,0 +1,210 @@
+/**
+ * Model catalog discovery per engine.
+ *
+ * OpenCode and Kilo can list their real catalogs (`opencode models`,
+ * `kilo models`) — we run that inside the agent Docker image with the stored
+ * credentials, in a throwaway container. Claude Code and Codex have no
+ * headless listing; they answer from the curated KNOWN_MODEL_SUGGESTIONS.
+ *
+ * Used by `forge models` and by the cockpit's "Fetch from device" button
+ * (models:catalog:request socket event, answered via answerCatalogRequest).
+ */
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { KNOWN_MODEL_SUGGESTIONS, LIVE_CATALOG_ENGINES, isAgentType, } from "@getforgeai/protocol";
+import { getAgentProfile } from "../orchestrator/agent-profiles.js";
+import { ensureImage, FORGEAI_IMAGE } from "../vm/image-manager.js";
+import { AGENT_API_KEY_DEFAULT_ENV, AGENT_AUTH_JSON_PATHS, loadAgentAuth, } from "../vm/agent-auth-manager.js";
+const CATALOG_TIMEOUT_MS = 45_000;
+/** Strip ANSI escapes and keep plausible model-id lines. Exported for tests. */
+export function parseCatalogOutput(raw) {
+    const seen = new Set();
+    const models = [];
+    for (const line of raw.split("\n")) {
+        // eslint-disable-next-line no-control-regex
+        const clean = line.replaceAll(/\x1b\[[0-9;]*m/g, "").trim();
+        // Model ids: single token containing a provider separator, no spaces
+        if (!clean || clean.includes(" ") || !clean.includes("/"))
+            continue;
+        if (!/^[\w.:@/-]+$/.test(clean))
+            continue;
+        if (clean.length > 120 || seen.has(clean))
+            continue;
+        seen.add(clean);
+        models.push(clean);
+    }
+    return models;
+}
+/**
+ * Best-effort teardown of the throwaway container. Killing the docker CLI
+ * client only detaches it — the container (holding credentials in env) keeps
+ * running and `--rm` never fires, so it must be removed by name.
+ */
+function forceRemoveContainer(name) {
+    const rm = spawn("docker", ["rm", "-f", name], { stdio: "ignore" });
+    rm.on("error", () => { });
+    rm.unref();
+}
+/**
+ * Run the engine's own catalog command in a throwaway agent container.
+ * Credentials travel as name-only `-e` env vars (values stay out of argv,
+ * same pattern as docker-executor's secretEnv).
+ */
+async function runLiveCatalog(engine) {
+    const auth = await loadAgentAuth(engine);
+    if (!auth) {
+        return {
+            models: [],
+            source: "live",
+            error: `No ${engine} credentials stored — run forge auth setup-${engine.toLowerCase()} first`,
+        };
+    }
+    const profile = getAgentProfile(engine);
+    const binary = profile.binary;
+    const containerEnv = { ...profile.spawnEnv };
+    let setup = "";
+    if (auth.kind === "api_key") {
+        const envVar = auth.envVar ?? AGENT_API_KEY_DEFAULT_ENV[engine];
+        containerEnv[envVar] = auth.value;
+    }
+    else {
+        const target = AGENT_AUTH_JSON_PATHS[engine];
+        const dir = target.slice(0, target.lastIndexOf("/"));
+        containerEnv.FORGE_AGENT_SECRET = auth.value;
+        setup = `mkdir -p ${dir} && printenv FORGE_AGENT_SECRET > ${target} && chmod 600 ${target} && `;
+    }
+    try {
+        await ensureImage();
+    }
+    catch (err) {
+        return {
+            models: [],
+            source: "live",
+            error: `Agent image unavailable: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    const containerName = `forge-catalog-${randomBytes(6).toString("hex")}`;
+    const script = `${setup}${binary} models`;
+    const args = [
+        "run",
+        "--rm",
+        "--name",
+        containerName,
+        "--label",
+        "forgeai.managed=true",
+        "--platform",
+        "linux/arm64",
+        ...Object.keys(containerEnv).flatMap((key) => ["-e", key]),
+        FORGEAI_IMAGE,
+        "bash",
+        "-c",
+        script,
+    ];
+    return new Promise((resolve) => {
+        const child = spawn("docker", args, {
+            env: { ...process.env, ...containerEnv },
+        });
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGKILL");
+            forceRemoveContainer(containerName);
+            resolve({
+                models: [],
+                source: "live",
+                error: `Catalog listing timed out (${CATALOG_TIMEOUT_MS / 1000}s)`,
+            });
+        }, CATALOG_TIMEOUT_MS);
+        child.stdout.on("data", (d) => {
+            stdout += d.toString();
+        });
+        child.stderr.on("data", (d) => {
+            stderr += d.toString();
+        });
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            resolve({
+                models: [],
+                source: "live",
+                error: err.code === "ENOENT"
+                    ? "Docker is not installed or not running on this device"
+                    : err.message,
+            });
+        });
+        child.on("exit", (code) => {
+            clearTimeout(timer);
+            if (timedOut) {
+                forceRemoveContainer(containerName);
+                return;
+            }
+            const models = parseCatalogOutput(stdout);
+            if (models.length > 0) {
+                resolve({ models, source: "live" });
+                return;
+            }
+            const cause = stderr.trim().slice(0, 200);
+            let error;
+            if (code === 0) {
+                error = "The engine returned no parsable model ids";
+            }
+            else if (code === 125) {
+                error = cause ? `Docker error: ${cause}` : "Docker error (exit 125)";
+            }
+            else if (code === 127) {
+                error = `${binary} not found in the agent image — pull the latest getforgeai/agent image`;
+            }
+            else {
+                error = `${binary} models exited with code ${code}${cause ? `: ${cause}` : ""}`;
+            }
+            resolve({ models: [], source: "live", error });
+        });
+    });
+}
+/**
+ * One catalog container per engine at a time: concurrent requests (cockpit
+ * spam, `forge models` racing a socket request) share the in-flight run.
+ */
+const inFlight = new Map();
+/**
+ * Fetch the model catalog for an engine: live from the engine when it
+ * supports listing, curated suggestions otherwise.
+ */
+export async function fetchEngineModelCatalog(engine) {
+    if (LIVE_CATALOG_ENGINES.includes(engine)) {
+        const running = inFlight.get(engine);
+        if (running)
+            return running;
+        const run = runLiveCatalog(engine).finally(() => {
+            inFlight.delete(engine);
+        });
+        inFlight.set(engine, run);
+        return run;
+    }
+    const suggestions = KNOWN_MODEL_SUGGESTIONS[engine] ?? [];
+    return { models: suggestions.map((s) => s.id), source: "curated" };
+}
+/**
+ * Answer a cockpit models:catalog:request payload. Never throws — every
+ * failure maps to a resolved value so the socket ack callback always fires.
+ */
+export async function answerCatalogRequest(payload) {
+    try {
+        const engine = payload && typeof payload === "object"
+            ? payload.engine
+            : undefined;
+        if (typeof engine !== "string" || !isAgentType(engine)) {
+            return { models: [], error: "Unknown engine" };
+        }
+        const result = await fetchEngineModelCatalog(engine);
+        return { models: result.models, error: result.error };
+    }
+    catch (err) {
+        return {
+            models: [],
+            error: err instanceof Error ? err.message : "Catalog fetch failed",
+        };
+    }
+}
+//# sourceMappingURL=model-catalog.js.map

package/dist/lib/rest-client.d.ts

@@ -9,6 +9,8 @@ type RegisterCliRequest = {
     name?: string;
     agentType?: string;
     agentSlots?: number;
+    /** Declared usable models per engine (ignored server-side when locked). */
+    availableModels?: Record<string, string[]>;
 };
 type RegisterCliResponse = {
     id: string;
@@ -17,6 +19,8 @@ type RegisterCliResponse = {
     memberId: string;
     agentType: string;
     agentSlots: number;
+    availableModels?: Record<string, string[]> | null;
+    modelsLocked?: boolean;
     createdAt: string;
 };
 type CliDeviceItem = {
@@ -54,6 +58,8 @@ type UpdateCliConfigRequest = {
     name?: string;
     agentType?: string;
     agentSlots?: number;
+    /** Declared usable models per engine (ignored server-side when locked). */
+    availableModels?: Record<string, string[]>;
 };
 type TaskDetail = {
     id: string;

package/dist/orchestrator/agent-profiles.d.ts

@@ -23,13 +23,31 @@ export type McpBridgeConfig = {
 };
 export type AgentConfigOptions = {
     /**
-     * Model in "provider/model" form (from CLI config, optional).
-     * OpenCode: e.g. "anthropic/claude-sonnet-4-5".
-     * Kilo: gateway models are "kilo/<vendor>/<model>", e.g.
-     * "kilo/anthropic/claude-sonnet-4.5".
+     * Model id, engine-specific:
+     * Claude Code: alias (sonnet/opus/haiku/fable) or full id.
+     * Codex: bare slug (e.g. "gpt-5.5").
+     * OpenCode: "provider/model" (e.g. "anthropic/claude-sonnet-4-5").
+     * Kilo: "kilo/<vendor>/<model>" (e.g. "kilo/anthropic/claude-sonnet-4.5").
      */
     model?: string;
+    /**
+     * Generic reasoning effort (EFFORT_LEVELS: low|medium|high|max), mapped per
+     * engine: Claude --effort as-is; Codex model_reasoning_effort (max→xhigh);
+     * OpenCode/Kilo --variant clamped per model vendor (mapEffortToVariant).
+     */
+    effort?: string;
 };
+/**
+ * Map the generic effort scale onto an OpenCode/Kilo model variant for the
+ * given vendor. Variants are vendor catalogs: OpenAI none…xhigh, Anthropic
+ * high/max, Google low/high. Unknown vendor → undefined (omit --variant
+ * rather than risk a server-side unknown-variant error).
+ */
+export declare function mapEffortToVariant(vendor: string | undefined, effort: string | undefined): string | undefined;
+/** Vendor of an OpenCode model id ("vendor/model") for variant mapping. */
+export declare function openCodeModelVendor(model: string | undefined): string | undefined;
+/** Vendor of a Kilo model id ("kilo/vendor/model") for variant mapping. */
+export declare function kiloModelVendor(model: string | undefined): string | undefined;
 export type AgentAuthErrorPatterns = {
     /** Substrings matched against stderr only (avoids stdout false positives). */
     stderr: string[];
@@ -49,9 +67,9 @@ export type AgentProfile = {
     /** Build the agent config file content (JSON or TOML depending on engine). */
     buildConfig(mcp: McpBridgeConfig, opts?: AgentConfigOptions): string;
     /** argv for a fresh non-interactive run. */
-    buildArgs(prompt: string): string[];
+    buildArgs(prompt: string, opts?: AgentConfigOptions): string[];
     /** argv to continue the latest on-disk session in the same home dir. */
-    buildContinueArgs(prompt: string): string[];
+    buildContinueArgs(prompt: string, opts?: AgentConfigOptions): string[];
     /** Non-secret env vars added to every agent spawn. */
     spawnEnv: Record<string, string>;
     /**

package/dist/orchestrator/agent-profiles.js

@@ -18,6 +18,37 @@ import { DEFAULT_AGENT_TYPE, isAgentType } from "@getforgeai/protocol";
 import { CodexJsonlExtractor } from "./codex-jsonl-extractor.js";
 import { OpenCodeJsonlExtractor } from "./opencode-jsonl-extractor.js";
 import { StreamJsonExtractor } from "./stream-json-extractor.js";
+/**
+ * Map the generic effort scale onto an OpenCode/Kilo model variant for the
+ * given vendor. Variants are vendor catalogs: OpenAI none…xhigh, Anthropic
+ * high/max, Google low/high. Unknown vendor → undefined (omit --variant
+ * rather than risk a server-side unknown-variant error).
+ */
+export function mapEffortToVariant(vendor, effort) {
+    if (!effort)
+        return undefined;
+    switch (vendor) {
+        case "openai":
+            return { low: "low", medium: "medium", high: "high", max: "xhigh" }[effort];
+        case "anthropic":
+            return { low: "high", medium: "high", high: "high", max: "max" }[effort];
+        case "google":
+            return { low: "low", medium: "low", high: "high", max: "high" }[effort];
+        default:
+            return undefined;
+    }
+}
+/** Vendor of an OpenCode model id ("vendor/model") for variant mapping. */
+export function openCodeModelVendor(model) {
+    return model?.split("/")[0] || undefined;
+}
+/** Vendor of a Kilo model id ("kilo/vendor/model") for variant mapping. */
+export function kiloModelVendor(model) {
+    if (!model)
+        return undefined;
+    const parts = model.split("/");
+    return parts[0] === "kilo" ? parts[1] || undefined : parts[0] || undefined;
+}
 /** Narrow an arbitrary config/dispatch string to a supported AgentType. */
 export function resolveAgentType(value) {
     if (value && isAgentType(value))
@@ -60,11 +91,14 @@ const claudeProfile = {
             },
         }, null, 2);
     },
-    buildArgs(prompt) {
+    buildArgs(prompt, opts) {
         return [
             "--dangerously-skip-permissions",
             "--mcp-config",
             CLAUDE_MCP_CONFIG_PATH,
+            // Model alias/id and generic effort map 1:1 onto Claude Code flags
+            ...(opts?.model ? ["--model", opts.model] : []),
+            ...(opts?.effort ? ["--effort", opts.effort] : []),
             "-p",
             prompt,
             "--output-format",
@@ -73,8 +107,8 @@ const claudeProfile = {
             "--include-partial-messages",
         ];
     },
-    buildContinueArgs(prompt) {
-        return ["--continue", ...this.buildArgs(prompt)];
+    buildContinueArgs(prompt, opts) {
+        return ["--continue", ...this.buildArgs(prompt, opts)];
     },
     spawnEnv: {},
     nativeSkillDiscovery: true,
@@ -110,12 +144,17 @@ const codexProfile = {
     type: "CODEX",
     binary: "codex",
     configTargetPath: "/home/agent/.codex/config.toml",
-    buildConfig(mcp) {
+    buildConfig(mcp, opts) {
+        // Codex reads model/effort from config.toml (regenerated per container,
+        // excluded from snapshots). Generic "max" maps to Codex's "xhigh".
+        const effort = opts?.effort === "max" ? "xhigh" : (opts?.effort ?? undefined);
         return [
             "# Generated by ForgeAI — do not edit",
             "# The Docker container is the security boundary; Codex's own sandbox is disabled.",
             'approval_policy = "never"',
             'sandbox_mode = "danger-full-access"',
+            ...(opts?.model ? [`model = ${tomlString(opts.model)}`] : []),
+            ...(effort ? [`model_reasoning_effort = ${tomlString(effort)}`] : []),
             "",
             "[mcp_servers.forgeai]",
             'command = "node"',
@@ -204,11 +243,26 @@ const openCodeProfile = {
             },
         }, null, 2);
     },
-    buildArgs(prompt) {
-        return ["run", "--format", "json", prompt];
+    buildArgs(prompt, opts) {
+        const variant = mapEffortToVariant(openCodeModelVendor(opts?.model), opts?.effort);
+        return [
+            "run",
+            ...(variant ? ["--variant", variant] : []),
+            "--format",
+            "json",
+            prompt,
+        ];
     },
-    buildContinueArgs(prompt) {
-        return ["run", "--continue", "--format", "json", prompt];
+    buildContinueArgs(prompt, opts) {
+        const variant = mapEffortToVariant(openCodeModelVendor(opts?.model), opts?.effort);
+        return [
+            "run",
+            "--continue",
+            ...(variant ? ["--variant", variant] : []),
+            "--format",
+            "json",
+            prompt,
+        ];
     },
     spawnEnv: { OPENCODE_PERMISSION: OPENCODE_PERMISSION_JSON },
     // OpenCode reads .claude/skills natively (OPENCODE_DISABLE_CLAUDE_CODE_SKILLS opts out)
@@ -268,14 +322,31 @@ const kiloProfile = {
             },
         }, null, 2);
     },
-    buildArgs(prompt) {
+    buildArgs(prompt, opts) {
         // --auto: auto-approve permissions (headless runs REJECT asks otherwise).
         // Spawn must close stdin: with a non-TTY open stdin, `kilo run` blocks
         // reading it to EOF before sending the prompt (Bun.stdin.text()).
-        return ["run", "--auto", "--format", "json", prompt];
+        const variant = mapEffortToVariant(kiloModelVendor(opts?.model), opts?.effort);
+        return [
+            "run",
+            "--auto",
+            ...(variant ? ["--variant", variant] : []),
+            "--format",
+            "json",
+            prompt,
+        ];
     },
-    buildContinueArgs(prompt) {
-        return ["run", "--continue", "--auto", "--format", "json", prompt];
+    buildContinueArgs(prompt, opts) {
+        const variant = mapEffortToVariant(kiloModelVendor(opts?.model), opts?.effort);
+        return [
+            "run",
+            "--continue",
+            "--auto",
+            ...(variant ? ["--variant", variant] : []),
+            "--format",
+            "json",
+            prompt,
+        ];
     },
     spawnEnv: {
         KILO_PERMISSION: KILO_PERMISSION_JSON,

package/dist/orchestrator/agent-spawner.d.ts

@@ -30,6 +30,10 @@ export declare const TaskDispatchSchema: z.ZodObject<{
     projectSlug: z.ZodOptional<z.ZodString>;
     repoUrl: z.ZodOptional<z.ZodString>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    modelConfig: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        effort: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type DispatchParams = z.infer<typeof TaskDispatchSchema> & {
     orgId: string;

package/dist/orchestrator/agent-spawner.js

@@ -68,6 +68,13 @@ export const TaskDispatchSchema = z.object({
     projectSlug: z.string().optional(),
     repoUrl: z.string().optional(),
     metadata: z.record(z.string(), z.unknown()).optional(),
+    /** Cloud-resolved model/effort for this dispatch (ResolvedModelConfig). */
+    modelConfig: z
+        .object({
+        model: z.string().optional(),
+        effort: z.string().optional(),
+    })
+        .optional(),
 });
 let registry = null;
 function getRegistry(agentSlots) {
@@ -641,6 +648,7 @@ export async function spawnAgent(params, ctx) {
             skillName: skill?.name ?? skillName,
             prompt: params.taskCommand,
             agentType: ctx.agentType,
+            modelConfig: params.modelConfig,
             repoUrl: params.repoUrl,
             taskBranch,
             workflowBaseBranch: params.workflowBaseBranch,
@@ -1010,6 +1018,7 @@ async function spawnWorkflowStepAgent(params, ctx) {
             skillName: skill?.name ?? skillName,
             prompt,
             agentType: ctx.agentType,
+            modelConfig: params.modelConfig,
             repoUrl: params.repoUrl,
             taskBranch: params.baseBranch,
             workflowBaseBranch: params.sourceBranch,
@@ -1278,6 +1287,7 @@ async function resumeWorkflowStepAgent(agentId, userMessage, lastAssistantConten
             skillName: DEFAULT_SKILL_NAME,
             prompt: userMessage,
             agentType: ctx.agentType,
+            modelConfig: originalParams.modelConfig,
             repoUrl: originalParams.repoUrl,
             taskBranch: originalParams.baseBranch,
             workflowBaseBranch: originalParams.sourceBranch,
@@ -1446,6 +1456,7 @@ export function registerWorkflowStepDispatchHandler(socket, orgId, ctx) {
             sourceBranch: data.sourceBranch,
             conversationHistory: data.conversationHistory,
             hasSnapshot: data.hasSnapshot,
+            modelConfig: data.modelConfig,
         }, ctx).catch((err) => {
             try {
                 vmLog.error("workflow-dispatch", `Failed to spawn agent for step ${data.stepId}: ${err instanceof Error ? err.message : String(err)}`);

package/dist/orchestrator/connectors/connector.d.ts

@@ -27,6 +27,14 @@ export type SpawnParams = {
     prompt?: string;
     /** Agent engine to run (AGENT_TYPE) — defaults to CLAUDE_CODE. */
     agentType?: string;
+    /**
+     * Cloud-resolved model/effort for this dispatch (column -> project -> org).
+     * Absent → the device's local default model applies.
+     */
+    modelConfig?: {
+        model?: string;
+        effort?: string;
+    };
 };
 /**
  * Extended spawn params for VM connector — includes repo/branch/skill context

package/dist/orchestrator/connectors/docker-connector.js

@@ -39,10 +39,26 @@ async function resolveMcpRelayHost() {
  * and authenticates to the bridge with the per-session secret.
  * Format and install path depend on the agent engine (see agent-profiles.ts).
  */
-function buildAgentConfig(profile, sessionIndex, mcpSecret, mcpHost) {
+/**
+ * Effective model/effort for a spawn: the cloud-resolved dispatch config wins,
+ * else the device's local default (first declared model for the engine, with
+ * the legacy per-engine model settings as fallback).
+ */
+function resolveEffectiveModelConfig(profile, dispatch) {
     const cliConfig = getConfig();
-    const model = profile.type === "KILO" ? cliConfig.kiloModel : cliConfig.opencodeModel;
-    return profile.buildConfig({ host: mcpHost, port: 20000 + sessionIndex, token: mcpSecret }, { model });
+    const declared = cliConfig.availableModels?.[profile.type];
+    const legacyDefault = profile.type === "KILO"
+        ? cliConfig.kiloModel
+        : profile.type === "OPENCODE"
+            ? cliConfig.opencodeModel
+            : undefined;
+    return {
+        model: dispatch?.model ?? declared?.[0] ?? legacyDefault,
+        effort: dispatch?.effort,
+    };
+}
+function buildAgentConfig(profile, sessionIndex, mcpSecret, mcpHost, modelOpts) {
+    return profile.buildConfig({ host: mcpHost, port: 20000 + sessionIndex, token: mcpSecret }, modelOpts);
 }
 /**
  * Bash script installing the staged config + context files into the container.
@@ -143,9 +159,13 @@ export const dockerConnector = {
                     });
                 }
             }
+            // Effective model/effort: dispatch-resolved wins, else device default.
+            // Pinned on the session so same-container resumes stay consistent.
+            const modelOpts = resolveEffectiveModelConfig(profile, params.modelConfig);
+            session.modelConfig = modelOpts;
             sm.prepareWorkspace(sessionId, {
                 contextJson: JSON.stringify(params.taskContext ?? {}, null, 2),
-                mcpConfigJson: buildAgentConfig(profile, session.sessionIndex, session.mcpSecret, await resolveMcpRelayHost()),
+                mcpConfigJson: buildAgentConfig(profile, session.sessionIndex, session.mcpSecret, await resolveMcpRelayHost(), modelOpts),
                 skillFiles,
             });
             // 5. Copy workspace files from volume mount into place inside container
@@ -175,7 +195,7 @@ export const dockerConnector = {
             const prompt = params.prompt
                 ? appendSkillPointer(params.prompt, profile, params.skill?.name)
                 : buildDefaultPrompt(params.skillName);
-            const agentArgs = profile.buildArgs(prompt);
+            const agentArgs = profile.buildArgs(prompt, modelOpts);
             const env = {};
             vmLog.magenta("docker-connector", `Spawning ${profile.type} agent in container ${sessionId}`, sessionId);
             const proxy = await sm.spawnAgent(params.taskId, profile.binary, agentArgs, env, profile.type);
@@ -232,12 +252,17 @@ export const dockerConnector = {
             vmLog.cyan("docker-connector", `Resuming ${profile.type} in existing container ${session.id}`, session.id);
             // Restart MCP bridge (stopped on previous agent exit)
             await startSessionMcpBridge(session, params);
+            // Session continuity: reuse the model/effort the session was
+            // provisioned with (config file was generated for it) — a mid-session
+            // demand change applies from the next fresh container.
+            const modelOpts = session.modelConfig ??
+                resolveEffectiveModelConfig(profile, params.modelConfig);
             // Continue the on-disk session for workflow resume in the existing
             // container (full context)
             if (params.workflowContext) {
                 const continuePrompt = params.prompt ??
                     "Continue your work from where you left off. Do not repeat completed work.";
-                const agentArgs = profile.buildContinueArgs(continuePrompt);
+                const agentArgs = profile.buildContinueArgs(continuePrompt, modelOpts);
                 const proxy = await sm.spawnAgent(params.taskId, profile.binary, agentArgs, {}, profile.type);
                 // Keep container alive for next idle window cycle
                 proxy.once("exit", () => {
@@ -253,7 +278,7 @@ export const dockerConnector = {
             // Board task resume: continue with user's answer (container alive from ask-human)
             const resumePrompt = ctx?.response ?? "Continue your work.";
             await startSessionMcpBridge(session, params);
-            const agentArgs = profile.buildContinueArgs(resumePrompt);
+            const agentArgs = profile.buildContinueArgs(resumePrompt, modelOpts);
             const proxy = await sm.spawnAgent(params.taskId, profile.binary, agentArgs, {}, profile.type);
             return {
                 pid: proxy.pid,
@@ -299,9 +324,13 @@ export const dockerConnector = {
                     });
                 }
             }
+            // Fresh container: the current demand applies (dispatch-resolved or
+            // device default), pinned for subsequent same-container resumes.
+            const modelOpts = resolveEffectiveModelConfig(profile, params.modelConfig);
+            session.modelConfig = modelOpts;
             sm.prepareWorkspace(sessionId, {
                 contextJson: JSON.stringify(params.taskContext ?? {}, null, 2),
-                mcpConfigJson: buildAgentConfig(profile, session.sessionIndex, session.mcpSecret, await resolveMcpRelayHost()),
+                mcpConfigJson: buildAgentConfig(profile, session.sessionIndex, session.mcpSecret, await resolveMcpRelayHost(), modelOpts),
                 skillFiles,
             });
             await sm.exec(params.taskId, "bash", [
@@ -331,14 +360,14 @@ export const dockerConnector = {
                 vmLog.cyan("docker-connector", `Spawning ${profile.type} continue (snapshot restored) in ${sessionId}`, sessionId);
                 const continuePrompt = params.prompt ??
                     "Continue your work from where you left off. Do not repeat completed work.";
-                proxy = await sm.spawnAgent(params.taskId, profile.binary, profile.buildContinueArgs(continuePrompt), {}, profile.type);
+                proxy = await sm.spawnAgent(params.taskId, profile.binary, profile.buildContinueArgs(continuePrompt, modelOpts), {}, profile.type);
             }
             else {
                 vmLog.warn("docker-connector", `Snapshot restore failed — falling back to prompt in ${sessionId}`, sessionId);
                 const prompt = params.prompt
                     ? appendSkillPointer(params.prompt, profile, params.skill?.name)
                     : buildDefaultPrompt(params.skillName);
-                proxy = await sm.spawnAgent(params.taskId, profile.binary, profile.buildArgs(prompt), {}, profile.type);
+                proxy = await sm.spawnAgent(params.taskId, profile.binary, profile.buildArgs(prompt, modelOpts), {}, profile.type);
             }
             // Workflow: keep container alive for idle window
             proxy.once("exit", () => {

package/dist/orchestrator/resume-handler.d.ts

@@ -16,6 +16,11 @@ export type ResumePayload = {
     projectSlug?: string;
     taskBranch?: string;
     repoUrl?: string;
+    /** Cloud-resolved model/effort for this resume dispatch. */
+    modelConfig?: {
+        model?: string;
+        effort?: string;
+    };
 };
 export type ResumeContext = {
     restClient: ReturnType<typeof createRestClient>;

package/dist/orchestrator/resume-handler.js

@@ -28,6 +28,13 @@ function enqueueWhenNoCapacity(payload, ctx) {
             orgId: payload.orgId,
             taskSlug: payload.taskSlug,
             projectSlug: payload.projectSlug,
+            skillSlug: payload.skillSlug,
+            taskCommand: payload.taskCommand,
+            repoUrl: payload.repoUrl,
+            taskBranch: payload.taskBranch,
+            // Keep the cloud-resolved model/effort — a queued resume must not
+            // respawn with the device's local default instead of the demand.
+            modelConfig: payload.modelConfig,
         });
     }
     ctx.socketClient.emitAgentStatus({
@@ -106,6 +113,7 @@ export async function handleResume(payload, ctx) {
             skillName: skill?.name ?? resumeSkillName,
             prompt: validatedPayload.taskCommand,
             agentType: ctx.agentType,
+            modelConfig: validatedPayload.modelConfig,
             repoUrl: payload.repoUrl,
             taskBranch,
             skill: skill ? { name: skill.name, files: skill.files } : undefined,

package/dist/vm/agent-auth-manager.d.ts

@@ -24,6 +24,14 @@ export type AgentAuthPayload = {
 };
 /** Container path where each engine expects its auth.json. */
 export declare const AGENT_AUTH_JSON_PATHS: Record<AuthAgent, string>;
+/**
+ * Default provider env var when an api_key payload carries no explicit envVar.
+ * (Codex api keys go through `codex login --with-api-key`, never an env var.)
+ */
+export declare const AGENT_API_KEY_DEFAULT_ENV: {
+    readonly OPENCODE: "ANTHROPIC_API_KEY";
+    readonly KILO: "KILO_API_KEY";
+};
 /** Host path each engine's own CLI stores its auth.json at (for import). */
 export declare function getHostAuthJsonPath(agent: AuthAgent): string;
 export declare function saveAgentAuth(agent: AuthAgent, payload: AgentAuthPayload): Promise<void>;

package/dist/vm/agent-auth-manager.js

@@ -43,6 +43,14 @@ export const AGENT_AUTH_JSON_PATHS = {
     OPENCODE: "/home/agent/.local/share/opencode/auth.json",
     KILO: "/home/agent/.local/share/kilo/auth.json",
 };
+/**
+ * Default provider env var when an api_key payload carries no explicit envVar.
+ * (Codex api keys go through `codex login --with-api-key`, never an env var.)
+ */
+export const AGENT_API_KEY_DEFAULT_ENV = {
+    OPENCODE: "ANTHROPIC_API_KEY",
+    KILO: "KILO_API_KEY",
+};
 /** Host path each engine's own CLI stores its auth.json at (for import). */
 export function getHostAuthJsonPath(agent) {
     switch (agent) {

package/dist/vm/session-manager.d.ts

@@ -39,6 +39,15 @@ export type SessionState = {
      * in the meantime.
      */
     agentType?: string;
+    /**
+     * Model/effort the container was provisioned with (its config file was
+     * generated for them). Same-container resumes reuse it for continuity; a
+     * demand change applies from the next fresh container.
+     */
+    modelConfig?: {
+        model?: string;
+        effort?: string;
+    };
     /**
      * Git credential for this session's repo, resolved from the host credential
      * helper at clone time. Kept in memory only (never written to disk or

package/dist/vm/session-manager.js

@@ -24,7 +24,7 @@ import { gitCredentialConfigArgs, gitCredentialSecretEnv, } from "./git-credenti
 import { ensureImage, FORGEAI_IMAGE } from "./image-manager.js";
 import { vmLog } from "./log.js";
 import { ensureClaudeToken } from "./claude-token-manager.js";
-import { AGENT_AUTH_JSON_PATHS, loadAgentAuth, } from "./agent-auth-manager.js";
+import { AGENT_API_KEY_DEFAULT_ENV, AGENT_AUTH_JSON_PATHS, loadAgentAuth, } from "./agent-auth-manager.js";
 import { getAgentProfile, resolveAgentType, } from "../orchestrator/agent-profiles.js";
 // ---------------------------------------------------------------------------
 // Paths
@@ -361,14 +361,16 @@ export class SessionManager {
         if (agentType === "OPENCODE") {
             const auth = await this.getAgentAuth("OPENCODE");
             if (auth.kind === "api_key") {
-                return { [auth.envVar ?? "ANTHROPIC_API_KEY"]: auth.value };
+                return {
+                    [auth.envVar ?? AGENT_API_KEY_DEFAULT_ENV.OPENCODE]: auth.value,
+                };
             }
         }
         if (agentType === "KILO") {
             const auth = await this.getAgentAuth("KILO");
             if (auth.kind === "api_key") {
                 // Kilo gateway key (app.kilo.ai profile) — read at request time
-                return { [auth.envVar ?? "KILO_API_KEY"]: auth.value };
+                return { [auth.envVar ?? AGENT_API_KEY_DEFAULT_ENV.KILO]: auth.value };
             }
         }
         return {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getforgeai/cli",
-  "version": "0.1.0-beta.5",
+  "version": "0.1.0-beta.7",
   "description": "ForgeAI CLI — runs AI coding agents in local Docker containers with your own AI tokens, and connects them to the ForgeAI cockpit.",
   "license": "Apache-2.0",
   "type": "module",
@@ -47,7 +47,7 @@
     "ora": "^8.2.0",
     "socket.io-client": "^4.8.3",
     "zod": "^4.3.6",
-    "@getforgeai/protocol": "0.1.0-beta.3"
+    "@getforgeai/protocol": "0.1.0-beta.5"
   },
   "devDependencies": {
     "@types/node": "^25.0.2",