@lesscap/baton-cli 0.4.1 → 0.4.3

package/dist/baton.mjs

@@ -3724,14 +3724,14 @@ function isUppercase(char = "") {
   if (NUMBER_CHAR_RE.test(char)) return;
   return char !== char.toLowerCase();
 }
-function splitByCase(str, separators) {
+function splitByCase(str3, separators) {
   const splitters = separators ?? STR_SPLITTERS;
   const parts = [];
-  if (!str || typeof str !== "string") return parts;
+  if (!str3 || typeof str3 !== "string") return parts;
   let buff = "";
   let previousUpper;
   let previousSplitter;
-  for (const char of str) {
+  for (const char of str3) {
     const isSplitter = splitters.includes(char);
     if (isSplitter === true) {
       parts.push(buff);
@@ -3762,23 +3762,23 @@ function splitByCase(str, separators) {
   parts.push(buff);
   return parts;
 }
-function upperFirst(str) {
-  return str ? str[0].toUpperCase() + str.slice(1) : "";
+function upperFirst(str3) {
+  return str3 ? str3[0].toUpperCase() + str3.slice(1) : "";
 }
-function lowerFirst(str) {
-  return str ? str[0].toLowerCase() + str.slice(1) : "";
+function lowerFirst(str3) {
+  return str3 ? str3[0].toLowerCase() + str3.slice(1) : "";
 }
-function pascalCase(str, opts) {
-  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => upperFirst(opts?.normalize ? p.toLowerCase() : p)).join("") : "";
+function pascalCase(str3, opts) {
+  return str3 ? (Array.isArray(str3) ? str3 : splitByCase(str3)).map((p) => upperFirst(opts?.normalize ? p.toLowerCase() : p)).join("") : "";
 }
-function camelCase(str, opts) {
-  return lowerFirst(pascalCase(str || "", opts));
+function camelCase(str3, opts) {
+  return lowerFirst(pascalCase(str3 || "", opts));
 }
-function kebabCase(str, joiner) {
-  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
+function kebabCase(str3, joiner) {
+  return str3 ? (Array.isArray(str3) ? str3 : splitByCase(str3)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
 }
-function snakeCase(str) {
-  return kebabCase(str || "", "_");
+function snakeCase(str3) {
+  return kebabCase(str3 || "", "_");
 }
 
 // ../../node_modules/.pnpm/citty@0.2.2/node_modules/citty/dist/index.mjs
@@ -4777,30 +4777,30 @@ import { join } from "node:path";
 var PROJECT_CONFIG_NAME = ".baton.json";
 var projectConfigPath = (cwd = process.cwd()) => join(cwd, PROJECT_CONFIG_NAME);
 var configPathFromArgs = (args, cwd) => args.config ?? projectConfigPath(cwd);
-var loadProjectConfig = (path) => {
+var loadProjectConfig = (path3) => {
   try {
-    return JSON.parse(readFileSync(path, "utf8"));
+    return JSON.parse(readFileSync(path3, "utf8"));
   } catch (err) {
-    const cause = err.code === "ENOENT" ? `not found at ${path}` : String(err);
+    const cause = err.code === "ENOENT" ? `not found at ${path3}` : String(err);
     throw new Error(`${PROJECT_CONFIG_NAME} ${cause} \u2014 run \`baton init\` first`);
   }
 };
-var loadProjectConfigOrNull = (path) => {
-  if (!existsSync(path)) return null;
+var loadProjectConfigOrNull = (path3) => {
+  if (!existsSync(path3)) return null;
   try {
-    return JSON.parse(readFileSync(path, "utf8"));
+    return JSON.parse(readFileSync(path3, "utf8"));
   } catch {
     return null;
   }
 };
-var saveProjectConfig = (path, config) => {
-  writeFileSync(path, `${JSON.stringify(config, null, 2)}
+var saveProjectConfig = (path3, config) => {
+  writeFileSync(path3, `${JSON.stringify(config, null, 2)}
 `, "utf8");
 };
-var patch = (path, fn) => {
-  saveProjectConfig(path, fn(loadProjectConfig(path)));
+var patch = (path3, fn) => {
+  saveProjectConfig(path3, fn(loadProjectConfig(path3)));
 };
-var setWorker = (path, w) => patch(path, (cfg) => ({ ...cfg, worker: w }));
+var setWorker = (path3, w) => patch(path3, (cfg) => ({ ...cfg, worker: w }));
 var requireBase = (cfg) => {
   if (!cfg.server || !cfg.project || !cfg.worker)
     throw new Error("project-config missing server/project/worker \u2014 run `baton worker register`");
@@ -4812,6 +4812,7 @@ var viewWorker = (cfg) => {
     server,
     projectId: project2,
     workerId: worker2.id,
+    agentKind: worker2.agentKind ?? "claude-code",
     name: worker2.name,
     machineId: worker2.machineId,
     apiToken: worker2.apiToken
@@ -4820,7 +4821,13 @@ var viewWorker = (cfg) => {
 var worktreeConfig = (cfg) => ({
   server: cfg.server,
   project: cfg.projectId,
-  worker: { id: cfg.workerId, name: cfg.name, machineId: cfg.machineId, apiToken: cfg.apiToken }
+  worker: {
+    id: cfg.workerId,
+    name: cfg.name,
+    agentKind: cfg.agentKind,
+    machineId: cfg.machineId,
+    apiToken: cfg.apiToken
+  }
 });
 
 // src/config.ts
@@ -4847,7 +4854,7 @@ var fmtComment = (c) => `${c.workerId !== void 0 ? `worker#${c.workerId}` : "you
 var fmtSession = (s) => `${s.id}  ${s.name}  ${s.attached ? "[active]" : "[inactive]"}  ${s.worktreePath ?? "(pending)"}`;
 var fmtWorker = (w) => {
   const offline = w.connected === false ? "  [offline]" : "";
-  return `W-${w.id}  ${w.name}  ${w.hostname}${offline}`;
+  return `W-${w.id}  ${w.name}  ${w.hostname}  ${w.agentKind}${offline}`;
 };
 var fmtInterval = (sec) => {
   if (sec % 86400 === 0) return `${sec / 86400}d`;
@@ -5133,7 +5140,12 @@ var createWorkerClient = (baseUrl, workerToken, sessionId) => {
       body: { active },
       headers: auth
     }),
-    listEvents: () => request(u(`/sessions/${sessionId}/events`), { method: "GET", headers: auth })
+    listEvents: () => request(u(`/sessions/${sessionId}/events`), { method: "GET", headers: auth }),
+    materialize: (input) => request(u(`/sessions/${sessionId}`), {
+      method: "PATCH",
+      body: input,
+      headers: auth
+    })
   };
 };
 
@@ -5554,7 +5566,7 @@ var BY_EXT = {
   ".json": "application/json",
   ".csv": "text/csv"
 };
-var contentTypeForPath = (path) => BY_EXT[extname(path).toLowerCase()] ?? "application/octet-stream";
+var contentTypeForPath = (path3) => BY_EXT[extname(path3).toLowerCase()] ?? "application/octet-stream";
 
 // src/commands/attach.ts
 import { openAsBlob } from "node:fs";
@@ -5562,12 +5574,12 @@ import { basename } from "node:path";
 var attachPaths = (raw) => (raw === void 0 ? [] : Array.isArray(raw) ? raw : [raw]).flatMap((p) => p.split(",")).map((p) => p.trim()).filter(Boolean);
 var uploadAttachments = async (client, sessionId, paths) => {
   const out = [];
-  for (const path of paths) {
-    const body = await openAsBlob(path, { type: contentTypeForPath(path) });
+  for (const path3 of paths) {
+    const body = await openAsBlob(path3, { type: contentTypeForPath(path3) });
     out.push(
       await client.sessions.uploadAttachment(sessionId, {
-        filename: basename(path),
-        contentType: contentTypeForPath(path),
+        filename: basename(path3),
+        contentType: contentTypeForPath(path3),
         body
       })
     );
@@ -5600,12 +5612,12 @@ var sendCommand = defineCommand({
     if (text === void 0 && args.file) text = readFileSync2(args.file, "utf8");
     if (text === void 0 && !process.stdin.isTTY) text = await readStdin();
     const attachments = [];
-    for (const path of attachPaths(args.attach)) {
+    for (const path3 of attachPaths(args.attach)) {
       attachments.push(
         await client.uploadAttachment(args.channel, {
-          filename: basename2(path),
-          contentType: contentTypeForPath(path),
-          body: await openAsBlob2(path, { type: contentTypeForPath(path) })
+          filename: basename2(path3),
+          contentType: contentTypeForPath(path3),
+          body: await openAsBlob2(path3, { type: contentTypeForPath(path3) })
         })
       );
     }
@@ -6451,10 +6463,10 @@ var parseFirstExchange = (content) => {
   return userText || assistantText ? { userText, assistantText } : null;
 };
 var readFirstExchange = (agentSessionId) => {
-  const path = findTranscriptPath(agentSessionId);
-  if (!path) return null;
+  const path3 = findTranscriptPath(agentSessionId);
+  if (!path3) return null;
   try {
-    return parseFirstExchange(readFileSync4(path, "utf8"));
+    return parseFirstExchange(readFileSync4(path3, "utf8"));
   } catch {
     return null;
   }
@@ -6511,6 +6523,687 @@ var augmentPrompt = (text, relPaths, labels) => {
 ${text}` : header;
 };
 
+// ../../node_modules/.pnpm/@openai+codex-sdk@0.142.5/node_modules/@openai/codex-sdk/dist/index.js
+import { promises as fs } from "fs";
+import os from "os";
+import path from "path";
+import { spawn } from "child_process";
+import { statSync as statSync2 } from "fs";
+import path2 from "path";
+import readline2 from "readline";
+import { createRequire } from "module";
+async function createOutputSchemaFile(schema) {
+  if (schema === void 0) {
+    return { cleanup: async () => {
+    } };
+  }
+  if (!isJsonObject(schema)) {
+    throw new Error("outputSchema must be a plain JSON object");
+  }
+  const schemaDir = await fs.mkdtemp(path.join(os.tmpdir(), "codex-output-schema-"));
+  const schemaPath = path.join(schemaDir, "schema.json");
+  const cleanup = async () => {
+    try {
+      await fs.rm(schemaDir, { recursive: true, force: true });
+    } catch {
+    }
+  };
+  try {
+    await fs.writeFile(schemaPath, JSON.stringify(schema), "utf8");
+    return { schemaPath, cleanup };
+  } catch (error) {
+    await cleanup();
+    throw error;
+  }
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var Thread = class {
+  _exec;
+  _options;
+  _id;
+  _threadOptions;
+  /** Returns the ID of the thread. Populated after the first turn starts. */
+  get id() {
+    return this._id;
+  }
+  /* @internal */
+  constructor(exec, options, threadOptions, id = null) {
+    this._exec = exec;
+    this._options = options;
+    this._id = id;
+    this._threadOptions = threadOptions;
+  }
+  /** Provides the input to the agent and streams events as they are produced during the turn. */
+  async runStreamed(input, turnOptions = {}) {
+    return { events: this.runStreamedInternal(input, turnOptions) };
+  }
+  async *runStreamedInternal(input, turnOptions = {}) {
+    const { schemaPath, cleanup } = await createOutputSchemaFile(turnOptions.outputSchema);
+    const options = this._threadOptions;
+    const { prompt, images } = normalizeInput(input);
+    const generator = this._exec.run({
+      input: prompt,
+      baseUrl: this._options.baseUrl,
+      apiKey: this._options.apiKey,
+      threadId: this._id,
+      images,
+      model: options?.model,
+      sandboxMode: options?.sandboxMode,
+      workingDirectory: options?.workingDirectory,
+      skipGitRepoCheck: options?.skipGitRepoCheck,
+      outputSchemaFile: schemaPath,
+      modelReasoningEffort: options?.modelReasoningEffort,
+      signal: turnOptions.signal,
+      networkAccessEnabled: options?.networkAccessEnabled,
+      webSearchMode: options?.webSearchMode,
+      webSearchEnabled: options?.webSearchEnabled,
+      approvalPolicy: options?.approvalPolicy,
+      additionalDirectories: options?.additionalDirectories
+    });
+    try {
+      for await (const item of generator) {
+        let parsed;
+        try {
+          parsed = JSON.parse(item);
+        } catch (error) {
+          throw new Error(`Failed to parse item: ${item}`, { cause: error });
+        }
+        if (parsed.type === "thread.started") {
+          this._id = parsed.thread_id;
+        }
+        yield parsed;
+      }
+    } finally {
+      await cleanup();
+    }
+  }
+  /** Provides the input to the agent and returns the completed turn. */
+  async run(input, turnOptions = {}) {
+    const generator = this.runStreamedInternal(input, turnOptions);
+    const items = [];
+    let finalResponse = "";
+    let usage = null;
+    let turnFailure = null;
+    for await (const event of generator) {
+      if (event.type === "item.completed") {
+        if (event.item.type === "agent_message") {
+          finalResponse = event.item.text;
+        }
+        items.push(event.item);
+      } else if (event.type === "turn.completed") {
+        usage = event.usage;
+      } else if (event.type === "turn.failed") {
+        turnFailure = event.error;
+        break;
+      }
+    }
+    if (turnFailure) {
+      throw new Error(turnFailure.message);
+    }
+    return { items, finalResponse, usage };
+  }
+};
+function normalizeInput(input) {
+  if (typeof input === "string") {
+    return { prompt: input, images: [] };
+  }
+  const promptParts = [];
+  const images = [];
+  for (const item of input) {
+    if (item.type === "text") {
+      promptParts.push(item.text);
+    } else if (item.type === "local_image") {
+      images.push(item.path);
+    }
+  }
+  return { prompt: promptParts.join("\n\n"), images };
+}
+var INTERNAL_ORIGINATOR_ENV = "CODEX_INTERNAL_ORIGINATOR_OVERRIDE";
+var TYPESCRIPT_SDK_ORIGINATOR = "codex_sdk_ts";
+var CODEX_NPM_NAME = "@openai/codex";
+var PLATFORM_PACKAGE_BY_TARGET = {
+  "x86_64-unknown-linux-musl": "@openai/codex-linux-x64",
+  "aarch64-unknown-linux-musl": "@openai/codex-linux-arm64",
+  "x86_64-apple-darwin": "@openai/codex-darwin-x64",
+  "aarch64-apple-darwin": "@openai/codex-darwin-arm64",
+  "x86_64-pc-windows-msvc": "@openai/codex-win32-x64",
+  "aarch64-pc-windows-msvc": "@openai/codex-win32-arm64"
+};
+var moduleRequire = createRequire(import.meta.url);
+var CodexExec = class {
+  executablePath;
+  pathDirs;
+  envOverride;
+  configOverrides;
+  constructor(executablePath = null, env, configOverrides) {
+    if (executablePath) {
+      this.executablePath = executablePath;
+      this.pathDirs = [];
+    } else {
+      const resolved = findCodexPath();
+      this.executablePath = resolved.executablePath;
+      this.pathDirs = resolved.pathDirs;
+    }
+    this.envOverride = env;
+    this.configOverrides = configOverrides;
+  }
+  async *run(args) {
+    const commandArgs = ["exec", "--experimental-json"];
+    if (this.configOverrides) {
+      for (const override of serializeConfigOverrides(this.configOverrides)) {
+        commandArgs.push("--config", override);
+      }
+    }
+    if (args.baseUrl) {
+      commandArgs.push(
+        "--config",
+        `openai_base_url=${toTomlValue(args.baseUrl, "openai_base_url")}`
+      );
+    }
+    if (args.model) {
+      commandArgs.push("--model", args.model);
+    }
+    if (args.sandboxMode) {
+      commandArgs.push("--sandbox", args.sandboxMode);
+    }
+    if (args.workingDirectory) {
+      commandArgs.push("--cd", args.workingDirectory);
+    }
+    if (args.additionalDirectories?.length) {
+      for (const dir of args.additionalDirectories) {
+        commandArgs.push("--add-dir", dir);
+      }
+    }
+    if (args.skipGitRepoCheck) {
+      commandArgs.push("--skip-git-repo-check");
+    }
+    if (args.outputSchemaFile) {
+      commandArgs.push("--output-schema", args.outputSchemaFile);
+    }
+    if (args.modelReasoningEffort) {
+      commandArgs.push("--config", `model_reasoning_effort="${args.modelReasoningEffort}"`);
+    }
+    if (args.networkAccessEnabled !== void 0) {
+      commandArgs.push(
+        "--config",
+        `sandbox_workspace_write.network_access=${args.networkAccessEnabled}`
+      );
+    }
+    if (args.webSearchMode) {
+      commandArgs.push("--config", `web_search="${args.webSearchMode}"`);
+    } else if (args.webSearchEnabled === true) {
+      commandArgs.push("--config", `web_search="live"`);
+    } else if (args.webSearchEnabled === false) {
+      commandArgs.push("--config", `web_search="disabled"`);
+    }
+    if (args.approvalPolicy) {
+      commandArgs.push("--config", `approval_policy="${args.approvalPolicy}"`);
+    }
+    if (args.threadId) {
+      commandArgs.push("resume", args.threadId);
+    }
+    if (args.images?.length) {
+      for (const image of args.images) {
+        commandArgs.push("--image", image);
+      }
+    }
+    const env = {};
+    if (this.envOverride) {
+      Object.assign(env, this.envOverride);
+    } else {
+      for (const [key, value] of Object.entries(process.env)) {
+        if (value !== void 0) {
+          env[key] = value;
+        }
+      }
+    }
+    if (!env[INTERNAL_ORIGINATOR_ENV]) {
+      env[INTERNAL_ORIGINATOR_ENV] = TYPESCRIPT_SDK_ORIGINATOR;
+    }
+    if (args.apiKey) {
+      env.CODEX_API_KEY = args.apiKey;
+    }
+    if (this.pathDirs.length > 0) {
+      prependPathDirs(env, this.pathDirs);
+    }
+    const child = spawn(this.executablePath, commandArgs, {
+      env,
+      signal: args.signal
+    });
+    let spawnError = null;
+    child.once("error", (err) => spawnError = err);
+    if (!child.stdin) {
+      child.kill();
+      throw new Error("Child process has no stdin");
+    }
+    child.stdin.write(args.input);
+    child.stdin.end();
+    if (!child.stdout) {
+      child.kill();
+      throw new Error("Child process has no stdout");
+    }
+    const stderrChunks = [];
+    if (child.stderr) {
+      child.stderr.on("data", (data) => {
+        stderrChunks.push(data);
+      });
+    }
+    const exitPromise = new Promise(
+      (resolve2) => {
+        child.once("exit", (code, signal) => {
+          resolve2({ code, signal });
+        });
+      }
+    );
+    const rl = readline2.createInterface({
+      input: child.stdout,
+      crlfDelay: Infinity
+    });
+    try {
+      for await (const line of rl) {
+        yield line;
+      }
+      if (spawnError) throw spawnError;
+      const { code, signal } = await exitPromise;
+      if (code !== 0 || signal) {
+        const stderrBuffer = Buffer.concat(stderrChunks);
+        const detail = signal ? `signal ${signal}` : `code ${code ?? 1}`;
+        throw new Error(`Codex Exec exited with ${detail}: ${stderrBuffer.toString("utf8")}`);
+      }
+    } finally {
+      rl.close();
+      child.removeAllListeners();
+      try {
+        if (!child.killed) child.kill();
+      } catch {
+      }
+    }
+  }
+};
+function serializeConfigOverrides(configOverrides) {
+  const overrides = [];
+  flattenConfigOverrides(configOverrides, "", overrides);
+  return overrides;
+}
+function flattenConfigOverrides(value, prefix, overrides) {
+  if (!isPlainObject(value)) {
+    if (prefix) {
+      overrides.push(`${prefix}=${toTomlValue(value, prefix)}`);
+      return;
+    } else {
+      throw new Error("Codex config overrides must be a plain object");
+    }
+  }
+  const entries = Object.entries(value);
+  if (!prefix && entries.length === 0) {
+    return;
+  }
+  if (prefix && entries.length === 0) {
+    overrides.push(`${prefix}={}`);
+    return;
+  }
+  for (const [key, child] of entries) {
+    if (!key) {
+      throw new Error("Codex config override keys must be non-empty strings");
+    }
+    if (child === void 0) {
+      continue;
+    }
+    const path3 = prefix ? `${prefix}.${key}` : key;
+    if (isPlainObject(child)) {
+      flattenConfigOverrides(child, path3, overrides);
+    } else {
+      overrides.push(`${path3}=${toTomlValue(child, path3)}`);
+    }
+  }
+}
+function toTomlValue(value, path3) {
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  } else if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error(`Codex config override at ${path3} must be a finite number`);
+    }
+    return `${value}`;
+  } else if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  } else if (Array.isArray(value)) {
+    const rendered = value.map((item, index) => toTomlValue(item, `${path3}[${index}]`));
+    return `[${rendered.join(", ")}]`;
+  } else if (isPlainObject(value)) {
+    const parts = [];
+    for (const [key, child] of Object.entries(value)) {
+      if (!key) {
+        throw new Error("Codex config override keys must be non-empty strings");
+      }
+      if (child === void 0) {
+        continue;
+      }
+      parts.push(`${formatTomlKey(key)} = ${toTomlValue(child, `${path3}.${key}`)}`);
+    }
+    return `{${parts.join(", ")}}`;
+  } else if (value === null) {
+    throw new Error(`Codex config override at ${path3} cannot be null`);
+  } else {
+    const typeName = typeof value;
+    throw new Error(`Unsupported Codex config override value at ${path3}: ${typeName}`);
+  }
+}
+var TOML_BARE_KEY = /^[A-Za-z0-9_-]+$/;
+function formatTomlKey(key) {
+  return TOML_BARE_KEY.test(key) ? key : JSON.stringify(key);
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function findCodexPath() {
+  const { platform, arch } = process;
+  let targetTriple = null;
+  switch (platform) {
+    case "linux":
+    case "android":
+      switch (arch) {
+        case "x64":
+          targetTriple = "x86_64-unknown-linux-musl";
+          break;
+        case "arm64":
+          targetTriple = "aarch64-unknown-linux-musl";
+          break;
+        default:
+          break;
+      }
+      break;
+    case "darwin":
+      switch (arch) {
+        case "x64":
+          targetTriple = "x86_64-apple-darwin";
+          break;
+        case "arm64":
+          targetTriple = "aarch64-apple-darwin";
+          break;
+        default:
+          break;
+      }
+      break;
+    case "win32":
+      switch (arch) {
+        case "x64":
+          targetTriple = "x86_64-pc-windows-msvc";
+          break;
+        case "arm64":
+          targetTriple = "aarch64-pc-windows-msvc";
+          break;
+        default:
+          break;
+      }
+      break;
+    default:
+      break;
+  }
+  if (!targetTriple) {
+    throw new Error(`Unsupported platform: ${platform} (${arch})`);
+  }
+  const platformPackage = PLATFORM_PACKAGE_BY_TARGET[targetTriple];
+  if (!platformPackage) {
+    throw new Error(`Unsupported target triple: ${targetTriple}`);
+  }
+  let vendorRoot;
+  try {
+    const codexPackageJsonPath = moduleRequire.resolve(`${CODEX_NPM_NAME}/package.json`);
+    const codexRequire = createRequire(codexPackageJsonPath);
+    const platformPackageJsonPath = codexRequire.resolve(`${platformPackage}/package.json`);
+    vendorRoot = path2.join(path2.dirname(platformPackageJsonPath), "vendor");
+  } catch {
+    throw new Error(
+      `Unable to locate Codex CLI binaries. Ensure ${CODEX_NPM_NAME} is installed with optional dependencies.`
+    );
+  }
+  const codexBinaryName = process.platform === "win32" ? "codex.exe" : "codex";
+  const nativePackage = resolveNativePackage(vendorRoot, targetTriple, codexBinaryName);
+  if (!nativePackage) {
+    throw new Error(
+      `Unable to locate Codex CLI binaries for ${targetTriple}. Ensure ${CODEX_NPM_NAME} is installed with optional dependencies.`
+    );
+  }
+  return nativePackage;
+}
+function resolveNativePackage(vendorRoot, targetTriple, codexBinaryName) {
+  const packageRoot = path2.join(vendorRoot, targetTriple);
+  const packageBinaryPath = path2.join(packageRoot, "bin", codexBinaryName);
+  if (isFile(packageBinaryPath) && isFile(path2.join(packageRoot, "codex-package.json"))) {
+    return {
+      executablePath: packageBinaryPath,
+      pathDirs: existingDirs(path2.join(packageRoot, "codex-path"))
+    };
+  }
+  const legacyBinaryPath = path2.join(packageRoot, "codex", codexBinaryName);
+  if (isFile(legacyBinaryPath)) {
+    return {
+      executablePath: legacyBinaryPath,
+      pathDirs: existingDirs(path2.join(packageRoot, "path"))
+    };
+  }
+  return null;
+}
+function existingDirs(...dirs) {
+  return dirs.filter(isDirectory);
+}
+function prependPathDirs(env, pathDirs, platform = process.platform) {
+  const pathKey = pathEnvKey(env, platform);
+  if (platform === "win32") {
+    for (const key of Object.keys(env)) {
+      if (key.toLowerCase() === "path" && key !== pathKey) {
+        delete env[key];
+      }
+    }
+  }
+  const existingEntries = (env[pathKey] ?? "").split(path2.delimiter).filter((entry) => entry.length > 0 && !pathDirs.includes(entry));
+  env[pathKey] = [...pathDirs, ...existingEntries].join(path2.delimiter);
+}
+function pathEnvKey(env, platform) {
+  if (platform !== "win32") {
+    return "PATH";
+  }
+  const matchingKeys = Object.keys(env).filter((key) => key.toLowerCase() === "path");
+  return matchingKeys.includes("Path") ? "Path" : matchingKeys.at(-1) ?? "PATH";
+}
+function isFile(filePath) {
+  try {
+    return statSync2(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+function isDirectory(filePath) {
+  try {
+    return statSync2(filePath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+var Codex = class {
+  exec;
+  options;
+  constructor(options = {}) {
+    const { codexPathOverride, env, config } = options;
+    this.exec = new CodexExec(codexPathOverride, env, config);
+    this.options = options;
+  }
+  /**
+   * Starts a new conversation with an agent.
+   * @returns A new thread instance.
+   */
+  startThread(options = {}) {
+    return new Thread(this.exec, this.options, options);
+  }
+  /**
+   * Resumes a conversation with an agent based on the thread id.
+   * Threads are persisted in ~/.codex/sessions.
+   *
+   * @param id The id of the thread to resume.
+   * @returns A new thread instance.
+   */
+  resumeThread(id, options = {}) {
+    return new Thread(this.exec, this.options, options, id);
+  }
+};
+
+// src/session/runner/codex.ts
+var isRecord2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var str = (v) => typeof v === "string" ? v : void 0;
+var compactEnv = (env) => {
+  if (!env) return void 0;
+  const out = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+};
+var statusOf = (v) => v === "in_progress" || v === "failed" || v === "completed" ? v : "completed";
+var itemId = (item) => str(item.id) ?? `${str(item.type) ?? "item"}-${Math.random().toString(36).slice(2)}`;
+var todoItems = (raw) => Array.isArray(raw) ? raw.filter(isRecord2).map((todo) => ({
+  text: str(todo.text) ?? str(todo.content) ?? "",
+  completed: todo.completed === true || todo.status === "completed"
+})) : [];
+var fileKind = (v) => v === "add" || v === "delete" || v === "update" ? v : "update";
+var toAgentItem = (raw) => {
+  if (!isRecord2(raw)) {
+    return {
+      type: "error",
+      id: "bad-item",
+      status: "failed",
+      message: "codex item was not an object"
+    };
+  }
+  const type = str(raw.type);
+  const id = itemId(raw);
+  const status = statusOf(raw.status);
+  if (type === "agent_message") {
+    return { type, id, status, text: str(raw.text) ?? str(raw.message) ?? "" };
+  }
+  if (type === "reasoning") {
+    return { type, id, status, text: str(raw.text) ?? str(raw.summary) ?? "" };
+  }
+  if (type === "command_execution") {
+    return {
+      type,
+      id,
+      status,
+      command: str(raw.command) ?? "",
+      output: str(raw.aggregated_output) ?? str(raw.output) ?? "",
+      exitCode: typeof raw.exit_code === "number" ? raw.exit_code : void 0
+    };
+  }
+  if (type === "file_change") {
+    const changes = Array.isArray(raw.changes) ? raw.changes.filter(isRecord2).map((change) => ({
+      path: str(change.path) ?? "",
+      kind: fileKind(change.kind)
+    })) : [];
+    return { type, id, status, changes };
+  }
+  if (type === "mcp_tool_call") {
+    return {
+      type,
+      id,
+      status,
+      server: str(raw.server) ?? "",
+      tool: str(raw.tool) ?? str(raw.name) ?? "",
+      arguments: raw.arguments ?? raw.input ?? null,
+      output: raw.result ?? raw.output ?? raw.error,
+      isError: raw.is_error === true || raw.error !== void 0
+    };
+  }
+  if (type === "web_search") {
+    return { type, id, status, query: str(raw.query) ?? "" };
+  }
+  if (type === "todo_list") {
+    return { type, id, status, items: todoItems(raw.items) };
+  }
+  if (type === "error") {
+    return { type, id, status: "failed", message: str(raw.message) ?? "codex error" };
+  }
+  return {
+    type: "tool_call",
+    id,
+    status,
+    name: str(raw.name) ?? type ?? "codex_item",
+    input: raw,
+    output: raw.output
+  };
+};
+var usageOf = (raw) => {
+  if (!isRecord2(raw)) return void 0;
+  return {
+    inputTokens: typeof raw.input_tokens === "number" ? raw.input_tokens : void 0,
+    cachedInputTokens: typeof raw.cached_input_tokens === "number" ? raw.cached_input_tokens : void 0,
+    outputTokens: typeof raw.output_tokens === "number" ? raw.output_tokens : void 0,
+    reasoningOutputTokens: typeof raw.reasoning_output_tokens === "number" ? raw.reasoning_output_tokens : void 0
+  };
+};
+var toAgentEvent = (raw) => {
+  if (!isRecord2(raw)) return { type: "raw", raw };
+  const type = str(raw.type);
+  if (type === "thread.started") {
+    return {
+      type,
+      sessionId: str(raw.thread_id) ?? str(raw.sessionId) ?? "",
+      model: str(raw.model),
+      raw
+    };
+  }
+  if (type === "turn.started") return { type, raw };
+  if ((type === "item.started" || type === "item.updated" || type === "item.completed") && raw.item !== void 0) {
+    return { type, item: toAgentItem(raw.item), raw };
+  }
+  if (type === "turn.completed") return { type, usage: usageOf(raw.usage), raw };
+  if (type === "turn.failed") {
+    const error = isRecord2(raw.error) ? raw.error : raw;
+    return { type, error: { message: str(error.message) ?? "codex turn failed" }, raw };
+  }
+  if (type === "error") return { type, message: str(raw.message) ?? "codex error", raw };
+  return { type: "raw", raw };
+};
+var withPlanPrefix = (input) => {
+  const prefix = "Plan mode: inspect and propose a plan only. Do not edit files or run mutating commands.\n\n";
+  if (typeof input === "string") return `${prefix}${input}`;
+  return input.map(
+    (entry, i) => i === 0 && entry.type === "text" ? { ...entry, text: `${prefix}${entry.text}` } : entry
+  );
+};
+async function* startCodexEvents(config, input, worker2, opts) {
+  const env = compactEnv(buildSdkEnv(opts.envOverlay));
+  const codex = new Codex(env ? { env } : void 0);
+  const resuming = !config.agentSessionId.startsWith("pending:");
+  const addDirs = additionalDirs();
+  const threadOptions = {
+    workingDirectory: config.worktreePath,
+    skipGitRepoCheck: true,
+    sandboxMode: opts.planMode ? "read-only" : "workspace-write",
+    approvalPolicy: "never",
+    ...opts.model ? { model: opts.model } : {},
+    ...addDirs ? { additionalDirectories: addDirs } : {}
+  };
+  const thread = resuming ? codex.resumeThread(config.agentSessionId, threadOptions) : codex.startThread(threadOptions);
+  const runInput = opts.planMode ? withPlanPrefix(input) : input;
+  const { events } = await thread.runStreamed(runInput, {
+    ...opts.signal ? { signal: opts.signal } : {}
+  });
+  for await (const raw of events) {
+    const event = toAgentEvent(raw);
+    if (event.type === "thread.started" && !resuming && event.sessionId) {
+      config.agentSessionId = event.sessionId;
+      await worker2.materialize({
+        agentSessionId: event.sessionId,
+        worktreePath: config.worktreePath
+      });
+      opts.log(`[codex] thread ${event.sessionId}`);
+    }
+    yield event;
+  }
+}
+
 // src/session/runner/query.ts
 var startQuery = (config, text, resuming, queryFn, abortController, log, { envOverlay, planMode = false, model } = {}) => {
   const env = buildSdkEnv(envOverlay);
@@ -6539,21 +7232,223 @@ var startQuery = (config, text, resuming, queryFn, abortController, log, { envOv
 };
 
 // src/session/runner/stream.ts
-var streamSdkEvents = async (messages, worker2) => {
+var streamAgentEvents = async (events, worker2) => {
   let result = null;
-  for await (const message of messages) {
-    await worker2.emitEvent("sdk_event", message);
-    if (message.type === "result") result = toTurnResult(message);
+  for await (const event of events) {
+    await worker2.emitEvent("agent_event", event);
+    if (event.type === "turn.completed") {
+      result = {
+        subtype: event.subtype ?? "success",
+        isError: false,
+        resultText: ""
+      };
+    } else if (event.type === "turn.failed") {
+      result = {
+        subtype: event.error.subtype ?? "error",
+        isError: true,
+        resultText: event.error.message
+      };
+    }
   }
   return result;
 };
-var toTurnResult = (message) => {
+var streamClaudeSdkEvents = (messages, worker2) => streamAgentEvents(claudeToAgentEvents(messages), worker2);
+var isRecord3 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var str2 = (v) => typeof v === "string" ? v : void 0;
+var messageContent = (payload) => {
+  const msg = payload.message;
+  if (!isRecord3(msg) || !Array.isArray(msg.content)) return [];
+  return msg.content.filter(isRecord3);
+};
+var textFromToolResult = (raw) => {
+  const c = raw.content;
+  if (typeof c === "string") return c;
+  if (Array.isArray(c)) {
+    return c.map((b) => isRecord3(b) && typeof b.text === "string" ? b.text : JSON.stringify(b)).join("\n");
+  }
+  return JSON.stringify(c ?? "");
+};
+var commandOf = (input) => {
+  if (!isRecord3(input)) return "";
+  return str2(input.command) ?? str2(input.cmd) ?? "";
+};
+var pathOf = (input) => {
+  if (!isRecord3(input)) return void 0;
+  return str2(input.file_path) ?? str2(input.path);
+};
+var fileKindOf = (name) => name === "Delete" ? "delete" : "update";
+var todoItems2 = (input) => {
+  if (!isRecord3(input) || !Array.isArray(input.todos)) return [];
+  return input.todos.filter(isRecord3).map((todo) => ({
+    text: str2(todo.content) ?? str2(todo.text) ?? "",
+    completed: todo.status === "completed" || todo.completed === true
+  }));
+};
+var mcpParts = (name) => {
+  const match = /^mcp__(.+?)__(.+)$/.exec(name);
+  return match ? { server: match[1] ?? "", tool: match[2] ?? "" } : null;
+};
+var startedItemFromToolUse = (block) => {
+  const id = str2(block.id) ?? `tool-${Math.random().toString(36).slice(2)}`;
+  const name = str2(block.name) ?? "tool";
+  const input = block.input ?? null;
+  if (name === "Bash") {
+    return {
+      type: "command_execution",
+      id,
+      status: "in_progress",
+      command: commandOf(input),
+      output: ""
+    };
+  }
+  if (name === "Edit" || name === "Write" || name === "MultiEdit" || name === "Delete") {
+    const path3 = pathOf(input);
+    return {
+      type: "file_change",
+      id,
+      status: "in_progress",
+      changes: path3 ? [{ path: path3, kind: fileKindOf(name) }] : []
+    };
+  }
+  const mcp = mcpParts(name);
+  if (mcp) {
+    return {
+      type: "mcp_tool_call",
+      id,
+      status: "in_progress",
+      server: mcp.server,
+      tool: mcp.tool,
+      arguments: input
+    };
+  }
+  if (name === "WebSearch" || name === "web_search") {
+    return {
+      type: "web_search",
+      id,
+      status: "in_progress",
+      query: isRecord3(input) ? str2(input.query) ?? "" : ""
+    };
+  }
+  if (name === "TodoWrite") {
+    return { type: "todo_list", id, status: "in_progress", items: todoItems2(input) };
+  }
+  return { type: "tool_call", id, status: "in_progress", name, input };
+};
+var completeItem = (item, output, isError) => {
+  if (item.type === "command_execution")
+    return { ...item, status: isError ? "failed" : "completed", output };
+  if (item.type === "mcp_tool_call")
+    return { ...item, status: isError ? "failed" : "completed", output, isError };
+  if (item.type === "tool_call")
+    return { ...item, status: isError ? "failed" : "completed", output, isError };
+  return { ...item, status: isError ? "failed" : "completed" };
+};
+var resultEvent = (message) => {
   const rec = message;
-  const subtype = typeof rec.subtype === "string" ? rec.subtype : "unknown";
+  const subtype = str2(rec.subtype) ?? "unknown";
   const isError = rec.is_error === true || subtype !== "success";
-  const resultText = typeof rec.result === "string" ? rec.result : "";
-  return { subtype, isError, resultText };
+  const resultText = str2(rec.result) ?? "";
+  const usage = {
+    numTurns: typeof rec.num_turns === "number" ? rec.num_turns : void 0,
+    totalCostUsd: typeof rec.total_cost_usd === "number" ? rec.total_cost_usd : void 0,
+    durationMs: typeof rec.duration_ms === "number" ? rec.duration_ms : void 0
+  };
+  return isError ? {
+    type: "turn.failed",
+    error: { message: resultText || `claude result: ${subtype}`, subtype },
+    usage,
+    raw: message
+  } : { type: "turn.completed", subtype, usage, raw: message };
 };
+async function* claudeToAgentEvents(messages) {
+  const pendingTools = /* @__PURE__ */ new Map();
+  let systemEmitted = false;
+  let textSeq = 0;
+  let reasoningSeq = 0;
+  for await (const message of messages) {
+    const p = message;
+    if (message.type === "system") {
+      if (!systemEmitted) {
+        systemEmitted = true;
+        yield {
+          type: "thread.started",
+          sessionId: str2(p.session_id) ?? "",
+          model: str2(p.model) ?? (isRecord3(p.model_info) ? str2(p.model_info.id) : void 0),
+          raw: message
+        };
+        yield { type: "turn.started", raw: message };
+      }
+      continue;
+    }
+    if (message.type === "assistant") {
+      for (const block of messageContent(p)) {
+        if (block.type === "text" && typeof block.text === "string") {
+          yield {
+            type: "item.completed",
+            item: {
+              type: "agent_message",
+              id: `assistant-${++textSeq}`,
+              status: "completed",
+              text: block.text
+            },
+            raw: block
+          };
+        } else if (block.type === "thinking" && typeof block.thinking === "string") {
+          const text = block.thinking.trim();
+          if (text) {
+            yield {
+              type: "item.completed",
+              item: {
+                type: "reasoning",
+                id: `reasoning-${++reasoningSeq}`,
+                status: "completed",
+                text
+              },
+              raw: block
+            };
+          }
+        } else if (block.type === "tool_use" || block.type === "server_tool_use") {
+          const item = startedItemFromToolUse(block);
+          pendingTools.set(item.id, item);
+          yield { type: "item.started", item, raw: block };
+        } else if (block.type === "tool_result") {
+          const id = str2(block.tool_use_id) ?? "";
+          const item = pendingTools.get(id);
+          if (item) {
+            const completed = completeItem(item, textFromToolResult(block), block.is_error === true);
+            pendingTools.set(id, completed);
+            yield { type: "item.completed", item: completed, raw: block };
+          } else {
+            yield { type: "raw", raw: block };
+          }
+        } else {
+          yield { type: "raw", raw: block };
+        }
+      }
+      continue;
+    }
+    if (message.type === "user") {
+      for (const block of messageContent(p)) {
+        if (block.type !== "tool_result") continue;
+        const id = str2(block.tool_use_id) ?? "";
+        const item = pendingTools.get(id);
+        if (!item) {
+          yield { type: "raw", raw: block };
+          continue;
+        }
+        const completed = completeItem(item, textFromToolResult(block), block.is_error === true);
+        pendingTools.set(id, completed);
+        yield { type: "item.completed", item: completed, raw: block };
+      }
+      continue;
+    }
+    if (message.type === "result") {
+      yield resultEvent(message);
+      continue;
+    }
+    yield { type: "raw", raw: message };
+  }
+}
 
 // src/session/runner/turn.ts
 var turnTimeoutMs = () => Number(process.env.BATON_TURN_TIMEOUT_MS) || 30 * 6e4;
@@ -6563,14 +7458,14 @@ var ABORTED = /* @__PURE__ */ Symbol("turn-aborted");
 var finalizeTurn = async (result, worker2, log) => {
   if (!result) {
     log("[exit] stream ended with no result");
-    await worker2.emitEvent("turn_error", { message: "claude produced no result" });
+    await worker2.emitEvent("turn_error", { message: "agent produced no result" });
     await worker2.emitEvent("turn_complete", {});
     return -1;
   }
   log(`[exit] subtype=${result.subtype} isError=${result.isError}`);
   if (result.isError) {
     await worker2.emitEvent("turn_error", {
-      message: result.resultText || `claude result: ${result.subtype}`,
+      message: result.resultText || `agent result: ${result.subtype}`,
       subtype: result.subtype
     });
   }
@@ -6578,7 +7473,7 @@ var finalizeTurn = async (result, worker2, log) => {
   return result.isError ? 1 : 0;
 };
 var buildPrompt = async (config, rawText, attachments, log, fetchImpl) => {
-  if (attachments.length === 0) return rawText;
+  if (attachments.length === 0) return { text: rawText, input: rawText };
   const relPaths = await materializeAttachments({
     worktreePath: config.worktreePath,
     serverBase: config.server,
@@ -6586,7 +7481,13 @@ var buildPrompt = async (config, rawText, attachments, log, fetchImpl) => {
     fetchImpl
   });
   log(`[attach] downloaded ${relPaths.length} file(s) \u2192 ${config.worktreePath}/attachments`);
-  return augmentPrompt(rawText, relPaths, labelAttachments(attachments));
+  const labels = labelAttachments(attachments);
+  const text = augmentPrompt(rawText, relPaths, labels);
+  const images = relPaths.flatMap((relPath, i) => {
+    const att = attachments[i];
+    return att?.contentType.startsWith("image/") ? [{ type: "local_image", path: `${config.worktreePath}/${relPath}` }] : [];
+  });
+  return images.length > 0 ? { text, input: [{ type: "text", text }, ...images] } : { text, input: text };
 };
 var runTurn = async (config, worker2, msg, resuming, queryFn, log = (m) => console.log(m), envOverlay, fetchImpl, externalSignal) => {
   await worker2.emitEvent("turn_start", { messageId: msg.id });
@@ -6599,9 +7500,9 @@ var runTurn = async (config, worker2, msg, resuming, queryFn, log = (m) => conso
     await worker2.emitEvent("turn_error", { message: "user_message missing text and attachments" });
     return -1;
   }
-  let text;
+  let built;
   try {
-    text = await buildPrompt(config, rawText, attachments, log, fetchImpl);
+    built = await buildPrompt(config, rawText, attachments, log, fetchImpl);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     await worker2.emitEvent("turn_error", { message: `attachment download failed: ${message}` });
@@ -6622,12 +7523,23 @@ var runTurn = async (config, worker2, msg, resuming, queryFn, log = (m) => conso
     heartbeat = setInterval(() => {
       void worker2.emitEvent("turn_heartbeat", {}).catch((e) => log(`[heartbeat] ${String(e)}`));
     }, heartbeatMs());
-    const messages = startQuery(config, text, resuming, queryFn, abort, log, {
-      envOverlay,
-      planMode,
-      model
-    });
-    const consume = streamSdkEvents(messages, worker2);
+    const consume = config.agentKind === "codex" ? streamAgentEvents(
+      startCodexEvents(config, built.input, worker2, {
+        envOverlay,
+        planMode,
+        model,
+        signal: abort.signal,
+        log
+      }),
+      worker2
+    ) : streamClaudeSdkEvents(
+      startQuery(config, built.text, resuming, queryFn, abort, log, {
+        envOverlay,
+        planMode,
+        model
+      }),
+      worker2
+    );
     void consume.catch(() => {
     });
     const outcome = await Promise.race([consume, timeout, interrupted]);
@@ -6639,10 +7551,10 @@ var runTurn = async (config, worker2, msg, resuming, queryFn, log = (m) => conso
       return -1;
     }
     if (outcome === TIMEOUT) {
-      log(`[watchdog] turn exceeded ${ceiling}ms \u2014 aborting claude`);
+      log(`[watchdog] turn exceeded ${ceiling}ms \u2014 aborting agent`);
       abort.abort();
       await worker2.emitEvent("turn_error", {
-        message: `turn exceeded ${ceiling}ms \u2014 claude aborted`
+        message: `turn exceeded ${ceiling}ms \u2014 agent aborted`
       });
       await worker2.emitEvent("turn_complete", {});
       return -1;
@@ -6698,7 +7610,7 @@ var runDaemon = async (config, deps, signal) => {
   log(`bin: ${claudeExecutable() ?? "(sdk bundled)"}  cwd: ${config.worktreePath}`);
   log(`runtime env keys: ${maskedEnvKeys(deps.env)}`);
   const state = {
-    firstSpawnDone: findTranscriptPath(config.agentSessionId) !== null,
+    firstSpawnDone: config.agentKind === "codex" ? !config.agentSessionId.startsWith("pending:") : findTranscriptPath(config.agentSessionId) !== null,
     seen: /* @__PURE__ */ new Set()
   };
   const pendingQueue = [];
@@ -6866,6 +7778,7 @@ var sessionRunCommand = defineCommand({
       server,
       sessionId,
       name: s.name,
+      agentKind: s.agentKind,
       agentSessionId: s.agentSessionId,
       worktreePath: s.worktreePath
     };
@@ -7147,7 +8060,7 @@ var task = defineCommand({
   }
 });
 
-// src/commands/worker.ts
+// src/commands/worker/index.ts
 import { hostname as osHostname } from "node:os";
 
 // src/worker/watchdog.ts
@@ -7202,7 +8115,7 @@ var createLiveness = (deps) => {
 };
 
 // src/worker/session-supervisor.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { existsSync as existsSync5 } from "node:fs";
 import { dirname as dirname2, join as join7 } from "node:path";
@@ -7335,12 +8248,12 @@ var ensureExcluded = (repo, pattern) => {
     });
     if (r.status !== 0) return;
     const rel = r.stdout.trim();
-    const path = isAbsolute2(rel) ? rel : resolve(repo, rel);
-    const current = existsSync4(path) ? readFileSync5(path, "utf8") : "";
+    const path3 = isAbsolute2(rel) ? rel : resolve(repo, rel);
+    const current = existsSync4(path3) ? readFileSync5(path3, "utf8") : "";
     if (current.split("\n").includes(pattern)) return;
-    mkdirSync3(dirname(path), { recursive: true });
+    mkdirSync3(dirname(path3), { recursive: true });
     const sep = current === "" || current.endsWith("\n") ? "" : "\n";
-    appendFileSync(path, `${sep}${pattern}
+    appendFileSync(path3, `${sep}${pattern}
 `, "utf8");
   } catch {
   }
@@ -7387,7 +8300,7 @@ var createSessionSupervisor = (deps) => {
   const children = /* @__PURE__ */ new Map();
   const spawnChild = (sessionId, worktreePath) => {
     if (children.has(sessionId)) return;
-    const child = spawn(process.execPath, [binPath(), "session", "run", String(sessionId)], {
+    const child = spawn2(process.execPath, [binPath(), "session", "run", String(sessionId)], {
       detached: true,
       stdio: "inherit",
       env: { ...process.env, BATON_SERVER: cfg.server, BATON_WORKER_TOKEN: cfg.apiToken }
@@ -7408,12 +8321,13 @@ var createSessionSupervisor = (deps) => {
     const session2 = await client.sessions.get(sessionId);
     let worktreePath = session2.worktreePath;
     if (!session2.agentSessionId || !worktreePath) {
-      const agentSessionId = randomUUID();
-      worktreePath = join7(worktreeDir, slug(`${name}-${agentSessionId.slice(0, 8)}`));
+      const sessionCode = randomUUID();
+      const agentSessionId = session2.agentKind === "codex" ? `pending:${sessionCode}` : sessionCode;
+      worktreePath = join7(worktreeDir, slug(`${name}-${sessionCode.slice(0, 8)}`));
       createWorktree({
         repo,
         worktreePath,
-        sessionCode: agentSessionId.slice(0, 8),
+        sessionCode: sessionCode.slice(0, 8),
         base: repoHeadBranch(repo)
       });
       await client.sessions.materialize(sessionId, { agentSessionId, worktreePath }, cfg.apiToken);
@@ -7448,6 +8362,8 @@ var createSessionSupervisor = (deps) => {
     log(`deleted session #${sessionId} (removed worktree)`);
   };
   const title = async (sessionId, agentSessionId, worktreePath) => {
+    const session2 = await client.sessions.get(sessionId);
+    if (session2.agentKind !== "claude-code") return log(`title #${sessionId}: unsupported agent`);
     const exchange = readFirstExchange(agentSessionId);
     if (!exchange) return log(`title #${sessionId}: no transcript yet, skipping`);
     const outcome = await generateTitle({
@@ -7490,7 +8406,7 @@ var createSessionSupervisor = (deps) => {
 
 // src/worker/terminal-manager.ts
 import { existsSync as existsSync7 } from "node:fs";
-import { spawn as spawn2 } from "node-pty";
+import { spawn as spawn3 } from "node-pty";
 
 // ../../node_modules/.pnpm/ws@8.21.0/node_modules/ws/wrapper.mjs
 var import_stream2 = __toESM(require_stream(), 1);
@@ -7529,7 +8445,7 @@ var createTerminalManager = (deps) => {
       return;
     }
     const claudeBin = process.env.BATON_CLAUDE_BIN ?? "claude";
-    const term = spawn2(claudeBin, ptyArgs(agentSessionId, hasSessionJsonl(agentSessionId)), {
+    const term = spawn3(claudeBin, ptyArgs(agentSessionId, hasSessionJsonl(agentSessionId)), {
       name: "xterm-color",
       cols: 80,
       rows: 24,
@@ -7682,19 +8598,19 @@ import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as rea
 import { homedir as homedir4 } from "node:os";
 import { dirname as dirname3, join as join9 } from "node:path";
 var machineIdPath = (env = process.env) => join9(env.XDG_DATA_HOME ?? join9(env.HOME ?? homedir4(), ".local/share"), "baton", "machine-id");
-var readOrCreateMachineId = (path = machineIdPath()) => {
-  if (existsSync8(path)) {
-    const s = readFileSync6(path, "utf8").trim();
+var readOrCreateMachineId = (path3 = machineIdPath()) => {
+  if (existsSync8(path3)) {
+    const s = readFileSync6(path3, "utf8").trim();
     if (s) return s;
   }
   const id = randomUUID2();
-  mkdirSync4(dirname3(path), { recursive: true });
-  writeFileSync5(path, `${id}
+  mkdirSync4(dirname3(path3), { recursive: true });
+  writeFileSync5(path3, `${id}
 `, "utf8");
   return id;
 };
 
-// src/commands/worker.ts
+// src/commands/worker/index.ts
 var resolveWorker = async (client, projectId, handle) => {
   const asId = parseWorkerHandle(handle);
   if (asId !== null) {
@@ -7705,9 +8621,15 @@ var resolveWorker = async (client, projectId, handle) => {
   if (byName) return { id: byName.id, name: byName.name };
   throw new Error(`worker "${handle}" not found in project ${projectId}`);
 };
+var parseAgentKind = (value) => {
+  const raw = typeof value === "string" && value.trim() ? value.trim() : "claude-code";
+  if (raw === "claude-code" || raw === "codex") return raw;
+  throw new Error(`invalid agent kind "${raw}" (expected claude-code or codex)`);
+};
 var registerWorker = async (client, input, cfgPath = projectConfigPath()) => {
   const out = await client.workers.register({
     projectId: input.projectId,
+    agentKind: input.agentKind,
     machineId: input.machineId,
     name: input.name,
     hostname: input.hostname
@@ -7720,6 +8642,7 @@ var registerWorker = async (client, input, cfgPath = projectConfigPath()) => {
   setWorker(cfgPath, {
     id: out.worker.id,
     name: out.worker.name,
+    agentKind: out.worker.agentKind,
     machineId: out.worker.machineId,
     apiToken: out.apiToken
   });
@@ -7740,6 +8663,10 @@ var worker = defineCommand({
           type: "string",
           description: "path to the worker config file (default: ./.baton.json)"
         },
+        agentKind: {
+          type: "string",
+          description: "agent engine for new sessions: claude-code or codex"
+        },
         ...common
       },
       run: async ({ args }) => {
@@ -7756,6 +8683,7 @@ var worker = defineCommand({
         const hostname = osHostname();
         const machineId = readOrCreateMachineId();
         const name = args.name ?? hostname;
+        const agentKind = parseAgentKind(args.agentKind ?? process.env.BATON_AGENT_KIND);
         const { out, configPath } = await registerWorker(
           c,
           {
@@ -7763,7 +8691,8 @@ var worker = defineCommand({
             name,
             server,
             hostname,
-            machineId
+            machineId,
+            agentKind
           },
           cfgPath
         );
@@ -7772,6 +8701,7 @@ var worker = defineCommand({
           return;
         }
         console.log(`worker #${out.worker.id} (${out.worker.name}) \u2014 ${out.outcome}`);
+        console.log(`  agentKind:      ${out.worker.agentKind}`);
         console.log(`  hostname:       ${out.worker.hostname}`);
         console.log(`  machineId:      ${out.worker.machineId}`);
         console.log(`  machineId file: ${machineIdPath()}`);
@@ -7886,6 +8816,7 @@ var worker = defineCommand({
         }
         console.log(`worker #${worker2.id} (${worker2.name})`);
         console.log(`  machineId: ${worker2.machineId}`);
+        console.log(`  agentKind: ${worker2.agentKind ?? "claude-code"}`);
         console.log(`  server:    ${cfg?.server}`);
       }
     })