@dadado/agent-kit-cli 5.17.0 → 5.18.0

package/dist/{chunk-OUQZC744.js → chunk-B5CH47OS.js}

@@ -1,3 +1,6 @@
+import {
+  findOnPath
+} from "./chunk-WGLPZXNU.js";
 import {
   HEADLESS_DENY_RULES
 } from "./chunk-MAPOQEA2.js";
@@ -38,10 +41,10 @@ var LineSplitter = class {
         onLine(segment);
       } else {
         this.parts.push(segment);
-        const line = this.parts.join("");
+        const line3 = this.parts.join("");
         this.parts = [];
         this.length = 0;
-        onLine(line);
+        onLine(line3);
       }
       start = nl + 1;
       nl = text.indexOf("\n", start);
@@ -80,17 +83,20 @@ var FALLBACK_WORDING_RES = [
   /skip or cancel means stop/i
 ];
 var TICK_SENTINEL_RE = /LOOP_TICK_RESULT:/;
-function parseHitlGateLine(line) {
-  const m = HITL_GATE_LINE_RE.exec(line.trim());
+function parseHitlGateLine(line3) {
+  const m = HITL_GATE_LINE_RE.exec(line3.trim());
   if (!m?.[1] || !m[2]) return null;
   const labels = m[2].split("|").map((s) => s.trim()).filter((s) => s.length > 0);
   if (labels.length === 0) return null;
   return { askId: m[1], labels, detection: "sentinel" };
 }
+function formatHitlGateLine(gate) {
+  return `HITL_GATE: ${gate.askId} | ${gate.labels.join(" | ")}`;
+}
 function findHitlGateInText(text) {
   let last = null;
-  for (const line of text.split(/\r?\n/)) {
-    const gate = parseHitlGateLine(line);
+  for (const line3 of text.split(/\r?\n/)) {
+    const gate = parseHitlGateLine(line3);
     if (gate) last = gate;
   }
   return last;
@@ -107,8 +113,8 @@ function detectFallbackGate(text) {
   if (!FALLBACK_WORDING_RES.some((re) => re.test(text))) return null;
   const labels = [];
   let expected = 1;
-  for (const line of text.split(/\r?\n/)) {
-    const m = NUMBERED_LINE_RE.exec(line);
+  for (const line3 of text.split(/\r?\n/)) {
+    const m = NUMBERED_LINE_RE.exec(line3);
     if (!m?.[1] || !m[2]) continue;
     const n = Number(m[1]);
     if (n === 1) {
@@ -192,7 +198,7 @@ function createTerminalAnswerReader(opts = {}) {
     readOpts.signal?.addEventListener("abort", onAbort, { once: true });
     rl.on("SIGINT", () => finish({ kind: "sigint" }));
     rl.on("close", () => finish({ kind: "eof" }));
-    rl.question("> ", (line) => finish({ kind: "line", text: line }));
+    rl.question("> ", (line3) => finish({ kind: "line", text: line3 }));
   });
 }
 function emptyHitlRecord() {
@@ -222,6 +228,15 @@ function unansweredStop(askId, cause) {
     exitCode: HITL_UNANSWERED_EXIT_CODE
   };
 }
+function driverStop(askId, raw) {
+  const detail = raw.detail ? `: ${raw.detail}` : "";
+  return {
+    askId,
+    cause: raw.cause,
+    message: raw.cause === "driver stop" ? `stopped-by-operator: gate ${askId}, no reply (driver stop)` : `stopped: unanswered gate (driver protocol error${detail})`,
+    exitCode: HITL_UNANSWERED_EXIT_CODE
+  };
+}
 function noRelayStop(askId, backend) {
   return {
     askId,
@@ -251,7 +266,9 @@ function formatGatePrompt(gate) {
 async function askOperator(gate, opts) {
   if (isReservedGateId(gate.askId)) return { kind: "stop", stop: reservedStop(gate.askId) };
   if (opts.policy === "off") return { kind: "stop", stop: unansweredStop(gate.askId, "--no-hitl") };
-  if (!opts.isTTY) return { kind: "stop", stop: unansweredStop(gate.askId, "no TTY") };
+  if (!opts.isTTY && opts.policy !== "driver") {
+    return { kind: "stop", stop: unansweredStop(gate.askId, "no TTY") };
+  }
   opts.onPromptStart?.();
   let raw;
   try {
@@ -265,14 +282,15 @@ async function askOperator(gate, opts) {
   }
   if (raw.kind === "eof") return { kind: "stop", stop: operatorStop(gate.askId, "EOF") };
   if (raw.kind === "sigint") return { kind: "stop", stop: operatorStop(gate.askId, "SIGINT") };
+  if (raw.kind === "stop") return { kind: "stop", stop: driverStop(gate.askId, raw) };
   const answer = resolveOperatorAnswer(raw.text, gate.labels);
   if (answer.kind === "stop") return { kind: "stop", stop: operatorStop(gate.askId, answer.cause) };
-  const line = formatHitlReply(gate.askId, answer);
+  const line3 = formatHitlReply(gate.askId, answer);
   const stamp = {
     askId: gate.askId,
     reply: answer.kind === "reply" ? `operator reply ${answer.n}` : "operator reply other",
     label: answer.kind === "reply" ? answer.label : answer.text,
-    line,
+    line: line3,
     at: (/* @__PURE__ */ new Date()).toISOString(),
     detection: gate.detection
   };
@@ -308,15 +326,15 @@ var TurnWatcher = class {
   feed(chunk) {
     const text = typeof chunk === "string" ? chunk : this.decoder.write(chunk);
     if (!text) return;
-    this.lines.feed(text, (line) => this.take(line));
+    this.lines.feed(text, (line3) => this.take(line3));
   }
   end() {
-    this.lines.feed(this.decoder.end(), (line) => this.take(line));
+    this.lines.feed(this.decoder.end(), (line3) => this.take(line3));
     const rest = this.lines.end();
     if (rest.trim()) this.take(rest);
   }
-  take(line) {
-    const trimmed = line.trim();
+  take(line3) {
+    const trimmed = line3.trim();
     if (!trimmed.startsWith("{")) return;
     let event;
     try {
@@ -354,10 +372,335 @@ var TurnWatcher = class {
 };
 
 // src/plan-loop/backends.ts
-import { execFileSync, spawn } from "child_process";
-import { createWriteStream } from "fs";
+import { execFileSync as execFileSync2, spawn } from "child_process";
+import { createWriteStream as createWriteStream2 } from "fs";
+import { access as access2 } from "fs/promises";
+import path2 from "path";
+import { StringDecoder as StringDecoder4 } from "string_decoder";
+
+// src/plan-loop/codex.ts
+import { execFileSync } from "child_process";
 import { access } from "fs/promises";
 import path from "path";
+
+// src/plan-loop/vendor-cli-pins.ts
+var VENDOR_CLI_PINS = {
+  claude: {
+    bin: "claude",
+    min: "2.1.259",
+    tested: "2.1.292",
+    testedOn: "2026-10-08 `claude --version` (Linux)",
+    versionRe: /(\d+\.\d+\.\d+)/
+  },
+  "cursor-agent": {
+    bin: "cursor-agent",
+    min: null,
+    tested: "2026.10.01",
+    testedOn: "2026-10-08 `cursor-agent --version` = 2026.10.01-e373342 (Linux)",
+    versionRe: /(\d{4}\.\d{2}\.\d{2})(?:-[0-9a-f]+)?/
+  },
+  codex: {
+    bin: "codex",
+    min: null,
+    tested: "0.160.1",
+    testedOn: "2026-10-08 `codex --version` = codex-cli 0.160.1 (Linux)",
+    versionRe: /(\d+\.\d+\.\d+)/
+  }
+};
+function parseVendorVersion(id, raw) {
+  if (!raw) return null;
+  return VENDOR_CLI_PINS[id].versionRe.exec(raw)?.[1] ?? null;
+}
+function compareVendorVersions(a, b) {
+  const pa = a.split(/\D+/).filter(Boolean).map(Number);
+  const pb = b.split(/\D+/).filter(Boolean).map(Number);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i += 1) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d;
+  }
+  return 0;
+}
+function vendorVersionStatus(id, raw) {
+  const pin = VENDOR_CLI_PINS[id];
+  const version = parseVendorVersion(id, raw);
+  if (!version) return { status: "unknown", version: null };
+  if (pin.min && compareVendorVersions(version, pin.min) < 0) {
+    return {
+      status: "too-old",
+      version,
+      message: `${pin.bin} ${version} is older than ${pin.min}, the oldest version the headless runner supports.`
+    };
+  }
+  if (compareVendorVersions(version, pin.tested) > 0) {
+    return {
+      status: "newer-than-tested",
+      version,
+      message: `${pin.bin} ${version} is newer than ${pin.tested}, the last version the kit's headless contract was checked against; continuing (a changed output format is named here first).`
+    };
+  }
+  return { status: "supported", version };
+}
+
+// src/plan-loop/codex.ts
+var CODEX_CHATGPT_LOGIN_ENV = "AGENT_KIT_CODEX_CHATGPT_LOGIN";
+var CODEX_MAX_RESUMES = 50;
+function codexExecArgs(opts) {
+  const args = [
+    "exec",
+    "--json",
+    "--color",
+    "never",
+    "--cd",
+    opts.workspace,
+    "--dangerously-bypass-approvals-and-sandbox"
+  ];
+  if (opts.model) args.push("--model", opts.model);
+  args.push("-");
+  return args;
+}
+function codexResumeArgs(opts) {
+  const args = ["exec", "resume", "--json", "--dangerously-bypass-approvals-and-sandbox"];
+  if (opts.model) args.push("--model", opts.model);
+  args.push(opts.threadId, "-");
+  return args;
+}
+function resolveCodexAuth(env) {
+  if (env[CODEX_CHATGPT_LOGIN_ENV] === "1") return { mode: "chatgpt-login", env };
+  const key = env.CODEX_API_KEY || env.OPENAI_API_KEY;
+  if (!key) {
+    return {
+      mode: "refused",
+      message: `codex backend: API-key mode needs OPENAI_API_KEY (or CODEX_API_KEY) in the environment. Using a ChatGPT sign-in is off by default until OpenAI clears it for third-party apps; set ${CODEX_CHATGPT_LOGIN_ENV}=1 to run on your own codex login.`
+    };
+  }
+  return { mode: "api-key", env: { ...env, CODEX_API_KEY: key } };
+}
+function codexSlashPointer(name) {
+  return [
+    `Read \`.cursor/commands/${name}.md\` now and follow that contract exactly \u2014 it is the source of truth for /${name}; this paragraph is only a thin adapter for the Codex CLI.`,
+    "",
+    "Adapter rules (Codex CLI, headless):",
+    "- Ask questions is unavailable here: print one line `HITL_GATE: <ask-id> | <label 1> | <label 2> | ...` immediately followed by the same labels as one numbered list, one list per message, then end your turn and WAIT for the answer (ask-id and labels: `.cursor/skills/core/hitl-gates/SKILL.md`). The answer arrives as your next prompt, `HITL_REPLY: <ask-id> | operator reply <n> | <label>`; cite that line as the Ask provenance.",
+    "- Skip or cancel means stop.",
+    "- Never `/git-prod` without an explicit operator yes.",
+    "- Do not clone Cursor hooks or invent behavior beyond the SoT file."
+  ].join("\n");
+}
+async function codexPrompt(workspace, prompt) {
+  const m = /^\/([A-Za-z0-9][A-Za-z0-9_-]*)/.exec(prompt.trimStart());
+  if (!m?.[1]) return { ok: true, prompt };
+  const rel = path.join(".cursor", "commands", `${m[1]}.md`);
+  try {
+    await access(path.join(workspace, rel));
+  } catch {
+    return { ok: false, missing: rel };
+  }
+  return { ok: true, prompt: `${codexSlashPointer(m[1])}
+
+${prompt}` };
+}
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var line = (event) => JSON.stringify(event);
+function createCodexTranslator(onThread) {
+  let lastMessage = "";
+  let threadId = "";
+  return (raw) => {
+    const text = raw.trim();
+    if (!text.startsWith("{")) return [];
+    let event;
+    try {
+      event = JSON.parse(text);
+    } catch {
+      return [];
+    }
+    if (!isRecord(event)) return [];
+    const item = isRecord(event.item) ? event.item : null;
+    const itemType = item ? item.type ?? item.item_type : void 0;
+    const isMessage = itemType === "agent_message" || itemType === "assistant_message";
+    switch (event.type) {
+      case "thread.started":
+        if (typeof event.thread_id === "string") {
+          threadId = event.thread_id;
+          onThread(threadId);
+        }
+        return [line({ type: "system", subtype: "init", session_id: threadId, model: "codex" })];
+      case "item.started":
+        if (itemType === "command_execution" && typeof item?.command === "string") {
+          return [
+            line({
+              type: "assistant",
+              message: {
+                content: [{ type: "tool_use", name: "shell", input: { command: item.command } }]
+              }
+            })
+          ];
+        }
+        return [];
+      case "item.completed":
+        if (isMessage && typeof item?.text === "string") {
+          lastMessage = item.text;
+          return [
+            line({ type: "assistant", message: { content: [{ type: "text", text: item.text }] } })
+          ];
+        }
+        if (item && itemType === "command_execution") {
+          const exit = typeof item.exit_code === "number" ? item.exit_code : null;
+          return [
+            line({
+              type: "user",
+              message: {
+                content: [
+                  {
+                    type: "tool_result",
+                    content: typeof item.aggregated_output === "string" ? item.aggregated_output : "",
+                    is_error: exit !== null && exit !== 0
+                  }
+                ]
+              }
+            })
+          ];
+        }
+        return [];
+      case "turn.completed": {
+        const result = lastMessage;
+        lastMessage = "";
+        return [
+          line({
+            type: "result",
+            subtype: "success",
+            is_error: false,
+            result,
+            session_id: threadId,
+            ...isRecord(event.usage) ? { usage: event.usage } : {}
+          })
+        ];
+      }
+      case "turn.failed": {
+        const message = isRecord(event.error) && typeof event.error.message === "string" ? event.error.message : "codex turn failed";
+        lastMessage = "";
+        return [
+          line({
+            type: "result",
+            subtype: "error_during_execution",
+            is_error: true,
+            result: message,
+            errors: [message],
+            session_id: threadId
+          })
+        ];
+      }
+      default:
+        return [];
+    }
+  };
+}
+var codexVersionCache = /* @__PURE__ */ new Map();
+function readCodexVersion(bin) {
+  if (!codexVersionCache.has(bin)) {
+    let out = null;
+    try {
+      out = execFileSync(bin, ["--version"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 1e4
+      });
+    } catch {
+      out = null;
+    }
+    codexVersionCache.set(bin, out);
+  }
+  return codexVersionCache.get(bin) ?? null;
+}
+function mergeRecords(records) {
+  const merged = emptyHitlRecord();
+  for (const r of records) {
+    merged.replies.push(...r.replies);
+    merged.fallbackDetections += r.fallbackDetections;
+    if (r.stop) merged.stop = r.stop;
+  }
+  return merged;
+}
+var codexBackend = {
+  id: "codex",
+  async resolve() {
+    return whichBinary("codex");
+  },
+  async run(opts) {
+    const log = opts.log ?? ((text) => console.log(text));
+    const auth = resolveCodexAuth(mergeChildEnv(opts.env));
+    if (auth.mode === "refused") throw new Error(auth.message);
+    const env = auth.env;
+    const redact = claudeRedactions(env);
+    const pin = vendorVersionStatus("codex", (opts.versionFn ?? readCodexVersion)("codex"));
+    if (pin.status === "newer-than-tested" || pin.status === "too-old") log(pin.message);
+    const prepared = await codexPrompt(opts.workspace, opts.prompt);
+    if (!prepared.ok) {
+      throw new Error(
+        `codex backend: ${prepared.missing} is missing in the workspace, so the tick's leading slash has no contract to point codex at. Install the kit (\`agent-kit install\`) and retry.`
+      );
+    }
+    log(
+      `codex tick: codex exec --json (no approvals, resume relay, ${auth.mode === "api-key" ? "API key" : "ChatGPT sign-in, opt-in"}).`
+    );
+    let threadId = null;
+    const translate = createCodexTranslator((id) => {
+      threadId = id;
+    });
+    const hitl = resolveHitlRunOptions(opts.hitl, { kind: "resume", backend: "codex" });
+    const common = {
+      cwd: opts.workspace,
+      env,
+      redact,
+      spawnFn: opts.spawnFn,
+      hitl,
+      render: opts.render,
+      onSpawn: opts.onSpawn,
+      backendId: "codex",
+      translate
+    };
+    const records = [];
+    let result;
+    try {
+      result = await spawnLogged(
+        "codex",
+        codexExecArgs({ workspace: opts.workspace, model: opts.model }),
+        opts.logPath,
+        { ...common, stdinText: prepared.prompt }
+      );
+      if (result.hitl) records.push(result.hitl);
+      for (let i = 0; result.resumeWith && i < CODEX_MAX_RESUMES; i += 1) {
+        const reply = result.resumeWith;
+        const thread = threadId;
+        if (!thread) {
+          const record = emptyHitlRecord();
+          record.stop = {
+            ...unansweredStop("none", "child exited"),
+            message: "stopped: codex reported no thread id, so the reply could not be delivered"
+          };
+          records.push(record);
+          break;
+        }
+        result = await spawnLogged(
+          "codex",
+          codexResumeArgs({ threadId: thread, model: opts.model }),
+          opts.logPath,
+          { ...common, stdinText: reply, appendLog: true }
+        );
+        if (result.hitl) records.push(result.hitl);
+      }
+    } catch (err) {
+      throw new Error(`codex backend failed to start: ${redactSecrets(String(err), redact)}`);
+    }
+    return {
+      exitCode: result.exitCode,
+      hitl: mergeRecords(records),
+      ...result.lastResult ? { lastResult: result.lastResult } : {}
+    };
+  }
+};
+
+// src/plan-loop/cursor-acp.ts
+import { createWriteStream } from "fs";
 import { StringDecoder as StringDecoder3 } from "string_decoder";
 
 // src/plan-loop/stream-render.ts
@@ -365,7 +708,7 @@ import { StringDecoder as StringDecoder2 } from "string_decoder";
 import { trueColor } from "kolorist";
 
 // src/plan-loop/stream-events.ts
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function asString(value) {
@@ -390,7 +733,7 @@ var SUMMARY_KEYS = [
 ];
 function summarizeToolInput(input) {
   if (typeof input === "string") return oneLine(input);
-  if (!isRecord(input)) return input === void 0 ? "" : oneLine(JSON.stringify(input));
+  if (!isRecord2(input)) return input === void 0 ? "" : oneLine(JSON.stringify(input));
   for (const key of SUMMARY_KEYS) {
     const value = input[key];
     if (typeof value === "string" && value.trim()) return oneLine(value);
@@ -403,31 +746,31 @@ function firstLineOfContent(content) {
   if (typeof content === "string") return firstNonEmptyLine(content);
   if (Array.isArray(content)) {
     for (const part of content) {
-      if (isRecord(part) && typeof part.text === "string") {
-        const line = firstNonEmptyLine(part.text);
-        if (line) return line;
+      if (isRecord2(part) && typeof part.text === "string") {
+        const line3 = firstNonEmptyLine(part.text);
+        if (line3) return line3;
       }
     }
     return "";
   }
-  if (isRecord(content)) return oneLine(JSON.stringify(content));
+  if (isRecord2(content)) return oneLine(JSON.stringify(content));
   return "";
 }
 function firstNonEmptyLine(text) {
-  for (const line of text.split(/\r?\n/)) {
-    const trimmed = line.trim();
+  for (const line3 of text.split(/\r?\n/)) {
+    const trimmed = line3.trim();
     if (trimmed) return trimmed;
   }
   return "";
 }
 function parseAssistant(event) {
   const message = event.message;
-  const content = isRecord(message) ? message.content : void 0;
+  const content = isRecord2(message) ? message.content : void 0;
   if (typeof content === "string") return content ? [{ kind: "text", text: content }] : [];
   if (!Array.isArray(content)) return [{ kind: "silent" }];
   const out = [];
   for (const part of content) {
-    if (!isRecord(part)) continue;
+    if (!isRecord2(part)) continue;
     const type = asString(part.type);
     if (type === "text" && typeof part.text === "string") {
       if (part.text) out.push({ kind: "text", text: part.text });
@@ -444,7 +787,7 @@ function parseAssistant(event) {
 var HITL_REPLY_PREFIX2 = "HITL_REPLY:";
 function parseUser(event) {
   const message = event.message;
-  const content = isRecord(message) ? message.content : void 0;
+  const content = isRecord2(message) ? message.content : void 0;
   if (typeof content === "string") {
     if (event.isReplay === true && content.startsWith(HITL_REPLY_PREFIX2)) {
       return [{ kind: "hitl_reply", line: oneLine(content) }];
@@ -455,7 +798,7 @@ function parseUser(event) {
   const out = [];
   let promptChars = 0;
   for (const part of content) {
-    if (!isRecord(part)) continue;
+    if (!isRecord2(part)) continue;
     const type = asString(part.type);
     if (type === "tool_result") {
       out.push({
@@ -504,16 +847,16 @@ function percent(value) {
   return n === void 0 ? null : `${Math.round(n * 100)}%`;
 }
 function parseRateLimit(event) {
-  const info = isRecord(event.rate_limit_info) ? event.rate_limit_info : event;
+  const info = isRecord2(event.rate_limit_info) ? event.rate_limit_info : event;
   const status = asString(info.status) ?? "unknown";
   const type = asString(info.rateLimitType);
   const parts = [];
   if (type) parts.push(type);
   parts.push(status);
-  const windows = isRecord(info.unifiedWindows) ? info.unifiedWindows : null;
+  const windows = isRecord2(info.unifiedWindows) ? info.unifiedWindows : null;
   if (windows) {
     for (const [name, window] of Object.entries(windows)) {
-      if (!isRecord(window)) continue;
+      if (!isRecord2(window)) continue;
       const used = percent(window.utilization);
       if (used) parts.push(`${name} ${used}`);
     }
@@ -521,30 +864,30 @@ function parseRateLimit(event) {
   return { kind: "rate_limit", line: parts.join(" \xB7 "), severe: status !== "allowed" };
 }
 function parseCursorToolCall(event) {
-  const call = isRecord(event.tool_call) ? event.tool_call : null;
-  const entry = call ? Object.entries(call).find(([, v]) => isRecord(v)) : void 0;
+  const call = isRecord2(event.tool_call) ? event.tool_call : null;
+  const entry = call ? Object.entries(call).find(([, v]) => isRecord2(v)) : void 0;
   const name = entry ? entry[0].replace(/ToolCall$/, "") : "tool";
-  const body = entry && isRecord(entry[1]) ? entry[1] : {};
+  const body = entry && isRecord2(entry[1]) ? entry[1] : {};
   const subtype = asString(event.subtype) ?? "";
   if (subtype === "started") {
     return { kind: "tool_use", name, summary: summarizeToolInput(body.args) };
   }
   if (subtype === "completed") {
-    const result = isRecord(body.result) ? body.result : null;
+    const result = isRecord2(body.result) ? body.result : null;
     const failed = result !== null && ("error" in result || "failure" in result || "rejected" in result);
-    let line = "";
+    let line3 = "";
     if (result) {
       const payload = failed ? result.error ?? result.failure ?? result.rejected : result.success;
-      line = firstLineOfContent(
+      line3 = firstLineOfContent(
         typeof payload === "string" ? payload : payload === void 0 ? result : payload
       );
     }
-    return { kind: "tool_result", ok: !failed, line };
+    return { kind: "tool_result", ok: !failed, line: line3 };
   }
   return { kind: "silent" };
 }
-function parseStreamLine(line) {
-  const trimmed = line.trim();
+function parseStreamLine(line3) {
+  const trimmed = line3.trim();
   if (!trimmed || !trimmed.startsWith("{")) return [{ kind: "unparsed" }];
   let event;
   try {
@@ -552,7 +895,7 @@ function parseStreamLine(line) {
   } catch {
     return [{ kind: "unparsed" }];
   }
-  if (!isRecord(event)) return [{ kind: "unparsed" }];
+  if (!isRecord2(event)) return [{ kind: "unparsed" }];
   switch (asString(event.type)) {
     case "assistant":
       return parseAssistant(event);
@@ -613,8 +956,8 @@ function renderStreamEvent(event, opts) {
     case "tool_result": {
       const label = event.ok ? "ok" : "error";
       const head = `  ${SPACE_MARKS.tick} ${label}`;
-      const line = truncate(oneLine(event.line), width - head.length - 3);
-      const text = line ? `${head} ${SPACE_MARKS.tick} ${line}` : head;
+      const line3 = truncate(oneLine(event.line), width - head.length - 3);
+      const text = line3 ? `${head} ${SPACE_MARKS.tick} ${line3}` : head;
       return paint(event.ok ? LABEL_MUTED : STATUS_ERR, text, color);
     }
     case "result": {
@@ -676,12 +1019,12 @@ var StreamRenderer = class {
       const combined = this.pending + text;
       const lines = combined.split("\n");
       this.pending = lines.pop() ?? "";
-      for (const line of lines) {
+      for (const line3 of lines) {
         if (this.dropped) {
           this.dropped = false;
           continue;
         }
-        this.renderLine(line);
+        this.renderLine(line3);
       }
       if (this.pending.length > PENDING_MAX_CHARS2) {
         this.pending = "";
@@ -700,8 +1043,8 @@ var StreamRenderer = class {
     } catch {
     }
   }
-  renderLine(line) {
-    for (const event of parseStreamLine(line)) {
+  renderLine(line3) {
+    for (const event of parseStreamLine(line3)) {
       const rendered = renderStreamEvent(event, { color: this.color, columns: this.columns });
       if (rendered === null) continue;
       if (event.kind === "text") {
@@ -724,7 +1067,402 @@ function createStreamRenderer(opts = {}) {
   return new StreamRenderer(opts);
 }
 
+// src/plan-loop/cursor-acp.ts
+var ACP_PROTOCOL_VERSION = 1;
+var CURSOR_ASK_QUESTION_ID = "cursor-ask-question";
+var ACP_EXIT_GRACE_MS = 1e3;
+var ACP_KILL_GRACE_MS = 5e3;
+var ACP_MAX_TURNS = 50;
+function cursorAcpArgs() {
+  return ["acp"];
+}
+var isRecord3 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function acpInitializeParams() {
+  return {
+    protocolVersion: ACP_PROTOCOL_VERSION,
+    clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
+    clientInfo: { name: "agent-kit", version: "1" }
+  };
+}
+function acpPermissionOutcome(params) {
+  const options = isRecord3(params) && Array.isArray(params.options) ? params.options : [];
+  const pick = options.find((o) => isRecord3(o) && (o.optionId === "allow-once" || o.kind === "allow_once")) ?? options.find(
+    (o) => isRecord3(o) && (typeof o.optionId === "string" && o.optionId.startsWith("allow") || typeof o.kind === "string" && o.kind.startsWith("allow"))
+  );
+  if (isRecord3(pick) && typeof pick.optionId === "string") {
+    return { outcome: { outcome: "selected", optionId: pick.optionId } };
+  }
+  return { outcome: { outcome: "cancelled" } };
+}
+function acpQuestions(params) {
+  const raw = isRecord3(params) && Array.isArray(params.questions) ? params.questions : [];
+  const out = [];
+  for (const q of raw) {
+    if (!isRecord3(q) || typeof q.id !== "string" || !Array.isArray(q.options)) continue;
+    const options = q.options.filter((o) => isRecord3(o) && typeof o.id === "string").map((o) => ({
+      id: o.id,
+      label: String(typeof o.label === "string" ? o.label : o.id).replace(/\|/g, "/").trim()
+    }));
+    if (options.length === 0) continue;
+    out.push({ id: q.id, prompt: typeof q.prompt === "string" ? q.prompt : "", options });
+  }
+  return out;
+}
+var line2 = (event) => `${JSON.stringify(event)}
+`;
+async function runCursorAcp(opts) {
+  const say = opts.log ?? ((text) => console.log(text));
+  const env = mergeChildEnv(opts.env);
+  const redact = claudeRedactions(env);
+  const hitl = resolveHitlRunOptions(opts.hitl, { kind: "none", backend: "cursor-acp" });
+  const render = opts.render ?? createStreamRenderer();
+  const spawnFn = opts.spawnFn ?? (await import("child_process")).spawn;
+  const record = emptyHitlRecord();
+  const abort = new AbortController();
+  if (opts.model) say("cursor-acp: --model is not sent over ACP; the agent's default model runs.");
+  say("cursor tick: cursor-agent acp (JSON-RPC stdio, HITL relay, tool permissions allow-once).");
+  const out = createWriteStream(opts.logPath, { flags: "w" });
+  let logError = null;
+  out.on("error", (err) => {
+    logError = err;
+  });
+  const logLine = (text) => out.write(`${redactSecrets(text, redact)}
+`);
+  const child = spawnFn("cursor-agent", cursorAcpArgs(), {
+    cwd: opts.workspace,
+    env,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const pending = /* @__PURE__ */ new Map();
+  let closed = false;
+  let exitCode = null;
+  let spawnError = null;
+  let resolveClosed = () => {
+  };
+  const closedPromise = new Promise((resolve) => {
+    resolveClosed = resolve;
+  });
+  const gone = (code2) => {
+    if (closed) return;
+    closed = true;
+    exitCode = code2;
+    abort.abort();
+    for (const p of pending.values()) {
+      p.reject({ message: `cursor-agent acp exited (code ${code2 ?? "signal"})` });
+    }
+    pending.clear();
+    resolveClosed();
+  };
+  child.on("close", (code2) => gone(code2));
+  child.on("error", (err) => {
+    spawnError = new Error(redactSecrets(String(err), redact));
+    gone(null);
+  });
+  let nextId = 1;
+  let turnText = "";
+  let sessionId = null;
+  const send = (msg) => {
+    const text = JSON.stringify(msg);
+    logLine(text);
+    try {
+      child.stdin?.write(`${text}
+`);
+    } catch {
+    }
+  };
+  const request = (method, params) => new Promise((resolve, reject) => {
+    if (closed) {
+      reject({ message: "cursor-agent acp is not running" });
+      return;
+    }
+    const id = nextId++;
+    pending.set(id, { resolve, reject });
+    send({ jsonrpc: "2.0", id, method, params });
+  });
+  const respond = (id, result) => send({ jsonrpc: "2.0", id, result });
+  const respondError = (id, code2, message) => send({ jsonrpc: "2.0", id, error: { code: code2, message } });
+  const ask = (gate) => askOperator(gate, {
+    isTTY: hitl.isTTY,
+    policy: hitl.policy,
+    readAnswer: hitl.readAnswer,
+    write: hitl.write,
+    signal: abort.signal,
+    onPromptStart: hitl.onPromptStart,
+    onPromptEnd: hitl.onPromptEnd
+  });
+  const cancelSession = () => {
+    if (sessionId && !closed)
+      send({ jsonrpc: "2.0", method: "session/cancel", params: { sessionId } });
+  };
+  const handleAskQuestion = async (id, params) => {
+    const answers = [];
+    for (const q of acpQuestions(params)) {
+      if (record.stop) break;
+      const gate = {
+        askId: CURSOR_ASK_QUESTION_ID,
+        labels: q.options.map((o) => o.label),
+        detection: "sentinel"
+      };
+      const outcome = await ask(gate);
+      if (outcome.kind === "stop") {
+        record.stop = outcome.stop;
+        break;
+      }
+      record.replies.push(outcome.stamp);
+      hitl.write(`\u2192 ${outcome.stamp.line}
+`);
+      const n = /operator reply (\d+)/.exec(outcome.stamp.reply)?.[1];
+      const option = n ? q.options[Number(n) - 1] : void 0;
+      if (!option) {
+        hitl.write(
+          "cursor-acp: a free-text answer has no cursor/ask_question option; the question is answered as cancelled.\n"
+        );
+        respond(id, { outcome: { outcome: "cancelled" } });
+        return;
+      }
+      answers.push({ questionId: q.id, selectedOptionIds: [option.id] });
+    }
+    if (record.stop) {
+      respond(id, { outcome: { outcome: "cancelled" } });
+      cancelSession();
+      return;
+    }
+    respond(id, { outcome: { outcome: "answered", answers } });
+  };
+  const handleRequest = (msg) => {
+    const { id, method, params } = msg;
+    if (method === "session/request_permission") {
+      respond(id, acpPermissionOutcome(params));
+      return;
+    }
+    if (method === "cursor/ask_question") {
+      void handleAskQuestion(id, params);
+      return;
+    }
+    respondError(id, -32601, `agent-kit does not implement ${String(method)}`);
+  };
+  const handleNotification = (msg) => {
+    if (msg.method !== "session/update" || !isRecord3(msg.params)) return;
+    const update = isRecord3(msg.params.update) ? msg.params.update : null;
+    if (!update) return;
+    if (update.sessionUpdate === "agent_message_chunk") {
+      const content = isRecord3(update.content) ? update.content : null;
+      if (content?.type === "text" && typeof content.text === "string") turnText += content.text;
+      return;
+    }
+    if (update.sessionUpdate === "tool_call") {
+      const title = typeof update.title === "string" ? update.title : "tool";
+      render.feed(
+        line2({
+          type: "assistant",
+          message: {
+            content: [
+              {
+                type: "tool_use",
+                name: typeof update.kind === "string" ? update.kind : "tool",
+                input: { title }
+              }
+            ]
+          }
+        })
+      );
+    }
+  };
+  const take = (raw) => {
+    const text = redactSecrets(raw.replace(/\r$/, ""), redact);
+    if (!text.trim()) return;
+    out.write(`${text}
+`);
+    let msg;
+    try {
+      msg = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (!isRecord3(msg)) return;
+    if (typeof msg.method === "string") {
+      if (msg.id !== void 0 && msg.id !== null) handleRequest(msg);
+      else handleNotification(msg);
+      return;
+    }
+    if (typeof msg.id === "number") {
+      const p = pending.get(msg.id);
+      if (!p) return;
+      pending.delete(msg.id);
+      if (isRecord3(msg.error)) {
+        p.reject({
+          message: typeof msg.error.message === "string" ? msg.error.message : "JSON-RPC error",
+          ...typeof msg.error.code === "number" ? { code: msg.error.code } : {}
+        });
+      } else p.resolve(msg.result);
+    }
+  };
+  const decoder = new StringDecoder3("utf8");
+  const splitter = new LineSplitter();
+  child.stdout?.on("data", (chunk) => {
+    splitter.feed(typeof chunk === "string" ? chunk : decoder.write(chunk), take);
+  });
+  const errBuffer = new RedactingStreamBuffer(redact);
+  child.stderr?.on("data", (chunk) => {
+    const text = redact.length ? errBuffer.push(chunk) : String(chunk);
+    if (text) out.write(text);
+  });
+  child.stdin?.on("error", () => {
+  });
+  let stopped = false;
+  const endChild = () => {
+    if (stopped) return;
+    stopped = true;
+    try {
+      child.stdin?.end();
+    } catch {
+    }
+    const term = setTimeout(() => {
+      if (closed) return;
+      child.kill("SIGTERM");
+      const kill = setTimeout(() => {
+        if (!closed) child.kill("SIGKILL");
+      }, ACP_KILL_GRACE_MS);
+      kill.unref?.();
+    }, ACP_EXIT_GRACE_MS);
+    term.unref?.();
+  };
+  opts.onSpawn?.({
+    backend: "cursor-acp",
+    pid: child.pid,
+    stop: (stop) => {
+      if (closed || record.stop) return;
+      record.stop = stop;
+      cancelSession();
+      abort.abort();
+      endChild();
+    }
+  });
+  let lastResult;
+  const finishTurn = (text, isError, subtype, errors) => {
+    render.feed(line2({ type: "assistant", message: { content: [{ type: "text", text }] } }));
+    render.feed(
+      line2({
+        type: "result",
+        subtype,
+        is_error: isError,
+        result: text,
+        session_id: sessionId ?? "",
+        ...errors.length ? { errors } : {}
+      })
+    );
+    lastResult = { resultText: text, assistantTexts: text ? [text] : [], isError, subtype, errors };
+  };
+  const failed = (message, subtype = "error") => finishTurn(message, true, subtype, [message]);
+  const session = async () => {
+    const init = await request("initialize", acpInitializeParams());
+    const methods = isRecord3(init) && Array.isArray(init.authMethods) ? init.authMethods : [];
+    if (methods.some((m) => isRecord3(m) && m.id === "cursor_login")) {
+      try {
+        await request("authenticate", { methodId: "cursor_login" });
+      } catch (err) {
+        const message = err.message ?? String(err);
+        throw {
+          message: `Cursor sign-in needed: run \`cursor-agent login\` in a terminal (the kit never handles Cursor credentials). ${message}`
+        };
+      }
+    }
+    const created = await request("session/new", { cwd: opts.workspace, mcpServers: [] });
+    if (!isRecord3(created) || typeof created.sessionId !== "string") {
+      throw { message: "cursor-agent acp returned no sessionId" };
+    }
+    sessionId = created.sessionId;
+    render.feed(
+      line2({ type: "system", subtype: "init", session_id: sessionId, model: "cursor-acp" })
+    );
+    let prompt = opts.prompt;
+    for (let turn = 0; turn < ACP_MAX_TURNS && !record.stop; turn += 1) {
+      turnText = "";
+      let stopReason = "end_turn";
+      try {
+        const res = await request("session/prompt", {
+          sessionId,
+          prompt: [{ type: "text", text: prompt }]
+        });
+        if (isRecord3(res) && typeof res.stopReason === "string") stopReason = res.stopReason;
+      } catch (err) {
+        failed(err.message ?? String(err));
+        return;
+      }
+      const text = turnText;
+      finishTurn(text, stopReason === "refusal", stopReason, []);
+      if (record.stop || stopReason === "cancelled") return;
+      const gate = detectHitlGate(text, []);
+      if (!gate) return;
+      if (gate.detection === "fallback") record.fallbackDetections += 1;
+      const outcome = await ask(gate);
+      if (outcome.kind === "stop") {
+        record.stop = outcome.stop;
+        return;
+      }
+      record.replies.push(outcome.stamp);
+      hitl.write(`\u2192 ${outcome.stamp.line}
+`);
+      prompt = outcome.stamp.line;
+    }
+  };
+  await session().catch((err) => {
+    failed(err.message ?? String(err));
+  });
+  const failure = spawnError;
+  if (failure) {
+    out.end();
+    throw new Error(`cursor-acp backend failed to start: ${failure.message}`);
+  }
+  const endedByClient = !closed;
+  endChild();
+  await closedPromise;
+  const rest = splitter.end();
+  if (rest.trim()) take(rest);
+  const errRest = errBuffer.flush();
+  if (errRest) out.write(errRest);
+  render.end();
+  await new Promise((resolve) => out.end(() => resolve()));
+  if (logError) throw new Error(`cursor-acp backend: ${redactSecrets(String(logError), redact)}`);
+  const code = lastResult?.isError ? 1 : endedByClient ? 0 : exitCode ?? 1;
+  return { exitCode: code, hitl: record, ...lastResult ? { lastResult } : {} };
+}
+var cursorAcpBackend = {
+  id: "cursor-acp",
+  async resolve() {
+    return whichBinary("cursor-agent");
+  },
+  run: runCursorAcp
+};
+
 // src/plan-loop/backends.ts
+function createLineTranslator(translate) {
+  const decoder = new StringDecoder4("utf8");
+  const lines = new LineSplitter();
+  const run = (line3, out) => {
+    try {
+      out.push(...translate(line3));
+    } catch {
+    }
+  };
+  return {
+    push(chunk) {
+      const text = typeof chunk === "string" ? chunk : decoder.write(chunk);
+      const out = [];
+      lines.feed(text, (line3) => run(line3, out));
+      return out.length ? `${out.join("\n")}
+` : "";
+    },
+    end() {
+      const out = [];
+      lines.feed(decoder.end(), (line3) => run(line3, out));
+      const rest = lines.end();
+      if (rest.trim()) run(rest, out);
+      return out.length ? `${out.join("\n")}
+` : "";
+    }
+  };
+}
 var HITL_KILL_GRACE_MS = 5e3;
 function resolveHitlRunOptions(hitl, transport) {
   return {
@@ -754,7 +1492,7 @@ function redactSecrets(text, secrets) {
 var REDACT_HOLD_MAX_CHARS = 64 * 1024;
 var RedactingStreamBuffer = class {
   pending = "";
-  decoder = new StringDecoder3("utf8");
+  decoder = new StringDecoder4("utf8");
   secrets;
   keep;
   constructor(secrets) {
@@ -839,6 +1577,14 @@ function claudeRunCaps(env) {
   }
   return { caps, invalid };
 }
+var VENDOR_SECRET_ENV = [
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "CURSOR_API_KEY",
+  "CURSOR_AUTH_TOKEN",
+  "OPENAI_API_KEY",
+  "CODEX_API_KEY",
+  "CODEX_ACCESS_TOKEN"
+];
 var REDACT_DERIVED_MIN_CHARS = 4;
 var REDACT_DERIVED_SKIP = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "0.0.0.0", "::1", "[::1]"]);
 function derivedSecretForms(value) {
@@ -874,7 +1620,7 @@ function claudeRedactions(env) {
     seen.add(value);
     entries.push({ label, value });
   };
-  for (const key of CLAUDE_ENV_PASSTHROUGH) {
+  for (const key of [...CLAUDE_ENV_PASSTHROUGH, ...VENDOR_SECRET_ENV]) {
     const value = env[key];
     if (!value) continue;
     add(key, value, false);
@@ -884,12 +1630,7 @@ function claudeRedactions(env) {
   return entries;
 }
 async function whichBinary(bin) {
-  try {
-    const out = execFileSync("which", [bin], { encoding: "utf8" }).trim();
-    return out || null;
-  } catch {
-    return null;
-  }
+  return findOnPath(bin);
 }
 function spawnLogged(command, args, logPath, options = {}) {
   const spawnFn = options.spawnFn ?? spawn;
@@ -897,18 +1638,19 @@ function spawnLogged(command, args, logPath, options = {}) {
   const redactedError = (err) => new Error(redactSecrets(String(err), redact));
   const hitl = options.hitl;
   const stdinTransport = hitl?.transport.kind === "stdin-stream-json";
+  const stdinPiped = stdinTransport || options.stdinText !== void 0;
   return new Promise((resolve, reject) => {
     let out;
     let child;
     let logError = null;
     try {
-      out = createWriteStream(logPath, { flags: "w" });
+      out = createWriteStream2(logPath, { flags: options.appendLog ? "a" : "w" });
       out.on("error", (err) => {
         logError = err;
         reject(redactedError(err));
       });
       child = spawnFn(command, args, {
-        stdio: [stdinTransport ? "pipe" : "ignore", "pipe", "pipe"],
+        stdio: [stdinPiped ? "pipe" : "ignore", "pipe", "pipe"],
         ...options.cwd ? { cwd: options.cwd } : {},
         ...options.env ? { env: options.env } : {}
       });
@@ -918,12 +1660,25 @@ function spawnLogged(command, args, logPath, options = {}) {
     }
     const render = options.render ?? createStreamRenderer();
     const relay = hitl ? createRelay(hitl, child, redactedError) : null;
-    const emit = (text) => {
+    const translator = options.translate ? createLineTranslator(options.translate) : null;
+    const sinks = (text) => {
       if (text.length === 0) return;
-      out.write(text);
       render.feed(text);
       relay?.feed(text);
     };
+    const emit = (text) => {
+      if (text.length === 0) return;
+      out.write(text);
+      sinks(translator ? translator.push(text) : text);
+    };
+    if (options.stdinText !== void 0 && !stdinTransport) {
+      const stdin = child.stdin;
+      if (stdin) {
+        stdin.on("error", () => {
+        });
+        stdin.end(options.stdinText);
+      }
+    }
     if (relay?.startError) {
       out.end();
       reject(relay.startError);
@@ -962,6 +1717,7 @@ function spawnLogged(command, args, logPath, options = {}) {
     });
     child.on("close", (code) => {
       for (const buffer of buffers) emit(buffer.flush());
+      if (translator) sinks(translator.end());
       render.end();
       relay?.finish();
       const finish = () => {
@@ -970,10 +1726,12 @@ function spawnLogged(command, args, logPath, options = {}) {
           if (failure) reject(redactedError(failure));
           else if (relay) {
             const lastResult = relay.lastResult();
+            const resumeWith = relay.resumeWith();
             resolve({
               exitCode: code ?? 1,
               hitl: relay.record,
-              ...lastResult ? { lastResult } : {}
+              ...lastResult ? { lastResult } : {},
+              ...resumeWith ? { resumeWith } : {}
             });
           } else resolve({ exitCode: code ?? 1 });
         });
@@ -986,6 +1744,8 @@ function spawnLogged(command, args, logPath, options = {}) {
 function createRelay(hitl, child, redactedError) {
   const record = emptyHitlRecord();
   const stdinTransport = hitl.transport.kind === "stdin-stream-json";
+  const resumeTransport = hitl.transport.kind === "resume";
+  let resumeWith;
   const abort = new AbortController();
   const grace = hitl.killAfterMs ?? HITL_KILL_GRACE_MS;
   let startError = null;
@@ -1065,6 +1825,13 @@ function createRelay(hitl, child, redactedError) {
           stopChild();
           return;
         }
+        if (resumeTransport) {
+          record.replies.push(outcome.stamp);
+          hitl.write(`\u2192 ${outcome.stamp.line}
+`);
+          resumeWith = outcome.stamp.line;
+          return;
+        }
         if (closed || !stdin) {
           record.stop = unansweredStop(gate.askId, "child exited");
           return;
@@ -1086,7 +1853,7 @@ function createRelay(hitl, child, redactedError) {
   child.on("close", () => {
     closed = true;
     for (const t of timers) clearTimeout(t);
-    abort.abort();
+    if (!resumeTransport) abort.abort();
     const settle = () => resolveClosed();
     if (pendingAsk) pendingAsk.then(settle, settle);
     else settle();
@@ -1095,6 +1862,7 @@ function createRelay(hitl, child, redactedError) {
     startError,
     record,
     lastResult: () => lastResult,
+    resumeWith: () => resumeWith,
     feed: (text) => watcher.feed(text),
     finish: () => watcher.end(),
     closed: () => closedPromise,
@@ -1143,7 +1911,7 @@ var cursorAgentBackend = {
     });
   }
 };
-var CLAUDE_MIN_VERSION = "2.1.259";
+var CLAUDE_MIN_VERSION = VENDOR_CLI_PINS.claude.min ?? "2.1.259";
 function parseClaudeVersion(raw) {
   if (!raw) return null;
   const m = /(\d+)\.(\d+)\.(\d+)/.exec(raw);
@@ -1161,7 +1929,7 @@ function compareVersions(a, b) {
 var claudeVersionCache = /* @__PURE__ */ new Map();
 function defaultVersionFn(bin) {
   try {
-    return execFileSync(bin, ["--version"], {
+    return execFileSync2(bin, ["--version"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -1188,6 +1956,8 @@ function checkClaudeVersion(bin, versionFn = defaultVersionFn) {
       message: `claude ${version} is older than ${CLAUDE_MIN_VERSION}, the first release that accepts \`--permission-prompts none\`. Run \`claude update\` and retry.`
     };
   }
+  const pin = vendorVersionStatus("claude", version);
+  if (pin.status === "newer-than-tested") return { ok: true, version, warning: pin.message };
   return { ok: true, version };
 }
 function claudeHeadlessArgs(opts = {}) {
@@ -1218,9 +1988,9 @@ function claudeHeadlessArgs(opts = {}) {
 async function missingClaudeAdapter(workspace, prompt) {
   const m = /^\/([A-Za-z0-9][A-Za-z0-9_-]*)/.exec(prompt.trimStart());
   if (!m?.[1]) return null;
-  const rel = path.join(".claude", "commands", `${m[1]}.md`);
+  const rel = path2.join(".claude", "commands", `${m[1]}.md`);
   try {
-    await access(path.join(workspace, rel));
+    await access2(path2.join(workspace, rel));
     return null;
   } catch {
     return rel;
@@ -1232,7 +2002,7 @@ var claudeBackend = {
     return whichBinary("claude");
   },
   async run(opts) {
-    const log = opts.log ?? ((line) => console.log(line));
+    const log = opts.log ?? ((line3) => console.log(line3));
     const env = claudeChildEnv(opts.env);
     const redact = claudeRedactions(env);
     const version = checkClaudeVersion("claude", opts.versionFn);
@@ -1279,14 +2049,19 @@ var claudeBackend = {
     }
   }
 };
-var BACKENDS = {
-  "cursor-agent": cursorAgentBackend,
-  claude: claudeBackend
-};
+function backends() {
+  return {
+    "cursor-agent": cursorAgentBackend,
+    claude: claudeBackend,
+    codex: codexBackend,
+    "cursor-acp": cursorAcpBackend
+  };
+}
 function getBackend(id) {
-  const backend = BACKENDS[id];
+  const all = backends();
+  const backend = all[id];
   if (!backend) {
-    throw new Error(`Unknown backend '${id}'. Supported: ${Object.keys(BACKENDS).join(", ")}`);
+    throw new Error(`Unknown backend '${id}'. Supported: ${Object.keys(all).join(", ")}`);
   }
   return backend;
 }
@@ -1295,11 +2070,14 @@ export {
   LineSplitter,
   RESERVED_GATE_IDS,
   HITL_UNANSWERED_EXIT_CODE,
+  formatHitlGateLine,
   operatorQuitStop,
   formatHitlSummary,
   hitlExitCode,
+  codexBackend,
   parseStreamLine,
   renderStreamEvent,
+  cursorAcpBackend,
   resolveHitlRunOptions,
   redactSecrets,
   RedactingStreamBuffer,