@lesscap/baton-cli 0.4.2 → 0.5.0

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
@@ -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
+    })
   };
 };
 
@@ -6511,6 +6523,161 @@ var augmentPrompt = (text, relPaths, labels) => {
 ${text}` : header;
 };
 
+// src/session/runner/codex.ts
+import { Codex } from "@openai/codex-sdk";
+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 +6706,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 path = pathOf(input);
+    return {
+      type: "file_change",
+      id,
+      status: "in_progress",
+      changes: path ? [{ path, 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 +6932,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 +6947,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 +6955,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 +6974,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 +6997,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 +7025,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 +7084,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 +7252,7 @@ var sessionRunCommand = defineCommand({
       server,
       sessionId,
       name: s.name,
+      agentKind: s.agentKind,
       agentSessionId: s.agentSessionId,
       worktreePath: s.worktreePath
     };
@@ -7147,7 +7534,7 @@ var task = defineCommand({
   }
 });
 
-// src/commands/worker.ts
+// src/commands/worker/index.ts
 import { hostname as osHostname } from "node:os";
 
 // src/worker/watchdog.ts
@@ -7408,12 +7795,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 +7836,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({
@@ -7694,7 +8084,7 @@ var readOrCreateMachineId = (path = machineIdPath()) => {
   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 +8095,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 +8116,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 +8137,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 +8157,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 +8165,8 @@ var worker = defineCommand({
             name,
             server,
             hostname,
-            machineId
+            machineId,
+            agentKind
           },
           cfgPath
         );
@@ -7772,6 +8175,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 +8290,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}`);
       }
     })

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@lesscap/baton-cli",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
   "type": "module",
   "description": "baton CLI — register/run a worker, manage projects/requirements/tasks/sessions",
   "bin": {
@@ -23,6 +26,7 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.3.161",
+    "@openai/codex-sdk": "^0.142.5",
     "node-pty": "^1.1.0",
     "ws": "^8.21.0"
   },