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

package/dist/cli.js

@@ -20,7 +20,7 @@ import { sessionRespondAction } from "./commands/session-respond.js";
 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, setupOpenCodeAuthAction, } from "./commands/auth-setup-agent.js";
+import { setupCodexAuthAction, setupKiloAuthAction, setupOpenCodeAuthAction, } from "./commands/auth-setup-agent.js";
 const program = new Command();
 program
     .name("forge")
@@ -55,6 +55,10 @@ authCmd
     .command("setup-opencode")
     .description("Store OpenCode credentials (import opencode login or provider API key)")
     .action(() => setupOpenCodeAuthAction());
+authCmd
+    .command("setup-kilo")
+    .description("Store Kilo credentials (import kilo login or gateway API key)")
+    .action(() => setupKiloAuthAction());
 program
     .command("connect")
     .description("Connect to ForgeAI Cloud (spawns background daemon by default)")
@@ -123,7 +127,7 @@ const configSetCmd = configCmd
     .description("Set a configuration value");
 configSetCmd
     .command("agent-type <value>")
-    .description("Set agent type (CLAUDE_CODE, CODEX or OPENCODE)")
+    .description("Set agent type (CLAUDE_CODE, CODEX, OPENCODE or KILO)")
     .action((value) => configSetAgentTypeAction(value));
 configSetCmd
     .command("agent-slots <value>")

package/dist/commands/auth-setup-agent.d.ts

@@ -11,5 +11,6 @@
  * encrypted file elsewhere) and injected into agent containers at spawn.
  */
 export declare function setupCodexAuthAction(): Promise<void>;
+export declare function setupKiloAuthAction(): Promise<void>;
 export declare function setupOpenCodeAuthAction(): Promise<void>;
 //# sourceMappingURL=auth-setup-agent.d.ts.map

package/dist/commands/auth-setup-agent.js

@@ -59,6 +59,36 @@ export async function setupCodexAuthAction() {
         process.exit(1);
     }
 }
+export async function setupKiloAuthAction() {
+    try {
+        const imported = await tryImportHostAuthJson("KILO");
+        if (!imported) {
+            console.log(chalk.dim("No Kilo login found to import. You can paste a Kilo gateway API key instead\n" +
+                "(from your profile at app.kilo.ai — or run `kilo auth login` first, then\n" +
+                "re-run this command to import it)."));
+            const key = await ask("Kilo API key: ");
+            if (!key) {
+                console.error(chalk.red("No API key provided."));
+                process.exit(1);
+            }
+            await saveAgentAuth("KILO", {
+                kind: "api_key",
+                envVar: "KILO_API_KEY",
+                value: key,
+            });
+            console.log(chalk.green("Kilo API key stored. Agents can now authenticate."));
+        }
+        const model = await ask("Kilo model (e.g. kilo/anthropic/claude-sonnet-4.5) — leave empty for Kilo's default: ");
+        if (model) {
+            setConfig({ kiloModel: model });
+            console.log(chalk.green(`Kilo model set to ${model}.`));
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+    }
+}
 const OPENCODE_PROVIDER_ENV_VARS = {
     anthropic: "ANTHROPIC_API_KEY",
     openai: "OPENAI_API_KEY",

package/dist/commands/config-set.js

@@ -7,6 +7,7 @@ const VALID_OPENERS = ["terminal", "vscode", "finder"];
 const AGENT_AUTH_SETUP_HINTS = {
     CODEX: "forge auth setup-codex",
     OPENCODE: "forge auth setup-opencode",
+    KILO: "forge auth setup-kilo",
 };
 export async function configSetAgentTypeAction(value) {
     const upper = value.toUpperCase();
@@ -51,6 +52,9 @@ export function configGetAction() {
     if (config.agentType === "OPENCODE") {
         console.log(`  OpenCode model: ${config.opencodeModel ?? "(OpenCode default)"}`);
     }
+    if (config.agentType === "KILO") {
+        console.log(`  Kilo model:  ${config.kiloModel ?? "(Kilo default)"}`);
+    }
     console.log(`  Agent slots: ${config.agentSlots ?? 5}`);
     console.log(`  Opener:      ${config.opener ?? "terminal"}`);
     console.log(`  Server URL:  ${config.serverUrl}`);

package/dist/commands/connect.js

@@ -123,14 +123,14 @@ async function connectForeground(options) {
     if (!ctx)
         return;
     // Ensure agent credentials are available for container authentication
-    if (ctx.agentType === "CODEX" || ctx.agentType === "OPENCODE") {
+    if (ctx.agentType === "CODEX" ||
+        ctx.agentType === "OPENCODE" ||
+        ctx.agentType === "KILO") {
         try {
             const { hasAgentAuth } = await import("../vm/agent-auth-manager.js");
             if (!(await hasAgentAuth(ctx.agentType))) {
-                const setupCmd = ctx.agentType === "CODEX"
-                    ? "forge auth setup-codex"
-                    : "forge auth setup-opencode";
-                console.warn(chalk.yellow(`[connect] No ${ctx.agentType} credentials stored. Agents may fail to authenticate. Run: ${setupCmd}`));
+                const { getAgentProfile } = await import("../orchestrator/agent-profiles.js");
+                console.warn(chalk.yellow(`[connect] No ${ctx.agentType} credentials stored. Agents may fail to authenticate. Run: ${getAgentProfile(ctx.agentType).authSetupHint}`));
             }
         }
         catch {

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

@@ -13,6 +13,8 @@ export type CliConfig = {
     agentType?: string;
     /** OpenCode model in "provider/model" form (used when agentType is OPENCODE). */
     opencodeModel?: string;
+    /** Kilo model, e.g. "kilo/anthropic/claude-sonnet-4.5" (used when agentType is KILO). */
+    kiloModel?: string;
     agentSlots?: number;
     opener?: Opener;
     lastSyncCursor?: string;

package/dist/lib/daemon-entry.js

@@ -18,14 +18,14 @@ if (!ctx) {
 }
 // Check agent credential availability for the configured engine
 try {
-    if (ctx.agentType === "CODEX" || ctx.agentType === "OPENCODE") {
+    if (ctx.agentType === "CODEX" ||
+        ctx.agentType === "OPENCODE" ||
+        ctx.agentType === "KILO") {
         const { hasAgentAuth } = await import("../vm/agent-auth-manager.js");
         if (!(await hasAgentAuth(ctx.agentType))) {
-            const setupCmd = ctx.agentType === "CODEX"
-                ? "forge auth setup-codex"
-                : "forge auth setup-opencode";
+            const { getAgentProfile } = await import("../orchestrator/agent-profiles.js");
             console.warn(chalk.yellow(`[daemon] No ${ctx.agentType} credentials stored — agents will fail to authenticate.`));
-            console.warn(chalk.yellow(`[daemon] Run: ${setupCmd}`));
+            console.warn(chalk.yellow(`[daemon] Run: ${getAgentProfile(ctx.agentType).authSetupHint}`));
         }
     }
     else {

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

@@ -9,6 +9,10 @@
  * | CLAUDE_CODE | claude     | /session/workspace/.claude/mcp_config.json (via --mcp-config) | --continue |
  * | CODEX       | codex      | /home/agent/.codex/config.toml           | exec resume --last |
  * | OPENCODE    | opencode   | /home/agent/.config/opencode/opencode.json | run --continue |
+ * | KILO        | kilo       | /home/agent/.config/kilo/kilo.json       | run --continue |
+ *
+ * KILO (kilo.ai) is an OpenCode fork: same config shape, same JSONL event
+ * stream (so it shares OpenCodeJsonlExtractor), Kilo gateway auth on top.
  */
 import type { AgentType } from "@getforgeai/protocol";
 import type { AgentStreamExtractor, QuestionData, ToolActivityData, TokenUsageData } from "./stream-json-extractor.js";
@@ -18,7 +22,12 @@ export type McpBridgeConfig = {
     token: string;
 };
 export type AgentConfigOptions = {
-    /** OpenCode model in "provider/model" form (from CLI config, optional). */
+    /**
+     * 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?: string;
 };
 export type AgentAuthErrorPatterns = {
@@ -45,6 +54,12 @@ export type AgentProfile = {
     buildContinueArgs(prompt: string): string[];
     /** Non-secret env vars added to every agent spawn. */
     spawnEnv: Record<string, string>;
+    /**
+     * Whether the engine discovers skills deposited in .claude/skills on its
+     * own (Claude Code and OpenCode do). When false, prompts must carry an
+     * explicit pointer to the SKILL.md — see appendSkillPointer().
+     */
+    nativeSkillDiscovery: boolean;
     /** Container dir holding the session state snapshotted for resume. */
     stateDir: string;
     /** tar --exclude patterns — credentials and cache junk never leave the container. */
@@ -55,6 +70,15 @@ export type AgentProfile = {
 };
 /** Narrow an arbitrary config/dispatch string to a supported AgentType. */
 export declare function resolveAgentType(value: string | undefined): AgentType;
+/**
+ * Make sure a cloud-provided prompt still leads the agent to the deposited
+ * skill. Cloud task/step commands (e.g. "forge_merge_back") replace the
+ * default prompt that pointed at the SKILL.md; engines with native skill
+ * discovery find the skill anyway, but Codex would otherwise never learn the
+ * skill exists. No-op when the engine discovers skills natively or when no
+ * skill was deposited.
+ */
+export declare function appendSkillPointer(prompt: string, profile: AgentProfile, skillName: string | undefined): string;
 export declare function getAgentProfile(agentType: string | undefined): AgentProfile;
 /**
  * Instantiate the stream extractor matching the agent engine.

package/dist/orchestrator/agent-profiles.js

@@ -9,6 +9,10 @@
  * | CLAUDE_CODE | claude     | /session/workspace/.claude/mcp_config.json (via --mcp-config) | --continue |
  * | CODEX       | codex      | /home/agent/.codex/config.toml           | exec resume --last |
  * | OPENCODE    | opencode   | /home/agent/.config/opencode/opencode.json | run --continue |
+ * | KILO        | kilo       | /home/agent/.config/kilo/kilo.json       | run --continue |
+ *
+ * KILO (kilo.ai) is an OpenCode fork: same config shape, same JSONL event
+ * stream (so it shares OpenCodeJsonlExtractor), Kilo gateway auth on top.
  */
 import { DEFAULT_AGENT_TYPE, isAgentType } from "@getforgeai/protocol";
 import { CodexJsonlExtractor } from "./codex-jsonl-extractor.js";
@@ -20,6 +24,19 @@ export function resolveAgentType(value) {
         return value;
     return DEFAULT_AGENT_TYPE;
 }
+/**
+ * Make sure a cloud-provided prompt still leads the agent to the deposited
+ * skill. Cloud task/step commands (e.g. "forge_merge_back") replace the
+ * default prompt that pointed at the SKILL.md; engines with native skill
+ * discovery find the skill anyway, but Codex would otherwise never learn the
+ * skill exists. No-op when the engine discovers skills natively or when no
+ * skill was deposited.
+ */
+export function appendSkillPointer(prompt, profile, skillName) {
+    if (profile.nativeSkillDiscovery || !skillName)
+        return prompt;
+    return `${prompt}\n\nThe "${skillName}" skill at .claude/skills/${skillName}/SKILL.md describes the procedure to follow — read it before starting.`;
+}
 // ---------------------------------------------------------------------------
 // Claude Code
 // ---------------------------------------------------------------------------
@@ -60,6 +77,7 @@ const claudeProfile = {
         return ["--continue", ...this.buildArgs(prompt)];
     },
     spawnEnv: {},
+    nativeSkillDiscovery: true,
     stateDir: "/home/agent/.claude",
     snapshotExcludes: [
         "settings.json",
@@ -132,6 +150,7 @@ const codexProfile = {
         ];
     },
     spawnEnv: {},
+    nativeSkillDiscovery: false,
     stateDir: "/home/agent/.codex",
     snapshotExcludes: ["auth.json", "config.toml", "log"],
     authErrorPatterns: {
@@ -192,6 +211,8 @@ const openCodeProfile = {
         return ["run", "--continue", "--format", "json", prompt];
     },
     spawnEnv: { OPENCODE_PERMISSION: OPENCODE_PERMISSION_JSON },
+    // OpenCode reads .claude/skills natively (OPENCODE_DISABLE_CLAUDE_CODE_SKILLS opts out)
+    nativeSkillDiscovery: true,
     stateDir: "/home/agent/.local/share/opencode",
     snapshotExcludes: ["auth.json", "log", "bin", "cache"],
     authErrorPatterns: {
@@ -207,12 +228,88 @@ const openCodeProfile = {
     authSetupHint: "forge auth setup-opencode",
 };
 // ---------------------------------------------------------------------------
+// Kilo (kilo.ai — OpenCode fork with the Kilo gateway on top)
+// ---------------------------------------------------------------------------
+/**
+ * Permission override merged over any config (KILO_PERMISSION env is merged
+ * over file config), so a repo-level kilo.json can never re-introduce "ask"
+ * prompts. Belt to the --auto flag's suspenders.
+ */
+const KILO_PERMISSION_JSON = JSON.stringify({
+    "*": "allow",
+    external_directory: { "**": "allow" },
+});
+const kiloProfile = {
+    type: "KILO",
+    binary: "kilo",
+    configTargetPath: "/home/agent/.config/kilo/kilo.json",
+    buildConfig(mcp, opts) {
+        return JSON.stringify({
+            $schema: "https://app.kilo.ai/config.json",
+            ...(opts?.model ? { model: opts.model } : {}),
+            permission: {
+                "*": "allow",
+                external_directory: { "**": "allow" },
+            },
+            // Headless container hygiene: no auto-upgrade, no product telemetry
+            autoupdate: false,
+            experimental: { openTelemetry: false },
+            mcp: {
+                forgeai: {
+                    type: "local",
+                    command: ["node", "/session/forge-mcp-relay.mjs"],
+                    environment: {
+                        FORGEAI_MCP_HOST: mcp.host,
+                        FORGEAI_MCP_PORT: String(mcp.port),
+                        FORGEAI_MCP_TOKEN: mcp.token,
+                    },
+                    enabled: true,
+                },
+            },
+        }, null, 2);
+    },
+    buildArgs(prompt) {
+        // --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];
+    },
+    buildContinueArgs(prompt) {
+        return ["run", "--continue", "--auto", "--format", "json", prompt];
+    },
+    spawnEnv: {
+        KILO_PERMISSION: KILO_PERMISSION_JSON,
+        KILO_DISABLE_AUTOUPDATE: "1",
+        KILO_TELEMETRY_LEVEL: "off",
+    },
+    // Kilo scans .claude/skills/**/SKILL.md natively (OpenCode heritage)
+    nativeSkillDiscovery: true,
+    // Sessions live in SQLite (kilo.db + -wal/-shm) keyed to the project dir
+    stateDir: "/home/agent/.local/share/kilo",
+    snapshotExcludes: ["auth.json", "mcp-auth.json", "log", "repos", "bin"],
+    authErrorPatterns: {
+        // Kilo surfaces auth failures as error events from the gateway/provider —
+        // it never prints "Not logged in" on the run path, and env-var names in
+        // the stdout tail would be tool-output false positives (ForgeAI itself
+        // injects KILO_API_KEY). Keep only API-error-shaped tokens.
+        stderr: [],
+        combined: [
+            '"authentication_error"',
+            "invalid_api_key",
+            "Incorrect API key",
+            "AuthError",
+        ],
+    },
+    authSetupHint: "forge auth setup-kilo",
+};
+// ---------------------------------------------------------------------------
 // Registry
 // ---------------------------------------------------------------------------
 const PROFILES = {
     CLAUDE_CODE: claudeProfile,
     CODEX: codexProfile,
     OPENCODE: openCodeProfile,
+    KILO: kiloProfile,
 };
 export function getAgentProfile(agentType) {
     return PROFILES[resolveAgentType(agentType)];
@@ -228,6 +325,9 @@ export function createStreamExtractor(agentType, onText, onQuestion, onToolActiv
         case "CODEX":
             return new CodexJsonlExtractor(onText, onQuestion, onToolActivity, onTokenUsage, sessionId);
         case "OPENCODE":
+        // Kilo is an OpenCode fork emitting the same JSONL event stream
+        // (text/tool_use/step_start/step_finish/error with sessionID + part).
+        case "KILO":
             return new OpenCodeJsonlExtractor(onText, onQuestion, onToolActivity, onTokenUsage, sessionId);
         default:
             return new StreamJsonExtractor(onText, onQuestion, onToolActivity, onTokenUsage, sessionId);

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

@@ -16,7 +16,7 @@ import { getDockerBridgeGatewayIp } from "../../vm/docker-executor.js";
 import { activeConnections } from "../../lib/connection-manager.js";
 import { vmLog } from "../../vm/log.js";
 import { getConfig } from "../../config/config-manager.js";
-import { getAgentProfile } from "../agent-profiles.js";
+import { appendSkillPointer, getAgentProfile } from "../agent-profiles.js";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -40,7 +40,9 @@ async function resolveMcpRelayHost() {
  * Format and install path depend on the agent engine (see agent-profiles.ts).
  */
 function buildAgentConfig(profile, sessionIndex, mcpSecret, mcpHost) {
-    return profile.buildConfig({ host: mcpHost, port: 20000 + sessionIndex, token: mcpSecret }, { model: getConfig().opencodeModel });
+    const cliConfig = getConfig();
+    const model = profile.type === "KILO" ? cliConfig.kiloModel : cliConfig.opencodeModel;
+    return profile.buildConfig({ host: mcpHost, port: 20000 + sessionIndex, token: mcpSecret }, { model });
 }
 /**
  * Bash script installing the staged config + context files into the container.
@@ -168,8 +170,11 @@ export const dockerConnector = {
             await sm.materializeAgentAuth(params.taskId, profile.type);
             // 7. Start MCP bridge (TCP server on host for forge-mcp-relay in container)
             await startSessionMcpBridge(session, params);
-            // 8. Spawn agent
-            const prompt = params.prompt ?? buildDefaultPrompt(params.skillName);
+            // 8. Spawn agent. Cloud-provided prompts get a pointer to the deposited
+            // skill when the engine has no native skill discovery (Codex).
+            const prompt = params.prompt
+                ? appendSkillPointer(params.prompt, profile, params.skill?.name)
+                : buildDefaultPrompt(params.skillName);
             const agentArgs = profile.buildArgs(prompt);
             const env = {};
             vmLog.magenta("docker-connector", `Spawning ${profile.type} agent in container ${sessionId}`, sessionId);
@@ -330,7 +335,9 @@ export const dockerConnector = {
             }
             else {
                 vmLog.warn("docker-connector", `Snapshot restore failed — falling back to prompt in ${sessionId}`, sessionId);
-                const prompt = params.prompt ?? buildDefaultPrompt(params.skillName);
+                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);
             }
             // Workflow: keep container alive for idle window

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

@@ -13,7 +13,7 @@
  * Storage: macOS Keychain / encrypted file via secure-store.ts. The payload
  * is stored as a JSON string.
  */
-export type AuthAgent = "CODEX" | "OPENCODE";
+export type AuthAgent = "CODEX" | "OPENCODE" | "KILO";
 export type AgentAuthPayload = {
     kind: "api_key";
     value: string;

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

@@ -30,17 +30,29 @@ const STORE_LOCATIONS = {
         fileName: "opencode-auth.json",
         fileSalt: "forgeai-opencode-auth-salt",
     },
+    KILO: {
+        keychainService: "ForgeAI-kilo-auth",
+        keychainAccount: "kilo-auth",
+        fileName: "kilo-auth.json",
+        fileSalt: "forgeai-kilo-auth-salt",
+    },
 };
 /** Container path where each engine expects its auth.json. */
 export const AGENT_AUTH_JSON_PATHS = {
     CODEX: "/home/agent/.codex/auth.json",
     OPENCODE: "/home/agent/.local/share/opencode/auth.json",
+    KILO: "/home/agent/.local/share/kilo/auth.json",
 };
 /** Host path each engine's own CLI stores its auth.json at (for import). */
 export function getHostAuthJsonPath(agent) {
-    return agent === "CODEX"
-        ? join(homedir(), ".codex", "auth.json")
-        : join(homedir(), ".local", "share", "opencode", "auth.json");
+    switch (agent) {
+        case "CODEX":
+            return join(homedir(), ".codex", "auth.json");
+        case "OPENCODE":
+            return join(homedir(), ".local", "share", "opencode", "auth.json");
+        case "KILO":
+            return join(homedir(), ".local", "share", "kilo", "auth.json");
+    }
 }
 export async function saveAgentAuth(agent, payload) {
     await saveSecret(STORE_LOCATIONS[agent], JSON.stringify(payload));

package/dist/vm/session-manager.js

@@ -318,6 +318,11 @@ export class SessionManager {
             secretEnv: await this.getAgentSecretEnv(resolveAgentType(agentType)),
             user: "agent",
         });
+        // Agents run one-shot and never receive stdin input. Close it so engines
+        // that read piped stdin to EOF before acting (OpenCode and Kilo both
+        // concatenate non-TTY stdin into the prompt via Bun.stdin.text()) don't
+        // block forever on the open docker-exec pipe.
+        dockerExecProcess.stdin?.end();
         // Create a kill function that removes the container when the process exits
         const killFn = async (signal) => {
             try {
@@ -359,6 +364,13 @@ export class SessionManager {
                 return { [auth.envVar ?? "ANTHROPIC_API_KEY"]: 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 {};
     }
     /** Load (and cache) stored Codex/OpenCode credentials, or throw with a fix hint. */
@@ -494,7 +506,9 @@ export class SessionManager {
      */
     async refreshToken(agentType = "CLAUDE_CODE") {
         const resolved = resolveAgentType(agentType);
-        if (resolved === "CODEX" || resolved === "OPENCODE") {
+        if (resolved === "CODEX" ||
+            resolved === "OPENCODE" ||
+            resolved === "KILO") {
             const previous = this.agentAuthCache[resolved];
             delete this.agentAuthCache[resolved];
             const fresh = await loadAgentAuth(resolved);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getforgeai/cli",
-  "version": "0.1.0-beta.3",
+  "version": "0.1.0-beta.5",
   "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.2"
+    "@getforgeai/protocol": "0.1.0-beta.3"
   },
   "devDependencies": {
     "@types/node": "^25.0.2",

package/rootfs/Dockerfile

@@ -6,23 +6,25 @@ ENV DEBIAN_FRONTEND=noninteractive
 RUN apt-get update -qq && \
     apt-get install -y -qq --no-install-recommends \
       ca-certificates curl git openssh-client build-essential \
-      python3 procps less sudo gnupg && \
+      python3 procps less sudo gnupg passwd xz-utils && \
     rm -rf /var/lib/apt/lists/*
 
-# Node.js 20 LTS via NodeSource
-RUN curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | \
-      gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg && \
-    echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_20.x nodistro main" | \
-      tee /etc/apt/sources.list.d/nodesource.list && \
-    apt-get update -qq && \
-    apt-get install -y -qq nodejs && \
-    rm -rf /var/lib/apt/lists/*
+# Node.js 20 LTS from the official nodejs.org tarball — pinned version, no
+# NodeSource apt repo (which intermittently 403s and breaks builds).
+ARG TARGETARCH=arm64
+ARG NODE_VERSION=20.20.2
+RUN NODE_ARCH=$([ "$TARGETARCH" = "amd64" ] && echo "x64" || echo "$TARGETARCH") && \
+    curl -fsSL "https://nodejs.org/dist/v${NODE_VERSION}/node-v${NODE_VERSION}-linux-${NODE_ARCH}.tar.xz" | \
+      tar -xJ -C /usr/local --strip-components=1 && \
+    node --version && npm --version
 
-# Agent CLIs: Claude Code (primary), Codex and OpenCode (alternative engines).
+# Agent CLIs: Claude Code (primary), Codex, OpenCode and Kilo (alternative engines).
 # No output pipe: `| tail` would mask npm failures (pipeline exit = tail's).
 # The `command -v` checks make a partial install fail the build loudly.
-RUN npm install -g --loglevel=error @anthropic-ai/claude-code @openai/codex opencode-ai && \
-    command -v claude && command -v codex && command -v opencode
+# @kilocode/cli ships its platform binary via optionalDependencies + postinstall,
+# so scripts must stay enabled for it.
+RUN npm install -g --loglevel=error @anthropic-ai/claude-code @openai/codex opencode-ai @kilocode/cli && \
+    command -v claude && command -v codex && command -v opencode && command -v kilo
 
 # ForgeAI MCP relay (baked-in copy for reference only — at runtime the CLI
 # stages its own copy into /session/forge-mcp-relay.mjs so the relay version
@@ -30,10 +32,10 @@ RUN npm install -g --loglevel=error @anthropic-ai/claude-code @openai/codex open
 RUN mkdir -p /opt/forgeai
 COPY forge-mcp-relay.mjs /opt/forgeai/forge-mcp-relay.mjs
 
-# Create non-root user (Claude Code refuses --dangerously-skip-permissions as root)
-RUN apt-get update -qq && apt-get install -y -qq --no-install-recommends passwd && \
-    rm -rf /var/lib/apt/lists/* && \
-    useradd -m -s /bin/bash -u 1001 agent
+# Create non-root user (Claude Code refuses --dangerously-skip-permissions as root).
+# passwd is installed with the base packages above: re-running apt-get update
+# here hits the NodeSource repo again, which intermittently 403s and fails builds.
+RUN useradd -m -s /bin/bash -u 1001 agent
 
 # Working directories (owned by agent user)
 RUN mkdir -p /workspace /session /shared && \