@surething/cockpit 1.0.256 → 1.0.257

package/dist/scheduledTasks.mjs

@@ -5,18 +5,19 @@ import {
   getSessionTitle,
   isRunActive,
   markRunIdle,
+  mergeStashedCodexRollout,
   mergeStashedTranscript,
   rekeyRun,
   requestStop,
   setRunAbort,
   startRun,
+  stashCodexRollout,
   stashTranscript,
   updateGlobalState
-} from "./chunk-AK47NPAX.mjs";
+} from "./chunk-L5TWVHYB.mjs";
 import {
   AgentError,
   AppRuntime,
-  CLAUDE2_DIR,
   COCKPIT_DIR,
   DEEPSEEK_CREDENTIALS_FILE,
   DEEPSEEK_DIR,
@@ -34,7 +35,6 @@ import {
   encodePath,
   findCodexSessionPath,
   getBuiltinSessionsRoot,
-  getClaude2SessionPath,
   getClaudeSessionPath,
   getDeepseekBuiltinSessionPath,
   getDeepseekSessionPath,
@@ -51,7 +51,7 @@ import {
   settlePendingRecord,
   withFileLock,
   writeJsonFile
-} from "./chunk-BKJB2B6J.mjs";
+} from "./chunk-RSRPFWNL.mjs";
 import {
   __export
 } from "./chunk-7P6ASYW6.mjs";
@@ -2207,9 +2207,9 @@ function listUserSkills() {
     return [];
   }
 }
-function readSkillName(path2) {
+function readSkillName(path) {
   try {
-    const txt = readFileSync(path2, "utf-8");
+    const txt = readFileSync(path, "utf-8");
     const fm = txt.match(/^---\r?\n([\s\S]*?)\r?\n---/);
     const block = fm ? fm[1] : txt;
     const m = block.match(/^name:\s*["']?([^"'\n]+?)["']?\s*$/m);
@@ -2443,617 +2443,6 @@ async function runSdkLoop(ctx, buildOptions2) {
   }
 }
 
-// packages/feature/agent/src/server/pty/claudePtyDriver.ts
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import * as crypto from "crypto";
-import * as pty from "node-pty";
-import { execSync } from "child_process";
-var shq = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
-function hasCmd(c) {
-  try {
-    execSync(`command -v ${c}`, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function clipboardImageSupported() {
-  if (process.platform === "darwin") return true;
-  if (process.platform === "linux") return hasCmd("wl-copy") || hasCmd("xclip");
-  return false;
-}
-function setClipboardImage(file2, isPng) {
-  try {
-    if (process.platform === "darwin") {
-      let png = file2;
-      if (!isPng) {
-        png = `${file2}.png`;
-        execSync(`sips -s format png ${shq(file2)} --out ${shq(png)}`, { stdio: "ignore" });
-      }
-      execSync(`osascript -e 'set the clipboard to (read (POSIX file ${JSON.stringify(png)}) as \xABclass PNGf\xBB)'`, { stdio: "ignore" });
-      return true;
-    }
-    if (process.platform === "linux") {
-      if (hasCmd("wl-copy")) {
-        execSync(`wl-copy --type image/png < ${shq(file2)}`, { shell: "/bin/bash", stdio: "ignore" });
-        return true;
-      }
-      if (hasCmd("xclip")) {
-        execSync(`xclip -selection clipboard -t image/png -i ${shq(file2)}`, { stdio: "ignore" });
-        return true;
-      }
-    }
-  } catch {
-  }
-  return false;
-}
-function getClipboardText() {
-  try {
-    if (process.platform === "darwin") return execSync("pbpaste", { encoding: "utf8" });
-    if (hasCmd("wl-paste")) return execSync("wl-paste -n", { encoding: "utf8" });
-    if (hasCmd("xclip")) return execSync("xclip -o -selection clipboard", { encoding: "utf8" });
-  } catch {
-  }
-  return null;
-}
-function setClipboardText(t) {
-  try {
-    if (process.platform === "darwin") {
-      execSync("pbcopy", { input: t });
-      return;
-    }
-    if (hasCmd("wl-copy")) {
-      execSync("wl-copy", { input: t });
-      return;
-    }
-    if (hasCmd("xclip")) {
-      execSync("xclip -selection clipboard", { input: t });
-      return;
-    }
-  } catch {
-  }
-}
-function sessionDirFor(cwd) {
-  let real = cwd;
-  try {
-    real = fs.realpathSync(cwd);
-  } catch {
-  }
-  const encoded = real.replace(/\//g, "-");
-  return path.join(os.homedir(), ".claude", "projects", encoded);
-}
-function jsonlPathFor(cwd, sessionId) {
-  return path.join(sessionDirFor(cwd), `${sessionId}.jsonl`);
-}
-var ASK_QUESTION_GUIDANCE = "Interactive questions cannot be displayed in this session. Do NOT retry this tool. Instead, present your questions as plain text in your reply - each question with its options and your recommended choice - then end your turn and wait for the user to answer in the next message.";
-function ensureHookSettings() {
-  const p = path.join(os.tmpdir(), "cockpit-claude-hooks-v2.json");
-  const content = JSON.stringify({
-    hooks: {
-      Stop: [{ hooks: [{ type: "command", command: "true" }] }],
-      PreToolUse: [{
-        matcher: "AskUserQuestion",
-        hooks: [{ type: "command", command: `echo ${shq(ASK_QUESTION_GUIDANCE)} >&2; exit 2` }]
-      }]
-    }
-  });
-  try {
-    if (fs.readFileSync(p, "utf8") === content) return p;
-  } catch {
-  }
-  const tmp = `${p}.${process.pid}.tmp`;
-  fs.writeFileSync(tmp, content);
-  fs.renameSync(tmp, p);
-  return p;
-}
-var ptyInputRegistry = /* @__PURE__ */ new Map();
-function trackBackgroundLifecycle(line, pending) {
-  const content = line.message?.content;
-  if (line.type === "user" && Array.isArray(content)) {
-    for (const b of content) {
-      if (b.type === "tool_result" && typeof b.content === "string") {
-        const m = b.content.match(/Command running in background with ID:\s*([A-Za-z0-9_-]+)/);
-        if (m) pending.add(m[1]);
-      }
-    }
-  }
-  const origin = line.origin;
-  if (line.type === "user" && origin?.kind === "task-notification") {
-    const raw = typeof content === "string" ? content : Array.isArray(content) ? content.filter((b) => b.type === "text").map((b) => b.text || "").join("") : "";
-    const id = raw.match(/<task-id>([\s\S]*?)<\/task-id>/)?.[1]?.trim();
-    if (id) pending.delete(id);
-  }
-}
-function runClaudeTurn(opts) {
-  const {
-    cwd,
-    prompt,
-    onJsonlLine,
-    onPtyData,
-    onSubmit,
-    onComplete,
-    onQuestionEsc,
-    onTurnBoundary,
-    signal,
-    debug = false,
-    idleMs = 3e3,
-    timeoutMs,
-    cols = 80,
-    rows = 24,
-    stuckMs = 1e4,
-    graceMs = 3e4,
-    onStuck
-  } = opts;
-  const sessionId = opts.sessionId || crypto.randomUUID();
-  const isResume = opts.resume === true;
-  const jsonlPath = jsonlPathFor(cwd, sessionId);
-  const settingsPath = ensureHookSettings();
-  const log = (...a) => {
-    if (debug) console.error("[driver]", ...a);
-  };
-  const EXT = { "image/png": "png", "image/jpeg": "jpg", "image/webp": "webp", "image/gif": "gif" };
-  const tempImageFiles = [];
-  for (const img of opts.images || []) {
-    try {
-      const p = path.join(os.tmpdir(), `cockpit-pty-img-${crypto.randomUUID()}.${EXT[img.media_type] || "png"}`);
-      fs.writeFileSync(p, Buffer.from(img.data, "base64"));
-      tempImageFiles.push({ path: p, isPng: img.media_type === "image/png" });
-    } catch {
-    }
-  }
-  const useClipboard = tempImageFiles.length > 0 && clipboardImageSupported();
-  const effectivePrompt = !useClipboard && tempImageFiles.length ? `${prompt}
-
-[Attached image(s)]:
-${tempImageFiles.map((f) => f.path).join("\n")}` : prompt;
-  const cleanupImages = () => {
-    for (const f of tempImageFiles) {
-      try {
-        fs.unlinkSync(f.path);
-      } catch {
-      }
-      try {
-        fs.unlinkSync(`${f.path}.png`);
-      } catch {
-      }
-    }
-  };
-  return new Promise((resolve) => {
-    let baseline = 0;
-    try {
-      baseline = fs.readFileSync(jsonlPath, "utf8").split("\n").filter(Boolean).length;
-    } catch {
-    }
-    const flags = isResume ? ["-r", sessionId, "--dangerously-skip-permissions"] : ["--session-id", sessionId, "--dangerously-skip-permissions"];
-    flags.push("--settings", settingsPath);
-    const cmd = `claude ${flags.join(" ")}`;
-    log("spawn:", cmd, "| jsonl:", jsonlPath, "| baseline:", baseline);
-    const shell = process.env.SHELL || (process.platform === "darwin" ? "/bin/zsh" : "/bin/bash");
-    let term;
-    try {
-      term = pty.spawn(shell, ["--login", "-c", cmd], {
-        name: "xterm-256color",
-        cols,
-        rows,
-        cwd,
-        env: sanitizedSpawnEnv()
-      });
-    } catch (e) {
-      cleanupImages();
-      resolve({ sessionId, jsonlPath, completed: false, completedVia: null, exitCode: null, crashed: true, crashError: `spawn failed: ${String(e)}`, newLines: [] });
-      return;
-    }
-    ptyInputRegistry.set(sessionId, (d) => {
-      try {
-        term.write(d);
-      } catch {
-      }
-    });
-    let rawBuf = "";
-    let lastDataTs = Date.now();
-    let menuHandled = false;
-    let questionEscSent = false;
-    let askQuestionUses = 0;
-    let promptSent = false;
-    let completed = false;
-    let completedVia = null;
-    let exitSent = false;
-    let exited = false;
-    let seen = baseline;
-    let lastJsonlTs = 0;
-    let sawAssistantText = false;
-    let crashed = false;
-    let crashError = "";
-    let timedOut = false;
-    const newLines = [];
-    const pendingBg = /* @__PURE__ */ new Set();
-    let awaitingNewTurn = false;
-    term.onData((d) => {
-      rawBuf += d;
-      if (rawBuf.length > 2e5) rawBuf = rawBuf.slice(-15e4);
-      lastDataTs = Date.now();
-      onPtyData?.(d);
-      if (!crashed && /claude-code\/cli\.js:\d+:\d+/.test(rawBuf)) {
-        crashed = true;
-        const m = rawBuf.match(/Cannot read properties of [^\n\x1b]+/);
-        crashError = (m ? m[0] : "claude-code internal crash").trim();
-        log("CRASH detected:", crashError);
-        setTimeout(() => {
-          if (!exited) {
-            try {
-              term.kill();
-            } catch {
-            }
-          }
-        }, 100);
-        setTimeout(() => {
-          if (!exited) {
-            try {
-              term.kill("SIGKILL");
-            } catch {
-            }
-          }
-        }, 1e3);
-        return;
-      }
-      if (!menuHandled && /Bypass Permissions mode|Yes, I accept/i.test(rawBuf)) {
-        menuHandled = true;
-        log("accept menu \u2192 Down + Enter");
-        setTimeout(() => term.write("\x1B[B"), 400);
-        setTimeout(() => term.write("\r"), 700);
-      }
-      if (!questionEscSent && promptSent && !completed && /Enter to select.*Esc to cancel/i.test(rawBuf)) {
-        questionEscSent = true;
-        log("AskUserQuestion UI detected \u2192 ESC + end turn");
-        onQuestionEsc?.();
-        setTimeout(() => {
-          try {
-            term.write("\x1B");
-          } catch {
-          }
-        }, 300);
-        setTimeout(() => complete("question_esc"), 600);
-      }
-    });
-    let replReadyTs = 0;
-    const readyCheck = setInterval(() => {
-      if (promptSent || exited) return;
-      const replReady = /bypass permissions on|shift\+tab/i.test(rawBuf);
-      if (replReady && !replReadyTs) replReadyTs = Date.now();
-      if (!replReady) return;
-      const settled = Date.now() - lastDataTs > 2200;
-      const readyTimeout = Date.now() - replReadyTs > 4e3;
-      if (settled || readyTimeout) submitPrompt();
-    }, 300);
-    let graceTimer = null;
-    const stuckTimer = setTimeout(() => {
-      if (promptSent || exited) return;
-      log(`not ready after ${stuckMs}ms \u2192 prompt for manual handling, grace ${graceMs}ms`);
-      onStuck?.();
-      graceTimer = setTimeout(() => {
-        if (promptSent || exited) return;
-        timedOut = true;
-        log("grace window elapsed and still not ready \u2192 kill");
-        try {
-          term.kill();
-        } catch {
-        }
-        setTimeout(() => {
-          if (!exited) {
-            try {
-              term.kill("SIGKILL");
-            } catch {
-            }
-          }
-        }, 1500);
-      }, graceMs);
-    }, stuckMs);
-    const clearStartupTimers = () => {
-      clearTimeout(stuckTimer);
-      if (graceTimer) clearTimeout(graceTimer);
-    };
-    let savedClip = null;
-    const waitImagePlaceholder = (n) => new Promise((res) => {
-      const start = Date.now();
-      const iv = setInterval(() => {
-        const count = (rawBuf.match(/\[Image/g) || []).length;
-        if (count >= n || Date.now() - start > 2500 || exited) {
-          clearInterval(iv);
-          res();
-        }
-      }, 100);
-    });
-    async function submitPrompt() {
-      if (promptSent) return;
-      promptSent = true;
-      clearStartupTimers();
-      if (useClipboard) {
-        savedClip = getClipboardText();
-        for (let i = 0; i < tempImageFiles.length && !exited; i++) {
-          if (!setClipboardImage(tempImageFiles[i].path, tempImageFiles[i].isPng)) {
-            log("clipboard set failed, skipping this image");
-            continue;
-          }
-          term.write("");
-          await waitImagePlaceholder(i + 1);
-        }
-      }
-      log("paste prompt + Enter" + (tempImageFiles.length ? ` (${useClipboard ? "clipboard" : "path"} x${tempImageFiles.length} img)` : ""));
-      term.write("\x1B[200~" + effectivePrompt + "\x1B[201~");
-      setTimeout(() => term.write("\r"), 250);
-      if (savedClip != null) setTimeout(() => {
-        if (savedClip != null) setClipboardText(savedClip);
-      }, 800);
-      onSubmit?.();
-    }
-    const poll = setInterval(() => {
-      let txt;
-      try {
-        txt = fs.readFileSync(jsonlPath, "utf8");
-      } catch {
-        return;
-      }
-      const lines = txt.split("\n").filter(Boolean);
-      for (let i = seen; i < lines.length; i++) {
-        let o;
-        try {
-          o = JSON.parse(lines[i]);
-        } catch {
-          continue;
-        }
-        newLines.push(o);
-        lastJsonlTs = Date.now();
-        trackBackgroundLifecycle(o, pendingBg);
-        if (awaitingNewTurn && o.type === "assistant") {
-          awaitingNewTurn = false;
-          onTurnBoundary?.("init");
-        }
-        onJsonlLine?.(o);
-        const blocks = Array.isArray(o.message?.content) ? o.message.content.map((b) => b.type).join(",") : "";
-        if (o.type === "assistant" && blocks.includes("text")) sawAssistantText = true;
-        if (o.type === "assistant" && Array.isArray(o.message?.content)) {
-          askQuestionUses += o.message.content.filter((b) => b.type === "tool_use" && b.name === "AskUserQuestion").length;
-          if (askQuestionUses >= 3 && !completed) {
-            log(`AskUserQuestion x${askQuestionUses} \u2192 break retry loop, end turn`);
-            onQuestionEsc?.();
-            complete("question_loop");
-          }
-        }
-        if (o.type === "system" && o.subtype === "stop_hook_summary" && !completed) {
-          if (pendingBg.size === 0) {
-            complete("stop_hook_summary");
-          } else {
-            log("stop_hook with background task(s) pending \u2192 staying resident", [...pendingBg]);
-            onTurnBoundary?.("result");
-            awaitingNewTurn = true;
-          }
-        }
-      }
-      seen = lines.length;
-    }, 150);
-    const idleCheck = setInterval(() => {
-      if (completed || !promptSent) return;
-      if (sawAssistantText && pendingBg.size === 0 && Date.now() - lastJsonlTs > idleMs && Date.now() - lastDataTs > idleMs) {
-        complete("idle");
-      }
-    }, 300);
-    function complete(via) {
-      if (completed) return;
-      completed = true;
-      completedVia = via;
-      log("complete via", via);
-      onComplete?.(via);
-      setTimeout(sendExit, 200);
-    }
-    function sendExit() {
-      if (exitSent) return;
-      exitSent = true;
-      log("exit: Ctrl+C x2 \u2192 SIGHUP \u2192 SIGKILL");
-      try {
-        term.write("");
-      } catch {
-      }
-      setTimeout(() => {
-        try {
-          term.write("");
-        } catch {
-        }
-      }, 150);
-      setTimeout(() => {
-        if (!exited) {
-          try {
-            term.kill();
-          } catch {
-          }
-        }
-      }, 900);
-      setTimeout(() => {
-        if (!exited) {
-          try {
-            term.kill("SIGKILL");
-          } catch {
-          }
-        }
-      }, 2e3);
-    }
-    const onAbort = () => {
-      log("aborted \u2192 interrupt + guaranteed kill");
-      try {
-        term.write("\x1B");
-        term.write("");
-      } catch {
-      }
-      setTimeout(() => {
-        if (!exited) {
-          try {
-            term.kill();
-          } catch {
-          }
-        }
-      }, 500);
-      setTimeout(() => {
-        if (!exited) {
-          try {
-            term.kill("SIGKILL");
-          } catch {
-          }
-        }
-      }, 1500);
-    };
-    let abortListenerAdded = false;
-    if (signal) {
-      if (signal.aborted) onAbort();
-      else {
-        signal.addEventListener("abort", onAbort, { once: true });
-        abortListenerAdded = true;
-      }
-    }
-    const timeout = timeoutMs ? setTimeout(() => {
-      if (!exited) {
-        log("TIMEOUT, killing");
-        try {
-          term.kill();
-        } catch {
-        }
-        setTimeout(() => {
-          if (!exited) {
-            try {
-              term.kill("SIGKILL");
-            } catch {
-            }
-          }
-        }, 1500);
-      }
-    }, timeoutMs) : null;
-    term.onExit(({ exitCode }) => {
-      exited = true;
-      clearInterval(poll);
-      clearInterval(readyCheck);
-      clearInterval(idleCheck);
-      clearStartupTimers();
-      if (timeout) clearTimeout(timeout);
-      ptyInputRegistry.delete(sessionId);
-      cleanupImages();
-      if (abortListenerAdded) signal?.removeEventListener("abort", onAbort);
-      log("exit code", exitCode, "completed", completed, "via", completedVia);
-      resolve({ sessionId, jsonlPath, completed, completedVia, exitCode, crashed, crashError, timedOut, newLines });
-    });
-  });
-}
-
-// packages/feature/agent/src/server/pty/ptySseMapper.ts
-function initEvent(sessionId) {
-  return { type: "system", subtype: "init", session_id: sessionId };
-}
-function resultEvent(sessionId, opts) {
-  return { type: "result", subtype: "success", session_id: sessionId, usage: opts?.usage };
-}
-function mapLineToEvents(line, sessionId) {
-  const out = [];
-  const content = line.message?.content;
-  const origin = line.origin;
-  if (line.type === "user" && origin?.kind === "task-notification") {
-    const raw = typeof content === "string" ? content : Array.isArray(content) ? content.filter((b) => b.type === "text").map((b) => b.text || "").join("") : "";
-    const pick2 = (tag) => raw.match(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`))?.[1]?.trim();
-    const ev = { type: "system", subtype: "task_notification", session_id: sessionId };
-    const taskId = pick2("task-id");
-    if (taskId) ev.task_id = taskId;
-    const status = pick2("status");
-    if (status) ev.status = status;
-    const summary = pick2("summary");
-    if (summary) ev.summary = summary;
-    const outputFile = pick2("output-file");
-    if (outputFile) ev.output_file = outputFile;
-    out.push(ev);
-    return out;
-  }
-  if (line.type === "assistant" && Array.isArray(content)) {
-    const blocks = content;
-    const text = blocks.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("");
-    if (text) {
-      out.push({
-        type: "stream_event",
-        session_id: sessionId,
-        event: { type: "content_block_delta", delta: { type: "text_delta", text } }
-      });
-    }
-    const toolUses = blocks.filter((b) => b.type === "tool_use");
-    if (toolUses.length > 0) {
-      out.push({
-        type: "assistant",
-        session_id: sessionId,
-        message: { role: "assistant", content: toolUses }
-      });
-    }
-    return out;
-  }
-  if (line.type === "user" && Array.isArray(content)) {
-    const blocks = content;
-    const toolResults = blocks.filter((b) => b.type === "tool_result" && b.tool_use_id);
-    if (toolResults.length > 0) {
-      out.push({
-        type: "user",
-        session_id: sessionId,
-        message: { role: "user", content: toolResults }
-      });
-    }
-    return out;
-  }
-  return out;
-}
-
-// packages/feature/agent/src/server/engines/shared/ptyBranch.ts
-async function runPtyTurn(ctx) {
-  const sid = ctx.currentKey();
-  const isResume = !!ctx.sessionId;
-  const promptText = ctx.prompt ?? "";
-  ctx.emit(initEvent(sid));
-  ctx.rekey(sid);
-  const turn = await runClaudeTurn({
-    cwd: ctx.cwd || process.cwd(),
-    prompt: promptText,
-    sessionId: sid,
-    resume: isResume,
-    ...ctx.images && ctx.images.length > 0 && {
-      images: ctx.images.map((img) => ({ media_type: img.media_type, data: img.data }))
-    },
-    ...ctx.params.ptyCols && { cols: ctx.params.ptyCols },
-    ...ctx.params.ptyRows && { rows: ctx.params.ptyRows },
-    signal: ctx.signal,
-    onJsonlLine: (line) => {
-      for (const ev of mapLineToEvents(line, sid)) {
-        ctx.emit(ev);
-      }
-    },
-    // Background-task persistence: the driver stays resident across a background task and signals
-    // synthetic turn boundaries. Map them to the SAME init/result events a normal turn emits, so the
-    // follow-up (auto-run) turn renders in its own bubble and the completion notification's event row
-    // shows (the client keys the row off a turn having ended).
-    onTurnBoundary: (kind) => ctx.emit(kind === "init" ? initEvent(sid) : resultEvent(sid)),
-    // floating-window dual-view: raw PTY output forwarded to the frontend xterm.
-    onPtyData: (data) => ctx.emit({ type: "pty_output", data }),
-    // Startup stuck (REPL not ready, likely a dialog) → ask the user to handle it in the terminal.
-    onStuck: () => ctx.emit({ type: "pty_notice", level: "warning", messageKey: "chat.ptyStuck" }),
-    // AskUserQuestion selector auto-cancelled (ESC), turn ended early.
-    onQuestionEsc: () => ctx.emit({ type: "pty_notice", level: "warning", messageKey: "chat.ptyQuestionEsc" })
-  });
-  if (turn.crashed) {
-    ctx.emit({
-      type: "pty_notice",
-      level: "error",
-      terminal: true,
-      messageKey: "chat.ptyCrash",
-      params: { error: turn.crashError }
-    });
-  }
-  if (turn.timedOut) {
-    ctx.emit({ type: "pty_notice", level: "warning", terminal: true, messageKey: "chat.ptyTimedOut" });
-  }
-  ctx.emit(resultEvent(sid));
-}
-
 // packages/feature/agent/src/server/engines/claude.ts
 var PLAN_EDIT_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
 var isPlanFilePath = (p) => /(^|\/)\.claude\/plans\//.test(p);
@@ -3066,22 +2455,22 @@ function planPermission(toolName, input, opts) {
     };
   }
   if (PLAN_EDIT_TOOLS.has(toolName)) {
-    const path2 = [input.file_path, input.notebook_path, input.path, opts?.blockedPath].find(
+    const path = [input.file_path, input.notebook_path, input.path, opts?.blockedPath].find(
       (v) => typeof v === "string"
     );
-    if (path2 && isPlanFilePath(path2)) {
+    if (path && isPlanFilePath(path)) {
       return { behavior: "allow", updatedInput: input };
     }
     return {
       behavior: "deny",
       // (C) read-only plan mode, no dialog → feedback instead of silent drop
-      message: `Plan mode is read-only and this environment has no approval dialog, so "${toolName}"${path2 ? ` on ${path2}` : ""} can't run. Only writes under .claude/plans/ are allowed. Capture the intended changes in your plan instead of editing files now.`
+      message: `Plan mode is read-only and this environment has no approval dialog, so "${toolName}"${path ? ` on ${path}` : ""} can't run. Only writes under .claude/plans/ are allowed. Capture the intended changes in your plan instead of editing files now.`
     };
   }
   return { behavior: "allow", updatedInput: input };
 }
 function buildClaudeOptions(ctx, independent) {
-  const { engine, permissionMode } = ctx.params;
+  const { permissionMode } = ctx.params;
   const isPlan = permissionMode === "plan";
   return (abort, resume, isRetry) => ({
     // Independent task: resume is what makes the CLI load the transcript, so the first
@@ -3102,27 +2491,21 @@ function buildClaudeOptions(ctx, independent) {
     },
     includePartialMessages: true,
     abortController: abort,
-    // env is ALWAYS passed (not just for claude2): without it the SDK inherits
-    // process.env verbatim, handing the agent this server's NODE_ENV=production.
-    // See sanitizedSpawnEnv. claude2 additionally points at ~/.claude2.
-    env: sanitizedSpawnEnv(engine === "claude2" ? { CLAUDE_CONFIG_DIR: CLAUDE2_DIR } : {})
+    // env is ALWAYS passed: without it the SDK inherits process.env verbatim,
+    // handing the agent this server's NODE_ENV=production. See sanitizedSpawnEnv.
+    env: sanitizedSpawnEnv({})
   });
 }
 var claudeSpec = {
   name: "claude",
   runner: {
     async run(ctx) {
-      const { mode, engine } = ctx.params;
-      if (mode === "pty" && (!engine || engine === "claude" || engine === "claude2")) {
-        await runPtyTurn(ctx);
-        return;
-      }
       const independent = ctx.params.noHistory === true && !!ctx.sessionId;
       if (!independent) {
         await runSdkLoop(ctx, buildClaudeOptions(ctx, false));
         return;
       }
-      const sessionPath = engine === "claude2" ? getClaude2SessionPath(ctx.cwd, ctx.sessionId) : getClaudeSessionPath(ctx.cwd, ctx.sessionId);
+      const sessionPath = getClaudeSessionPath(ctx.cwd, ctx.sessionId);
       const stashed = stashTranscript(sessionPath);
       try {
         await runSdkLoop(ctx, buildClaudeOptions(ctx, true));
@@ -3153,7 +2536,7 @@ var glmApiKey = createApiKeyStore(GLM_CREDENTIALS_FILE);
 
 // packages/feature/agent/src/server/engines/builtinAgent/index.ts
 import { streamText, stepCountIs } from "ai";
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // packages/feature/agent/src/server/engines/builtinAgent/prompt.ts
 function buildSystemPrompt(cwd) {
@@ -3217,18 +2600,18 @@ Accuracy:
 }
 
 // packages/feature/agent/src/server/engines/builtinAgent/session.ts
-import { readFileSync as readFileSync3, existsSync, mkdirSync as mkdirSync2, appendFileSync } from "fs";
-import { join as join3 } from "path";
+import { readFileSync as readFileSync2, existsSync, mkdirSync as mkdirSync2, appendFileSync } from "fs";
+import { join as join2 } from "path";
 function getSessionDir(root, cwd) {
-  return join3(root, encodePath(cwd));
+  return join2(root, encodePath(cwd));
 }
 function getSessionPath(root, cwd, sessionId) {
-  return join3(getSessionDir(root, cwd), `${sessionId}.jsonl`);
+  return join2(getSessionDir(root, cwd), `${sessionId}.jsonl`);
 }
 function readSessionMessages(root, cwd, sessionId) {
-  const path2 = getSessionPath(root, cwd, sessionId);
-  if (!existsSync(path2)) return [];
-  const lines = readFileSync3(path2, "utf-8").split("\n").filter(Boolean);
+  const path = getSessionPath(root, cwd, sessionId);
+  if (!existsSync(path)) return [];
+  const lines = readFileSync2(path, "utf-8").split("\n").filter(Boolean);
   const transcriptEntries = [];
   for (const line of lines) {
     try {
@@ -3328,8 +2711,8 @@ function readSessionMessages(root, cwd, sessionId) {
 function appendSessionLine(root, cwd, sessionId, line) {
   const dir = getSessionDir(root, cwd);
   mkdirSync2(dir, { recursive: true });
-  const path2 = getSessionPath(root, cwd, sessionId);
-  appendFileSync(path2, JSON.stringify(line) + "\n", "utf-8");
+  const path = getSessionPath(root, cwd, sessionId);
+  appendFileSync(path, JSON.stringify(line) + "\n", "utf-8");
 }
 function appendUserText(root, cwd, sessionId, text, opts) {
   appendSessionLine(root, cwd, sessionId, {
@@ -4138,10 +3521,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path2) {
-  if (!path2)
+function getElementAtPath(obj, path) {
+  if (!path)
     return obj;
-  return path2.reduce((acc, key) => acc?.[key], obj);
+  return path.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -4524,11 +3907,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path2, issues) {
+function prefixIssues(path, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path2);
+    iss.path.unshift(path);
     return iss;
   });
 }
@@ -4711,7 +4094,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path2 = []) => {
+  const processError = (error49, path = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -4721,7 +4104,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path2, ...issue2.path];
+        const fullpath = [...path, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -4753,8 +4136,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path2 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path2) {
+  const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -16731,13 +16114,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path2 = ref.slice(1).split("/").filter(Boolean);
-  if (path2.length === 0) {
+  const path = ref.slice(1).split("/").filter(Boolean);
+  if (path.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path2[0] === defsKey) {
-    const key = path2[1];
+  if (path[0] === defsKey) {
+    const key = path[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -17140,17 +16523,17 @@ function date4(params) {
 config(en_default());
 
 // packages/feature/agent/src/server/engines/builtinAgent/tools.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
 import { writeFile, mkdir, readdir, stat, unlink } from "fs/promises";
-import { isAbsolute, join as join4 } from "path";
-import { tmpdir as tmpdir2 } from "os";
+import { isAbsolute, join as join3 } from "path";
+import { tmpdir } from "os";
 import { exec, execFile } from "child_process";
 import { promisify } from "util";
 import fg from "fast-glob";
 import { rgPath as RG_PATH } from "@vscode/ripgrep";
 var execAsync = promisify(exec);
 var execFileAsync = promisify(execFile);
-var SPILL_DIR = join4(tmpdir2(), "cockpit-tool-outputs");
+var SPILL_DIR = join3(tmpdir(), "cockpit-tool-outputs");
 var SPILL_MAX_FILES = 200;
 async function spillToFile(text, kind) {
   try {
@@ -17160,7 +16543,7 @@ async function spillToFile(text, kind) {
       if (entries.length >= SPILL_MAX_FILES) {
         const statted = await Promise.all(
           entries.map(async (name) => {
-            const p = join4(SPILL_DIR, name);
+            const p = join3(SPILL_DIR, name);
             try {
               return { p, mtime: (await stat(p)).mtimeMs };
             } catch {
@@ -17177,7 +16560,7 @@ async function spillToFile(text, kind) {
     }
     const stamp = Date.now().toString(36);
     const rand = Math.random().toString(36).slice(2, 8);
-    const file2 = join4(SPILL_DIR, `${kind}-${stamp}-${rand}.log`);
+    const file2 = join3(SPILL_DIR, `${kind}-${stamp}-${rand}.log`);
     await writeFile(file2, text, "utf-8");
     return file2;
   } catch {
@@ -17236,7 +16619,7 @@ function createTools(context) {
       execute: async ({ file_path, offset, limit }) => {
         try {
           if (!isAbsolute(file_path)) return "Error: file_path must be an absolute path.";
-          const content = readFileSync4(file_path, "utf-8");
+          const content = readFileSync3(file_path, "utf-8");
           const lines = content.split("\n");
           const total = lines.length;
           const start = Math.max(0, offset - 1);
@@ -17262,7 +16645,7 @@ function createTools(context) {
       execute: async ({ file_path, content }) => {
         try {
           if (!isAbsolute(file_path)) return "Error: file_path must be an absolute path.";
-          writeFileSync3(file_path, content, "utf-8");
+          writeFileSync2(file_path, content, "utf-8");
           return `File written: ${file_path}`;
         } catch (err) {
           return `Error writing file: ${err.message}`;
@@ -17288,12 +16671,12 @@ function createTools(context) {
       }) => {
         try {
           if (!isAbsolute(file_path)) return "Error: file_path must be an absolute path.";
-          const content = readFileSync4(file_path, "utf-8");
+          const content = readFileSync3(file_path, "utf-8");
           if (!content.includes(old_string)) {
             return `Error: old_string not found in ${file_path}. The file may have changed.`;
           }
           const updated = replace_all ? content.split(old_string).join(new_string) : content.replace(old_string, new_string);
-          writeFileSync3(file_path, updated, "utf-8");
+          writeFileSync2(file_path, updated, "utf-8");
           return `File edited: ${file_path}`;
         } catch (err) {
           return `Error editing file: ${err.message}`;
@@ -17384,14 +16767,14 @@ ${stderrCapped}`;
       ),
       execute: async ({
         pattern,
-        path: path2,
+        path,
         ignore_case,
         output_mode,
         "-n": showLineNumbers
       }) => {
         try {
-          if (path2 && !isAbsolute(path2)) return "Error: path must be an absolute path.";
-          const target = path2 || context.cwd;
+          if (path && !isAbsolute(path)) return "Error: path must be an absolute path.";
+          const target = path || context.cwd;
           const args = [
             "--no-heading",
             "--color",
@@ -17612,7 +16995,7 @@ async function runBuiltinAgent(ctx, config2) {
   const noHistory = ctx.params.noHistory === true;
   const existing = noHistory ? [] : readSessionMessages(sessionsRoot, cwd, sid);
   const messages = [...existing, { role: "user", content: prompt }];
-  appendUserText(sessionsRoot, cwd, sid, prompt, { uuid: randomUUID3(), timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  appendUserText(sessionsRoot, cwd, sid, prompt, { uuid: randomUUID2(), timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   emit(`data: ${JSON.stringify({ type: "system", subtype: "init", session_id: sid })}
 
 `);
@@ -17642,7 +17025,7 @@ async function runBuiltinAgent(ctx, config2) {
     for (const [toolUseId] of pendingToolCalls) {
       try {
         appendToolResult(sessionsRoot, cwd, sid, toolUseId, reason, {
-          uuid: randomUUID3(),
+          uuid: randomUUID2(),
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           is_error: true
         });
@@ -17676,7 +17059,7 @@ async function runBuiltinAgent(ctx, config2) {
               cwd,
               sid,
               [{ type: "tool_use", id: toolUseId, name: toolName, input }],
-              { uuid: randomUUID3(), timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+              { uuid: randomUUID2(), timestamp: (/* @__PURE__ */ new Date()).toISOString() }
             );
           } catch {
           }
@@ -17685,7 +17068,7 @@ async function runBuiltinAgent(ctx, config2) {
           try {
             pendingToolCalls.delete(toolUseId);
             appendToolResult(sessionsRoot, cwd, sid, toolUseId, content, {
-              uuid: randomUUID3(),
+              uuid: randomUUID2(),
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
               is_error: Boolean(isError)
             });
@@ -17695,7 +17078,7 @@ async function runBuiltinAgent(ctx, config2) {
         onTextFlush: (flushedText) => {
           try {
             appendAssistantMessage(sessionsRoot, cwd, sid, [{ type: "text", text: flushedText }], {
-              uuid: randomUUID3(),
+              uuid: randomUUID2(),
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
           } catch {
@@ -17707,7 +17090,7 @@ async function runBuiltinAgent(ctx, config2) {
     emitResultMessage(usage.inputTokens || 0, usage.outputTokens || 0, emit);
     if (!ctx.signal.aborted) {
       appendAssistantMessage(sessionsRoot, cwd, sid, text ? [{ type: "text", text }] : [], {
-        uuid: randomUUID3(),
+        uuid: randomUUID2(),
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         usage: {
           input_tokens: usage.inputTokens || 0,
@@ -17729,7 +17112,7 @@ async function runBuiltinAgent(ctx, config2) {
         cwd,
         sid,
         [{ type: "text", text: `\u26A0\uFE0F ${formatProviderError(error48)}` }],
-        { uuid: randomUUID3(), timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+        { uuid: randomUUID2(), timestamp: (/* @__PURE__ */ new Date()).toISOString() }
       );
     } catch {
     }
@@ -17989,12 +17372,104 @@ var glmProvider = {
 var glmSpec = makeAnthropicCompatSpec(glmProvider);
 
 // packages/feature/agent/src/server/engines/codex.ts
-import { spawn as spawn2 } from "child_process";
-import { randomUUID as randomUUID4 } from "crypto";
-import { createInterface } from "readline";
-import { writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync3, existsSync as existsSync2 } from "fs";
-import { join as join5 } from "path";
-import { tmpdir as tmpdir3 } from "os";
+import { randomUUID as randomUUID3 } from "crypto";
+import { writeFileSync as writeFileSync3, unlinkSync, mkdirSync as mkdirSync3, existsSync as existsSync2, statSync, openSync, readSync, closeSync } from "fs";
+import { StringDecoder } from "string_decoder";
+import { join as join4 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+
+// packages/feature/agent/src/server/api/session/codexTools.ts
+var CODEX_IMAGE_ONLY_TEXT = "[Image]";
+var CODEX_TOOL_NAMES = {
+  bash: "Bash",
+  applyPatch: "ApplyPatch",
+  /** `spawn_agent` → claude's Task, so one bubble == one sub-agent. */
+  task: "Task",
+  /** `update_plan` / live `todo_list` → the checklist MessageBubble already renders. */
+  todo: "TodoWrite",
+  webSearch: "WebSearch",
+  webFetch: "WebFetch"
+};
+var CODEX_MCP_NAMESPACE_PREFIX = "mcp__";
+var codexMcpToolName = (server, tool2) => `${CODEX_MCP_NAMESPACE_PREFIX}${server}__${tool2}`;
+var CODEX_SPAWN_FN_NAME = "spawn_agent";
+function codexTodoInput(items) {
+  return {
+    todos: (items ?? []).flatMap(
+      (i) => typeof i?.text === "string" ? [{ content: i.text, status: i.completed ? "completed" : "pending" }] : []
+    )
+  };
+}
+function codexTodoResultText(todos) {
+  const done = todos.filter((t) => t.status === "completed").length;
+  return `${done}/${todos.length} completed`;
+}
+function codexWebSearchCall(query2, action) {
+  if (action?.type === "open_page" && action.url) {
+    return { name: CODEX_TOOL_NAMES.webFetch, input: { url: action.url }, result: action.url };
+  }
+  const q = action?.query || query2 || "";
+  const queries = action?.queries?.length ? action.queries : q ? [q] : [];
+  return {
+    name: CODEX_TOOL_NAMES.webSearch,
+    input: { query: q },
+    // codex reports the queries it ran but never the hits; showing the queries beats
+    // an empty result, which would leave the bubble looking unfinished.
+    result: queries.join("\n")
+  };
+}
+function codexMcpResultText(item) {
+  if (item.error?.message) return item.error.message;
+  if (item.result === null || item.result === void 0) return "";
+  return typeof item.result === "string" ? item.result : JSON.stringify(item.result, null, 2);
+}
+var CODEX_AGENT_DONE = /* @__PURE__ */ new Set(["completed", "errored", "interrupted", "not_found", "failed"]);
+function parseCodexSpawnInput(args, extra) {
+  const prompt = typeof args.message === "string" ? args.message : "";
+  const agentType = typeof args.agent_type === "string" ? args.agent_type : void 0;
+  return {
+    ...agentType ? { subagent_type: agentType } : {},
+    description: codexSpawnDescription(extra?.nickname, agentType, prompt),
+    prompt,
+    ...extra?.agentId ? { agent_id: extra.agentId } : {}
+  };
+}
+function codexSpawnDescription(nickname, agentType, prompt) {
+  if (nickname) return agentType ? `${nickname} (${agentType})` : nickname;
+  const firstLine = prompt.split("\n", 1)[0]?.trim() || "";
+  if (firstLine) return firstLine.slice(0, 80);
+  return agentType || "subagent";
+}
+function parseCodexSpawnOutput(output) {
+  try {
+    const parsed = JSON.parse(output);
+    if (typeof parsed?.agent_id !== "string" || !parsed.agent_id) return null;
+    return {
+      agentId: parsed.agent_id,
+      ...typeof parsed.nickname === "string" ? { nickname: parsed.nickname } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function parseCodexAgentsStates(states) {
+  if (!states || typeof states !== "object") return [];
+  return Object.entries(states).flatMap(([agentId, raw]) => {
+    const status = typeof raw?.status === "string" ? raw.status : "";
+    if (!status) return [];
+    return [{
+      agentId,
+      status,
+      message: typeof raw?.message === "string" ? raw.message : "",
+      done: CODEX_AGENT_DONE.has(status)
+    }];
+  });
+}
+function codexAgentResultText(state) {
+  return state.message || `(agent ${state.status})`;
+}
+
+// packages/feature/agent/src/server/engines/codex.ts
 var MEDIA_EXT = {
   "image/png": ".png",
   "image/jpeg": ".jpg",
@@ -18002,170 +17477,532 @@ var MEDIA_EXT = {
   "image/gif": ".gif"
 };
 function writeImagesToTemp(images) {
-  const dir = join5(tmpdir3(), "cockpit-codex-images");
+  const dir = join4(tmpdir2(), "cockpit-codex-images");
   if (!existsSync2(dir)) mkdirSync3(dir, { recursive: true });
   return images.map((img, i) => {
     const ext = MEDIA_EXT[img.media_type] || ".png";
-    const filePath = join5(dir, `img-${Date.now()}-${i}${ext}`);
-    writeFileSync4(filePath, Buffer.from(img.data, "base64"));
+    const filePath = join4(dir, `img-${Date.now()}-${i}${ext}`);
+    writeFileSync3(filePath, Buffer.from(img.data, "base64"));
     return filePath;
   });
 }
-var codexSpec = {
-  name: "codex",
-  // Require a text prompt (codex passes it as the positional arg; an images-only message would
-  // otherwise spawn with an undefined prompt). Matches the original route's 400 guard.
-  async preflight(params) {
-    return typeof params.prompt === "string" && params.prompt.trim() ? { ok: true } : { ok: false, status: 400, error: "codex requires a text prompt" };
-  },
-  runner: {
-    run(ctx) {
-      const { cwd, sessionId } = ctx;
-      const prompt = ctx.prompt;
-      const imageFiles = ctx.images && ctx.images.length > 0 ? writeImagesToTemp(ctx.images) : [];
-      return new Promise((resolve, reject) => {
-        let terminated = false;
-        let failure = null;
-        const cleanup = () => {
-          for (const f of imageFiles) {
-            try {
-              unlinkSync2(f);
-            } catch {
-            }
-          }
-        };
-        const args = ["exec"];
-        if (sessionId) {
-          args.push("resume", sessionId, "--json");
-          for (const imgPath of imageFiles) args.push("--image", imgPath);
-          args.push(prompt);
-        } else {
-          args.push("--json", "--sandbox", "workspace-write", "--skip-git-repo-check");
-          if (cwd) args.push("-C", cwd);
-          for (const imgPath of imageFiles) args.push("--image", imgPath);
-          args.push(prompt);
+function codexToolUseId(item) {
+  return item.call_id || item.id || `tool-${randomUUID3()}`;
+}
+var CODEX_EXEC_FN_NAMES = /* @__PURE__ */ new Set(["exec_command", "shell_command", "local_shell"]);
+function parsePatchFiles(input) {
+  const files = [];
+  const re = /^\*\*\* (?:Add|Update|Delete) File: (.+)$/gm;
+  let m;
+  while (m = re.exec(input)) files.push(m[1].trim());
+  return files;
+}
+function parseCallLines(text, exec2, patch, spawns, mcps) {
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const p = entry.payload;
+    if (!p) continue;
+    if (p.type === "function_call" && p.name && CODEX_EXEC_FN_NAMES.has(p.name)) {
+      let cmd = "";
+      try {
+        cmd = String(JSON.parse(p.arguments || "{}").cmd || "");
+      } catch {
+      }
+      exec2.push({ callId: p.call_id, cmd });
+    } else if (p.type === "custom_tool_call" && p.name === "apply_patch") {
+      patch.push({ callId: p.call_id, files: parsePatchFiles(p.input || "") });
+    } else if (p.type === "function_call" && p.name && p.namespace?.startsWith(CODEX_MCP_NAMESPACE_PREFIX)) {
+      mcps.push({
+        callId: p.call_id,
+        server: p.namespace.slice(CODEX_MCP_NAMESPACE_PREFIX.length),
+        tool: p.name
+      });
+    } else if (p.type === "function_call" && p.name === CODEX_SPAWN_FN_NAME) {
+      let args = {};
+      try {
+        args = JSON.parse(p.arguments || "{}");
+      } catch {
+      }
+      spawns.push({ callId: p.call_id, args });
+    } else if (p.type === "function_call_output" && p.call_id) {
+      const target = spawns.find((s) => s.callId === p.call_id && !s.agentId);
+      if (target) {
+        const parsed = parseCodexSpawnOutput(p.output || "");
+        if (parsed) {
+          target.agentId = parsed.agentId;
+          target.nickname = parsed.nickname;
         }
-        const child = spawn2("codex", args, {
-          stdio: ["ignore", "pipe", "pipe"],
-          cwd: cwd || void 0,
-          env: sanitizedSpawnEnv()
-        });
-        ctx.signal.addEventListener("abort", () => child.kill("SIGTERM"), { once: true });
-        const pendingToolCalls = /* @__PURE__ */ new Map();
-        const rl = createInterface({ input: child.stdout });
-        rl.on("line", (line) => {
-          if (terminated) return;
-          let event;
-          try {
-            event = JSON.parse(line);
-          } catch {
-            return;
-          }
-          switch (event.type) {
-            case "thread.started": {
-              const threadId = event.thread_id || `codex-${randomUUID4()}`;
-              ctx.rekey(threadId);
-              ctx.emit({ type: "system", subtype: "init", session_id: threadId });
-              break;
-            }
-            case "item.completed": {
-              const item = event.item;
-              if (!item) break;
-              if (item.type === "agent_message" && item.text) {
-                ctx.emit({ type: "assistant", message: { content: [{ type: "text", text: item.text }] } });
-              }
-              if (item.type === "error" && (item.message || item.text)) {
-                ctx.emit({ type: "error", error: item.message || item.text });
-              }
-              if (item.type === "reasoning" && item.text) {
-                ctx.emit({
-                  type: "assistant",
-                  message: { content: [{ type: "text", text: `<details><summary>Reasoning</summary>
+      }
+    }
+  }
+}
+function createRolloutCallReader() {
+  let boundPath = null;
+  let offset = 0;
+  let carry = "";
+  let decoder = new StringDecoder("utf8");
+  const exec2 = [];
+  const patch = [];
+  const spawns = [];
+  const mcps = [];
+  const reset = (p) => {
+    boundPath = p;
+    offset = 0;
+    carry = "";
+    decoder = new StringDecoder("utf8");
+    exec2.length = 0;
+    patch.length = 0;
+    spawns.length = 0;
+    mcps.length = 0;
+  };
+  return (rolloutPath) => {
+    if (rolloutPath !== boundPath) reset(rolloutPath);
+    let size = 0;
+    try {
+      size = statSync(rolloutPath).size;
+    } catch {
+      return { exec: exec2, patch, spawn: spawns, mcp: mcps };
+    }
+    if (size < offset) reset(rolloutPath);
+    if (size === offset) return { exec: exec2, patch, spawn: spawns, mcp: mcps };
+    let chunk = "";
+    try {
+      const fd = openSync(rolloutPath, "r");
+      try {
+        const len = size - offset;
+        const buf = Buffer.allocUnsafe(len);
+        const n = readSync(fd, buf, 0, len, offset);
+        chunk = decoder.write(buf.subarray(0, n));
+        offset += n;
+      } finally {
+        closeSync(fd);
+      }
+    } catch {
+      return { exec: exec2, patch, spawn: spawns, mcp: mcps };
+    }
+    const data = carry + chunk;
+    const lastNl = data.lastIndexOf("\n");
+    if (lastNl === -1) {
+      carry = data;
+      return { exec: exec2, patch, spawn: spawns, mcp: mcps };
+    }
+    carry = data.slice(lastNl + 1);
+    parseCallLines(data.slice(0, lastNl), exec2, patch, spawns, mcps);
+    return { exec: exec2, patch, spawn: spawns, mcp: mcps };
+  };
+}
+var basename = (p) => p.replace(/[/\\]+$/, "").split(/[/\\]/).pop() || p;
+function unwrapShellCommand(command) {
+  const m = command.match(/^\/bin\/\S+ -lc (['"])([\s\S]*)\1\s*$/);
+  return m ? m[2] : command;
+}
+function normalizeCmd(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
+var SHELL_WRAPPER_SLACK = 32;
+function resolveCodexCallId(execCalls, index, liveCommand) {
+  const target = execCalls[index];
+  if (!target?.callId) return null;
+  const persisted = normalizeCmd(target.cmd);
+  const live = normalizeCmd(unwrapShellCommand(liveCommand || ""));
+  const liveRaw = normalizeCmd(liveCommand || "");
+  if (!live || live === persisted || persisted.startsWith(live) || live.startsWith(persisted) || !!persisted && liveRaw.includes(persisted) && liveRaw.length - persisted.length <= SHELL_WRAPPER_SLACK) {
+    return target.callId;
+  }
+  return null;
+}
+function resolveCodexPatchCallId(patchCalls, index, changePaths) {
+  const target = patchCalls[index];
+  if (!target?.callId) return null;
+  if (target.files.length === 0 || changePaths.length === 0) return target.callId;
+  const wanted = new Set(target.files.map(basename));
+  if (changePaths.some((p) => wanted.has(basename(p)))) return target.callId;
+  return null;
+}
+function resolveCodexSpawnCall(spawnCalls, index, agentId) {
+  if (agentId) {
+    const exact = spawnCalls.find((s) => s.agentId === agentId);
+    if (exact?.callId) return exact;
+  }
+  const byOrder = spawnCalls[index];
+  return byOrder?.callId ? byOrder : null;
+}
+function resolveCodexMcpCallId(mcpCalls, index, server, tool2) {
+  const target = mcpCalls[index];
+  if (!target?.callId) return null;
+  if (server && tool2 && (target.server !== server || target.tool !== tool2)) return null;
+  return target.callId;
+}
+function createCodexEventAdapter(ctx) {
+  const { sessionId } = ctx;
+  let terminated = false;
+  let failure = null;
+  const pendingToolCalls = /* @__PURE__ */ new Map();
+  let rolloutPath = null;
+  let execBase = 0;
+  let patchBase = 0;
+  let execSeen = 0;
+  let patchSeen = 0;
+  let spawnBase = 0;
+  let spawnSeen = 0;
+  let mcpBase = 0;
+  let mcpSeen = 0;
+  const agentToolUseIds = /* @__PURE__ */ new Map();
+  let codexThreadId = sessionId || null;
+  let rolloutLookups = 0;
+  const MAX_ROLLOUT_LOOKUPS = 8;
+  const resolvedToolUseIds = /* @__PURE__ */ new Map();
+  const readRollout = createRolloutCallReader();
+  if (sessionId) {
+    try {
+      rolloutPath = findCodexSessionPath(sessionId);
+      if (rolloutPath) {
+        const c = readRollout(rolloutPath);
+        execBase = c.exec.length;
+        patchBase = c.patch.length;
+        spawnBase = c.spawn.length;
+        mcpBase = c.mcp.length;
+      }
+    } catch {
+      rolloutPath = null;
+      execBase = 0;
+      patchBase = 0;
+      spawnBase = 0;
+      mcpBase = 0;
+    }
+  }
+  const ensureRolloutPath = () => {
+    if (rolloutPath || !codexThreadId || rolloutLookups >= MAX_ROLLOUT_LOOKUPS) return rolloutPath;
+    rolloutLookups += 1;
+    try {
+      rolloutPath = findCodexSessionPath(codexThreadId);
+    } catch {
+      rolloutPath = null;
+    }
+    return rolloutPath;
+  };
+  const resolveExecToolUseId = (item) => {
+    const key = item.id || item.call_id || `codex-${randomUUID3()}`;
+    const cached2 = resolvedToolUseIds.get(key);
+    if (cached2) return cached2;
+    let toolUseId = codexToolUseId(item);
+    const path = ensureRolloutPath();
+    if (!item.call_id && path) {
+      const callId = resolveCodexCallId(readRollout(path).exec, execBase + execSeen, item.command || "");
+      if (callId) toolUseId = callId;
+    }
+    resolvedToolUseIds.set(key, toolUseId);
+    execSeen += 1;
+    return toolUseId;
+  };
+  const resolvePatchToolUseId = (item) => {
+    const key = item.id || item.call_id || `codex-${randomUUID3()}`;
+    const cached2 = resolvedToolUseIds.get(key);
+    if (cached2) return cached2;
+    let toolUseId = codexToolUseId(item);
+    const path = ensureRolloutPath();
+    if (!item.call_id && path) {
+      const paths = (item.changes || []).map((c) => c.path || "").filter(Boolean);
+      const callId = resolveCodexPatchCallId(readRollout(path).patch, patchBase + patchSeen, paths);
+      if (callId) toolUseId = callId;
+    }
+    resolvedToolUseIds.set(key, toolUseId);
+    patchSeen += 1;
+    return toolUseId;
+  };
+  const patchInput = (item) => ({
+    changes: (item.changes || []).map((c) => ({ path: c.path || "", kind: c.kind || "update" }))
+  });
+  const patchResultText = (item) => {
+    const cs = item.changes || [];
+    if (cs.length === 0) return "apply_patch";
+    return cs.map((c) => `${c.kind || "update"} ${c.path || ""}`.trim()).join("\n");
+  };
+  const emitSpawn = (item) => {
+    const agentIds = item.receiver_thread_ids ?? [];
+    const path = ensureRolloutPath();
+    const entry = path ? resolveCodexSpawnCall(readRollout(path).spawn, spawnBase + spawnSeen, agentIds[0]) : null;
+    spawnSeen += 1;
+    const toolUseId = entry?.callId || codexToolUseId(item);
+    const args = entry?.args && Object.keys(entry.args).length > 0 ? entry.args : { message: item.prompt || "" };
+    const input = parseCodexSpawnInput(args, {
+      nickname: entry?.nickname,
+      agentId: agentIds[0] || entry?.agentId
+    });
+    for (const id of agentIds) agentToolUseIds.set(id, toolUseId);
+    pendingToolCalls.set(toolUseId, toolUseId);
+    ctx.emit({
+      type: "assistant",
+      message: { content: [{ type: "tool_use", id: toolUseId, name: CODEX_TOOL_NAMES.task, input }] }
+    });
+  };
+  const emitAgentReports = (item) => {
+    for (const state of parseCodexAgentsStates(item.agents_states)) {
+      if (!state.done) continue;
+      const toolUseId = agentToolUseIds.get(state.agentId);
+      if (!toolUseId) continue;
+      ctx.emit({
+        type: "user",
+        message: { content: [{ tool_use_id: toolUseId, content: codexAgentResultText(state) }] }
+      });
+      pendingToolCalls.delete(toolUseId);
+      agentToolUseIds.delete(state.agentId);
+    }
+  };
+  const resolveMcpToolUseId = (item) => {
+    const key = item.id || `codex-${randomUUID3()}`;
+    const cached2 = resolvedToolUseIds.get(key);
+    if (cached2) return cached2;
+    let toolUseId = codexToolUseId(item);
+    const path = ensureRolloutPath();
+    if (!item.call_id && path) {
+      const callId = resolveCodexMcpCallId(readRollout(path).mcp, mcpBase + mcpSeen, item.server, item.tool);
+      if (callId) toolUseId = callId;
+    }
+    resolvedToolUseIds.set(key, toolUseId);
+    mcpSeen += 1;
+    return toolUseId;
+  };
+  const emitMcpCall = (item, done) => {
+    const toolUseId = resolveMcpToolUseId(item);
+    const name = codexMcpToolName(item.server || "mcp", item.tool || "tool");
+    if (!pendingToolCalls.has(toolUseId)) {
+      pendingToolCalls.set(toolUseId, toolUseId);
+      ctx.emit({
+        type: "assistant",
+        message: { content: [{ type: "tool_use", id: toolUseId, name, input: item.arguments || {} }] }
+      });
+    }
+    if (!done) return;
+    ctx.emit({
+      type: "user",
+      message: { content: [{ tool_use_id: toolUseId, content: codexMcpResultText(item) || `(${item.status || "completed"})` }] }
+    });
+    pendingToolCalls.delete(toolUseId);
+  };
+  const emitWebSearch = (item) => {
+    const toolUseId = codexToolUseId(item);
+    const { name, input, result } = codexWebSearchCall(item.query, item.action);
+    ctx.emit({
+      type: "assistant",
+      message: { content: [{ type: "tool_use", id: toolUseId, name, input }] }
+    });
+    ctx.emit({ type: "user", message: { content: [{ tool_use_id: toolUseId, content: result }] } });
+  };
+  const emitTodoList = (item) => {
+    const toolUseId = codexToolUseId(item);
+    const input = codexTodoInput(item.items);
+    ctx.emit({
+      type: "assistant",
+      message: { content: [{ type: "tool_use", id: toolUseId, name: CODEX_TOOL_NAMES.todo, input }] }
+    });
+    ctx.emit({
+      type: "user",
+      message: { content: [{ tool_use_id: toolUseId, content: codexTodoResultText(input.todos) }] }
+    });
+  };
+  const handleCollabItem = (item) => {
+    if (item.tool === CODEX_SPAWN_FN_NAME) {
+      emitSpawn(item);
+      return;
+    }
+    emitAgentReports(item);
+  };
+  const handle = (event) => {
+    if (terminated) return;
+    switch (event.type) {
+      case "thread.started": {
+        const threadId = event.thread_id || `codex-${randomUUID3()}`;
+        if (event.thread_id) codexThreadId = event.thread_id;
+        ctx.rekey(threadId);
+        ctx.emit({ type: "system", subtype: "init", session_id: threadId });
+        ensureRolloutPath();
+        break;
+      }
+      case "item.completed": {
+        const item = event.item;
+        if (!item) break;
+        if (item.type === "agent_message" && item.text) {
+          ctx.emit({ type: "assistant", message: { content: [{ type: "text", text: item.text }] } });
+        }
+        if (item.type === "error" && (item.message || item.text)) {
+          ctx.emit({ type: "error", error: item.message || item.text });
+        }
+        if (item.type === "reasoning" && item.text) {
+          ctx.emit({
+            type: "assistant",
+            message: { content: [{ type: "text", text: `<details><summary>Reasoning</summary>
 
 ${item.text}
 
 </details>` }] }
-                });
-              }
-              if (item.type === "command_execution") {
-                const toolUseId = item.id || `tool-${randomUUID4()}`;
-                if (!pendingToolCalls.has(toolUseId)) {
-                  ctx.emit({
-                    type: "assistant",
-                    message: { content: [{ type: "tool_use", id: toolUseId, name: "Bash", input: { command: item.command || "" } }] }
-                  });
-                }
-                ctx.emit({
-                  type: "user",
-                  message: { content: [{ tool_use_id: toolUseId, content: item.aggregated_output || `(exit code: ${item.exit_code ?? "unknown"})` }] }
-                });
-                pendingToolCalls.delete(toolUseId);
-              }
-              break;
-            }
-            case "item.started": {
-              const item = event.item;
-              if (item?.type === "command_execution" && item.command) {
-                const toolUseId = item.id || `tool-${randomUUID4()}`;
-                pendingToolCalls.set(toolUseId, toolUseId);
-                ctx.emit({
-                  type: "assistant",
-                  message: { content: [{ type: "tool_use", id: toolUseId, name: "Bash", input: { command: item.command } }] }
-                });
-              }
-              break;
-            }
-            case "turn.completed": {
-              const usage = event.usage || {};
-              ctx.emit({
-                type: "result",
-                subtype: "success",
-                usage: {
-                  input_tokens: usage.input_tokens || 0,
-                  output_tokens: usage.output_tokens || 0,
-                  cache_creation_input_tokens: 0,
-                  cache_read_input_tokens: usage.cached_input_tokens || 0
-                },
-                total_cost_usd: 0
-              });
-              break;
-            }
-            case "turn.failed": {
-              terminated = true;
-              failure = new Error(event.error?.message || "Codex turn failed");
-              break;
-            }
-            case "error": {
-              terminated = true;
-              failure = new Error(event.message || "Codex error");
-              break;
-            }
+          });
+        }
+        if (item.type === "command_execution") {
+          const toolUseId = resolveExecToolUseId(item);
+          if (!pendingToolCalls.has(toolUseId)) {
+            ctx.emit({
+              type: "assistant",
+              message: { content: [{ type: "tool_use", id: toolUseId, name: CODEX_TOOL_NAMES.bash, input: { command: item.command || "" } }] }
+            });
           }
+          ctx.emit({
+            type: "user",
+            message: { content: [{ tool_use_id: toolUseId, content: item.aggregated_output || `(exit code: ${item.exit_code ?? "unknown"})` }] }
+          });
+          pendingToolCalls.delete(toolUseId);
+        }
+        if (item.type === "collab_tool_call") handleCollabItem(item);
+        if (item.type === "mcp_tool_call") emitMcpCall(item, true);
+        if (item.type === "web_search") emitWebSearch(item);
+        if (item.type === "todo_list") emitTodoList(item);
+        if (item.type === "file_change") {
+          const toolUseId = resolvePatchToolUseId(item);
+          if (!pendingToolCalls.has(toolUseId)) {
+            ctx.emit({
+              type: "assistant",
+              message: { content: [{ type: "tool_use", id: toolUseId, name: CODEX_TOOL_NAMES.applyPatch, input: patchInput(item) }] }
+            });
+          }
+          ctx.emit({
+            type: "user",
+            message: { content: [{ tool_use_id: toolUseId, content: patchResultText(item) }] }
+          });
+          pendingToolCalls.delete(toolUseId);
+        }
+        break;
+      }
+      case "item.started": {
+        const item = event.item;
+        if (item?.type === "mcp_tool_call") emitMcpCall(item, false);
+        if (item?.type === "command_execution" && item.command) {
+          const toolUseId = resolveExecToolUseId(item);
+          pendingToolCalls.set(toolUseId, toolUseId);
+          ctx.emit({
+            type: "assistant",
+            message: { content: [{ type: "tool_use", id: toolUseId, name: CODEX_TOOL_NAMES.bash, input: { command: item.command } }] }
+          });
+        }
+        if (item?.type === "file_change" && (item.changes?.length ?? 0) > 0) {
+          const toolUseId = resolvePatchToolUseId(item);
+          pendingToolCalls.set(toolUseId, toolUseId);
+          ctx.emit({
+            type: "assistant",
+            message: { content: [{ type: "tool_use", id: toolUseId, name: CODEX_TOOL_NAMES.applyPatch, input: patchInput(item) }] }
+          });
+        }
+        break;
+      }
+      case "turn.completed": {
+        const usage = event.usage || {};
+        ctx.emit({
+          type: "result",
+          subtype: "success",
+          usage: {
+            input_tokens: usage.input_tokens || 0,
+            output_tokens: usage.output_tokens || 0,
+            cache_creation_input_tokens: usage.cache_write_input_tokens || 0,
+            cache_read_input_tokens: usage.cached_input_tokens || 0
+          },
+          total_cost_usd: 0
         });
-        let stderrBuf = "";
-        child.stderr?.on("data", (chunk) => {
-          stderrBuf += chunk.toString();
-        });
-        child.on("error", (err) => {
-          cleanup();
-          reject(err);
-        });
-        child.on("close", (code) => {
-          cleanup();
-          if (code !== 0 && stderrBuf.trim()) console.error(`[Codex] exited with code ${code}: ${stderrBuf.trim()}`);
-          if (failure) reject(failure);
-          else resolve();
-        });
-      });
+        break;
+      }
+      case "turn.failed": {
+        terminated = true;
+        failure = new Error(event.error?.message || "Codex turn failed");
+        break;
+      }
+      case "error": {
+        terminated = true;
+        failure = new Error(event.message || "Codex error");
+        break;
+      }
+    }
+  };
+  return {
+    handle,
+    assertSuccess() {
+      if (failure) throw failure;
+    }
+  };
+}
+function cleanupImageFiles(imageFiles) {
+  for (const f of imageFiles) {
+    try {
+      unlinkSync(f);
+    } catch {
+    }
+  }
+}
+function codexSdkInput(prompt, imageFiles) {
+  if (imageFiles.length === 0) return prompt;
+  return [
+    { type: "text", text: prompt || CODEX_IMAGE_ONLY_TEXT },
+    ...imageFiles.map((path) => ({ type: "local_image", path }))
+  ];
+}
+function codexThreadOptions(ctx) {
+  return {
+    ...ctx.params.model ? { model: ctx.params.model } : {},
+    ...ctx.cwd ? { workingDirectory: ctx.cwd } : {},
+    sandboxMode: "danger-full-access",
+    approvalPolicy: "never",
+    skipGitRepoCheck: true
+  };
+}
+async function runCodexSdk(ctx) {
+  const imageFiles = ctx.images && ctx.images.length > 0 ? writeImagesToTemp(ctx.images) : [];
+  const adapter = createCodexEventAdapter(ctx);
+  try {
+    const { Codex } = await import("@openai/codex-sdk");
+    const env = sanitizedSpawnEnv({});
+    let codex;
+    try {
+      codex = new Codex({ env });
+    } catch (error48) {
+      const message = error48 instanceof Error ? error48.message : "";
+      if (!message.includes("Unable to locate Codex CLI binaries")) throw error48;
+      codex = new Codex({ codexPathOverride: "codex", env });
+    }
+    const thread = ctx.sessionId ? codex.resumeThread(ctx.sessionId, codexThreadOptions(ctx)) : codex.startThread(codexThreadOptions(ctx));
+    const { events } = await thread.runStreamed(codexSdkInput(ctx.prompt ?? "", imageFiles), { signal: ctx.signal });
+    for await (const event of events) adapter.handle(event);
+    adapter.assertSuccess();
+  } finally {
+    cleanupImageFiles(imageFiles);
+  }
+}
+var codexSpec = {
+  name: "codex",
+  // No preflight: the orchestrator's own "prompt or images" check is sufficient.
+  runner: {
+    async run(ctx) {
+      if (ctx.params.noHistory !== true || !ctx.sessionId) {
+        await runCodexSdk(ctx);
+        return;
+      }
+      const sessionPath = findCodexSessionPath(ctx.sessionId);
+      const stashed = sessionPath ? stashCodexRollout(sessionPath) : false;
+      try {
+        await runCodexSdk(ctx);
+      } finally {
+        if (stashed && sessionPath) mergeStashedCodexRollout(sessionPath);
+      }
     }
-    // No resolveTitle → teardown 'unread' with undefined title (matches original).
+    // No resolveTitle -> teardown 'unread' with undefined title (matches original).
   }
 };
 
 // packages/feature/agent/src/server/engines/registry.ts
 var SPECS = {
   claude: claudeSpec,
-  claude2: claudeSpec,
   deepseek: deepseekSpec,
   ollama: ollamaSpec,
   kimi: kimiSpec,
@@ -18243,10 +18080,17 @@ var en_default2 = {
     current: "Current"
   },
   htmlApps: {
+    title: "HTML Apps",
     addTooltip: "Add to HTML panel",
     added: "Added to HTML panel",
     alreadyAdded: "Already added",
-    addFailed: "Failed to add"
+    addFailed: "Failed to add",
+    emptyNoApps: "No HTML apps yet.",
+    emptyCreatePrefix: "Use",
+    emptyCreateSuffix: "in chat to create a new app.",
+    addExisting: "add an existing HTML file",
+    viewDocs: "view docs",
+    emptyNoMatch: "No HTML apps match your search."
   },
   skills: {
     addTooltip: "Add to Skills panel",
@@ -18257,8 +18101,11 @@ var en_default2 = {
     searchPlaceholder: "Search skills...",
     clearSearch: "Clear",
     addSkill: "Add Skill",
-    emptyNoSkills: 'No skills yet. Click "Add Skill" to add one.',
+    emptyNoSkills: "No skills yet.",
+    emptyIntroPrefix: "Use",
+    emptyIntroSuffix: "in chat to distil a reusable workflow into a SKILL.md file.",
     emptyNoMatch: "No skills match your search.",
+    viewDocs: "view docs",
     pathLabel: "Absolute path to SKILL.md",
     pathPlaceholder: "/Users/you/.../skills/foo/SKILL.md",
     add: "Add",
@@ -18349,6 +18196,7 @@ var en_default2 = {
     collapseSidebar: "Collapse sidebar",
     notes: "Notes",
     skills: "Skills",
+    apps: "Apps",
     settings: "Settings",
     help: "Help",
     updateAvailable: "v{{version}} available",
@@ -18669,7 +18517,7 @@ var en_default2 = {
     context: "Context",
     output: "Output",
     copiedCommandTooltip: "Copied!",
-    copyCommandTooltip: "Copy command: claude -r {{sessionId}}",
+    copyCommandTooltip: "Copy command: {{command}}",
     executedCommand: "Executed `{{command}}`{{exitInfo}}, output:\n```\n{{output}}\n```",
     executedCommandFailed: "Failed to execute `{{command}}`: {{error}}",
     executionMode: "Execution Mode",
@@ -18685,7 +18533,6 @@ var en_default2 = {
     quotaEmpty: "No quota returned",
     quotaResetAt: "Resets {{time}}",
     openProviderConsole: "Open the provider console",
-    ptyModeHint: "Subscription billing mode: uses interactive claude CLI",
     planMode: "Plan mode",
     planModeDesc: "read-only \xB7 plan first, no edits",
     planModeOn: "Plan mode on \u2014 read-only; send a task to get a plan",
@@ -18694,19 +18541,10 @@ var en_default2 = {
     noHistory: "Independent task",
     noHistoryDesc: "no history sent",
     noHistoryHint: "Independent task: each message is sent to the model on its own, with no prior conversation. The transcript above still records everything.",
-    noHistoryPtyHint: "Not available in PTY mode: the interactive claude CLI holds the conversation itself. Switch to SDK mode to use it.",
     planTitle: "Plan (awaiting your review)",
     approvePlan: "Approve & run",
     planApproveHint: "No approval dialog here \u2014 click to exit plan mode and execute",
-    approvePlanPrompt: "Approved \u2014 proceed with the plan above.",
-    ptyTerminal: "PTY Terminal",
-    ptyRunning: "running",
-    ptyCollapse: "Collapse",
-    ptyExpand: "Expand",
-    ptyStuck: "PTY seems stuck (waiting for a dialog?). Please handle it in the terminal below.",
-    ptyTimedOut: "PTY timed out without manual handling; the turn was terminated.",
-    ptyCrash: "Claude CLI render crash (upstream bug): {{error}}. This session's history may contain edits that fail to render.",
-    ptyQuestionEsc: "AI asked an interactive question, which cannot be answered in this mode; it was auto-cancelled and the turn was ended. See the question in the chat and answer it in your next message."
+    approvePlanPrompt: "Approved \u2014 proceed with the plan above."
   },
   console: {
     enterCommandOrUrl: "Enter a command or URL to start",
@@ -19437,10 +19275,17 @@ var zh_default = {
     current: "\u5F53\u524D"
   },
   htmlApps: {
+    title: "HTML \u5C0F\u5E94\u7528",
     addTooltip: "\u6DFB\u52A0\u5230 HTML \u9762\u677F",
     added: "\u5DF2\u6DFB\u52A0\u5230 HTML \u9762\u677F",
     alreadyAdded: "\u5DF2\u6DFB\u52A0\u8FC7",
-    addFailed: "\u6DFB\u52A0\u5931\u8D25"
+    addFailed: "\u6DFB\u52A0\u5931\u8D25",
+    emptyNoApps: "\u8FD8\u6CA1\u6709 HTML \u5E94\u7528\u3002",
+    emptyCreatePrefix: "\u5728\u804A\u5929\u91CC\u4F7F\u7528",
+    emptyCreateSuffix: "\u521B\u5EFA\u65B0\u5E94\u7528\u3002",
+    addExisting: "\u6DFB\u52A0\u5DF2\u6709 HTML \u6587\u4EF6",
+    viewDocs: "\u67E5\u770B\u6587\u6863",
+    emptyNoMatch: "\u6CA1\u6709\u5339\u914D\u7684 HTML \u5E94\u7528\u3002"
   },
   skills: {
     addTooltip: "\u6DFB\u52A0\u5230 Skills \u9762\u677F",
@@ -19451,8 +19296,11 @@ var zh_default = {
     searchPlaceholder: "\u641C\u7D22 skills...",
     clearSearch: "\u6E05\u9664",
     addSkill: "\u6DFB\u52A0 Skill",
-    emptyNoSkills: "\u8FD8\u6CA1\u6709 skill\uFF0C\u70B9\u51FB\u300C\u6DFB\u52A0 Skill\u300D\u6DFB\u52A0\u4E00\u4E2A\u3002",
+    emptyNoSkills: "\u8FD8\u6CA1\u6709 skill\u3002",
+    emptyIntroPrefix: "\u5728\u804A\u5929\u91CC\u4F7F\u7528",
+    emptyIntroSuffix: "\u628A\u53EF\u590D\u7528\u7ECF\u9A8C\u6574\u7406\u6210 SKILL.md\u3002",
     emptyNoMatch: "\u6CA1\u6709\u5339\u914D\u7684 skill\u3002",
+    viewDocs: "\u67E5\u770B\u6587\u6863",
     pathLabel: "SKILL.md \u7684\u7EDD\u5BF9\u8DEF\u5F84",
     pathPlaceholder: "/Users/you/.../skills/foo/SKILL.md",
     add: "\u6DFB\u52A0",
@@ -19543,6 +19391,7 @@ var zh_default = {
     collapseSidebar: "\u6298\u53E0\u4FA7\u8FB9\u680F",
     notes: "\u7B14\u8BB0",
     skills: "\u6280\u80FD",
+    apps: "\u5E94\u7528",
     settings: "\u8BBE\u7F6E",
     help: "\u5E2E\u52A9",
     updateAvailable: "\u65B0\u7248\u672C v{{version}} \u53EF\u7528",
@@ -19863,7 +19712,7 @@ var zh_default = {
     context: "\u4E0A\u4E0B\u6587",
     output: "\u8F93\u51FA",
     copiedCommandTooltip: "\u5DF2\u590D\u5236!",
-    copyCommandTooltip: "\u590D\u5236\u547D\u4EE4: claude -r {{sessionId}}",
+    copyCommandTooltip: "\u590D\u5236\u547D\u4EE4: {{command}}",
     executedCommand: "\u6267\u884C\u4E86 `{{command}}`{{exitInfo}}\uFF0C\u8F93\u51FA\uFF1A\n```\n{{output}}\n```",
     executedCommandFailed: "\u6267\u884C `{{command}}` \u5931\u8D25\uFF1A{{error}}",
     executionMode: "\u6267\u884C\u6A21\u5F0F",
@@ -19879,7 +19728,6 @@ var zh_default = {
     quotaEmpty: "\u672A\u8FD4\u56DE\u989D\u5EA6\u4FE1\u606F",
     quotaResetAt: "{{time}} \u91CD\u7F6E",
     openProviderConsole: "\u6253\u5F00\u670D\u52A1\u5546\u63A7\u5236\u53F0",
-    ptyModeHint: "\u8BA2\u9605\u8BA1\u8D39\u6A21\u5F0F\uFF1A\u7528\u4EA4\u4E92\u5F0F claude CLI \u9A71\u52A8",
     planMode: "\u8BA1\u5212\u6A21\u5F0F",
     planModeDesc: "\u53EA\u8BFB\xB7\u5148\u51FA\u8BA1\u5212\u4E0D\u6539\u4EE3\u7801",
     planModeOn: "\u5DF2\u5F00\u542F\u8BA1\u5212\u6A21\u5F0F\u2014\u2014\u53EA\u8BFB;\u53D1\u4E00\u4E2A\u4EFB\u52A1\u5373\u53EF\u62FF\u5230\u8BA1\u5212",
@@ -19888,19 +19736,10 @@ var zh_default = {
     noHistory: "\u72EC\u7ACB\u4EFB\u52A1",
     noHistoryDesc: "\u4E0D\u53D1\u9001\u5386\u53F2",
     noHistoryHint: "\u72EC\u7ACB\u4EFB\u52A1\uFF1A\u6BCF\u6761\u6D88\u606F\u5355\u72EC\u53D1\u7ED9\u6A21\u578B\uFF0C\u4E0D\u5E26\u4E4B\u524D\u7684\u5BF9\u8BDD\u3002\u4E0A\u65B9\u7684\u4F1A\u8BDD\u8BB0\u5F55\u7167\u5E38\u4FDD\u7559\u3002",
-    noHistoryPtyHint: "PTY \u6A21\u5F0F\u4E0B\u4E0D\u53EF\u7528\uFF1A\u5BF9\u8BDD\u7531\u4EA4\u4E92\u5F0F claude CLI \u81EA\u5DF1\u6301\u6709\u3002\u5207\u6362\u5230 SDK \u6A21\u5F0F\u5373\u53EF\u4F7F\u7528\u3002",
     planTitle: "\u8BA1\u5212\uFF08\u5F85\u4F60\u786E\u8BA4\uFF09",
     approvePlan: "\u6279\u51C6\u5E76\u6267\u884C",
     planApproveHint: "\u672C\u73AF\u5883\u65E0\u5BA1\u6279\u5F39\u7A97\uFF0C\u70B9\u6B64\u9000\u51FA\u8BA1\u5212\u6A21\u5F0F\u5E76\u6267\u884C",
-    approvePlanPrompt: "\u5DF2\u6279\u51C6\uFF0C\u6309\u4E0A\u8FF0\u8BA1\u5212\u5F00\u59CB\u6267\u884C\u3002",
-    ptyTerminal: "PTY \u7EC8\u7AEF",
-    ptyRunning: "\u8FD0\u884C\u4E2D",
-    ptyCollapse: "\u6536\u8D77",
-    ptyExpand: "\u5C55\u5F00",
-    ptyStuck: "PTY \u4F3C\u4E4E\u5361\u4F4F\uFF08\u53EF\u80FD\u5728\u7B49\u5F85\u5BF9\u8BDD\u6846\u8F93\u5165\uFF09\uFF0C\u8BF7\u5728 PTY \u7EC8\u7AEF\u624B\u52A8\u5904\u7406\u3002",
-    ptyTimedOut: "PTY \u8D85\u65F6\u672A\u4EBA\u5DE5\u5904\u7406\uFF0C\u5DF2\u7ED3\u675F\u8BE5\u56DE\u5408\u3002",
-    ptyCrash: "Claude CLI \u6E32\u67D3\u5D29\u6E83\uFF08\u4E0A\u6E38 bug\uFF09\uFF1A{{error}}\u3002\u8BE5\u4F1A\u8BDD\u5386\u53F2\u53EF\u80FD\u542B\u65E0\u6CD5\u6E32\u67D3\u7684\u7F16\u8F91\u8BB0\u5F55\u3002",
-    ptyQuestionEsc: "AI \u7684\u4EA4\u4E92\u5F0F\u63D0\u95EE\u65E0\u6CD5\u5728\u672C\u6A21\u5F0F\u4E2D\u5E94\u7B54\uFF0C\u5DF2\u81EA\u52A8\u53D6\u6D88\u5E76\u7ED3\u675F\u672C\u8F6E\u3002\u95EE\u9898\u5185\u5BB9\u89C1\u804A\u5929\u533A\uFF0C\u4E0B\u4E00\u6761\u6D88\u606F\u76F4\u63A5\u56DE\u7B54\u5373\u53EF\u3002"
+    approvePlanPrompt: "\u5DF2\u6279\u51C6\uFF0C\u6309\u4E0A\u8FF0\u8BA1\u5212\u5F00\u59CB\u6267\u884C\u3002"
   },
   console: {
     enterCommandOrUrl: "\u8F93\u5165\u547D\u4EE4\u6216\u7F51\u5740\u5F00\u59CB\u4F7F\u7528",
@@ -20653,7 +20492,6 @@ var dispatchEngineMessageEff = (task, engine, startFresh) => Effect_exports.tryP
       ...startFresh ? {} : { sessionId: task.sessionId },
       cwd: task.cwd,
       engine,
-      // selects claude2's CLAUDE_CONFIG_DIR; no-op for the others
       ...task.model && { model: task.model },
       ...builtinLoop && { mode: "builtin" },
       ...noHistory && { noHistory: true }
@@ -20683,9 +20521,8 @@ var dispatchEngineMessageEff = (task, engine, startFresh) => Effect_exports.tryP
     }
     return true;
   },
-  // claude2 shares the 'claude' provider for error classification (same SDK).
   catch: (cause) => new AgentError({
-    provider: engine === "claude2" ? "claude" : engine,
+    provider: engine,
     kind: "unknown",
     cause
   })
@@ -20705,13 +20542,11 @@ function isBuiltinLoopSession(engine, task) {
   return !!resolve && existsSync3(resolve(task.cwd, task.sessionId));
 }
 async function readSessionNoHistory(task, engine, builtinLoop) {
-  const sdkClaude = engine === "claude" || engine === "claude2";
-  if (engine !== "ollama" && !builtinLoop && !sdkClaude) return false;
+  if (engine !== "ollama" && !builtinLoop && engine !== "claude" && engine !== "codex") return false;
   const state = await readJsonFile(getSessionFilePath(task.cwd), {});
   return state.noHistories?.[task.sessionId] === true;
 }
 function sessionPathFor(engine, task) {
-  if (engine === "claude2") return getClaude2SessionPath(task.cwd, task.sessionId);
   if (engine === "ollama") return getOllamaSessionPath(task.cwd, task.sessionId);
   if (isBuiltinLoopSession(engine, task)) return BUILTIN_LOOP_PATHS[engine](task.cwd, task.sessionId);
   const sdkStorePath = SDK_STORE_PATHS[engine];
@@ -20721,7 +20556,7 @@ function sessionPathFor(engine, task) {
 }
 var sendChatMessageEff = (task) => Effect_exports.gen(function* () {
   const engine = task.engine ?? "claude";
-  if (!["claude", "claude2", "ollama", "codex", "kimi", "deepseek", "glm"].includes(engine)) {
+  if (!["claude", "ollama", "codex", "kimi", "deepseek", "glm"].includes(engine)) {
     return yield* Effect_exports.fail(
       new AgentError({
         provider: "claude",
@@ -20733,7 +20568,7 @@ var sendChatMessageEff = (task) => Effect_exports.gen(function* () {
   if (task.taskFile && !existsSync3(task.taskFile)) {
     return yield* Effect_exports.fail(
       new AgentError({
-        provider: engine === "claude2" ? "claude" : engine,
+        provider: engine,
         kind: "unknown",
         cause: new Error(`task file not found: ${task.taskFile} (task ${task.id})`)
       })