agentbox-sdk 0.1.1 → 0.1.3

package/dist/{chunk-G27423WX.js → chunk-4MBB6QHD.js}

@@ -2,31 +2,37 @@ import {
   createNormalizedEvent,
   normalizeRawAgentEvent,
   toAISDKStream
-} from "./chunk-7FLLQJ6J.js";
+} from "./chunk-ZOWBRUQR.js";
 import {
-  AGENT_RESERVED_PORTS,
   AgentBoxError,
   AsyncQueue,
   UnsupportedProviderError,
   asError,
-  getAvailablePort,
+  debugAgent,
+  debugClaude,
+  debugCodex,
+  debugOpencode,
+  debugRelay,
+  debugRuntime,
+  debugSetup,
   linesFromTextChunks,
   sleep,
+  time,
   waitFor
-} from "./chunk-O7HCJXKW.js";
+} from "./chunk-INMA52FV.js";
 import {
   shellQuote
 } from "./chunk-NSJM57Z4.js";
 import {
   AgentProvider,
   SandboxProvider
-} from "./chunk-2NKMDGYH.js";
+} from "./chunk-GOFJNFAD.js";
 
 // src/agents/Agent.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // src/agents/providers/claude-code.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID } from "crypto";
 import path8 from "path";
 
 // src/agents/approval.ts
@@ -682,7 +688,6 @@ function assertHooksSupported(provider, options) {
 }
 
 // src/agents/config/mcp.ts
-import path4 from "path";
 var SAFE_TOML_KEY = /^[a-zA-Z0-9_-]+$/;
 function assertSafeTomlKey(name, context) {
   if (!SAFE_TOML_KEY.test(name)) {
@@ -765,8 +770,20 @@ function buildOpenCodeMcpConfig(mcps) {
     })
   );
 }
-function buildCodexConfigToml(mcps, agentSections = [], enableHooks = false) {
+function buildCodexConfigToml(opts = {}) {
+  const {
+    mcps,
+    agentSections = [],
+    enableHooks = false,
+    enableSkills = false,
+    enableMultiAgent = false,
+    openAiBaseUrl
+  } = opts;
   const blocks = [];
+  if (openAiBaseUrl) {
+    blocks.push(`openai_base_url = ${tomlString(openAiBaseUrl)}`);
+    blocks.push("");
+  }
   for (const mcp of mcps ?? []) {
     if (mcp.enabled === false) {
       continue;
@@ -798,9 +815,13 @@ function buildCodexConfigToml(mcps, agentSections = [], enableHooks = false) {
     }
     blocks.push("");
   }
-  if (enableHooks) {
+  const featureLines = [];
+  if (enableHooks) featureLines.push("codex_hooks = true");
+  if (enableSkills) featureLines.push("skills = true");
+  if (enableMultiAgent) featureLines.push("multi_agent = true");
+  if (featureLines.length > 0) {
     blocks.push("[features]");
-    blocks.push("codex_hooks = true");
+    blocks.push(...featureLines);
     blocks.push("");
   }
   blocks.push(...agentSections);
@@ -810,21 +831,11 @@ function buildCodexConfigToml(mcps, agentSections = [], enableHooks = false) {
   return `${blocks.join("\n").trim()}
 `;
 }
-function buildClaudeMcpArtifact(mcps, claudeDir) {
-  const content = buildClaudeMcpConfig(mcps);
-  if (!content) {
-    return void 0;
-  }
-  return {
-    path: path4.join(claudeDir, "agentbox-mcp.json"),
-    content
-  };
-}
 
-// src/agents/config/runtime.ts
-import { mkdtemp, mkdir, chmod, rm, writeFile } from "fs/promises";
+// src/agents/config/setup.ts
+import { mkdir, chmod, rm, writeFile } from "fs/promises";
 import os from "os";
-import path5 from "path";
+import path4 from "path";
 
 // src/agents/transports/spawn.ts
 import { spawn } from "child_process";
@@ -877,160 +888,333 @@ async function* linesFromNodeStream(stream) {
   }
 }
 
-// src/agents/config/runtime.ts
-function createLayout(homeDir) {
-  const xdgConfigHome = path5.join(homeDir, ".config");
-  const codexDir = path5.join(homeDir, ".codex");
+// src/agents/config/setup.ts
+function shortLabel(command) {
+  const oneLine = command.replace(/\s+/g, " ").trim();
+  return oneLine.length > 60 ? `${oneLine.slice(0, 60)}\u2026` : oneLine;
+}
+function agentboxRoot(provider, hasSandbox) {
+  return hasSandbox ? `/tmp/agentbox/${provider}` : path4.join(os.tmpdir(), `agentbox-${provider}`);
+}
+function buildLayout(rootDir) {
+  const xdgConfigHome = path4.join(rootDir, ".config");
   return {
-    rootDir: homeDir,
-    homeDir,
+    rootDir,
+    homeDir: rootDir,
     xdgConfigHome,
-    agentsDir: path5.join(homeDir, ".agents"),
-    claudeDir: path5.join(homeDir, ".claude"),
-    opencodeDir: path5.join(xdgConfigHome, "opencode"),
-    codexDir
+    agentsDir: path4.join(rootDir, ".agents"),
+    claudeDir: path4.join(rootDir, ".claude"),
+    opencodeDir: path4.join(xdgConfigHome, "opencode"),
+    codexDir: path4.join(rootDir, ".codex")
   };
 }
-var HostRuntimeTarget = class {
+function buildLayoutEnv(provider, layout) {
+  switch (provider) {
+    case "claude-code":
+      return { CLAUDE_CONFIG_DIR: layout.claudeDir };
+    case "codex":
+      return { CODEX_HOME: layout.codexDir };
+    case "open-code":
+      return {
+        OPENCODE_CONFIG: path4.join(layout.opencodeDir, "agentbox.json"),
+        OPENCODE_CONFIG_DIR: layout.opencodeDir
+      };
+  }
+}
+var HostSetupTarget = class {
   constructor(provider, layout, cwd, baseEnv) {
     this.provider = provider;
     this.layout = layout;
     this.cwd = cwd;
     this.baseEnv = baseEnv;
-    this.env = {};
+    this.env = buildLayoutEnv(provider, layout);
   }
   provider;
   layout;
   cwd;
   baseEnv;
   env;
-  async writeArtifact(artifact) {
-    await mkdir(path5.dirname(artifact.path), { recursive: true });
-    await writeFile(artifact.path, artifact.content, "utf8");
-    if (artifact.executable) {
-      await chmod(artifact.path, 493);
-    }
+  /**
+   * Host implementation: write each artifact directly to the local
+   * filesystem (we're already on the box), then run the command via
+   * `sh -c`. No tarball needed since there's no RPC to amortize.
+   */
+  async uploadAndRun(files, command) {
+    return time(
+      debugRuntime,
+      `host uploadAndRun ${shortLabel(command)}`,
+      async () => {
+        await Promise.all(
+          files.map(async (entry) => {
+            await mkdir(path4.dirname(entry.path), { recursive: true });
+            const content = typeof entry.content === "string" ? entry.content : entry.content;
+            await writeFile(entry.path, content);
+            if (entry.mode && (entry.mode & 73) !== 0) {
+              await chmod(entry.path, entry.mode);
+            }
+          })
+        );
+        const handle = spawnCommand({
+          command: "sh",
+          args: ["-c", command],
+          cwd: this.cwd,
+          env: {
+            ...process.env,
+            ...this.baseEnv,
+            ...this.env
+          }
+        });
+        const exitCode = await handle.wait();
+        return {
+          exitCode,
+          stdout: "",
+          stderr: "",
+          combinedOutput: ""
+        };
+      },
+      (result) => ({ exit: result.exitCode, files: files.length })
+    );
   }
   async runCommand(command, extraEnv) {
-    const handle = spawnCommand({
-      command: process.env.SHELL || "sh",
-      args: ["-lc", command],
-      cwd: this.cwd,
-      env: {
-        ...process.env,
-        ...this.baseEnv,
-        ...this.env,
-        ...extraEnv ?? {}
+    await time(
+      debugRuntime,
+      `host runCommand ${shortLabel(command)}`,
+      async () => {
+        const handle = spawnCommand({
+          command: process.env.SHELL || "sh",
+          args: ["-c", command],
+          cwd: this.cwd,
+          env: {
+            ...process.env,
+            ...this.baseEnv,
+            ...this.env,
+            ...extraEnv ?? {}
+          }
+        });
+        const exitCode = await handle.wait();
+        if (exitCode !== 0) {
+          throw new Error(`Setup command failed (${exitCode}): ${command}`);
+        }
       }
-    });
-    const exitCode = await handle.wait();
-    if (exitCode !== 0) {
-      throw new Error(`Setup command failed (${exitCode}): ${command}`);
-    }
+    );
   }
   async cleanup() {
     await rm(this.layout.rootDir, { recursive: true, force: true });
   }
 };
-var SandboxRuntimeTarget = class {
+var SandboxSetupTarget = class {
   constructor(provider, layout, options) {
     this.provider = provider;
     this.layout = layout;
     this.options = options;
-    this.env = {};
+    this.env = buildLayoutEnv(provider, layout);
   }
   provider;
   layout;
   options;
   env;
-  async writeArtifact(artifact) {
-    const marker = `__AGENTBOX_${Math.random().toString(36).slice(2)}__`;
-    const command = `mkdir -p ${shellQuote(
-      path5.posix.dirname(artifact.path)
-    )} && cat > ${shellQuote(artifact.path)} <<'${marker}'
-${artifact.content}
-${marker}`;
-    await this.options.sandbox?.run(command, {
-      cwd: this.options.cwd,
-      env: {
-        ...this.options.env ?? {},
-        ...this.env
-      }
-    });
-    if (artifact.executable) {
-      await this.options.sandbox?.run(`chmod +x ${shellQuote(artifact.path)}`, {
-        cwd: this.options.cwd,
-        env: {
-          ...this.options.env ?? {},
-          ...this.env
-        }
-      });
-    }
-  }
-  async runCommand(command, extraEnv) {
-    const result = await this.options.sandbox?.run(command, {
-      cwd: this.options.cwd,
-      env: {
-        ...this.options.env ?? {},
-        ...this.env,
-        ...extraEnv ?? {}
-      }
-    });
-    if (result && result.exitCode !== 0) {
+  /**
+   * Sandbox implementation: delegate to `Sandbox.uploadAndRun` so the
+   * tarball + extract + exec all happen in a single Modal RPC. This is
+   * the hot path used by `applyDifferentialSetup`.
+   */
+  async uploadAndRun(files, command) {
+    const sandbox = this.options.sandbox;
+    if (!sandbox) {
       throw new Error(
-        `Sandbox setup command failed (${result.exitCode}): ${command}`
+        "SandboxSetupTarget.uploadAndRun called without a sandbox."
       );
     }
-  }
-  async cleanup() {
-    await this.options.sandbox?.run(
-      `rm -rf ${shellQuote(this.layout.rootDir)}`,
-      {
+    return time(
+      debugRuntime,
+      `sandbox uploadAndRun ${shortLabel(command)}`,
+      () => sandbox.uploadAndRun(files, command, {
         cwd: this.options.cwd,
         env: {
           ...this.options.env ?? {},
           ...this.env
         }
-      }
+      }),
+      (result) => ({ exit: result.exitCode, files: files.length })
     );
   }
-};
-async function createRuntimeTarget(provider, runId, options) {
-  if (options.sandbox) {
-    const layout2 = createLayout(`/tmp/agentbox/${provider}/${runId}`);
-    await options.sandbox.run(
-      [
-        `mkdir -p ${shellQuote(layout2.homeDir)}`,
-        `mkdir -p ${shellQuote(layout2.xdgConfigHome)}`,
-        `mkdir -p ${shellQuote(layout2.agentsDir)}`,
-        `mkdir -p ${shellQuote(layout2.claudeDir)}`,
-        `mkdir -p ${shellQuote(layout2.opencodeDir)}`,
-        `mkdir -p ${shellQuote(layout2.codexDir)}`
-      ].join(" && "),
-      {
-        cwd: options.cwd,
-        env: {
-          ...options.env ?? {}
+  async runCommand(command, extraEnv) {
+    await time(
+      debugRuntime,
+      `sandbox runCommand ${shortLabel(command)}`,
+      async () => {
+        const result = await this.options.sandbox?.run(command, {
+          cwd: this.options.cwd,
+          env: {
+            ...this.options.env ?? {},
+            ...this.env,
+            ...extraEnv ?? {}
+          }
+        });
+        if (result && result.exitCode !== 0) {
+          throw new Error(
+            `Sandbox setup command failed (${result.exitCode}): ${command}`
+          );
         }
       }
     );
-    return new SandboxRuntimeTarget(provider, layout2, options);
   }
-  const rootDir = await mkdtemp(
-    path5.join(os.tmpdir(), `agentbox-${provider}-`)
-  );
-  const layout = createLayout(rootDir);
-  await mkdir(layout.homeDir, { recursive: true });
-  await mkdir(layout.xdgConfigHome, { recursive: true });
-  await mkdir(layout.agentsDir, { recursive: true });
-  await mkdir(layout.claudeDir, { recursive: true });
-  await mkdir(layout.opencodeDir, { recursive: true });
-  await mkdir(layout.codexDir, { recursive: true });
-  return new HostRuntimeTarget(
-    provider,
-    layout,
-    options.cwd ?? process.cwd(),
-    options.env ?? {}
+  async cleanup() {
+  }
+};
+async function createSetupTarget(provider, setupId, options) {
+  return time(debugRuntime, `createSetupTarget ${provider}`, async () => {
+    void setupId;
+    const layout = buildLayout(
+      agentboxRoot(provider, Boolean(options.sandbox))
+    );
+    if (options.sandbox) {
+      return new SandboxSetupTarget(provider, layout, options);
+    }
+    await mkdir(layout.homeDir, { recursive: true });
+    await mkdir(layout.xdgConfigHome, { recursive: true });
+    await mkdir(layout.agentsDir, { recursive: true });
+    await mkdir(layout.claudeDir, { recursive: true });
+    await mkdir(layout.opencodeDir, { recursive: true });
+    await mkdir(layout.codexDir, { recursive: true });
+    return new HostSetupTarget(
+      provider,
+      layout,
+      options.cwd ?? process.cwd(),
+      options.env ?? {}
+    );
+  });
+}
+
+// src/agents/config/setup-manifest.ts
+import { createHash } from "crypto";
+import path5 from "path";
+var MANIFEST_FILENAME = "setup-manifest.json";
+var TARGET_MANIFEST_FILENAME = "setup-target.json";
+var INSTALL_SCRIPT_FILENAME = "install.sh";
+var MANIFEST_VERSION = 1;
+function hashArtifact(artifact) {
+  const hasher = createHash("sha256");
+  hasher.update(artifact.executable ? "1" : "0");
+  hasher.update("\0");
+  hasher.update(artifact.content, "utf8");
+  return hasher.digest("hex");
+}
+function hashCommand(command) {
+  return createHash("sha256").update(command, "utf8").digest("hex");
+}
+function computeTargetArtifacts(artifacts) {
+  const result = {};
+  for (const artifact of artifacts) {
+    result[artifact.path] = hashArtifact(artifact);
+  }
+  return result;
+}
+function buildInstallScript(rootDir, installCommandsByKey) {
+  const commandsB64 = Buffer.from(
+    JSON.stringify(installCommandsByKey),
+    "utf8"
+  ).toString("base64");
+  return `#!/usr/bin/env bash
+set -e
+ROOT_DIR=${shellQuote(rootDir)}
+TARGET_MANIFEST="$ROOT_DIR/${TARGET_MANIFEST_FILENAME}"
+EXISTING_MANIFEST="$ROOT_DIR/${MANIFEST_FILENAME}"
+export TARGET_MANIFEST EXISTING_MANIFEST
+
+# Compute stale commands: any command whose hash in the target manifest
+# differs from (or is missing in) the existing manifest. The python block
+# emits the commands themselves, NUL-separated, so bash never has to
+# deserialize JSON.
+STALE_CMDS_FILE="$(mktemp)"
+trap 'rm -f "$STALE_CMDS_FILE"' EXIT
+COMMANDS_B64=${shellQuote(commandsB64)} \\
+MANIFEST_VERSION=${MANIFEST_VERSION} \\
+python3 - <<'PY' > "$STALE_CMDS_FILE"
+import base64, json, os, sys
+with open(os.environ["TARGET_MANIFEST"], "r", encoding="utf-8") as fh:
+    target = json.load(fh)
+existing = {}
+try:
+    with open(os.environ["EXISTING_MANIFEST"], "r", encoding="utf-8") as fh:
+        existing = json.load(fh)
+except FileNotFoundError:
+    pass
+expected_version = int(os.environ["MANIFEST_VERSION"])
+target_cmds = target.get("installCommands", {})
+existing_cmds = (
+    existing.get("installCommands", {})
+    if existing.get("version") == expected_version
+    else {}
+)
+commands = json.loads(base64.b64decode(os.environ["COMMANDS_B64"]))
+stale = [
+    commands[key]
+    for key, hashed in target_cmds.items()
+    if commands.get(key) is not None and existing_cmds.get(key) != hashed
+]
+sys.stdout.write("\\0".join(stale))
+PY
+
+if [ -s "$STALE_CMDS_FILE" ]; then
+  while IFS= read -r -d '' CMD; do
+    [ -z "$CMD" ] && continue
+    bash -c "$CMD" &
+  done < "$STALE_CMDS_FILE"
+  wait
+fi
+
+# Persist target manifest as the new manifest atomically. Doing this last
+# means an interrupted install run doesn't poison the cache for next time.
+mv "$TARGET_MANIFEST" "$EXISTING_MANIFEST"
+`;
+}
+async function applyDifferentialSetup(target, artifacts, installCommands) {
+  await time(
+    debugSetup,
+    `applyDifferentialSetup ${target.provider}`,
+    async () => {
+      const installCommandsByKey = {};
+      for (let i = 0; i < installCommands.length; i++) {
+        installCommandsByKey[`cmd${i}`] = installCommands[i];
+      }
+      const targetForSandbox = {
+        version: MANIFEST_VERSION,
+        artifacts: computeTargetArtifacts(artifacts),
+        installCommands: Object.fromEntries(
+          Object.entries(installCommandsByKey).map(([key, command]) => [
+            key,
+            hashCommand(command)
+          ])
+        )
+      };
+      const rootDir = target.layout.rootDir;
+      const tarballEntries = [
+        ...artifacts.map((artifact) => ({
+          path: artifact.path,
+          content: artifact.content,
+          mode: artifact.executable ? 493 : 420
+        })),
+        {
+          path: path5.posix.join(rootDir, TARGET_MANIFEST_FILENAME),
+          content: JSON.stringify(targetForSandbox),
+          mode: 420
+        },
+        {
+          path: path5.posix.join(rootDir, INSTALL_SCRIPT_FILENAME),
+          content: buildInstallScript(rootDir, installCommandsByKey),
+          mode: 493
+        }
+      ];
+      await target.uploadAndRun(
+        tarballEntries,
+        `bash ${shellQuote(path5.posix.join(rootDir, INSTALL_SCRIPT_FILENAME))}`
+      );
+    },
+    () => ({
+      artifacts: artifacts.length,
+      installCommands: installCommands.length
+    })
   );
 }
 
@@ -1043,12 +1227,15 @@ function getSkillTargetDir(provider, layout, skillName) {
     case AgentProvider.OpenCode:
       return path6.join(layout.opencodeDir, "skills", skillName);
     case AgentProvider.Codex:
-      return path6.join(layout.agentsDir, "skills", skillName);
+      return path6.join(layout.codexDir, "skills", skillName);
   }
 }
+function skillsCliAgentName(provider) {
+  return provider === AgentProvider.OpenCode ? "opencode" : provider;
+}
 function buildSkillsInstallerCommand(provider, skill) {
   const repo = skill.repo ?? "https://github.com/anthropics/skills";
-  return `npx skills add ${shellQuote(repo)} -g --skill ${shellQuote(skill.name)} --agent ${shellQuote(provider)} -y`;
+  return `npx skills add ${shellQuote(repo)} -g --skill ${shellQuote(skill.name)} --agent ${shellQuote(skillsCliAgentName(provider))} -y`;
 }
 async function prepareSkillArtifacts(provider, skills, layout) {
   const artifacts = [];
@@ -1077,11 +1264,6 @@ async function prepareSkillArtifacts(provider, skills, layout) {
     preparedSkills
   };
 }
-async function installSkills(target, installCommands, extraEnv) {
-  for (const command of installCommands) {
-    await target.runCommand(command, extraEnv);
-  }
-}
 
 // src/agents/config/subagents.ts
 import path7 from "path";
@@ -1092,21 +1274,32 @@ function toToolsArray(tools) {
 function tomlString2(value) {
   return JSON.stringify(value);
 }
-function buildClaudeAgentsConfig(subAgents) {
+function yamlScalar(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function buildClaudeSubagentArtifacts(subAgents, layout) {
   if (!subAgents || subAgents.length === 0) {
-    return void 0;
+    return [];
   }
-  return Object.fromEntries(
-    subAgents.map((subAgent) => [
-      subAgent.name,
-      {
-        description: subAgent.description,
-        prompt: subAgent.instructions,
-        ...subAgent.model ? { model: subAgent.model } : {},
-        ...toToolsArray(subAgent.tools) ? { tools: toToolsArray(subAgent.tools) } : {}
-      }
-    ])
-  );
+  return subAgents.map((subAgent) => {
+    const tools = toToolsArray(subAgent.tools);
+    const frontmatterLines = [
+      `name: ${yamlScalar(subAgent.name)}`,
+      `description: ${yamlScalar(subAgent.description)}`,
+      ...subAgent.model ? [`model: ${yamlScalar(subAgent.model)}`] : [],
+      ...tools ? [`tools: ${tools.join(", ")}`] : []
+    ];
+    const content = `---
+${frontmatterLines.join("\n")}
+---
+
+${subAgent.instructions.trim()}
+`;
+    return {
+      path: path7.join(layout.claudeDir, "agents", `${subAgent.name}.md`),
+      content
+    };
+  });
 }
 function mapOpenCodeTools(tools) {
   if (!tools || tools.length === 0) {
@@ -1131,27 +1324,28 @@ function buildCodexSubagentArtifacts(subAgents, layout) {
   const artifacts = [];
   const agentSections = [];
   for (const subAgent of subAgents ?? []) {
-    if (subAgent.model) {
-      throw new Error(
-        `Codex sub-agent "${subAgent.name}" specifies a model override, which is not supported in this package yet.`
-      );
-    }
     const roleConfigRelativePath = `./agents/${subAgent.name}.toml`;
     const roleConfigPromptPath = `../prompts/${subAgent.name}.md`;
     artifacts.push({
       path: path7.join(layout.codexDir, "prompts", `${subAgent.name}.md`),
       content: subAgent.instructions
     });
+    const tomlLines = [
+      `model_instructions_file = ${tomlString2(roleConfigPromptPath)}`
+    ];
+    if (subAgent.model) {
+      tomlLines.push(`model = ${tomlString2(subAgent.model)}`);
+    }
+    tomlLines.push(
+      `model_reasoning_effort = ${tomlString2("medium")}`,
+      "",
+      "[features]",
+      "multi_agent = false",
+      ""
+    );
     artifacts.push({
       path: path7.join(layout.codexDir, "agents", `${subAgent.name}.toml`),
-      content: [
-        `model_instructions_file = ${tomlString2(roleConfigPromptPath)}`,
-        `model_reasoning_effort = ${tomlString2("medium")}`,
-        "",
-        "[features]",
-        "multi_agent = false",
-        ""
-      ].join("\n")
+      content: tomlLines.join("\n")
     });
     agentSections.push(
       `[agents.${subAgent.name}]`,
@@ -1167,355 +1361,166 @@ function buildCodexSubagentArtifacts(subAgents, layout) {
   };
 }
 
-// src/agents/transports/sdk-ws.ts
-import { randomUUID } from "crypto";
-import {
-  WebSocket,
-  WebSocketServer
-} from "ws";
-function handleIncomingMessage(text, messagesQueue, pendingResponses) {
-  const lines = text.split("\n").map((line) => line.trim()).filter(Boolean);
-  for (const line of lines) {
-    let message;
-    try {
-      message = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (message.type === "control_response" && typeof message.response === "object" && message.response !== null) {
-      const requestId = String(
-        message.response.request_id ?? ""
-      );
-      const pending = pendingResponses.get(requestId);
-      if (pending) {
-        pendingResponses.delete(requestId);
-        pending.resolve(message);
-      }
-    }
-    messagesQueue.push(message);
-  }
-}
-var SdkWsServer = class {
-  server;
-  socket;
-  messagesQueue = new AsyncQueue();
-  pendingResponses = /* @__PURE__ */ new Map();
-  host;
-  port;
-  constructor(options) {
-    this.host = options?.host ?? "127.0.0.1";
-    this.port = options?.port;
-  }
-  get url() {
-    if (!this.port) {
-      throw new Error("SDK WebSocket server has not been started yet.");
-    }
-    return `ws://${this.host}:${this.port}`;
-  }
-  async start() {
-    if (this.server) {
-      return;
-    }
-    this.port ??= await getAvailablePort(this.host);
-    this.server = new WebSocketServer({ host: this.host, port: this.port });
-    this.server.on("connection", (socket) => {
-      this.socket = socket;
-      socket.on("message", (data) => this.handleMessage(data));
-      socket.on("close", () => {
-        if (this.socket === socket) {
-          this.socket = void 0;
-        }
-      });
-    });
-    this.server.on("error", (error) => {
-      this.messagesQueue.fail(error);
-    });
-  }
-  async waitForConnection(timeoutMs = 15e3) {
-    await waitFor(async () => Boolean(this.socket), {
-      timeoutMs,
-      intervalMs: 100
-    });
-  }
-  async send(message) {
-    await this.waitForConnection();
-    const socket = this.socket;
-    if (!socket) {
-      throw new Error("SDK WebSocket server has no active connection.");
-    }
-    await new Promise((resolve, reject) => {
-      socket.send(`${JSON.stringify(message)}
-`, (error) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve();
-      });
-    });
+// src/agents/cost.ts
+function addIfNumber(target, key, value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return;
   }
-  async request(request) {
-    const requestId = randomUUID();
-    const response = new Promise((resolve, reject) => {
-      this.pendingResponses.set(requestId, { resolve, reject });
-    });
-    await this.send({
-      type: "control_request",
-      request_id: requestId,
-      request
-    });
-    return response;
+  target[key] = (target[key] ?? 0) + value;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function mergeUsage(target, source) {
+  if (!source) {
+    return;
   }
-  async close() {
-    this.messagesQueue.finish();
-    for (const pending of this.pendingResponses.values()) {
-      pending.reject(new Error("SDK WebSocket server closed."));
-    }
-    this.pendingResponses.clear();
-    this.socket?.close();
-    if (!this.server) {
-      return;
+  addIfNumber(target, "input_tokens", source.input_tokens);
+  addIfNumber(target, "input_tokens", source.inputTokens);
+  addIfNumber(target, "input_tokens", source.input);
+  addIfNumber(target, "output_tokens", source.output_tokens);
+  addIfNumber(target, "output_tokens", source.outputTokens);
+  addIfNumber(target, "output_tokens", source.output);
+  addIfNumber(
+    target,
+    "cache_read_input_tokens",
+    source.cache_read_input_tokens
+  );
+  addIfNumber(target, "cache_read_input_tokens", source.cached_input_tokens);
+  addIfNumber(target, "cache_read_input_tokens", source.cachedInputTokens);
+  addIfNumber(
+    target,
+    "cache_creation_input_tokens",
+    source.cache_creation_input_tokens
+  );
+  addIfNumber(target, "cache_creation_input_tokens", source.cacheWrite);
+  const cache = asRecord(source.cache);
+  if (cache) {
+    addIfNumber(target, "cache_read_input_tokens", cache.read);
+    addIfNumber(target, "cache_creation_input_tokens", cache.write);
+  }
+}
+function compactCostData(costData) {
+  const usage = costData.usage ? Object.fromEntries(
+    Object.entries(costData.usage).filter(([, value]) => value !== 0)
+  ) : void 0;
+  const compacted = {
+    ...costData.total_cost_usd !== void 0 ? { total_cost_usd: costData.total_cost_usd } : {},
+    ...costData.duration_ms !== void 0 ? { duration_ms: costData.duration_ms } : {},
+    ...costData.duration_api_ms !== void 0 ? { duration_api_ms: costData.duration_api_ms } : {},
+    ...costData.num_turns !== void 0 ? { num_turns: costData.num_turns } : {},
+    ...usage && Object.keys(usage).length > 0 ? { usage } : {}
+  };
+  return Object.keys(compacted).length > 0 ? compacted : null;
+}
+function extractClaudeCostData(events) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (!event) {
+      continue;
     }
-    await new Promise((resolve, reject) => {
-      this.server?.close((error) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve();
-      });
-    });
-    this.server = void 0;
-    this.socket = void 0;
-  }
-  messages() {
-    return this.messagesQueue;
-  }
-  handleMessage(rawData) {
-    handleIncomingMessage(
-      rawData.toString(),
-      this.messagesQueue,
-      this.pendingResponses
-    );
-  }
-};
-var SharedSdkWsChannel = class {
-  constructor(connection, runId, onClose) {
-    this.connection = connection;
-    this.runId = runId;
-    this.onClose = onClose;
-  }
-  connection;
-  runId;
-  onClose;
-  messagesQueue = new AsyncQueue();
-  pendingResponses = /* @__PURE__ */ new Map();
-  closed = false;
-  handleIncomingMessage(message) {
-    if (this.closed) {
-      return;
+    if (event.type !== "result") {
+      continue;
     }
-    if (message.type === "control_response" && typeof message.response === "object" && message.response !== null) {
-      const requestId = String(
-        message.response.request_id ?? ""
-      );
-      const pending = this.pendingResponses.get(requestId);
-      if (pending) {
-        this.pendingResponses.delete(requestId);
-        pending.resolve(message);
+    const totalCost = typeof event.total_cost_usd === "number" ? event.total_cost_usd : void 0;
+    const usage = {};
+    const modelUsage = asRecord(event.modelUsage);
+    if (modelUsage) {
+      for (const value of Object.values(modelUsage)) {
+        mergeUsage(usage, asRecord(value));
       }
     }
-    this.messagesQueue.push(message);
-  }
-  handleConnectionClosed(error) {
-    if (this.closed) {
-      return;
-    }
-    for (const pending of this.pendingResponses.values()) {
-      pending.reject(error);
-    }
-    this.pendingResponses.clear();
-    this.messagesQueue.fail(error);
-  }
-  async waitForConnection(timeoutMs = 15e3) {
-    await this.connection.waitForConnection(timeoutMs);
-  }
-  async send(message) {
-    await this.connection.sendToRun(this.runId, message);
-  }
-  async request(request) {
-    const requestId = randomUUID();
-    const response = new Promise((resolve, reject) => {
-      this.pendingResponses.set(requestId, { resolve, reject });
+    return compactCostData({
+      ...totalCost !== void 0 ? { total_cost_usd: totalCost } : {},
+      duration_ms: typeof event.duration_ms === "number" ? event.duration_ms : void 0,
+      duration_api_ms: typeof event.duration_api_ms === "number" ? event.duration_api_ms : void 0,
+      num_turns: typeof event.num_turns === "number" ? event.num_turns : void 0,
+      usage
     });
-    await this.send({
-      type: "control_request",
-      request_id: requestId,
-      request
-    });
-    return response;
   }
-  async close() {
-    if (this.closed) {
-      return;
-    }
-    this.closed = true;
-    for (const pending of this.pendingResponses.values()) {
-      pending.reject(new Error("SDK WebSocket channel closed."));
+  return null;
+}
+function extractCodexCostData(events) {
+  const usage = {};
+  let sawUsage = false;
+  for (const event of events) {
+    const params = asRecord(event.params);
+    const usageCandidate = asRecord(event.usage) ?? asRecord(params?.usage) ?? asRecord(params?.tokenUsage) ?? asRecord(asRecord(params?.turn)?.usage) ?? asRecord(asRecord(params?.turn)?.tokenUsage);
+    if (usageCandidate) {
+      sawUsage = true;
+      mergeUsage(usage, usageCandidate);
     }
-    this.pendingResponses.clear();
-    this.messagesQueue.finish();
-    this.onClose();
   }
-  messages() {
-    return this.messagesQueue;
-  }
-};
-var MAX_PENDING_MESSAGES_PER_RUN = 1e3;
-var SharedSdkWsConnection = class {
-  constructor(url, headers = {}) {
-    this.url = url;
-    this.headers = headers;
-  }
-  url;
-  headers;
-  socket;
-  channels = /* @__PURE__ */ new Map();
-  pendingMessages = /* @__PURE__ */ new Map();
-  async start() {
-    if (this.socket?.readyState === WebSocket.OPEN) {
-      return;
+  return sawUsage ? compactCostData({ usage }) : null;
+}
+function extractOpenCodeCostData(events) {
+  const usage = {};
+  let totalCost = 0;
+  let sawCostData = false;
+  for (const event of events) {
+    const properties = asRecord(event.properties);
+    const part = asRecord(properties?.part) ?? asRecord(event.part);
+    if (part?.type !== "step-finish") {
+      continue;
     }
-    const socket = new WebSocket(this.url, { headers: this.headers });
-    this.socket = socket;
-    socket.on("message", (data) => {
-      const lines = data.toString().split("\n").map((line) => line.trim()).filter(Boolean);
-      for (const line of lines) {
-        try {
-          const envelope = JSON.parse(line);
-          if (!envelope.runId || !envelope.message) {
-            continue;
-          }
-          const channel = this.channels.get(envelope.runId);
-          if (channel) {
-            channel.handleIncomingMessage(envelope.message);
-            continue;
-          }
-          const pending = this.pendingMessages.get(envelope.runId) ?? [];
-          if (pending.length < MAX_PENDING_MESSAGES_PER_RUN) {
-            pending.push(envelope.message);
-            this.pendingMessages.set(envelope.runId, pending);
-          }
-        } catch (error) {
-          const failure = error instanceof Error ? error : new Error("Failed to parse shared SDK message.");
-          for (const channel of this.channels.values()) {
-            channel.handleConnectionClosed(failure);
-          }
-        }
-      }
-    });
-    socket.on("close", () => {
-      if (this.socket === socket) {
-        this.socket = void 0;
-      }
-      const error = new Error("Shared SDK WebSocket connection closed.");
-      for (const channel of this.channels.values()) {
-        channel.handleConnectionClosed(error);
-      }
-    });
-    socket.on("error", (error) => {
-      for (const channel of this.channels.values()) {
-        channel.handleConnectionClosed(error);
-      }
-    });
-    await new Promise((resolve, reject) => {
-      const cleanup = () => {
-        socket.off("open", handleOpen);
-        socket.off("error", handleError);
-      };
-      const handleOpen = () => {
-        cleanup();
-        resolve();
-      };
-      const handleError = (error) => {
-        cleanup();
-        reject(error);
-      };
-      socket.once("open", handleOpen);
-      socket.once("error", handleError);
-    });
-  }
-  async waitForConnection(timeoutMs = 15e3) {
-    await waitFor(async () => this.socket?.readyState === WebSocket.OPEN, {
-      timeoutMs,
-      intervalMs: 100
-    });
-  }
-  createChannel(runId) {
-    const existing = this.channels.get(runId);
-    if (existing) {
-      return existing;
+    if (typeof part.cost === "number") {
+      totalCost += part.cost;
+      sawCostData = true;
     }
-    const channel = new SharedSdkWsChannel(this, runId, () => {
-      this.channels.delete(runId);
-    });
-    this.channels.set(runId, channel);
-    const pending = this.pendingMessages.get(runId);
-    if (pending?.length) {
-      for (const message of pending) {
-        channel.handleIncomingMessage(message);
-      }
-      this.pendingMessages.delete(runId);
+    const tokens = asRecord(part.tokens);
+    if (tokens) {
+      sawCostData = true;
+      mergeUsage(usage, tokens);
     }
-    return channel;
   }
-  async sendToRun(runId, message) {
-    await this.waitForConnection();
-    const socket = this.socket;
-    if (!socket) {
-      throw new Error("Shared SDK WebSocket connection is not open.");
+  return sawCostData ? compactCostData({
+    ...totalCost > 0 ? { total_cost_usd: totalCost } : {},
+    usage
+  }) : null;
+}
+
+// src/agents/providers/claude-code.ts
+var DAEMON_PROTOCOL_VERSION = "1";
+var DAEMON_PORT = 43180;
+var DAEMON_PATH = "/tmp/agentbox/claude-code/daemon.mjs";
+var DAEMON_LOG_PATH = "/tmp/agentbox/claude-code/daemon.log";
+var DAEMON_PID_PATH = "/tmp/agentbox/claude-code/daemon.pid";
+function claudeConfigDir(options) {
+  return path8.join(
+    agentboxRoot(AgentProvider.ClaudeCode, Boolean(options.sandbox)),
+    ".claude"
+  );
+}
+function buildClaudeQueryOptions(params) {
+  const provider = params.request.options.provider;
+  const run = params.request.run;
+  const extraArgs = {
+    "mcp-config": params.mcpConfigPath
+  };
+  for (const arg of provider?.args ?? []) {
+    if (typeof arg !== "string") continue;
+    if (arg.startsWith("--")) {
+      extraArgs[arg.slice(2)] = null;
     }
-    await new Promise((resolve, reject) => {
-      socket.send(`${JSON.stringify({ runId, message })}
-`, (error) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve();
-      });
-    });
   }
-  async close() {
-    for (const channel of this.channels.values()) {
-      await channel.close();
-    }
-    this.channels.clear();
-    this.pendingMessages.clear();
-    if (!this.socket) {
-      return;
-    }
-    await new Promise((resolve) => {
-      const socket = this.socket;
-      this.socket = void 0;
-      if (!socket) {
-        resolve();
-        return;
-      }
-      if (socket.readyState === WebSocket.CLOSED || socket.readyState === WebSocket.CLOSING) {
-        resolve();
-        return;
-      }
-      socket.once("close", () => resolve());
-      socket.close();
-    });
+  if (run.systemPrompt) {
+    extraArgs["append-system-prompt"] = run.systemPrompt;
   }
-};
-
-// src/agents/providers/claude-code.ts
-var REMOTE_SDK_RELAY_PORT = 43180;
-var REMOTE_SDK_RELAY_PATH = "/tmp/agentbox/claude-code/relay.mjs";
-var sharedRemoteConnectionBySandbox = /* @__PURE__ */ new WeakMap();
+  return {
+    cwd: params.cwd ?? params.request.options.cwd,
+    env: params.env,
+    pathToClaudeCodeExecutable: provider?.binary ?? "claude",
+    settings: params.settingsPath,
+    extraArgs,
+    includePartialMessages: true,
+    ...run.model ? { model: run.model } : {},
+    ...run.reasoning ? { effort: run.reasoning } : {},
+    ...provider?.permissionMode ? { permissionMode: provider.permissionMode } : {},
+    ...provider?.permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {},
+    ...provider?.allowedTools?.length ? { allowedTools: provider.allowedTools } : {},
+    ...run.resumeSessionId ? { resume: run.resumeSessionId } : {}
+  };
+}
 function toRawEvent(runId, payload, type) {
   return {
     provider: AgentProvider.ClaudeCode,
@@ -1526,917 +1531,740 @@ function toRawEvent(runId, payload, type) {
   };
 }
 function extractAssistantText(message) {
-  const content = message.message;
-  if (Array.isArray(content)) {
-    return content.filter((block) => block.type === "text").map((block) => String(block.text ?? "")).join("");
-  }
-  if (content && Array.isArray(content.content)) {
-    return content.content.filter((block) => block.type === "text").map((block) => String(block.text ?? "")).join("");
-  }
-  return "";
-}
-function extractStreamDelta(message) {
+  const content = message.message?.content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((block) => block.type === "text").map((block) => String(block.text ?? "")).join("");
+}
+function extractAssistantThinking(message) {
+  const content = message.message?.content;
+  if (!Array.isArray(content)) return "";
+  return content.filter(
+    (block) => block.type === "thinking" || block.type === "redacted_thinking"
+  ).map((block) => String(block.thinking ?? "")).filter(Boolean).join("");
+}
+function extractStreamDeltas(message) {
   const event = message.event;
-  if (!event) {
-    return "";
+  if (!event || event.type !== "content_block_delta") {
+    return { text: "", thinking: "" };
   }
   const delta = event.delta;
-  if (typeof delta?.text === "string") {
-    return delta.text;
+  if (!delta) return { text: "", thinking: "" };
+  if (delta.type === "text_delta" && typeof delta.text === "string") {
+    return { text: delta.text, thinking: "" };
   }
-  if (typeof event.text === "string") {
-    return event.text;
+  if (delta.type === "thinking_delta" && typeof delta.thinking === "string") {
+    return { text: "", thinking: delta.thinking };
   }
-  return "";
+  return { text: "", thinking: "" };
 }
-function createClaudePermissionEvent(request, message) {
-  const requestPayload = message.request ?? {};
-  return createNormalizedEvent(
-    "permission.requested",
-    {
-      provider: request.provider,
-      runId: request.runId,
-      raw: toRawEvent(request.runId, message, message.type)
-    },
-    {
-      requestId: String(message.request_id ?? ""),
-      kind: "tool",
-      title: `Approve ${String(requestPayload.tool_name ?? "tool")} tool`,
-      message: `Claude wants to use ${String(requestPayload.tool_name ?? "tool")}.`,
-      input: requestPayload.input,
-      canRemember: false
-    }
-  );
+function createClaudeCodeDaemonScript() {
+  const version = JSON.stringify(DAEMON_PROTOCOL_VERSION);
+  return `import http from "node:http";
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+
+const VERSION = ${version};
+const port = Number(process.argv[2] ?? "${DAEMON_PORT}");
+const liveRuns = new Map();
+
+// The SDK's default spawn does \`existsSync(pathToClaudeCodeExecutable)\`
+// before invoking child_process.spawn \u2014 that check fails on bare names
+// like "claude" because existsSync doesn't do PATH lookup. Resolve to an
+// absolute path once at daemon startup so the SDK is happy regardless of
+// what the host passes.
+function resolveClaudeBinary(hint) {
+  if (hint && (hint.includes("/") || hint.includes(String.fromCharCode(92)))) {
+    return hint;
+  }
+  const name = hint || "claude";
+  try {
+    const out = execSync("command -v " + name + " || which " + name, {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    if (out && existsSync(out)) return out;
+  } catch {}
+  return name;
 }
-async function prepareClaudeRuntime(request) {
-  const options = request.options;
-  const provider = options.provider;
-  const target = await createRuntimeTarget(
-    request.provider,
-    request.runId,
-    options
-  );
-  const hooks = assertHooksSupported(request.provider, options);
-  assertCommandsSupported(request.provider, options.commands);
-  const { artifacts: skillArtifacts, installCommands } = await prepareSkillArtifacts(
-    request.provider,
-    options.skills,
-    target.layout
-  );
-  const artifacts = [
-    ...skillArtifacts,
-    ...buildClaudeCommandArtifacts(options.commands, target.layout)
-  ];
-  const mcpArtifact = buildClaudeMcpArtifact(
-    options.mcps,
-    target.layout.claudeDir
-  );
-  if (mcpArtifact) {
-    artifacts.push(mcpArtifact);
-  }
-  const hookSettings = buildClaudeHookSettings(hooks);
-  let settingsPath;
-  if (hookSettings) {
-    settingsPath = path8.join(target.layout.claudeDir, "settings.json");
-    artifacts.push({
-      path: settingsPath,
-      content: JSON.stringify(hookSettings, null, 2)
-    });
-  }
-  for (const artifact of artifacts) {
-    await target.writeArtifact(artifact);
-  }
-  await installSkills(target, installCommands);
-  const agents = buildClaudeAgentsConfig(options.subAgents);
-  const initializeRequest = Object.keys({
-    ...request.run.systemPrompt ? { systemPrompt: request.run.systemPrompt } : {},
-    ...agents ? { agents } : {}
-  }).length ? {
-    subtype: "initialize",
-    ...request.run.systemPrompt ? { systemPrompt: request.run.systemPrompt } : {},
-    ...agents ? { agents } : {}
-  } : void 0;
-  const buildArgs = (sdkUrl) => [
-    "--sdk-url",
-    sdkUrl,
-    "--print",
-    "--output-format",
-    "stream-json",
-    "--input-format",
-    "stream-json",
-    ...provider?.verbose ? ["--verbose"] : [],
-    ...request.run.model ? ["--model", request.run.model] : [],
-    ...provider?.permissionMode ? ["--permission-mode", provider.permissionMode] : [],
-    ...provider?.allowedTools?.length ? ["--allowedTools", provider.allowedTools.join(",")] : [],
-    ...request.run.resumeSessionId ? ["-r", request.run.resumeSessionId] : [],
-    ...settingsPath ? ["--settings", settingsPath] : [],
-    ...mcpArtifact ? ["--mcp-config", mcpArtifact.path] : [],
-    ...provider?.args ?? [],
-    "-p",
-    ""
-  ];
-  const env = {
-    ...options.env ?? {},
-    ...target.env
-  };
+
+function createPromptStream() {
+  const queue = [];
+  let resolver = null;
+  let ended = false;
   return {
-    target,
-    buildArgs,
-    env,
-    initializeRequest
+    [Symbol.asyncIterator]: async function* () {
+      while (true) {
+        if (queue.length > 0) { yield queue.shift(); continue; }
+        if (ended) return;
+        await new Promise((r) => { resolver = r; });
+      }
+    },
+    push(message) {
+      queue.push(message);
+      const r = resolver; resolver = null; r?.();
+    },
+    end() {
+      ended = true;
+      const r = resolver; resolver = null; r?.();
+    },
   };
 }
-function createRemoteSdkRelayScript() {
-  return `
-import crypto from "node:crypto";
-import http from "node:http";
-
-const port = Number(process.argv[2] ?? "43180");
-const magic = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
-const channels = new Map();
-let hostSocket = null;
 
-function getChannel(runId) {
-  let channel = channels.get(runId);
-  if (!channel) {
-    channel = {
-      claude: null,
-      pending: {
-        toHost: [],
-        claude: [],
-      },
-    };
-    channels.set(runId, channel);
-  }
-  return channel;
+function readJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let total = 0;
+    req.on("data", (c) => {
+      total += c.length;
+      if (total > 8 * 1024 * 1024) {
+        req.destroy(new Error("body too large"));
+        return;
+      }
+      chunks.push(c);
+    });
+    req.on("end", () => {
+      try {
+        const text = Buffer.concat(chunks).toString("utf8");
+        resolve(text ? JSON.parse(text) : {});
+      } catch (e) { reject(e); }
+    });
+    req.on("error", reject);
+  });
 }
 
-function sendFrame(socket, payload, opcode = 0x1) {
-  const length = payload.length;
-  let header;
-  if (length < 126) {
-    header = Buffer.alloc(2);
-    header[1] = length;
-  } else if (length < 65536) {
-    header = Buffer.alloc(4);
-    header[1] = 126;
-    header.writeUInt16BE(length, 2);
-  } else {
-    header = Buffer.alloc(10);
-    header[1] = 127;
-    header.writeBigUInt64BE(BigInt(length), 2);
-  }
-  header[0] = 0x80 | opcode;
-  socket.write(Buffer.concat([header, payload]));
+function autoApproveCanUseTool(_toolName, input) {
+  return { behavior: "allow", updatedInput: input };
 }
 
-function parseFrame(buffer) {
-  if (buffer.length < 2) {
-    return null;
+async function handleStart(req, res, runId) {
+  let body;
+  try { body = await readJsonBody(req); }
+  catch (e) {
+    res.writeHead(400, { "content-type": "application/json" });
+    res.end(JSON.stringify({ error: String(e?.message ?? e) }));
+    return;
+  }
+  const { prompt, options } = body || {};
+  if (!prompt) {
+    res.writeHead(400);
+    res.end("missing prompt");
+    return;
   }
 
-  const first = buffer[0];
-  const second = buffer[1];
-  const fin = (first & 0x80) !== 0;
-  const opcode = first & 0x0f;
-  const masked = (second & 0x80) !== 0;
-  let length = second & 0x7f;
-  let offset = 2;
+  const promptStream = createPromptStream();
+  promptStream.push(prompt);
 
-  if (length === 126) {
-    if (buffer.length < offset + 2) {
-      return null;
-    }
-    length = buffer.readUInt16BE(offset);
-    offset += 2;
-  } else if (length === 127) {
-    if (buffer.length < offset + 8) {
-      return null;
-    }
-    length = Number(buffer.readBigUInt64BE(offset));
-    offset += 8;
-  }
+  res.writeHead(200, {
+    "content-type": "application/x-ndjson",
+    "transfer-encoding": "chunked",
+    "x-daemon-version": VERSION,
+  });
 
-  let mask;
-  if (masked) {
-    if (buffer.length < offset + 4) {
-      return null;
-    }
-    mask = buffer.subarray(offset, offset + 4);
-    offset += 4;
-  }
+  const opts = { ...(options || {}) };
+  const autoApprove = !!opts.autoApproveTools;
+  delete opts.autoApproveTools;
+  opts.pathToClaudeCodeExecutable = resolveClaudeBinary(
+    opts.pathToClaudeCodeExecutable,
+  );
 
-  if (buffer.length < offset + length) {
-    return null;
+  let queryHandle;
+  try {
+    queryHandle = query({
+      prompt: promptStream,
+      options: {
+        ...opts,
+        ...(autoApprove ? { canUseTool: autoApproveCanUseTool } : {}),
+      },
+    });
+  } catch (e) {
+    res.write(JSON.stringify({ _error: String(e?.message ?? e) }) + "\\n");
+    res.end();
+    return;
   }
 
-  let payload = buffer.subarray(offset, offset + length);
-  if (mask) {
-    payload = Buffer.from(payload);
-    for (let index = 0; index < payload.length; index += 1) {
-      payload[index] ^= mask[index % 4];
-    }
-  }
+  liveRuns.set(runId, { query: queryHandle, prompt: promptStream });
 
-  return {
-    fin,
-    opcode,
-    payload,
-    bytesUsed: offset + length,
-  };
-}
+  // Client disconnected (e.g. host process killed) \u2192 tear down.
+  req.on("close", () => {
+    if (!liveRuns.has(runId)) return;
+    liveRuns.delete(runId);
+    promptStream.end();
+    queryHandle.interrupt().catch(() => {});
+  });
 
-function sendHostEnvelope(runId, message) {
-  if (!hostSocket) {
-    return false;
+  try {
+    for await (const message of queryHandle) {
+      res.write(JSON.stringify(message) + "\\n");
+      if (message.type === "result") break;
+    }
+  } catch (e) {
+    res.write(JSON.stringify({ _error: String(e?.message ?? e) }) + "\\n");
+  } finally {
+    liveRuns.delete(runId);
+    promptStream.end();
+    res.end();
   }
-  sendFrame(
-    hostSocket,
-    Buffer.from(JSON.stringify({ runId, message }), "utf8"),
-  );
-  return true;
 }
 
-function flushClaude(channel) {
-  const socket = channel.claude;
-  if (!socket) {
+async function handleSendMessage(req, res, runId) {
+  const run = liveRuns.get(runId);
+  if (!run) {
+    res.writeHead(404, { "content-type": "application/json" });
+    res.end(JSON.stringify({ error: "no such run" }));
     return;
   }
-  while (channel.pending.claude.length > 0) {
-    sendFrame(socket, Buffer.from(channel.pending.claude.shift(), "utf8"));
+  let body;
+  try { body = await readJsonBody(req); }
+  catch (e) {
+    res.writeHead(400);
+    res.end(String(e?.message ?? e));
+    return;
   }
+  run.prompt.push({
+    type: "user",
+    message: { role: "user", content: body.content },
+    parent_tool_use_id: null,
+  });
+  res.writeHead(204);
+  res.end();
 }
 
-function flushHostBacklog() {
-  if (!hostSocket) {
+async function handleAbort(_req, res, runId) {
+  const run = liveRuns.get(runId);
+  if (!run) {
+    res.writeHead(404);
+    res.end();
     return;
   }
-  for (const [runId, channel] of channels.entries()) {
-    while (channel.pending.toHost.length > 0) {
-      sendHostEnvelope(runId, channel.pending.toHost.shift());
-    }
-  }
+  await run.query.interrupt().catch(() => {});
+  res.writeHead(204);
+  res.end();
 }
 
-function relayFromClaude(runId, message) {
-  const channel = getChannel(runId);
-  if (!sendHostEnvelope(runId, message)) {
-    channel.pending.toHost.push(message);
+async function handleDelete(_req, res, runId) {
+  const run = liveRuns.get(runId);
+  if (run) {
+    liveRuns.delete(runId);
+    run.prompt.end();
+    await run.query.interrupt().catch(() => {});
   }
+  res.writeHead(204);
+  res.end();
 }
 
-function registerClaudePeer(socket, runId) {
-  const channel = getChannel(runId);
-  channel.claude = socket;
-  flushClaude(channel);
-  let buffer = Buffer.alloc(0);
-  let fragments = [];
-
-  socket.on("data", (chunk) => {
-    buffer = Buffer.concat([buffer, chunk]);
-
-    while (true) {
-      const frame = parseFrame(buffer);
-      if (!frame) {
-        return;
-      }
-      buffer = buffer.subarray(frame.bytesUsed);
-
-      if (frame.opcode === 0x8) {
-        socket.end();
-        return;
-      }
-      if (frame.opcode === 0x9) {
-        sendFrame(socket, frame.payload, 0xA);
-        continue;
-      }
-      if (frame.opcode === 0xA) {
-        continue;
-      }
-      if (frame.opcode === 0x1) {
-        fragments = [frame.payload];
-      } else if (frame.opcode === 0x0) {
-        fragments.push(frame.payload);
-      } else {
-        continue;
-      }
-
-      if (frame.fin) {
-        const text = Buffer.concat(fragments).toString("utf8");
-        for (const line of text
-          .split("\\n")
-          .map((value) => value.trim())
-          .filter(Boolean)) {
-          relayFromClaude(runId, JSON.parse(line));
-        }
-        fragments = [];
-      }
-    }
-  });
-
-  const clearPeer = () => {
-    const latestChannel = channels.get(runId);
-    if (!latestChannel) {
-      return;
-    }
-    if (latestChannel.claude === socket) {
-      latestChannel.claude = null;
-    }
-    if (
-      latestChannel.claude === null &&
-      latestChannel.pending.toHost.length === 0 &&
-      latestChannel.pending.claude.length === 0
-    ) {
-      channels.delete(runId);
-    }
-  };
-  socket.on("close", clearPeer);
-  socket.on("error", clearPeer);
-}
-
-function registerHostPeer(socket) {
-  hostSocket = socket;
-  flushHostBacklog();
-
-  let buffer = Buffer.alloc(0);
-  let fragments = [];
-
-  socket.on("data", (chunk) => {
-    buffer = Buffer.concat([buffer, chunk]);
-
-    while (true) {
-      const frame = parseFrame(buffer);
-      if (!frame) {
-        return;
-      }
-      buffer = buffer.subarray(frame.bytesUsed);
-
-      if (frame.opcode === 0x8) {
-        socket.end();
-        return;
-      }
-      if (frame.opcode === 0x9) {
-        sendFrame(socket, frame.payload, 0xA);
-        continue;
-      }
-      if (frame.opcode === 0xA) {
-        continue;
-      }
-      if (frame.opcode === 0x1) {
-        fragments = [frame.payload];
-      } else if (frame.opcode === 0x0) {
-        fragments.push(frame.payload);
-      } else {
-        continue;
-      }
-
-      if (frame.fin) {
-        const envelope = JSON.parse(Buffer.concat(fragments).toString("utf8"));
-        const runId = String(envelope.runId ?? "");
-        const message = envelope.message;
-        if (!runId || !message) {
-          fragments = [];
-          continue;
-        }
-        const channel = getChannel(runId);
-        if (channel.claude) {
-          sendFrame(
-            channel.claude,
-            Buffer.from(JSON.stringify(message) + "\\n", "utf8"),
-          );
-        } else {
-          channel.pending.claude.push(JSON.stringify(message) + "\\n");
-        }
-        fragments = [];
-      }
-    }
-  });
-
-  const clearHost = () => {
-    if (hostSocket === socket) {
-      hostSocket = null;
-    }
-  };
-  socket.on("close", clearHost);
-  socket.on("error", clearHost);
-}
-
-const server = http.createServer((_request, response) => {
-  response.writeHead(426, { "content-type": "text/plain" });
-  response.end("Upgrade Required");
-});
-
-server.on("upgrade", (request, socket) => {
-  if (request.headers.upgrade?.toLowerCase() !== "websocket") {
-    socket.destroy();
+const server = http.createServer((req, res) => {
+  if (req.method === "GET" && req.url === "/__version") {
+    res.writeHead(200, { "content-type": "text/plain" });
+    res.end(VERSION);
     return;
   }
-
-  const key = request.headers["sec-websocket-key"];
-  if (typeof key !== "string") {
-    socket.destroy();
+  const url = req.url ?? "";
+  let m;
+  if (req.method === "POST" && (m = url.match(/^\\/runs\\/([^/]+)\\/start$/))) {
+    handleStart(req, res, decodeURIComponent(m[1]));
     return;
   }
-
-  const accept = crypto
-    .createHash("sha1")
-    .update(key + magic)
-    .digest("base64");
-  socket.write(
-    [
-      "HTTP/1.1 101 Switching Protocols",
-      "Upgrade: websocket",
-      "Connection: Upgrade",
-      "Sec-WebSocket-Accept: " + accept,
-      "",
-      "",
-    ].join("\\r\\n"),
-  );
-
-  const url = new URL(request.url ?? "/", "http://127.0.0.1");
-  const role = url.searchParams.get("role") === "host" ? "host" : "claude";
-  if (role === "host") {
-    registerHostPeer(socket);
+  if (req.method === "POST" && (m = url.match(/^\\/runs\\/([^/]+)\\/sendMessage$/))) {
+    handleSendMessage(req, res, decodeURIComponent(m[1]));
     return;
   }
-
-  const runId = url.searchParams.get("runId") ?? "default";
-  registerClaudePeer(socket, runId);
+  if (req.method === "POST" && (m = url.match(/^\\/runs\\/([^/]+)\\/abort$/))) {
+    handleAbort(req, res, decodeURIComponent(m[1]));
+    return;
+  }
+  if (req.method === "DELETE" && (m = url.match(/^\\/runs\\/([^/]+)$/))) {
+    handleDelete(req, res, decodeURIComponent(m[1]));
+    return;
+  }
+  res.writeHead(404, { "content-type": "text/plain" });
+  res.end("not found");
 });
 
-server.listen(port, "0.0.0.0");
+server.listen(port, "0.0.0.0", () => {
+  console.error("[claude-code-daemon] listening on :" + port + " v" + VERSION);
+});
 
 const shutdown = () => {
-  hostSocket?.destroy();
-  for (const channel of channels.values()) {
-    channel.claude?.destroy();
+  for (const r of liveRuns.values()) {
+    r.prompt.end();
+    r.query.interrupt().catch(() => {});
   }
-  server.close(() => process.exit(0));
+  server.close();
+  setTimeout(() => process.exit(0), 100).unref();
 };
-
-process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
-`.trimStart();
-}
-function toWebSocketUrl(url) {
-  const parsed = new URL(url);
-  parsed.protocol = parsed.protocol === "https:" ? "wss:" : "ws:";
-  return parsed.toString();
-}
-function toSharedHostWebSocketUrl(url) {
-  const parsed = new URL(toWebSocketUrl(url));
-  parsed.searchParams.set("role", "host");
-  parsed.searchParams.delete("runId");
-  return parsed.toString();
+process.on("SIGINT", shutdown);
+`;
 }
-function toClaudeRelayUrl(port, runId) {
-  const parsed = new URL(`ws://127.0.0.1:${port}/`);
-  parsed.searchParams.set("role", "claude");
-  parsed.searchParams.set("runId", runId);
-  return parsed.toString();
+var daemonInflight = /* @__PURE__ */ new WeakMap();
+async function ensureClaudeCodeDaemon(options, env) {
+  const sandbox = options.sandbox;
+  if (!sandbox) return;
+  const key = sandbox;
+  const existing = daemonInflight.get(key);
+  if (existing) return existing;
+  const promise = ensureClaudeCodeDaemonUncached(options, env);
+  daemonInflight.set(key, promise);
+  promise.finally(() => {
+    if (daemonInflight.get(key) === promise) daemonInflight.delete(key);
+  });
+  return promise;
 }
-function buildLocalSdkUrl(server, sandboxProvider) {
-  if (sandboxProvider === SandboxProvider.LocalDocker) {
-    return server.url.replace("127.0.0.1", "host.docker.internal").replace("0.0.0.0", "host.docker.internal");
-  }
-  return server.url;
+async function ensureClaudeCodeDaemonUncached(options, env) {
+  return time(debugRelay, "ensureClaudeCodeDaemon", async () => {
+    const sandbox = options.sandbox;
+    const probe = await time(
+      debugRelay,
+      "probe daemon version",
+      () => sandbox.run(
+        `curl -fsS --max-time 1 http://127.0.0.1:${DAEMON_PORT}/__version 2>/dev/null`,
+        { cwd: options.cwd, timeoutMs: 1e4 }
+      )
+    );
+    if (probe.exitCode === 0 && probe.combinedOutput.trim() === DAEMON_PROTOCOL_VERSION) {
+      debugRelay(
+        "daemon v%s already running \u2014 reusing",
+        DAEMON_PROTOCOL_VERSION
+      );
+      return;
+    }
+    const daemonDir = path8.posix.dirname(DAEMON_PATH);
+    const daemonNodeModules = `${daemonDir}/node_modules/@anthropic-ai`;
+    const launchCommand = [
+      `NPM_ROOT="$(npm root -g 2>/dev/null)"`,
+      `if [ -z "$NPM_ROOT" ] || [ ! -d "$NPM_ROOT/@anthropic-ai/claude-agent-sdk" ]; then echo "claude-code daemon launch: @anthropic-ai/claude-agent-sdk not found under $NPM_ROOT" >&2; exit 1; fi`,
+      `mkdir -p ${shellQuote(daemonNodeModules)}`,
+      `ln -sfn "$NPM_ROOT/@anthropic-ai/claude-agent-sdk" ${shellQuote(daemonNodeModules + "/claude-agent-sdk")}`,
+      `if [ -f ${shellQuote(DAEMON_PID_PATH)} ]; then kill -TERM "$(cat ${shellQuote(DAEMON_PID_PATH)})" 2>/dev/null || true; fi`,
+      `(fuser -k -n tcp ${DAEMON_PORT} 2>/dev/null || true)`,
+      // Brief grace so the kernel releases the port before the new
+      // daemon's listen() — only matters on warm-sandbox respawns;
+      // adds 200ms otherwise.
+      `sleep 0.2`,
+      `(nohup node ${shellQuote(DAEMON_PATH)} ${DAEMON_PORT} > ${shellQuote(DAEMON_LOG_PATH)} 2>&1 & echo $! > ${shellQuote(DAEMON_PID_PATH)})`
+    ].join(" && ");
+    const launch = await time(
+      debugRelay,
+      "uploadAndRun daemon (write + spawn)",
+      () => sandbox.uploadAndRun(
+        [
+          {
+            path: DAEMON_PATH,
+            content: createClaudeCodeDaemonScript(),
+            mode: 420
+          }
+        ],
+        launchCommand,
+        { cwd: options.cwd, env: { ...env, IS_SANDBOX: "1" } }
+      )
+    );
+    if (launch.exitCode !== 0) {
+      throw new Error(
+        `Could not start claude-code daemon: ${launch.stderr || launch.combinedOutput || "(no output)"}`
+      );
+    }
+  });
 }
-async function connectRemoteTransport(url, headers = {}) {
-  const startedAt = Date.now();
+var DAEMON_FIRST_REQUEST_RETRY_BUDGET_MS = 3e4;
+var DAEMON_FIRST_REQUEST_RETRY_INTERVAL_MS = 250;
+async function fetchWithDaemonRetry(input, init) {
+  const deadline = Date.now() + DAEMON_FIRST_REQUEST_RETRY_BUDGET_MS;
   let lastError;
-  while (Date.now() - startedAt < 3e4) {
-    const client = new SharedSdkWsConnection(url, headers);
+  while (Date.now() < deadline) {
     try {
-      await Promise.race([
-        client.start(),
-        sleep(2e3).then(() => {
-          throw new Error(
-            `Timed out connecting to remote SDK bridge at ${url}.`
-          );
-        })
-      ]);
-      return client;
+      return await fetch(input, init);
     } catch (error) {
       lastError = error;
-      await client.close().catch(() => void 0);
-      await sleep(250);
+      const aborted = error?.name === "AbortError";
+      if (aborted) {
+        throw error;
+      }
+      await sleep(DAEMON_FIRST_REQUEST_RETRY_INTERVAL_MS);
     }
   }
-  throw lastError ?? new Error(`Could not connect to remote SDK bridge at ${url}.`);
+  throw lastError ?? new Error("claude-code daemon request timed out");
 }
-async function canConnectToRemoteRelay(previewUrl, headers = {}) {
-  const parsed = new URL(toWebSocketUrl(previewUrl));
-  parsed.searchParams.set("role", "claude");
-  parsed.searchParams.set("runId", "__probe__");
-  const client = new SharedSdkWsConnection(parsed.toString(), headers);
-  try {
-    await Promise.race([
-      client.start(),
-      sleep(2e3).then(() => {
-        throw new Error("Timed out connecting to remote relay.");
-      })
-    ]);
-    return true;
-  } catch {
-    return false;
-  } finally {
-    await client.close().catch(() => void 0);
+async function* parseNdjsonStream(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    let idx;
+    while ((idx = buffer.indexOf("\n")) !== -1) {
+      const line = buffer.slice(0, idx).trim();
+      buffer = buffer.slice(idx + 1);
+      if (line) {
+        try {
+          yield JSON.parse(line);
+        } catch {
+        }
+      }
+    }
   }
-}
-async function ensureSharedRemoteConnection(sandbox, previewUrl) {
-  const key = sandbox;
-  const existing = sharedRemoteConnectionBySandbox.get(key);
-  if (existing) {
+  buffer += decoder.decode();
+  if (buffer.trim()) {
     try {
-      const connection = await existing;
-      await connection.connection.waitForConnection(1e3);
-      return connection;
+      yield JSON.parse(buffer);
     } catch {
-      try {
-        const stale = await existing;
-        await stale.connection.close().catch(() => void 0);
-      } catch {
-      }
-      sharedRemoteConnectionBySandbox.delete(key);
     }
   }
-  const created = (async () => {
-    const url = toSharedHostWebSocketUrl(previewUrl);
-    const connection = await connectRemoteTransport(url, sandbox.previewHeaders);
-    return { previewUrl, connection };
-  })();
-  sharedRemoteConnectionBySandbox.set(key, created);
-  try {
-    return await created;
-  } catch (error) {
-    sharedRemoteConnectionBySandbox.delete(key);
-    throw error;
-  }
 }
-async function ensureRemoteRelay(request, prepared) {
-  const sandbox = request.options.sandbox;
-  await sandbox.openPort(REMOTE_SDK_RELAY_PORT);
-  const previewUrl = await sandbox.getPreviewLink(REMOTE_SDK_RELAY_PORT);
-  const previewHeaders = sandbox.previewHeaders;
-  if (await canConnectToRemoteRelay(previewUrl, previewHeaders)) {
-    return {
-      relayPort: REMOTE_SDK_RELAY_PORT,
-      relayPath: REMOTE_SDK_RELAY_PATH,
-      previewUrl
-    };
-  }
-  await prepared.target.writeArtifact({
-    path: REMOTE_SDK_RELAY_PATH,
-    content: createRemoteSdkRelayScript()
-  });
-  const relayLogPath = "/tmp/agentbox/claude-code/relay.log";
-  const relayHandle = await sandbox.runAsync(
-    [
-      `mkdir -p ${shellQuote(path8.posix.dirname(REMOTE_SDK_RELAY_PATH))}`,
-      `mkdir -p ${shellQuote(path8.posix.dirname(relayLogPath))}`,
-      `node ${shellQuote(REMOTE_SDK_RELAY_PATH)} ${shellQuote(String(REMOTE_SDK_RELAY_PORT))} > ${shellQuote(relayLogPath)} 2>&1`
-    ].join(" && "),
-    {
-      cwd: request.options.cwd,
-      env: { ...prepared.env, IS_SANDBOX: "1" }
-    }
-  );
-  let relayExit;
-  void relayHandle.wait().then((result) => {
-    relayExit = result;
-  }).catch((error) => {
-    relayExit = error;
-  });
-  const startedAt = Date.now();
-  while (Date.now() - startedAt < 3e4) {
-    if (await canConnectToRemoteRelay(previewUrl, previewHeaders)) {
-      return {
-        relayPort: REMOTE_SDK_RELAY_PORT,
-        relayPath: REMOTE_SDK_RELAY_PATH,
-        previewUrl,
-        handle: relayHandle
-      };
-    }
-    if (relayExit !== void 0) {
-      break;
-    }
-    await sleep(250);
-  }
-  await relayHandle.kill().catch(() => void 0);
-  throw new Error(`Timed out waiting for Claude relay on ${previewUrl}.`);
+async function daemonBaseUrl(sandbox) {
+  const url = await sandbox.getPreviewLink(DAEMON_PORT);
+  return url.replace(/\/$/, "");
 }
-async function createLocalRuntime(request, prepared) {
-  const sandboxProvider = request.options.sandbox?.provider;
-  const transport = new SdkWsServer({
-    host: sandboxProvider === SandboxProvider.LocalDocker ? "0.0.0.0" : "127.0.0.1"
-  });
-  await transport.start();
-  const args = prepared.buildArgs(buildLocalSdkUrl(transport, sandboxProvider));
-  if (request.options.sandbox) {
-    const handle = await request.options.sandbox.runAsync(
-      [request.options.provider?.binary ?? "claude", ...args],
-      {
-        cwd: request.options.cwd,
-        env: {
-          ...prepared.env
-        },
-        pty: true
+var ClaudeCodeAgentAdapter = class {
+  /**
+   * Sandbox-side preparation. Uploads `.claude/` artifacts and ensures
+   * the daemon is running. `execute()` then dials the daemon directly.
+   */
+  async setup(request) {
+    await time(debugClaude, "claude-code setup()", async () => {
+      const options = request.options;
+      const provider = request.provider;
+      const sandbox = options.sandbox;
+      if (!sandbox) {
+        throw new Error(
+          "claude-code requires a sandbox (the SDK transport runs as a daemon inside the sandbox)."
+        );
       }
-    );
-    return {
-      transport,
-      cleanup: async () => {
-        await handle.kill();
-        await transport.close();
-        await prepared.target.cleanup();
-      },
-      raw: { transport, handle, layout: prepared.target.layout },
-      initializeRequest: prepared.initializeRequest
-    };
-  }
-  const processHandle = spawnCommand({
-    command: request.options.provider?.binary ?? "claude",
-    args,
-    cwd: request.options.cwd,
-    env: {
-      ...process.env,
-      ...prepared.env
-    }
-  });
-  return {
-    transport,
-    cleanup: async () => {
-      await processHandle.kill();
-      await transport.close();
-      await prepared.target.cleanup();
-    },
-    raw: { transport, processHandle, layout: prepared.target.layout },
-    initializeRequest: prepared.initializeRequest
-  };
-}
-async function createRemoteSandboxRuntime(request, prepared) {
-  const sandbox = request.options.sandbox;
-  const relay = await ensureRemoteRelay(request, prepared);
-  const args = prepared.buildArgs(
-    toClaudeRelayUrl(relay.relayPort, request.runId)
-  );
-  const handle = await sandbox.runAsync(
-    [request.options.provider?.binary ?? "claude", ...args],
-    {
-      cwd: request.options.cwd,
-      env: { ...prepared.env, IS_SANDBOX: "1" },
-      pty: true
-    }
-  );
-  const sharedConnection = await ensureSharedRemoteConnection(
-    sandbox,
-    relay.previewUrl
-  );
-  const transport = sharedConnection.connection.createChannel(request.runId);
-  return {
-    transport,
-    cleanup: async () => {
-      await handle.kill().catch(() => void 0);
-      await transport.close().catch(() => void 0);
-      await prepared.target.cleanup();
-    },
-    raw: { transport, handle, relay, layout: prepared.target.layout },
-    initializeRequest: prepared.initializeRequest
-  };
-}
-async function createRuntime(request) {
-  if (request.options.sandbox && request.options.sandbox.provider !== SandboxProvider.LocalDocker) {
-    await request.options.sandbox.openPort(REMOTE_SDK_RELAY_PORT);
-    const prepared2 = await prepareClaudeRuntime(request);
-    return createRemoteSandboxRuntime(request, prepared2);
+      const target = await createSetupTarget(provider, "shared-setup", options);
+      const settingsPath = path8.join(target.layout.claudeDir, "settings.json");
+      const mcpConfigPath = path8.join(
+        target.layout.claudeDir,
+        "agentbox-mcp.json"
+      );
+      const hooks = assertHooksSupported(provider, options);
+      assertCommandsSupported(provider, options.commands);
+      const { artifacts: skillArtifacts, installCommands } = await time(
+        debugClaude,
+        "prepareSkillArtifacts",
+        () => prepareSkillArtifacts(provider, options.skills, target.layout)
+      );
+      const hookSettings = buildClaudeHookSettings(hooks) ?? {};
+      const mcpConfigJson = buildClaudeMcpConfig(options.mcps) ?? JSON.stringify({ mcpServers: {} }, null, 2);
+      const artifacts = [
+        ...skillArtifacts,
+        ...buildClaudeCommandArtifacts(options.commands, target.layout),
+        ...buildClaudeSubagentArtifacts(options.subAgents, target.layout),
+        { path: settingsPath, content: JSON.stringify(hookSettings, null, 2) },
+        { path: mcpConfigPath, content: mcpConfigJson }
+      ];
+      const env = { ...options.env ?? {}, ...target.env };
+      await Promise.all([
+        time(
+          debugClaude,
+          "applyDifferentialSetup",
+          () => applyDifferentialSetup(target, artifacts, installCommands)
+        ),
+        ensureClaudeCodeDaemon(options, env)
+      ]);
+    });
   }
-  const prepared = await prepareClaudeRuntime(request);
-  return createLocalRuntime(request, prepared);
-}
-var ClaudeCodeAgentAdapter = class {
   async execute(request, sink) {
-    const inputParts = await validateProviderUserInput(
-      request.provider,
-      request.run.input
+    const executeStartedAt = Date.now();
+    debugClaude("execute() start runId=%s", request.runId);
+    const sandbox = request.options.sandbox;
+    if (!sandbox) {
+      throw new Error(
+        "claude-code requires a sandbox (the SDK transport runs as a daemon inside the sandbox)."
+      );
+    }
+    const claudeDir = claudeConfigDir(request.options);
+    const settingsPath = path8.join(claudeDir, "settings.json");
+    const mcpConfigPath = path8.join(claudeDir, "agentbox-mcp.json");
+    const env = {
+      ...request.options.env ?? {},
+      CLAUDE_CONFIG_DIR: claudeDir,
+      // `IS_SANDBOX=1` lets the in-sandbox claude binary accept
+      // `--dangerously-skip-permissions` (i.e. permissionMode
+      // bypassPermissions) when running as root, which is the default
+      // user inside our images.
+      IS_SANDBOX: "1"
+    };
+    const inputParts = await time(
+      debugClaude,
+      "validateProviderUserInput",
+      () => validateProviderUserInput(request.provider, request.run.input)
     );
     const userContent = mapToClaudeUserContent(inputParts);
-    let sessionId = "";
-    let accumulatedText = "";
-    let usedStreaming = false;
-    let pendingMessages = 1;
+    const initialUuid = randomUUID();
+    const presetSessionId = request.run.resumeSessionId ?? randomUUID();
+    sink.setSessionId(presetSessionId);
+    const baseUrl = await time(
+      debugClaude,
+      "getPreviewLink daemon",
+      () => daemonBaseUrl(sandbox)
+    );
+    const startUrl = `${baseUrl}/runs/${encodeURIComponent(request.runId)}/start`;
+    const sdkOptions = buildClaudeQueryOptions({
+      request,
+      settingsPath,
+      mcpConfigPath,
+      env
+    });
     const autoApproveTools = shouldAutoApproveClaudeTools(request.options);
-    const transportRef = {};
-    const queuedSends = [];
+    const requestBody = {
+      prompt: {
+        type: "user",
+        message: {
+          role: "user",
+          content: userContent
+        },
+        parent_tool_use_id: null
+      },
+      options: {
+        ...sdkOptions,
+        // `sessionId` and `resume` are mutually exclusive — buildClaudeQueryOptions
+        // already set `resume` for the resume path, so only stamp `sessionId` for
+        // fresh runs.
+        ...request.run.resumeSessionId ? {} : { sessionId: presetSessionId },
+        autoApproveTools
+      }
+    };
+    const fetchAbort = new AbortController();
+    const cleanup = async () => {
+      try {
+        await fetch(
+          `${baseUrl}/runs/${encodeURIComponent(request.runId)}/abort`,
+          { method: "POST", headers: sandbox.previewHeaders }
+        );
+      } catch {
+      }
+      fetchAbort.abort();
+    };
+    sink.setAbort(cleanup);
     sink.onMessage(async (content) => {
-      pendingMessages++;
       const parts = await validateProviderUserInput(request.provider, content);
       const mapped = mapToClaudeUserContent(parts);
-      accumulatedText = "";
-      usedStreaming = false;
-      const payload = {
-        type: "user",
-        message: { role: "user", content: mapped },
-        parent_tool_use_id: null,
-        session_id: sessionId || request.run.resumeSessionId || "",
-        uuid: randomUUID2()
-      };
-      if (transportRef.current) {
-        await transportRef.current.send(payload);
-      } else {
-        queuedSends.push(payload);
-      }
+      const messageUuid = randomUUID();
+      await fetch(
+        `${baseUrl}/runs/${encodeURIComponent(request.runId)}/sendMessage`,
+        {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            ...sandbox.previewHeaders
+          },
+          body: JSON.stringify({ content: mapped })
+        }
+      );
+      return { messageId: messageUuid };
     });
-    const runtime = await createRuntime(request);
-    transportRef.current = runtime.transport;
-    sink.setRaw(runtime.raw);
-    sink.setAbort(runtime.cleanup);
+    const response = await time(
+      debugClaude,
+      "POST /runs/<id>/start",
+      () => fetchWithDaemonRetry(startUrl, {
+        method: "POST",
+        signal: fetchAbort.signal,
+        headers: {
+          "content-type": "application/json",
+          ...sandbox.previewHeaders
+        },
+        body: JSON.stringify(requestBody)
+      })
+    );
+    if (!response.ok || !response.body) {
+      const text = await response.text().catch(() => "");
+      throw new Error(
+        `claude-code daemon /start failed: ${response.status} ${text}`
+      );
+    }
+    sink.setRaw({ baseUrl, runId: request.runId, claudeDir });
     sink.emitEvent(
       createNormalizedEvent("run.started", {
         provider: request.provider,
         runId: request.runId
       })
     );
-    const completion = new Promise((resolve, reject) => {
-      void (async () => {
-        for await (const message of runtime.transport.messages()) {
-          sink.emitRaw(toRawEvent(request.runId, message, message.type));
-          if (message.type === "system" && message.subtype === "init") {
-            sessionId = String(message.session_id ?? "");
-            if (sessionId) {
-              sink.setSessionId(sessionId);
-            }
-            continue;
-          }
-          if (message.type === "control_request" && message.request?.subtype === "can_use_tool") {
-            const requestId = String(message.request_id ?? "");
-            const requestPayload = message.request;
-            const response = autoApproveTools ? {
-              requestId,
-              decision: "allow"
-            } : await sink.requestPermission(
-              createClaudePermissionEvent(request, message)
+    sink.emitEvent(
+      createNormalizedEvent(
+        "message.started",
+        { provider: request.provider, runId: request.runId },
+        { messageId: initialUuid }
+      )
+    );
+    let accumulatedText = "";
+    let pendingMessages = 1;
+    let firstStreamEventLogged = false;
+    let firstTextDeltaLogged = false;
+    const rawPayloads = [];
+    try {
+      for await (const item of parseNdjsonStream(response.body)) {
+        if (item && typeof item === "object" && "_error" in item) {
+          throw new Error(
+            String(item._error ?? "daemon error")
+          );
+        }
+        const message = item;
+        rawPayloads.push(message);
+        sink.emitRaw(toRawEvent(request.runId, message, message.type));
+        if (message.type === "system") {
+          const sys = message;
+          if (sys.subtype === "init" && sys.session_id) {
+            debugClaude(
+              "\u2605 session.init session_id=%s (%dms)",
+              sys.session_id.slice(0, 8),
+              Date.now() - executeStartedAt
             );
-            if (response.decision === "allow") {
-              sink.emitEvent(
-                createNormalizedEvent(
-                  "tool.call.started",
-                  {
-                    provider: request.provider,
-                    runId: request.runId
-                  },
-                  {
-                    toolName: String(requestPayload.tool_name ?? "tool"),
-                    callId: requestId,
-                    input: requestPayload.input
-                  }
-                )
-              );
-            }
-            await runtime.transport.send({
-              type: "control_response",
-              response: {
-                subtype: "success",
-                request_id: requestId,
-                response: response.decision === "allow" ? {
-                  behavior: "allow",
-                  updatedInput: requestPayload.input
-                } : {
-                  behavior: "deny",
-                  message: "User denied this action."
-                }
-              }
-            });
-            continue;
           }
-          if (message.type === "stream_event") {
-            const delta = extractStreamDelta(message);
-            if (delta) {
-              usedStreaming = true;
-              accumulatedText += delta;
-              sink.emitEvent(
-                createNormalizedEvent(
-                  "text.delta",
-                  {
-                    provider: request.provider,
-                    runId: request.runId
-                  },
-                  {
-                    delta
-                  }
-                )
-              );
-            }
-            continue;
+          continue;
+        }
+        if (message.type === "stream_event") {
+          if (!firstStreamEventLogged) {
+            firstStreamEventLogged = true;
+            debugClaude(
+              "\u2605 first stream_event (%dms since execute start)",
+              Date.now() - executeStartedAt
+            );
           }
-          if (message.type === "assistant") {
-            const text = extractAssistantText(message);
-            if (!usedStreaming && text) {
-              accumulatedText = text;
-              sink.emitEvent(
-                createNormalizedEvent(
-                  "text.delta",
-                  {
-                    provider: request.provider,
-                    runId: request.runId
-                  },
-                  {
-                    delta: text
-                  }
-                )
-              );
-            }
+          const partial = message;
+          const { text, thinking } = extractStreamDeltas(partial);
+          if (thinking) {
             sink.emitEvent(
               createNormalizedEvent(
-                "message.completed",
-                {
-                  provider: request.provider,
-                  runId: request.runId
-                },
-                {
-                  text
-                }
+                "reasoning.delta",
+                { provider: request.provider, runId: request.runId },
+                { delta: thinking }
               )
             );
-            continue;
           }
-          if (message.type === "result") {
-            const subtype = String(message.subtype ?? "success");
-            if (subtype === "success") {
-              pendingMessages--;
-              if (pendingMessages <= 0) {
-                resolve({ text: accumulatedText });
-                return;
-              }
-              continue;
-            } else {
-              reject(
-                new Error(
-                  String(
-                    message.result ?? message.error ?? "Claude Code run failed."
-                  )
-                )
+          if (text) {
+            if (!firstTextDeltaLogged) {
+              firstTextDeltaLogged = true;
+              debugClaude(
+                "\u2605 first text delta (%dms since execute start)",
+                Date.now() - executeStartedAt
               );
             }
-            return;
+            accumulatedText += text;
+            sink.emitEvent(
+              createNormalizedEvent(
+                "text.delta",
+                { provider: request.provider, runId: request.runId },
+                { delta: text }
+              )
+            );
           }
-          if (message.type === "auth_status" && message.authenticated === false) {
-            reject(
-              new Error("Claude Code reported an authentication failure.")
+          continue;
+        }
+        if (message.type === "assistant") {
+          const asst = message;
+          const thinking = extractAssistantThinking(asst);
+          if (thinking) {
+            sink.emitEvent(
+              createNormalizedEvent(
+                "reasoning.delta",
+                { provider: request.provider, runId: request.runId },
+                { delta: thinking }
+              )
             );
-            return;
           }
+          const text = extractAssistantText(asst);
+          sink.emitEvent(
+            createNormalizedEvent(
+              "message.completed",
+              { provider: request.provider, runId: request.runId },
+              {
+                text,
+                ...asst.uuid ? { messageId: String(asst.uuid) } : {}
+              }
+            )
+          );
+          continue;
+        }
+        if (message.type === "result") {
+          const result = message;
+          const resultText = result.subtype === "success" ? result.result : accumulatedText;
+          if (resultText && resultText !== accumulatedText) {
+            accumulatedText = resultText;
+          }
+          pendingMessages--;
+          if (pendingMessages <= 0) break;
+          continue;
         }
-        reject(new Error("Claude Code transport closed before run completed."));
-      })().catch(reject);
-    });
-    try {
-      await runtime.transport.waitForConnection(3e4);
-      if (runtime.initializeRequest) {
-        const response = await runtime.transport.request(
-          runtime.initializeRequest
-        );
-        sink.emitRaw(
-          toRawEvent(request.runId, response, "control_response:initialize")
-        );
       }
-      await runtime.transport.send({
-        type: "user",
-        message: {
-          role: "user",
-          content: userContent
-        },
-        parent_tool_use_id: null,
-        session_id: request.run.resumeSessionId ?? "",
-        uuid: randomUUID2()
-      });
-      sink.emitEvent(
-        createNormalizedEvent("message.started", {
-          provider: request.provider,
-          runId: request.runId
-        })
+      const finalText = accumulatedText;
+      debugClaude(
+        "\u2605 run.completed (%dms since execute start) chars=%d",
+        Date.now() - executeStartedAt,
+        finalText.length
       );
-      for (const queued of queuedSends.splice(0)) {
-        await runtime.transport.send(queued);
-      }
-      const { text } = await completion;
       sink.emitEvent(
         createNormalizedEvent(
           "run.completed",
-          {
-            provider: request.provider,
-            runId: request.runId
-          },
-          {
-            text
-          }
+          { provider: request.provider, runId: request.runId },
+          { text: finalText }
         )
       );
-      sink.complete({ text });
+      sink.complete({
+        text: finalText,
+        costData: extractClaudeCostData(rawPayloads)
+      });
     } finally {
-      await runtime.cleanup().catch(() => void 0);
+      fetchAbort.abort();
     }
     return async () => void 0;
   }
+  /**
+   * Stateless abort. POSTs to the in-sandbox daemon's
+   * `/runs/<id>/abort`. The daemon calls `query.interrupt()` on the
+   * matching live run; the originating instance's NDJSON read loop
+   * sees the run unwind via a non-success `result` (or stream close).
+   */
+  async attachAbort(request) {
+    const baseUrl = await daemonBaseUrl(request.sandbox);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3e3);
+    try {
+      await fetch(
+        `${baseUrl}/runs/${encodeURIComponent(request.runId)}/abort`,
+        {
+          method: "POST",
+          signal: controller.signal,
+          headers: request.sandbox.previewHeaders
+        }
+      ).catch((error) => {
+        debugClaude("attachAbort POST failed: %o", error);
+      });
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  /**
+   * Stateless message injection. POSTs `{ content }` to the daemon's
+   * `/runs/<id>/sendMessage`. The daemon pushes the message into the
+   * matching run's prompt iterable, which the SDK forwards to claude
+   * as a fresh user turn.
+   */
+  async attachSendMessage(request, content) {
+    const baseUrl = await daemonBaseUrl(request.sandbox);
+    const inputParts = await validateProviderUserInput(
+      AgentProvider.ClaudeCode,
+      content
+    );
+    const mapped = mapToClaudeUserContent(inputParts);
+    const response = await fetch(
+      `${baseUrl}/runs/${encodeURIComponent(request.runId)}/sendMessage`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          ...request.sandbox.previewHeaders
+        },
+        body: JSON.stringify({ content: mapped })
+      }
+    );
+    if (!response.ok) {
+      throw new Error(
+        `claude-code attachSendMessage failed: ${response.status} ${await response.text().catch(() => "")}`
+      );
+    }
+  }
 };
 
 // src/agents/providers/codex.ts
@@ -2444,7 +2272,7 @@ import path9 from "path";
 
 // src/agents/transports/app-server.ts
 import { createParser } from "eventsource-parser";
-import { WebSocket as WebSocket2 } from "ws";
+import { WebSocket } from "ws";
 async function fetchJson(url, init) {
   const response = await fetch(url, init);
   if (!response.ok) {
@@ -2507,7 +2335,7 @@ async function* streamSse(url, init) {
 }
 async function connectJsonRpcWebSocket(url, options) {
   const notifications = new AsyncQueue();
-  const socket = new WebSocket2(url, { headers: options?.headers });
+  const socket = new WebSocket(url, { headers: options?.headers });
   await new Promise((resolve, reject) => {
     const cleanup = () => {
       socket.off("open", handleOpen);
@@ -2548,7 +2376,7 @@ async function connectJsonRpcWebSocket(url, options) {
     },
     close: async () => {
       await new Promise((resolve) => {
-        if (socket.readyState === WebSocket2.CLOSED || socket.readyState === WebSocket2.CLOSING) {
+        if (socket.readyState === WebSocket.CLOSED || socket.readyState === WebSocket.CLOSING) {
           resolve();
           return;
         }
@@ -2633,6 +2461,12 @@ var JsonRpcLineClient = class {
 };
 
 // src/agents/providers/codex.ts
+function codexConfigDir(options) {
+  return path9.join(
+    agentboxRoot(AgentProvider.Codex, Boolean(options.sandbox)),
+    ".codex"
+  );
+}
 var REMOTE_CODEX_APP_SERVER_PORT = 43181;
 var REMOTE_CODEX_APP_SERVER_ID = "shared-app-server";
 function compactEnv(values) {
@@ -2681,16 +2515,31 @@ function buildTurnSandboxPolicy(options) {
   };
 }
 function buildTurnCollaborationMode(request) {
-  if (!request.run.systemPrompt) {
+  const systemPrompt = request.run.systemPrompt;
+  if (!systemPrompt) {
     return void 0;
   }
   return {
     mode: "custom",
     settings: {
-      developer_instructions: request.run.systemPrompt
+      developer_instructions: systemPrompt
     }
   };
 }
+function buildCodexTurnStartParams(params) {
+  const { threadId, inputItems, request, turnStartOverrides } = params;
+  const sandboxPolicy = buildTurnSandboxPolicy(request.options);
+  return {
+    threadId,
+    input: inputItems,
+    approvalPolicy: isInteractiveApproval(request.options) ? "untrusted" : "never",
+    ...sandboxPolicy ? { sandboxPolicy } : {},
+    ...turnStartOverrides ?? {},
+    model: request.run.model ?? null,
+    effort: request.run.reasoning ?? null,
+    outputSchema: null
+  };
+}
 function toRawEvent2(runId, payload, type) {
   return {
     provider: AgentProvider.Codex,
@@ -2706,8 +2555,13 @@ function shouldIgnoreCodexError(notification) {
   }
   return notification.params?.willRetry === true;
 }
-function buildCodexCommandArgs(binary, args) {
-  return ["-u", "CODEX_HOME", "-u", "XDG_CONFIG_HOME", binary, ...args];
+function buildCodexCommandArgs(binary, args, options) {
+  const overrides = [];
+  if (options?.provider?.supportsWebsockets === false) {
+    overrides.push(["supports_websockets", "false"]);
+  }
+  const overrideArgs = overrides.flatMap(([k, v]) => ["-c", `${k}=${v}`]);
+  return ["-u", "XDG_CONFIG_HOME", binary, ...overrideArgs, ...args];
 }
 function toNormalizedCodexEvents(runId, notification) {
   const base = {
@@ -2716,7 +2570,23 @@ function toNormalizedCodexEvents(runId, notification) {
     raw: toRawEvent2(runId, notification, notification.method)
   };
   if (notification.method === "turn/started") {
-    return [createNormalizedEvent("message.started", base)];
+    const turn = notification.params?.turn;
+    const turnId = typeof turn?.id === "string" ? turn.id : void 0;
+    return [
+      createNormalizedEvent(
+        "message.started",
+        base,
+        turnId ? { messageId: turnId } : void 0
+      )
+    ];
+  }
+  if (notification.method === "item/agentMessage/delta") {
+    const delta = typeof notification.params?.delta === "string" ? notification.params.delta : "";
+    return delta ? [createNormalizedEvent("text.delta", base, { delta })] : [];
+  }
+  if (notification.method === "item/reasoning/summaryTextDelta" || notification.method === "item/reasoning/textDelta") {
+    const delta = typeof notification.params?.delta === "string" ? notification.params.delta : typeof notification.params?.text === "string" ? notification.params.text : "";
+    return delta ? [createNormalizedEvent("reasoning.delta", base, { delta })] : [];
   }
   if (notification.method === "item/completed") {
     const item = notification.params?.item;
@@ -2725,7 +2595,6 @@ function toNormalizedCodexEvents(runId, notification) {
     }
     if (item.type === "agentMessage" && typeof item.text === "string") {
       return [
-        createNormalizedEvent("text.delta", base, { delta: item.text }),
         createNormalizedEvent("message.completed", base, { text: item.text })
       ];
     }
@@ -2852,22 +2721,6 @@ function toCodexApprovalDecision(notification, response) {
   }
   return "accept";
 }
-function buildCodexSkillInputItems(skills) {
-  return skills.map((skill) => ({
-    type: "skill",
-    name: skill.name,
-    path: skill.skillFilePath
-  }));
-}
-function buildCodexPromptText(prompt, skills) {
-  if (skills.length === 0) {
-    return prompt;
-  }
-  return [
-    `Available skills for this run: ${skills.map((skill) => `$${skill.name}`).join(", ")}.`,
-    prompt
-  ].join("\n\n");
-}
 function codexImageExtension(mediaType) {
   switch (mediaType) {
     case "image/gif":
@@ -2882,35 +2735,41 @@ function codexImageExtension(mediaType) {
       return ".img";
   }
 }
-async function materializeCodexImage(target, part, index) {
+async function materializeCodexImage(options, part, index) {
   if (part.source.type === "url") {
     return part.source.url;
   }
+  const root = agentboxRoot(AgentProvider.Codex, Boolean(options.sandbox));
   const imagePath = path9.join(
-    target.layout.rootDir,
+    root,
     "inputs",
     `codex-image-${index}${codexImageExtension(part.mediaType)}`
   );
-  const encodedPath = `${imagePath}.b64`;
-  await target.writeArtifact({
-    path: encodedPath,
-    content: part.source.data
-  });
-  await target.runCommand(
-    [
-      `mkdir -p ${shellQuote(path9.posix.dirname(imagePath))}`,
-      `(base64 --decode < ${shellQuote(encodedPath)} > ${shellQuote(imagePath)} || base64 -D < ${shellQuote(encodedPath)} > ${shellQuote(imagePath)})`,
-      `rm -f ${shellQuote(encodedPath)}`
-    ].join(" && ")
-  );
+  if (options.sandbox) {
+    const encodedPath = `${imagePath}.b64`;
+    await options.sandbox.uploadAndRun(
+      [{ path: encodedPath, content: part.source.data }],
+      [
+        `mkdir -p ${shellQuote(path9.posix.dirname(imagePath))}`,
+        `(base64 --decode < ${shellQuote(encodedPath)} > ${shellQuote(imagePath)} || base64 -D < ${shellQuote(encodedPath)} > ${shellQuote(imagePath)})`,
+        `rm -f ${shellQuote(encodedPath)}`
+      ].join(" && "),
+      { cwd: options.cwd, env: options.env }
+    );
+    return imagePath;
+  }
+  const fs = await import("fs/promises");
+  await fs.mkdir(path9.dirname(imagePath), { recursive: true });
+  await fs.writeFile(imagePath, Buffer.from(part.source.data, "base64"));
   return imagePath;
 }
-function resolveCodexOpenAiBaseUrl(request) {
-  return request.options.env?.OPENAI_BASE_URL ?? request.options.provider?.env?.OPENAI_BASE_URL;
+function resolveCodexOpenAiBaseUrlFromOptions(options) {
+  return options.env?.OPENAI_BASE_URL ?? options.provider?.env?.OPENAI_BASE_URL;
 }
-async function ensureCodexLogin(request, target) {
-  const openAiApiKey = request.options.env?.OPENAI_API_KEY ?? request.options.provider?.env?.OPENAI_API_KEY;
-  const openAiBaseUrl = resolveCodexOpenAiBaseUrl(request);
+async function ensureCodexLoginViaConfig(request, target) {
+  const options = request.options;
+  const openAiApiKey = options.env?.OPENAI_API_KEY ?? options.provider?.env?.OPENAI_API_KEY;
+  const openAiBaseUrl = resolveCodexOpenAiBaseUrlFromOptions(options);
   const extraEnv = {};
   if (openAiApiKey) {
     extraEnv.OPENAI_API_KEY = openAiApiKey;
@@ -2919,7 +2778,11 @@ async function ensureCodexLogin(request, target) {
     extraEnv.OPENAI_BASE_URL = openAiBaseUrl;
   }
   await target.runCommand(
-    'if [ -z "${OPENAI_API_KEY:-}" ]; then exit 0; fi; printenv OPENAI_API_KEY | env -u CODEX_HOME -u XDG_CONFIG_HOME codex login --with-api-key >/dev/null 2>&1',
+    [
+      'if [ -z "${OPENAI_API_KEY:-}" ]; then exit 0; fi',
+      'mkdir -p "${CODEX_HOME:-$HOME/.codex}"',
+      "printenv OPENAI_API_KEY | env -u XDG_CONFIG_HOME codex login --with-api-key"
+    ].join("; "),
     Object.keys(extraEnv).length > 0 ? extraEnv : void 0
   );
 }
@@ -2928,90 +2791,109 @@ function toRemoteCodexWebSocketUrl(url) {
   parsed.protocol = parsed.protocol === "https:" ? "wss:" : "ws:";
   return parsed.toString();
 }
-async function connectRemoteCodexAppServer(url, headers = {}) {
-  const startedAt = Date.now();
-  let lastError;
-  while (Date.now() - startedAt < 3e4) {
-    try {
-      return await connectJsonRpcWebSocket(url, { headers });
-    } catch (error) {
-      lastError = error;
-      await sleep(250);
-    }
+async function withCodexAppServer(request, body) {
+  const sandbox = request.sandbox;
+  if (sandbox.provider === SandboxProvider.LocalDocker) {
+    throw new Error(
+      "Codex stateless attach is not supported for local-docker sandboxes; the app-server is in-process."
+    );
   }
-  throw lastError ?? new Error(`Could not connect to Codex app-server at ${url}.`);
-}
-async function waitForInternalCodexReady(sandbox, port, cwd, env) {
-  const startedAt = Date.now();
-  while (Date.now() - startedAt < 6e4) {
-    const result = await sandbox.run(`curl -fsS http://127.0.0.1:${port}/readyz >/dev/null`, {
-      cwd,
-      env,
-      timeoutMs: 5e3
-    }).catch(() => void 0);
-    if (result?.exitCode === 0) {
-      return;
-    }
-    await sleep(250);
+  const previewUrl = await sandbox.getPreviewLink(REMOTE_CODEX_APP_SERVER_PORT);
+  const transport = await connectJsonRpcWebSocket(
+    toRemoteCodexWebSocketUrl(previewUrl),
+    { headers: sandbox.previewHeaders }
+  );
+  const client = new JsonRpcLineClient(
+    transport.source,
+    transport.send
+  );
+  try {
+    await client.request("initialize", {
+      clientInfo: { title: "AgentBox", name: "AgentBox", version: "0.1.0" },
+      capabilities: { experimentalApi: true }
+    });
+    await client.notify("initialized", {});
+    return await body(client);
+  } finally {
+    await transport.close().catch(() => void 0);
   }
-  throw new Error(`Codex internal app-server did not become ready on ${port}.`);
 }
-async function createRuntime2(request, inputParts) {
+async function connectRemoteCodexAppServer(url, headers = {}) {
+  return time(debugCodex, "connectRemoteCodexAppServer", async () => {
+    const startedAt = Date.now();
+    let attempt = 0;
+    let lastError;
+    while (Date.now() - startedAt < 3e4) {
+      attempt++;
+      try {
+        const conn = await connectJsonRpcWebSocket(url, { headers });
+        if (attempt > 1) {
+          debugCodex("connected after %d attempt(s)", attempt);
+        }
+        return conn;
+      } catch (error) {
+        lastError = error;
+        await sleep(250);
+      }
+    }
+    throw lastError ?? new Error(`Could not connect to Codex app-server at ${url}.`);
+  });
+}
+async function setupCodex(request) {
   const options = request.options;
+  const provider = request.provider;
+  const hooks = assertHooksSupported(provider, options);
+  assertCommandsSupported(provider, options.commands);
   const usesRemoteWebSocket = options.sandbox && options.sandbox.provider !== SandboxProvider.LocalDocker;
-  const hooks = assertHooksSupported(request.provider, options);
-  assertCommandsSupported(request.provider, options.commands);
+  function buildArtifactsFor(layoutTarget) {
+    const { artifacts: subAgentArtifacts, agentSections } = buildCodexSubagentArtifacts(options.subAgents, layoutTarget.layout);
+    const hooksFile = buildCodexHooksFile(hooks);
+    const enableMultiAgent = (options.subAgents?.length ?? 0) > 0;
+    const enableSkills = (options.skills?.length ?? 0) > 0;
+    const openAiBaseUrl = resolveCodexOpenAiBaseUrlFromOptions(options);
+    const configToml = buildCodexConfigToml({
+      mcps: options.mcps,
+      agentSections,
+      enableHooks: Boolean(hooksFile),
+      enableSkills,
+      enableMultiAgent,
+      openAiBaseUrl
+    });
+    const artifacts = [...subAgentArtifacts];
+    if (configToml) {
+      artifacts.push({
+        path: path9.join(layoutTarget.layout.codexDir, "config.toml"),
+        content: configToml
+      });
+    }
+    if (hooksFile) {
+      artifacts.push({
+        path: path9.join(layoutTarget.layout.codexDir, "hooks.json"),
+        content: JSON.stringify(hooksFile, null, 2)
+      });
+    }
+    return { artifacts, installCommands: [] };
+  }
   if (usesRemoteWebSocket && options.sandbox) {
     const sandbox = options.sandbox;
-    await sandbox.openPort(REMOTE_CODEX_APP_SERVER_PORT);
-    const sharedTarget = await createRuntimeTarget(
-      request.provider,
+    const sharedTarget = await createSetupTarget(
+      provider,
       REMOTE_CODEX_APP_SERVER_ID,
       options
     );
-    await ensureCodexLogin(request, sharedTarget);
-    const env2 = compactEnv({
+    const target2 = await createSetupTarget(provider, "shared-setup", options);
+    const env = compactEnv({
       ...options.env ?? {},
       ...sharedTarget.env,
       ...options.provider?.env ?? {}
     });
-    const serverCwd = sharedTarget.layout.rootDir;
-    const previewUrl = await sandbox.getPreviewLink(
-      REMOTE_CODEX_APP_SERVER_PORT
+    await time(
+      debugCodex,
+      "ensureCodexLogin",
+      () => ensureCodexLoginViaConfig(request, sharedTarget)
     );
-    const {
-      artifacts: subAgentArtifacts2,
-      agentSections: agentSections2,
-      enableMultiAgent: enableMultiAgent2
-    } = buildCodexSubagentArtifacts(options.subAgents, sharedTarget.layout);
-    const serverArtifacts = [...subAgentArtifacts2];
-    const hooksFile2 = buildCodexHooksFile(hooks);
-    const configToml2 = buildCodexConfigToml(
-      options.mcps,
-      agentSections2,
-      Boolean(hooksFile2)
-    );
-    if (configToml2) {
-      serverArtifacts.push({
-        path: path9.join(sharedTarget.layout.codexDir, "config.toml"),
-        content: configToml2
-      });
-    }
-    if (hooksFile2) {
-      serverArtifacts.push({
-        path: path9.join(sharedTarget.layout.codexDir, "hooks.json"),
-        content: JSON.stringify(hooksFile2, null, 2)
-      });
-    }
-    for (const artifact of serverArtifacts) {
-      await sharedTarget.writeArtifact(artifact);
-    }
-    const configArgs2 = [];
-    configArgs2.push("-c", `features.multi_agent=${enableMultiAgent2}`);
-    const openAiBaseUrl2 = resolveCodexOpenAiBaseUrl(request);
-    if (openAiBaseUrl2) {
-      configArgs2.push("-c", `openai_base_url=${JSON.stringify(openAiBaseUrl2)}`);
-    }
+    const { artifacts: serverArtifacts } = buildArtifactsFor(sharedTarget);
+    await applyDifferentialSetup(sharedTarget, serverArtifacts, []);
     const binary = options.provider?.binary ?? "codex";
     const pidFilePath = path9.posix.join(
       sharedTarget.layout.rootDir,
@@ -3021,219 +2903,115 @@ async function createRuntime2(request, inputParts) {
       sharedTarget.layout.rootDir,
       "codex-app-server.log"
     );
-    const launchResult = await sandbox.run(
-      [
-        `mkdir -p ${shellQuote(sharedTarget.layout.rootDir)}`,
-        `if curl -fsS http://127.0.0.1:${REMOTE_CODEX_APP_SERVER_PORT}/readyz >/dev/null 2>&1; then exit 0; fi`,
-        `if [ -f ${shellQuote(pidFilePath)} ]; then kill "$(cat ${shellQuote(pidFilePath)})" >/dev/null 2>&1 || true; rm -f ${shellQuote(pidFilePath)}; fi`,
-        `(${[
-          `nohup ${[
-            "env",
-            ...buildCodexCommandArgs(binary, [
-              ...configArgs2,
-              "app-server",
-              "--listen",
-              `ws://0.0.0.0:${REMOTE_CODEX_APP_SERVER_PORT}`
-            ])
-          ].map(shellQuote).join(" ")} > ${shellQuote(logFilePath)} 2>&1 &`,
-          `echo $! > ${shellQuote(pidFilePath)}`
-        ].join(" ")})`
-      ].join(" && "),
-      {
-        cwd: serverCwd,
-        env: env2
-      }
+    const serverCwd = sharedTarget.layout.rootDir;
+    const launchResult = await time(
+      debugCodex,
+      "launch app-server (probe + spawn-if-cold)",
+      () => sandbox.run(
+        [
+          `mkdir -p ${shellQuote(sharedTarget.layout.rootDir)}`,
+          `if curl -fsS http://127.0.0.1:${REMOTE_CODEX_APP_SERVER_PORT}/readyz >/dev/null 2>&1; then exit 0; fi`,
+          `if [ -f ${shellQuote(pidFilePath)} ]; then kill "$(cat ${shellQuote(pidFilePath)})" >/dev/null 2>&1 || true; rm -f ${shellQuote(pidFilePath)}; fi`,
+          `(${[
+            `nohup ${[
+              "env",
+              ...buildCodexCommandArgs(
+                binary,
+                [
+                  "app-server",
+                  "--listen",
+                  `ws://0.0.0.0:${REMOTE_CODEX_APP_SERVER_PORT}`
+                ],
+                options
+              )
+            ].map(shellQuote).join(" ")} > ${shellQuote(logFilePath)} 2>&1 &`,
+            `echo $! > ${shellQuote(pidFilePath)}`
+          ].join(" ")})`
+        ].join(" && "),
+        {
+          cwd: serverCwd,
+          env
+        }
+      )
     );
     if (launchResult.exitCode !== 0) {
       throw new Error(
         `Could not start Codex app-server: ${launchResult.combinedOutput || launchResult.stderr}`
       );
     }
-    await waitForInternalCodexReady(
-      sandbox,
-      REMOTE_CODEX_APP_SERVER_PORT,
-      serverCwd,
-      env2
-    );
-    const target2 = await createRuntimeTarget(
-      request.provider,
-      request.runId,
-      options
-    );
     try {
-      const {
-        artifacts: skillArtifacts2,
-        installCommands: installCommands2,
-        preparedSkills: preparedSkills2
-      } = await prepareSkillArtifacts(
-        request.provider,
-        options.skills,
-        target2.layout
-      );
-      for (const artifact of skillArtifacts2) {
-        await target2.writeArtifact(artifact);
-      }
-      await installSkills(target2, installCommands2);
-      const textPrompt2 = joinTextParts(
-        inputParts.filter(
-          (part) => part.type === "text"
-        )
-      );
-      const codexPromptText2 = buildCodexPromptText(textPrompt2, preparedSkills2);
-      const inputItems2 = [];
-      if (codexPromptText2.trim().length > 0) {
-        inputItems2.push({
-          type: "text",
-          text: codexPromptText2,
-          text_elements: []
-        });
-      }
-      inputItems2.push(
-        ...await mapToCodexPromptParts(
-          inputParts,
-          async (part, index) => materializeCodexImage(target2, part, index)
-        )
-      );
-      inputItems2.push(...buildCodexSkillInputItems(preparedSkills2));
-      const transport = await connectRemoteCodexAppServer(
-        toRemoteCodexWebSocketUrl(previewUrl),
-        sandbox.previewHeaders
-      );
-      return {
-        source: transport.source,
-        writeLine: transport.send,
-        cleanup: async () => {
-          await transport?.close().catch(() => void 0);
-          await target2.cleanup().catch(() => void 0);
-        },
-        raw: {
-          transport: transport.raw,
-          previewUrl,
-          port: REMOTE_CODEX_APP_SERVER_PORT,
-          serverLayout: sharedTarget.layout,
-          layout: target2.layout
-        },
-        inputItems: inputItems2,
-        turnStartOverrides: buildTurnCollaborationMode(request)
-      };
+      const { artifacts: skillArtifacts2, installCommands: installCommands2 } = await prepareSkillArtifacts(provider, options.skills, target2.layout);
+      await applyDifferentialSetup(target2, skillArtifacts2, installCommands2);
     } catch (error) {
       await target2.cleanup().catch(() => void 0);
       throw error;
     }
+    return;
   }
-  const target = await createRuntimeTarget(
-    request.provider,
-    request.runId,
-    options
-  );
+  const target = await createSetupTarget(provider, "shared-setup", options);
   try {
-    await ensureCodexLogin(request, target);
+    await ensureCodexLoginViaConfig(request, target);
   } catch (error) {
     await target.cleanup().catch(() => void 0);
     throw error;
   }
+  const { artifacts: skillArtifacts, installCommands } = await prepareSkillArtifacts(provider, options.skills, target.layout);
+  const { artifacts: configArtifacts } = buildArtifactsFor(target);
+  await applyDifferentialSetup(
+    target,
+    [...skillArtifacts, ...configArtifacts],
+    installCommands
+  );
+}
+async function createRuntime(request, inputParts) {
+  const options = request.options;
+  const codexDir = codexConfigDir(options);
   const env = compactEnv({
     ...options.env ?? {},
-    ...target.env,
+    CODEX_HOME: codexDir,
     ...options.provider?.env ?? {}
   });
-  const runtimeCwd = target.layout.rootDir;
-  const {
-    artifacts: skillArtifacts,
-    installCommands,
-    preparedSkills
-  } = await prepareSkillArtifacts(
-    request.provider,
-    options.skills,
-    target.layout
-  );
-  const {
-    artifacts: subAgentArtifacts,
-    agentSections,
-    enableMultiAgent
-  } = buildCodexSubagentArtifacts(options.subAgents, target.layout);
-  const artifacts = [...skillArtifacts, ...subAgentArtifacts];
-  const hooksFile = buildCodexHooksFile(hooks);
-  const configToml = buildCodexConfigToml(
-    options.mcps,
-    agentSections,
-    Boolean(hooksFile)
-  );
-  if (configToml) {
-    artifacts.push({
-      path: path9.join(target.layout.codexDir, "config.toml"),
-      content: configToml
-    });
-  }
-  if (hooksFile) {
-    artifacts.push({
-      path: path9.join(target.layout.codexDir, "hooks.json"),
-      content: JSON.stringify(hooksFile, null, 2)
-    });
-  }
-  let instructionsFilePath;
-  if (request.run.systemPrompt) {
-    instructionsFilePath = path9.join(
-      target.layout.codexDir,
-      "prompts",
-      "agentbox-system.md"
+  const runtimeCwd = path9.dirname(codexDir);
+  const inputItems = await buildCodexInputItems(options, inputParts);
+  const usesRemoteWebSocket = options.sandbox && options.sandbox.provider !== SandboxProvider.LocalDocker;
+  if (usesRemoteWebSocket && options.sandbox) {
+    const sandbox = options.sandbox;
+    const previewUrl = await time(
+      debugCodex,
+      "getPreviewLink app-server",
+      () => sandbox.getPreviewLink(REMOTE_CODEX_APP_SERVER_PORT)
     );
-    artifacts.push({
-      path: instructionsFilePath,
-      content: request.run.systemPrompt
-    });
-  }
-  for (const artifact of artifacts) {
-    await target.writeArtifact(artifact);
-  }
-  await installSkills(target, installCommands);
-  const configArgs = [];
-  if (instructionsFilePath) {
-    configArgs.push(
-      "-c",
-      `model_instructions_file=${JSON.stringify(instructionsFilePath)}`
+    const transport = await connectRemoteCodexAppServer(
+      toRemoteCodexWebSocketUrl(previewUrl),
+      sandbox.previewHeaders
     );
+    debugCodex("\u2605 codex transport established");
+    return {
+      source: transport.source,
+      writeLine: transport.send,
+      cleanup: async () => {
+        await transport?.close().catch(() => void 0);
+      },
+      raw: {
+        transport: transport.raw,
+        previewUrl,
+        port: REMOTE_CODEX_APP_SERVER_PORT,
+        codexDir
+      },
+      inputItems,
+      turnStartOverrides: buildTurnCollaborationMode(request)
+    };
   }
-  configArgs.push("-c", `features.multi_agent=${enableMultiAgent}`);
-  const openAiBaseUrl = resolveCodexOpenAiBaseUrl(request);
-  if (openAiBaseUrl) {
-    configArgs.push("-c", `openai_base_url=${JSON.stringify(openAiBaseUrl)}`);
-  }
-  const textPrompt = joinTextParts(
-    inputParts.filter(
-      (part) => part.type === "text"
-    )
-  );
-  const codexPromptText = buildCodexPromptText(textPrompt, preparedSkills);
-  const inputItems = [];
-  if (codexPromptText.trim().length > 0) {
-    inputItems.push({
-      type: "text",
-      text: codexPromptText,
-      text_elements: []
-    });
-  }
-  inputItems.push(
-    ...await mapToCodexPromptParts(
-      inputParts,
-      async (part, index) => materializeCodexImage(target, part, index)
-    )
+  const codexArgs = buildCodexCommandArgs(
+    options.provider?.binary ?? "codex",
+    ["app-server"],
+    options
   );
-  inputItems.push(...buildCodexSkillInputItems(preparedSkills));
   if (options.sandbox) {
-    const handle = await options.sandbox.runAsync(
-      [
-        "env",
-        ...buildCodexCommandArgs(options.provider?.binary ?? "codex", [
-          ...configArgs,
-          "app-server"
-        ])
-      ],
-      {
-        cwd: runtimeCwd,
-        env
-      }
-    );
+    const handle = await options.sandbox.runAsync(["env", ...codexArgs], {
+      cwd: runtimeCwd,
+      env
+    });
     if (!handle.write) {
       throw new Error(
         "The selected sandbox does not expose an interactive stdin channel for Codex."
@@ -3257,18 +3035,15 @@ async function createRuntime2(request, inputParts) {
       },
       cleanup: async () => {
         await handle.kill();
-        await target.cleanup();
       },
-      raw: { handle, layout: target.layout },
-      inputItems
+      raw: { handle, codexDir },
+      inputItems,
+      turnStartOverrides: buildTurnCollaborationMode(request)
     };
   }
   const processHandle = spawnCommand({
     command: "env",
-    args: buildCodexCommandArgs(options.provider?.binary ?? "codex", [
-      ...configArgs,
-      "app-server"
-    ]),
+    args: codexArgs,
     cwd: runtimeCwd,
     env: {
       ...process.env,
@@ -3283,19 +3058,51 @@ async function createRuntime2(request, inputParts) {
     },
     cleanup: async () => {
       await processHandle.kill();
-      await target.cleanup();
     },
-    raw: { processHandle, layout: target.layout },
-    inputItems
+    raw: { processHandle, codexDir },
+    inputItems,
+    turnStartOverrides: buildTurnCollaborationMode(request)
   };
 }
+async function buildCodexInputItems(options, inputParts) {
+  const textPrompt = joinTextParts(
+    inputParts.filter(
+      (part) => part.type === "text"
+    )
+  );
+  const inputItems = [];
+  if (textPrompt.trim().length > 0) {
+    inputItems.push({
+      type: "text",
+      text: textPrompt,
+      text_elements: []
+    });
+  }
+  inputItems.push(
+    ...await mapToCodexPromptParts(
+      inputParts,
+      async (part, index) => materializeCodexImage(options, part, index)
+    )
+  );
+  return inputItems;
+}
 var CodexAgentAdapter = class {
+  async setup(request) {
+    await setupCodex(request);
+  }
   async execute(request, sink) {
-    const inputParts = await validateProviderUserInput(
-      request.provider,
-      request.run.input
+    const executeStartedAt = Date.now();
+    debugCodex("execute() start runId=%s", request.runId);
+    const inputParts = await time(
+      debugCodex,
+      "validateProviderUserInput",
+      () => validateProviderUserInput(request.provider, request.run.input)
+    );
+    const runtime = await time(
+      debugCodex,
+      "createRuntime",
+      () => createRuntime(request, inputParts)
     );
-    const runtime = await createRuntime2(request, inputParts);
     sink.setRaw(runtime.raw);
     sink.emitEvent(
       createNormalizedEvent("run.started", {
@@ -3343,24 +3150,35 @@ var CodexAgentAdapter = class {
       if (text.trim().length > 0) {
         inputItems.push({ type: "text", text, text_elements: [] });
       }
-      pendingTurns++;
-      const sandboxPolicy = buildTurnSandboxPolicy(request.options);
-      await client.request("turn/start", {
-        threadId: rootThreadId,
-        input: inputItems,
-        approvalPolicy: isInteractiveApproval(request.options) ? "untrusted" : "never",
-        ...sandboxPolicy ? { sandboxPolicy } : {},
-        model: request.run.model ?? null,
-        effort: null,
-        outputSchema: null
-      });
+      const response = await client.request(
+        "turn/start",
+        buildCodexTurnStartParams({
+          threadId: rootThreadId,
+          inputItems,
+          request
+        })
+      );
+      return {
+        ...typeof response?.turn?.id === "string" ? { messageId: response.turn.id } : {}
+      };
     };
     sink.onMessage(sendTurn);
+    const rawPayloads = [];
     const completion = new Promise((resolve, reject) => {
       let finalText = "";
       void (async () => {
+        let firstClientMessageLogged = false;
         for await (const message of client.messages()) {
+          if (!firstClientMessageLogged) {
+            firstClientMessageLogged = true;
+            debugCodex(
+              "\u2605 first transport message (%dms since execute start) method=%s",
+              Date.now() - executeStartedAt,
+              message.method
+            );
+          }
           const raw = toRawEvent2(request.runId, message, message.method);
+          rawPayloads.push(message);
           sink.emitRaw(raw);
           if (message.method === "tool/requestUserInput" && message.id !== void 0) {
             reject(
@@ -3435,6 +3253,7 @@ var CodexAgentAdapter = class {
         client.bindThread(threadResponse.thread.id);
       }
       sink.setSessionId(threadResponse.thread.id);
+      rawPayloads.push(threadResponse);
       sink.emitRaw(
         toRawEvent2(
           request.runId,
@@ -3442,30 +3261,107 @@ var CodexAgentAdapter = class {
           request.run.resumeSessionId ? "thread/resume:result" : "thread/start:result"
         )
       );
-      const sandboxPolicy = buildTurnSandboxPolicy(request.options);
+      await client.request(
+        "turn/start",
+        buildCodexTurnStartParams({
+          threadId: threadResponse.thread.id,
+          inputItems: runtime.inputItems,
+          request,
+          turnStartOverrides: runtime.turnStartOverrides
+        })
+      );
+      const { text } = await completion;
+      debugCodex(
+        "\u2605 run.completed (%dms since execute start) chars=%d",
+        Date.now() - executeStartedAt,
+        text?.length ?? 0
+      );
+      sink.complete({ text, costData: extractCodexCostData(rawPayloads) });
+    } finally {
+      await runtime.cleanup().catch(() => void 0);
+    }
+    return async () => void 0;
+  }
+  /**
+   * Stateless abort. Calls `turn/interrupt` against the in-sandbox
+   * app-server using `(sessionId, turnId)` provided by the caller —
+   * the SDK does not persist turn state itself; bookkeeping the
+   * current turnId is the caller's responsibility (e.g. via Redis,
+   * driven by the normalized `message.started` event whose
+   * `messageId` IS the codex turnId).
+   *
+   * If `sessionId` or `turnId` is missing the call is a no-op.
+   */
+  async attachAbort(request) {
+    const threadId = request.sessionId;
+    const turnId = request.turnId;
+    if (!threadId || !turnId) {
+      debugCodex(
+        "attachAbort runId=%s skipped: threadId=%s turnId=%s",
+        request.runId,
+        threadId,
+        turnId
+      );
+      return;
+    }
+    await withCodexAppServer(request, async (client) => {
+      await Promise.race([
+        client.request("turn/interrupt", { threadId, turnId }),
+        new Promise(
+          (_, reject) => setTimeout(
+            () => reject(new Error("codex turn/interrupt timed out")),
+            3e3
+          )
+        )
+      ]).catch((error) => {
+        debugCodex(
+          "attachAbort runId=%s turn/interrupt failed: %o",
+          request.runId,
+          error
+        );
+      });
+    });
+  }
+  /**
+   * Stateless message injection. Uses `request.sessionId` as the codex
+   * threadId and starts a fresh turn against it via `turn/start`.
+   */
+  async attachSendMessage(request, content) {
+    const threadId = request.sessionId;
+    if (!threadId) {
+      throw new Error(
+        `Cannot attachSendMessage to codex run ${request.runId}: sessionId (threadId) is required.`
+      );
+    }
+    const parts = normalizeUserInput(content);
+    const text = joinTextParts(
+      parts.filter(
+        (part) => part.type === "text"
+      )
+    );
+    const inputItems = [];
+    if (text.trim().length > 0) {
+      inputItems.push({ type: "text", text, text_elements: [] });
+    }
+    await withCodexAppServer(request, async (client) => {
       await client.request("turn/start", {
-        threadId: threadResponse.thread.id,
-        input: runtime.inputItems,
-        approvalPolicy: isInteractiveApproval(request.options) ? "untrusted" : "never",
-        ...sandboxPolicy ? { sandboxPolicy } : {},
-        ...runtime.turnStartOverrides ?? {},
-        model: request.run.model ?? null,
+        threadId,
+        input: inputItems,
+        approvalPolicy: "never",
+        model: null,
         effort: null,
         outputSchema: null
       });
-      const { text } = await completion;
-      sink.complete({ text });
-    } finally {
-      await runtime.cleanup().catch(() => void 0);
-    }
-    return async () => void 0;
+    });
   }
 };
 
 // src/agents/providers/opencode.ts
 import path10 from "path";
 var SANDBOX_OPENCODE_PORT = 4096;
+var LOCAL_OPENCODE_PORT = 4096;
 var SANDBOX_OPENCODE_READY_TIMEOUT_MS = 9e4;
+var LOCAL_OPENCODE_READY_TIMEOUT_MS = 2e4;
 var SHARED_OPENCODE_TARGET_ID = "shared-opencode-server";
 function toRawEvent3(runId, payload, type) {
   return {
@@ -3509,6 +3405,40 @@ function extractText(value) {
   }
   return "";
 }
+function extractAssistantMessageId(response) {
+  if (!response || typeof response !== "object") {
+    return void 0;
+  }
+  const record = response;
+  const info = record.info && typeof record.info === "object" ? record.info : record.message && typeof record.message === "object" ? record.message : void 0;
+  const id = info?.id ?? record.id;
+  return typeof id === "string" ? id : void 0;
+}
+function extractReasoning(value) {
+  if (!value) {
+    return "";
+  }
+  if (Array.isArray(value)) {
+    return value.map(extractReasoning).filter(Boolean).join("");
+  }
+  if (typeof value === "object") {
+    const record = value;
+    if (record.type === "reasoning") {
+      if (typeof record.text === "string") {
+        return record.text;
+      }
+      if (typeof record.reasoning === "string") {
+        return record.reasoning;
+      }
+    }
+    return [
+      extractReasoning(record.message),
+      extractReasoning(record.content),
+      extractReasoning(record.parts)
+    ].filter(Boolean).join("");
+  }
+  return "";
+}
 function toOpenCodeModel(model) {
   if (!model) {
     return void 0;
@@ -3566,156 +3496,182 @@ function createOpenCodePermissionEvent(request, raw, payload) {
     }
   );
 }
-function buildOpenCodeConfig(request, interactiveApproval) {
-  const options = request.options;
+var OPEN_CODE_REASONING_LEVELS = ["low", "medium", "high", "xhigh"];
+function openCodeAgentSlug(reasoning) {
+  return reasoning ? `agentbox-${reasoning}` : "agentbox";
+}
+function buildOpenCodeConfig(options, systemPrompt, interactiveApproval) {
   const mcpConfig = buildOpenCodeMcpConfig(options.mcps);
   const commandsConfig = buildOpenCodeCommandsConfig(options.commands);
+  const baseAgent = {
+    mode: "primary",
+    prompt: systemPrompt,
+    permission: buildOpenCodePermissionConfig(interactiveApproval),
+    tools: {
+      write: true,
+      edit: true,
+      bash: true,
+      webfetch: true,
+      skill: true
+    }
+  };
+  const reasoningVariants = Object.fromEntries(
+    OPEN_CODE_REASONING_LEVELS.map((level) => [
+      `agentbox-${level}`,
+      { ...baseAgent, reasoningEffort: level }
+    ])
+  );
   return {
     $schema: "https://opencode.ai/config.json",
     ...mcpConfig ? { mcp: mcpConfig } : {},
     ...commandsConfig ? { command: commandsConfig } : {},
     agent: {
-      agentbox: {
-        mode: "primary",
-        prompt: request.run.systemPrompt ?? "",
-        permission: buildOpenCodePermissionConfig(interactiveApproval),
-        tools: {
-          write: true,
-          edit: true,
-          bash: true,
-          webfetch: true,
-          skill: true
-        }
-      },
+      agentbox: baseAgent,
+      ...reasoningVariants,
       ...buildOpenCodeSubagentConfig(options.subAgents)
     }
   };
 }
 async function ensureSandboxOpenCodeServer(request) {
-  const sandbox = request.options.sandbox;
-  const options = request.options;
-  const port = SANDBOX_OPENCODE_PORT;
-  await sandbox.openPort(port);
-  const previewHeaders = sandbox.previewHeaders;
-  const healthCheck = await sandbox.run(
-    `curl -fsS http://127.0.0.1:${port}/global/health >/dev/null 2>&1`,
-    { cwd: options.cwd, timeoutMs: 5e3 }
-  );
-  if (healthCheck.exitCode === 0) {
-    const baseUrl2 = (await sandbox.getPreviewLink(port)).replace(/\/$/, "");
-    return {
-      baseUrl: baseUrl2,
-      previewHeaders,
-      cleanup: async () => {
-      },
-      raw: { baseUrl: baseUrl2, port, reused: true }
+  return time(debugOpencode, "ensureSandboxOpenCodeServer", async () => {
+    const sandbox = request.options.sandbox;
+    const options = request.options;
+    const port = SANDBOX_OPENCODE_PORT;
+    const healthCheck = await time(
+      debugOpencode,
+      "health probe (warm path)",
+      () => sandbox.run(
+        `curl -fsS http://127.0.0.1:${port}/global/health >/dev/null 2>&1`,
+        { cwd: options.cwd, timeoutMs: 5e3 }
+      )
+    );
+    if (healthCheck.exitCode === 0) {
+      debugOpencode("opencode server already running \u2014 reusing");
+      return;
+    }
+    debugOpencode("opencode server not running \u2014 cold-spawning");
+    const plugins = assertHooksSupported(request.provider, options);
+    assertCommandsSupported(request.provider, options.commands);
+    const interactiveApproval = isInteractiveApproval(options);
+    const target = await createSetupTarget(
+      request.provider,
+      SHARED_OPENCODE_TARGET_ID,
+      options
+    );
+    const { artifacts: skillArtifacts, installCommands } = await prepareSkillArtifacts(
+      request.provider,
+      options.skills,
+      target.layout
+    );
+    const pluginArtifacts = buildOpenCodePluginArtifacts(
+      plugins,
+      target.layout.opencodeDir
+    );
+    const configPath = path10.join(target.layout.opencodeDir, "agentbox.json");
+    const openCodeConfig = buildOpenCodeConfig(
+      options,
+      request.config.systemPrompt ?? "",
+      interactiveApproval
+    );
+    const commonEnv = {
+      OPENCODE_CONFIG: configPath,
+      OPENCODE_CONFIG_DIR: target.layout.opencodeDir,
+      OPENCODE_DISABLE_DEFAULT_PLUGINS: "true"
     };
-  }
-  const plugins = assertHooksSupported(request.provider, options);
-  assertCommandsSupported(request.provider, options.commands);
-  const interactiveApproval = isInteractiveApproval(options);
-  const target = await createRuntimeTarget(
-    request.provider,
-    SHARED_OPENCODE_TARGET_ID,
-    options
-  );
-  const { artifacts: skillArtifacts, installCommands } = await prepareSkillArtifacts(
-    request.provider,
-    options.skills,
-    target.layout
-  );
-  const pluginArtifacts = buildOpenCodePluginArtifacts(
-    plugins,
-    target.layout.opencodeDir
-  );
-  for (const artifact of [...skillArtifacts, ...pluginArtifacts]) {
-    await target.writeArtifact(artifact);
-  }
-  const configPath = path10.join(target.layout.opencodeDir, "agentbox.json");
-  const openCodeConfig = buildOpenCodeConfig(request, interactiveApproval);
-  await target.writeArtifact({
-    path: configPath,
-    content: JSON.stringify(openCodeConfig, null, 2)
-  });
-  const commonEnv = {
-    OPENCODE_CONFIG: configPath,
-    OPENCODE_CONFIG_DIR: target.layout.opencodeDir,
-    OPENCODE_DISABLE_DEFAULT_PLUGINS: "true"
-  };
-  await installSkills(target, installCommands, commonEnv);
-  const binary = options.provider?.binary ?? "opencode";
-  const pidFilePath = path10.posix.join(
-    target.layout.rootDir,
-    "opencode-serve.pid"
-  );
-  const logFilePath = path10.posix.join(
-    target.layout.rootDir,
-    "opencode-serve.log"
-  );
-  const serveEnv = { ...options.env ?? {}, ...commonEnv };
-  const launchCommand = [
-    `mkdir -p ${shellQuote(target.layout.rootDir)}`,
-    `(${[
-      `nohup ${[
-        binary,
-        "serve",
-        "--hostname",
-        "0.0.0.0",
-        "--port",
-        String(port),
-        ...options.provider?.args ?? []
-      ].map(shellQuote).join(" ")} > ${shellQuote(logFilePath)} 2>&1 &`,
-      `echo $! > ${shellQuote(pidFilePath)}`
-    ].join(" ")})`
-  ].join(" && ");
-  const launchHandle = await sandbox.runAsync(launchCommand, {
-    cwd: options.cwd,
-    env: serveEnv
-  });
-  const launchResult = await launchHandle.wait();
-  if (launchResult.exitCode !== 0) {
-    await target.cleanup().catch(() => void 0);
-    throw new Error(
-      `Could not start OpenCode server: ${launchResult.combinedOutput || launchResult.stderr}`
+    await applyDifferentialSetup(
+      target,
+      [
+        ...skillArtifacts,
+        ...pluginArtifacts,
+        {
+          path: configPath,
+          content: JSON.stringify(openCodeConfig, null, 2)
+        }
+      ],
+      installCommands
     );
-  }
-  const readyDeadline = Date.now() + SANDBOX_OPENCODE_READY_TIMEOUT_MS;
-  let ready = false;
-  while (Date.now() < readyDeadline) {
-    const probe = await sandbox.run(
-      `curl -fsS http://127.0.0.1:${port}/global/health >/dev/null 2>&1`,
-      { cwd: options.cwd, timeoutMs: 5e3 }
+    const binary = options.provider?.binary ?? "opencode";
+    const pidFilePath = path10.posix.join(
+      target.layout.rootDir,
+      "opencode-serve.pid"
     );
-    if (probe.exitCode === 0) {
-      ready = true;
-      break;
-    }
-    await sleep(500);
-  }
-  if (!ready) {
-    await target.cleanup().catch(() => void 0);
-    throw new Error(
-      `OpenCode server did not become ready within ${SANDBOX_OPENCODE_READY_TIMEOUT_MS}ms.`
+    const logFilePath = path10.posix.join(
+      target.layout.rootDir,
+      "opencode-serve.log"
     );
-  }
-  const baseUrl = (await sandbox.getPreviewLink(port)).replace(/\/$/, "");
-  return {
-    baseUrl,
-    previewHeaders,
-    cleanup: async () => {
+    const serveEnv = { ...options.env ?? {}, ...commonEnv };
+    const launchCommand = [
+      `mkdir -p ${shellQuote(target.layout.rootDir)}`,
+      `(${[
+        `nohup ${[
+          binary,
+          "serve",
+          "--hostname",
+          "0.0.0.0",
+          "--port",
+          String(port),
+          ...options.provider?.args ?? []
+        ].map(shellQuote).join(" ")} > ${shellQuote(logFilePath)} 2>&1 &`,
+        `echo $! > ${shellQuote(pidFilePath)}`
+      ].join(" ")})`
+    ].join(" && ");
+    const launchResult = await time(
+      debugOpencode,
+      "spawn opencode serve",
+      async () => {
+        const launchHandle = await sandbox.runAsync(launchCommand, {
+          cwd: options.cwd,
+          env: serveEnv
+        });
+        return launchHandle.wait();
+      }
+    );
+    if (launchResult.exitCode !== 0) {
       await target.cleanup().catch(() => void 0);
-    },
-    raw: { pidFilePath, logFilePath, baseUrl, layout: target.layout, port }
-  };
+      throw new Error(
+        `Could not start OpenCode server: ${launchResult.combinedOutput || launchResult.stderr}`
+      );
+    }
+    await time(debugOpencode, "poll opencode until ready", async () => {
+      const readyDeadline = Date.now() + SANDBOX_OPENCODE_READY_TIMEOUT_MS;
+      let attempt = 0;
+      while (Date.now() < readyDeadline) {
+        attempt++;
+        const probe = await sandbox.run(
+          `curl -fsS http://127.0.0.1:${port}/global/health >/dev/null 2>&1`,
+          { cwd: options.cwd, timeoutMs: 5e3 }
+        );
+        if (probe.exitCode === 0) {
+          debugOpencode("ready after %d probe attempt(s)", attempt);
+          return;
+        }
+        await sleep(500);
+      }
+      await target.cleanup().catch(() => void 0);
+      throw new Error(
+        `OpenCode server did not become ready within ${SANDBOX_OPENCODE_READY_TIMEOUT_MS}ms.`
+      );
+    });
+  });
 }
-async function createLocalRuntime2(request) {
+async function ensureLocalOpenCodeServer(request) {
   const options = request.options;
+  try {
+    await waitForHttpReady(
+      `http://127.0.0.1:${LOCAL_OPENCODE_PORT}/global/health`,
+      { timeoutMs: 1e3 }
+    );
+    debugOpencode("local opencode server already running \u2014 reusing");
+    return;
+  } catch {
+    debugOpencode("local opencode server not running \u2014 cold-spawning");
+  }
   const plugins = assertHooksSupported(request.provider, options);
   assertCommandsSupported(request.provider, options.commands);
   const interactiveApproval = isInteractiveApproval(options);
-  const target = await createRuntimeTarget(
+  const target = await createSetupTarget(
     request.provider,
-    request.runId,
+    "shared-setup",
     options
   );
   const { artifacts: skillArtifacts, installCommands } = await prepareSkillArtifacts(
@@ -3727,30 +3683,37 @@ async function createLocalRuntime2(request) {
     plugins,
     target.layout.opencodeDir
   );
-  for (const artifact of [...skillArtifacts, ...pluginArtifacts]) {
-    await target.writeArtifact(artifact);
-  }
   const configPath = path10.join(target.layout.opencodeDir, "agentbox.json");
-  const openCodeConfig = buildOpenCodeConfig(request, interactiveApproval);
-  await target.writeArtifact({
-    path: configPath,
-    content: JSON.stringify(openCodeConfig, null, 2)
-  });
+  const openCodeConfig = buildOpenCodeConfig(
+    options,
+    request.config.systemPrompt ?? "",
+    interactiveApproval
+  );
   const commonEnv = {
     OPENCODE_CONFIG: configPath,
     OPENCODE_CONFIG_DIR: target.layout.opencodeDir,
     OPENCODE_DISABLE_DEFAULT_PLUGINS: "true"
   };
-  await installSkills(target, installCommands, commonEnv);
-  const hostPort = await getAvailablePort();
-  const processHandle = spawnCommand({
+  await applyDifferentialSetup(
+    target,
+    [
+      ...skillArtifacts,
+      ...pluginArtifacts,
+      {
+        path: configPath,
+        content: JSON.stringify(openCodeConfig, null, 2)
+      }
+    ],
+    installCommands
+  );
+  spawnCommand({
     command: options.provider?.binary ?? "opencode",
     args: [
       "serve",
       "--hostname",
       "127.0.0.1",
       "--port",
-      String(hostPort),
+      String(LOCAL_OPENCODE_PORT),
       ...options.provider?.args ?? []
     ],
     cwd: options.cwd,
@@ -3760,33 +3723,53 @@ async function createLocalRuntime2(request) {
       ...commonEnv
     }
   });
-  const baseUrl = `http://127.0.0.1:${hostPort}`;
-  await waitForHttpReady(`${baseUrl}/global/health`, { timeoutMs: 2e4 });
+  await waitForHttpReady(
+    `http://127.0.0.1:${LOCAL_OPENCODE_PORT}/global/health`,
+    { timeoutMs: LOCAL_OPENCODE_READY_TIMEOUT_MS }
+  );
+}
+async function setupOpenCode(request) {
+  if (request.options.sandbox) {
+    await ensureSandboxOpenCodeServer(request);
+    return;
+  }
+  await ensureLocalOpenCodeServer(request);
+}
+async function buildOpenCodeRuntime(options) {
+  if (options.sandbox) {
+    const sandbox = options.sandbox;
+    const baseUrl2 = (await sandbox.getPreviewLink(SANDBOX_OPENCODE_PORT)).replace(/\/$/, "");
+    return {
+      baseUrl: baseUrl2,
+      previewHeaders: sandbox.previewHeaders,
+      raw: { baseUrl: baseUrl2, port: SANDBOX_OPENCODE_PORT }
+    };
+  }
+  const baseUrl = `http://127.0.0.1:${LOCAL_OPENCODE_PORT}`;
   return {
     baseUrl,
     previewHeaders: {},
-    cleanup: async () => {
-      await processHandle.kill();
-      await target.cleanup();
-    },
-    raw: { processHandle, layout: target.layout }
+    raw: { baseUrl, port: LOCAL_OPENCODE_PORT }
   };
 }
-async function createRuntime3(request) {
-  if (request.options.sandbox) {
-    return ensureSandboxOpenCodeServer(request);
-  }
-  return createLocalRuntime2(request);
-}
 var OpenCodeAgentAdapter = class {
+  async setup(request) {
+    await setupOpenCode(request);
+  }
   async execute(request, sink) {
-    const inputParts = await validateProviderUserInput(
-      request.provider,
-      request.run.input
+    const executeStartedAt = Date.now();
+    debugOpencode("execute() start runId=%s", request.runId);
+    const inputParts = await time(
+      debugOpencode,
+      "validateProviderUserInput",
+      () => validateProviderUserInput(request.provider, request.run.input)
     );
     let pendingMessages = 0;
     let finalText = "";
+    let streamedTextFromSse = "";
+    const settledMessageIds = /* @__PURE__ */ new Set();
     let dispatchError;
+    let firstSseEventLogged = false;
     let resolveAllDone;
     const allDone = new Promise((resolve) => {
       resolveAllDone = resolve;
@@ -3801,7 +3784,10 @@ var OpenCodeAgentAdapter = class {
     sink.onMessage(async (content) => {
       pendingMessages++;
       try {
-        const parts = await validateProviderUserInput(request.provider, content);
+        const parts = await validateProviderUserInput(
+          request.provider,
+          content
+        );
         const mapped = mapToOpenCodeParts(parts);
         if (sendToSession) {
           sendToSession(mapped);
@@ -3817,7 +3803,11 @@ var OpenCodeAgentAdapter = class {
         throw error;
       }
     });
-    const runtime = await createRuntime3(request);
+    const runtime = await time(
+      debugOpencode,
+      "buildOpenCodeRuntime",
+      () => buildOpenCodeRuntime(request.options)
+    );
     sink.setRaw(runtime.raw);
     sink.emitEvent(
       createNormalizedEvent("run.started", {
@@ -3825,6 +3815,7 @@ var OpenCodeAgentAdapter = class {
         runId: request.runId
       })
     );
+    const rawPayloads = [];
     const sseAbort = new AbortController();
     let sseTask;
     const dispatchAbort = new AbortController();
@@ -3846,9 +3837,7 @@ var OpenCodeAgentAdapter = class {
             ),
             new Promise(
               (_, reject) => setTimeout(
-                () => reject(
-                  new Error("opencode POST /session/abort timed out")
-                ),
+                () => reject(new Error("opencode POST /session/abort timed out")),
                 3e3
               )
             )
@@ -3877,12 +3866,22 @@ var OpenCodeAgentAdapter = class {
       if (!sessionId) {
         throw new Error("OpenCode did not return a session id.");
       }
+      const announcedUserMessageIds = /* @__PURE__ */ new Set();
+      const foreignMessageIds = /* @__PURE__ */ new Set();
       sseTask = (async () => {
         try {
           for await (const event of streamSse(`${runtime.baseUrl}/event`, {
             headers: runtime.previewHeaders,
             signal: sseAbort.signal
           })) {
+            if (!firstSseEventLogged) {
+              firstSseEventLogged = true;
+              debugOpencode(
+                "\u2605 first SSE event (%dms since execute start) type=%s",
+                Date.now() - executeStartedAt,
+                event.event
+              );
+            }
             let payload = event.data;
             try {
               payload = JSON.parse(event.data);
@@ -3893,8 +3892,33 @@ var OpenCodeAgentAdapter = class {
               payload,
               `sse:${event.event ?? "message"}`
             );
+            if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+              rawPayloads.push(payload);
+            }
             sink.emitRaw(raw);
             const eventType = typeof payload?.type === "string" ? String(payload.type) : event.event;
+            if (eventType === "message.updated") {
+              const properties = payload.properties;
+              const info = properties?.info;
+              if (info && typeof info.id === "string" && typeof info.sessionID === "string") {
+                if (info.sessionID !== sessionId) {
+                  foreignMessageIds.add(info.id);
+                } else if (info.role === "user" && !announcedUserMessageIds.has(info.id)) {
+                  announcedUserMessageIds.add(info.id);
+                  sink.emitEvent(
+                    createNormalizedEvent(
+                      "message.started",
+                      {
+                        provider: request.provider,
+                        runId: request.runId,
+                        raw
+                      },
+                      { messageId: info.id }
+                    )
+                  );
+                }
+              }
+            }
             if (eventType === "permission.asked") {
               const properties = payload.properties;
               if (properties && typeof properties.sessionID === "string" && properties.sessionID === sessionId) {
@@ -3923,8 +3947,61 @@ var OpenCodeAgentAdapter = class {
               }
               continue;
             }
-            for (const normalized of normalizeRawAgentEvent(raw)) {
-              sink.emitEvent(normalized);
+            const payloadRecord = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : null;
+            if ((payloadRecord?.type === "session.idle" || payloadRecord?.type === "session.error") && !dispatchAbort.signal.aborted) {
+              const properties = payloadRecord.properties;
+              const eventSessionId = typeof properties?.sessionID === "string" ? properties.sessionID : void 0;
+              if (!eventSessionId || eventSessionId === sessionId) {
+                debugOpencode(
+                  "\u2605 %s for session=%s \u2014 aborting in-flight dispatch",
+                  payloadRecord.type,
+                  sessionId
+                );
+                dispatchAbort.abort();
+              }
+            }
+            if (payloadRecord?.type === "message.part.delta") {
+              const properties = payloadRecord.properties;
+              const eventSessionId = typeof properties?.sessionID === "string" ? properties.sessionID : void 0;
+              const eventMessageId = typeof properties?.messageID === "string" ? properties.messageID : void 0;
+              const isForeignSession = eventSessionId !== void 0 && eventSessionId !== sessionId || eventSessionId === void 0 && eventMessageId !== void 0 && foreignMessageIds.has(eventMessageId);
+              if (isForeignSession) {
+                continue;
+              }
+              if (eventMessageId !== void 0 && settledMessageIds.has(eventMessageId)) {
+                continue;
+              }
+              const delta = typeof properties?.delta === "string" ? properties.delta : "";
+              if (delta && properties?.field === "text") {
+                streamedTextFromSse += delta;
+                sink.emitEvent(
+                  createNormalizedEvent(
+                    "text.delta",
+                    {
+                      provider: request.provider,
+                      runId: request.runId,
+                      raw
+                    },
+                    { delta }
+                  )
+                );
+              } else if (delta && (properties?.field === "reasoning" || properties?.field === "thinking")) {
+                sink.emitEvent(
+                  createNormalizedEvent(
+                    "reasoning.delta",
+                    {
+                      provider: request.provider,
+                      runId: request.runId,
+                      raw
+                    },
+                    { delta }
+                  )
+                );
+              }
+            } else {
+              for (const normalized of normalizeRawAgentEvent(raw)) {
+                sink.emitEvent(normalized);
+              }
             }
           }
         } catch {
@@ -3939,13 +4016,18 @@ var OpenCodeAgentAdapter = class {
           request.run.resumeSessionId ? "session.resumed" : "session.created"
         )
       );
+      if (createdSession) {
+        rawPayloads.push(createdSession);
+      }
       sink.emitEvent(
         createNormalizedEvent("message.started", {
           provider: request.provider,
           runId: request.runId
         })
       );
+      const agentSlug = openCodeAgentSlug(request.run.reasoning);
       const dispatchMessage = async (parts) => {
+        const sseTextLengthBeforeDispatch = streamedTextFromSse.length;
         try {
           const response = await fetchJson(
             `${runtime.baseUrl}/session/${sessionId}/message`,
@@ -3958,7 +4040,7 @@ var OpenCodeAgentAdapter = class {
               },
               body: JSON.stringify({
                 ...request.run.model ? { model: toOpenCodeModel(request.run.model) } : {},
-                agent: "agentbox",
+                agent: agentSlug,
                 parts
               })
             }
@@ -3968,24 +4050,59 @@ var OpenCodeAgentAdapter = class {
             response,
             "message.response"
           );
+          if (response && typeof response === "object" && !Array.isArray(response)) {
+            rawPayloads.push(response);
+          }
           sink.emitRaw(rawResponse);
           for (const event of normalizeRawAgentEvent(rawResponse)) {
             sink.emitEvent(event);
           }
-          const text = extractText(response);
-          if (text) {
-            finalText = text;
+          const reasoning = extractReasoning(response);
+          if (reasoning) {
             sink.emitEvent(
               createNormalizedEvent(
-                "text.delta",
+                "reasoning.delta",
                 {
                   provider: request.provider,
-                  runId: request.runId
+                  runId: request.runId,
+                  raw: rawResponse
                 },
-                { delta: text }
+                { delta: reasoning }
               )
             );
           }
+          const text = extractText(response);
+          if (text) {
+            finalText = text;
+            const sseTextForThisDispatch = streamedTextFromSse.slice(
+              sseTextLengthBeforeDispatch
+            );
+            let missing;
+            if (text.startsWith(sseTextForThisDispatch)) {
+              missing = text.slice(sseTextForThisDispatch.length);
+            } else if (sseTextForThisDispatch.length === 0) {
+              missing = text;
+            } else {
+              missing = "";
+            }
+            if (missing.length > 0) {
+              streamedTextFromSse += missing;
+              sink.emitEvent(
+                createNormalizedEvent(
+                  "text.delta",
+                  {
+                    provider: request.provider,
+                    runId: request.runId
+                  },
+                  { delta: missing }
+                )
+              );
+            }
+            const assistantMessageId = extractAssistantMessageId(response);
+            if (assistantMessageId) {
+              settledMessageIds.add(assistantMessageId);
+            }
+          }
         } catch (error) {
           if (!dispatchError) {
             dispatchError = error;
@@ -4004,9 +4121,14 @@ var OpenCodeAgentAdapter = class {
       pendingMessages++;
       void dispatchMessage(mapToOpenCodeParts(inputParts));
       await allDone;
-      if (dispatchError) {
+      if (dispatchError && !dispatchAbort.signal.aborted) {
         throw dispatchError;
       }
+      debugOpencode(
+        "\u2605 run.completed (%dms since execute start) chars=%d",
+        Date.now() - executeStartedAt,
+        finalText.length
+      );
       sink.emitEvent(
         createNormalizedEvent(
           "run.completed",
@@ -4019,16 +4141,86 @@ var OpenCodeAgentAdapter = class {
       );
       sseAbort.abort();
       await sseTask;
-      sink.complete({ text: finalText });
+      sink.complete({
+        text: finalText,
+        costData: extractOpenCodeCostData(rawPayloads)
+      });
     } finally {
       sseAbort.abort();
       if (sseTask) {
         await sseTask.catch(() => void 0);
       }
-      await runtime.cleanup().catch(() => void 0);
     }
     return async () => void 0;
   }
+  /**
+   * Stateless abort. Resolve the in-sandbox base URL via
+   * `sandbox.getPreviewLink` and POST to `/session/:id/abort`. Best-effort:
+   * a 3s timeout protects against an unresponsive server, and any error
+   * is swallowed since the originating run will tear itself down once
+   * the server-side abort takes effect.
+   */
+  async attachAbort(request) {
+    if (!request.sessionId) {
+      throw new Error(
+        `Cannot attachAbort to opencode run ${request.runId}: sessionId is required.`
+      );
+    }
+    const baseUrl = (await request.sandbox.getPreviewLink(SANDBOX_OPENCODE_PORT)).replace(/\/$/, "");
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3e3);
+    try {
+      await fetch(`${baseUrl}/session/${request.sessionId}/abort`, {
+        method: "POST",
+        signal: controller.signal,
+        headers: {
+          "content-type": "application/json",
+          ...request.sandbox.previewHeaders
+        }
+      }).catch((error) => {
+        debugOpencode(
+          "attachAbort runId=%s POST /abort failed: %o",
+          request.runId,
+          error
+        );
+      });
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  /**
+   * Stateless message injection. POST a fresh user message to
+   * `/session/:id/message` with `agent` defaulting to the build agent
+   * — opencode appends it to the running session and the originating
+   * instance picks up the new turn through its existing SSE stream.
+   */
+  async attachSendMessage(request, content) {
+    if (!request.sessionId) {
+      throw new Error(
+        `Cannot attachSendMessage to opencode run ${request.runId}: sessionId is required.`
+      );
+    }
+    const baseUrl = (await request.sandbox.getPreviewLink(SANDBOX_OPENCODE_PORT)).replace(/\/$/, "");
+    const inputParts = await validateProviderUserInput(
+      AgentProvider.OpenCode,
+      content
+    );
+    const parts = mapToOpenCodeParts(inputParts);
+    await fetchJson(
+      `${baseUrl}/session/${request.sessionId}/message`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          ...request.sandbox.previewHeaders
+        },
+        body: JSON.stringify({
+          agent: openCodeAgentSlug(void 0),
+          parts
+        })
+      }
+    );
+  }
 };
 
 // src/agents/Agent.ts
@@ -4092,11 +4284,7 @@ function createAdapter(provider) {
       throw new UnsupportedProviderError("agent", provider);
   }
 }
-function prepareAgentOptions(provider, options) {
-  const ports = AGENT_RESERVED_PORTS[provider] ?? [];
-  for (const port of ports) {
-    void options.sandbox?.openPort(port);
-  }
+function prepareAgentOptions(_provider, options) {
   return options;
 }
 var AgentRunController = class {
@@ -4114,6 +4302,7 @@ var AgentRunController = class {
   pendingPermissions = /* @__PURE__ */ new Map();
   messageHandler;
   text = "";
+  costData = null;
   settled = false;
   finished;
   resolveSessionIdReady;
@@ -4205,14 +4394,18 @@ var AgentRunController = class {
       );
     }
     const textContent = normalizeUserInput(content).filter((p) => p.type === "text").map((p) => p.text).join("");
+    const handlerResult = await this.messageHandler(content);
+    const messageId = handlerResult?.messageId;
     this.pushEvent(
       createNormalizedEvent(
         "message.injected",
         { provider: this.provider, runId: this.id },
-        { content: textContent || "(non-text content)" }
+        {
+          content: textContent || "(non-text content)",
+          ...messageId ? { messageId } : {}
+        }
       )
     );
-    await this.messageHandler(content);
   }
   async respondToPermission(response) {
     const pending = this.pendingPermissions.get(response.requestId);
@@ -4263,6 +4456,9 @@ var AgentRunController = class {
     if (result?.text) {
       this.text = result.text;
     }
+    if (result && "costData" in result) {
+      this.costData = result.costData ?? null;
+    }
     this.eventQueue.finish();
     this.rawQueue.finish();
     if (!this.sessionId) {
@@ -4279,7 +4475,8 @@ var AgentRunController = class {
       sessionId: this.sessionId,
       text: this.text,
       rawEvents: [...this.rawEventsList],
-      events: [...this.events]
+      events: [...this.events],
+      costData: this.costData
     });
   }
   fail(error) {
@@ -4326,23 +4523,93 @@ var Agent = class {
   adapter;
   provider;
   options;
+  setupPromise;
   constructor(provider, options) {
     this.provider = provider;
     this.options = prepareAgentOptions(provider, options);
     this.adapter = createAdapter(provider);
   }
+  /**
+   * The sandbox the agent will run inside, if any was passed via
+   * `options.sandbox`. Returns `undefined` for host-mode runs (no sandbox).
+   */
+  get sandbox() {
+    return this.options.sandbox;
+  }
+  /**
+   * Prepare provider-specific runtime state on the configured sandbox
+   * (skill artifacts, MCP/hook/sub-agent config, app-server / relay boot, …).
+   *
+   * `setup()` is REQUIRED before {@link Agent.stream} or {@link Agent.run}
+   * for any sandbox-backed run. `stream` and the underlying
+   * `adapter.execute` deliberately do not trigger setup themselves so
+   * callers can run sandbox-side preparation in parallel with other
+   * long-running work (e.g. `git clone`).
+   *
+   * `execute` does not consume any setup output and does not re-do
+   * setup work. It assumes the relay/server boot performed here is
+   * already up. Skipping `setup()` against a remote sandbox is a
+   * programmer error and surfaces as a connect-retry timeout inside
+   * `execute`, not a silent fallback.
+   *
+   * Idempotent across repeated invocations: subsequent calls return the
+   * promise from the first call. The differential setup cache and the
+   * relay/server probes also make this cheap on warm sandboxes — the
+   * second `setup()` against the same sandbox does ~one round-trip of
+   * work.
+   */
+  async setup(config = {}) {
+    if (this.setupPromise) {
+      await this.setupPromise;
+      return;
+    }
+    debugAgent("setup() provider=%s", this.provider);
+    const startedAt = Date.now();
+    this.setupPromise = (async () => {
+      await this.adapter.setup({
+        provider: this.provider,
+        options: this.options,
+        config
+      });
+      debugAgent(
+        "setup() returned provider=%s after %dms",
+        this.provider,
+        Date.now() - startedAt
+      );
+    })();
+    try {
+      await this.setupPromise;
+    } catch (error) {
+      this.setupPromise = void 0;
+      throw error;
+    }
+  }
   stream(runConfig) {
-    const runId = randomUUID3();
+    const runId = runConfig.runId ?? randomUUID2();
+    const streamCalledAt = Date.now();
+    debugAgent("stream() provider=%s runId=%s", this.provider, runId);
     const run = new AgentRunController(this.provider, runId);
-    const request = {
-      runId,
-      provider: this.provider,
-      options: this.options,
-      run: buildRunConfig(this.options, runConfig)
-    };
+    const setupPromise = this.setupPromise;
+    const provider = this.provider;
+    const options = this.options;
+    const adapter = this.adapter;
     void (async () => {
       try {
-        const cleanup = await this.adapter.execute(request, run);
+        if (setupPromise) {
+          await setupPromise;
+        }
+        const request = {
+          runId,
+          provider,
+          options,
+          run: buildRunConfig(options, runConfig)
+        };
+        const cleanup = await adapter.execute(request, run);
+        debugAgent(
+          "adapter.execute() returned for runId=%s after %dms",
+          runId,
+          Date.now() - streamCalledAt
+        );
         run.setAbort(async () => {
           await cleanup();
         });
@@ -4358,6 +4625,32 @@ var Agent = class {
   rawEvents(runConfig) {
     return this.stream(runConfig).rawEvents();
   }
+  /**
+   * Stateless control plane for an in-flight run.
+   *
+   * Returns an {@link AttachedRun} whose `abort()` / `sendMessage()` methods
+   * dial the in-sandbox provider server directly (codex app-server, opencode
+   * HTTP server, claude-code relay control endpoint) — there is no shared
+   * in-memory registry or Redis broker. Any process with the right `sandbox`
+   * + `runId` (+ optional provider-native `sessionId`) can issue commands
+   * against a run started on a different process.
+   *
+   * The originating process keeps owning the event stream that
+   * `agent.stream()` returned; commands attached here cause the in-sandbox
+   * server to emit the natural follow-up events (`turn/aborted`, message
+   * events, etc.), which the originating process ingests through its
+   * existing transport.
+   *
+   * The handle is short-lived: each method call opens a fresh connection,
+   * performs the operation with a timeout, and tears the connection down.
+   */
+  static async attach(request) {
+    const adapter = createAdapter(request.provider);
+    return {
+      abort: () => adapter.attachAbort(request),
+      sendMessage: (content) => adapter.attachSendMessage(request, content)
+    };
+  }
 };
 
 export {