@surething/cockpit 1.0.273 → 1.0.274

package/dist/scheduledTasks.mjs

@@ -15,7 +15,7 @@ import {
   stashCodexRollout,
   stashTranscript,
   updateGlobalState
-} from "./chunk-TOA52B2X.mjs";
+} from "./chunk-OFFSCRWY.mjs";
 import {
   AgentError,
   AppRuntime,
@@ -46,7 +46,7 @@ import {
   settlePendingRecord,
   withFileLock,
   writeJsonFile
-} from "./chunk-4EU4KZIO.mjs";
+} from "./chunk-SJ7VM26B.mjs";
 import {
   __export
 } from "./chunk-7P6ASYW6.mjs";
@@ -124,13 +124,13 @@ var forkSnapshot = (effect) => {
     )
   );
 };
-function snapshotOnRunStart(cwd, sessionKey, provider, runId) {
+function snapshotOnRunStart(cwd, sessionKey, provider) {
   if (!cwd) return;
   forkSnapshot(
-    Effect_exports.flatMap(SnapshotService, (svc) => svc.baseline(cwd, sessionKey, provider, runId))
+    Effect_exports.flatMap(SnapshotService, (svc) => svc.baseline(cwd, sessionKey, provider))
   );
 }
-function snapshotOnRunEvent(cwd, sessionKey, provider, event, runId) {
+function snapshotOnRunEvent(cwd, sessionKey, provider, event) {
   if (!cwd) return;
   if (event.type === "assistant") {
     for (const b of contentBlocks(event)) {
@@ -160,7 +160,6 @@ function snapshotOnRunEvent(cwd, sessionKey, provider, event, runId) {
           (svc) => svc.record({
             cwd,
             sessionKey,
-            runId,
             provider,
             toolId,
             toolName: meta3?.name ?? "tool",
@@ -410,7 +409,7 @@ async function dispatchChat(spec, body, request) {
     updateGlobalState(cwd, sessionId, "loading", void 0, promptText, spec.name).catch(() => {
     });
   }
-  snapshotOnRunStart(cwd || "", currentKey, spec.name, runId);
+  snapshotOnRunStart(cwd || "", currentKey, spec.name);
   const ctx = {
     prompt: promptText,
     images,
@@ -421,7 +420,7 @@ async function dispatchChat(spec, body, request) {
     emit(event) {
       if (isClosed) return;
       appendRun(currentKey, event);
-      snapshotOnRunEvent(cwd || "", currentKey, spec.name, event, runId);
+      snapshotOnRunEvent(cwd || "", currentKey, spec.name, event);
     },
     rekey(realSessionId) {
       if (!realSessionId) return;
@@ -2501,8 +2500,8 @@ function emoji() {
 }
 var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
 var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
-var mac = (delimiter) => {
-  const escapedDelim = escapeRegex(delimiter ?? ":");
+var mac = (delimiter2) => {
+  const escapedDelim = escapeRegex(delimiter2 ?? ":");
   return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
 };
 var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
@@ -15426,11 +15425,454 @@ var glmProvider = {
 };
 var glmSpec = makeAnthropicCompatSpec(glmProvider);
 
+// packages/feature/agent/src/server/engines/codexAppServer/client.ts
+import { spawn } from "child_process";
+import { StringDecoder } from "string_decoder";
+
+// packages/feature/agent/src/server/engines/codexAppServer/binary.ts
+import { statSync as statSync2 } from "fs";
+import { join as join5, delimiter } from "path";
+var CODEX_NPM_NAME = "@openai/codex";
+var PLATFORM_PACKAGE_BY_TARGET = {
+  "x86_64-unknown-linux-musl": "@openai/codex-linux-x64",
+  "aarch64-unknown-linux-musl": "@openai/codex-linux-arm64",
+  "x86_64-apple-darwin": "@openai/codex-darwin-x64",
+  "aarch64-apple-darwin": "@openai/codex-darwin-arm64",
+  "x86_64-pc-windows-msvc": "@openai/codex-win32-x64",
+  "aarch64-pc-windows-msvc": "@openai/codex-win32-arm64"
+};
+function codexTargetTriple(platform = process.platform, arch = process.arch) {
+  switch (platform) {
+    // Android ships the musl build, matching the upstream launcher.
+    case "linux":
+    case "android":
+      if (arch === "x64") return "x86_64-unknown-linux-musl";
+      if (arch === "arm64") return "aarch64-unknown-linux-musl";
+      return null;
+    case "darwin":
+      if (arch === "x64") return "x86_64-apple-darwin";
+      if (arch === "arm64") return "aarch64-apple-darwin";
+      return null;
+    case "win32":
+      if (arch === "x64") return "x86_64-pc-windows-msvc";
+      if (arch === "arm64") return "aarch64-pc-windows-msvc";
+      return null;
+    default:
+      return null;
+  }
+}
+var isFile = (p) => {
+  try {
+    return statSync2(p).isFile();
+  } catch {
+    return false;
+  }
+};
+function platformPackageRoots(cockpitRoot, platformPackage) {
+  const parts = platformPackage.split("/");
+  return [
+    join5(cockpitRoot, "node_modules", ...parts),
+    join5(cockpitRoot, "node_modules", CODEX_NPM_NAME, "node_modules", ...parts)
+  ];
+}
+function resolveCodexBinary() {
+  const triple = codexTargetTriple();
+  if (!triple) {
+    throw new Error(`Codex: unsupported platform ${process.platform} (${process.arch})`);
+  }
+  const platformPackage = PLATFORM_PACKAGE_BY_TARGET[triple];
+  const cockpitRoot = process.env.COCKPIT_ROOT || process.cwd();
+  const binaryName = process.platform === "win32" ? "codex.exe" : "codex";
+  for (const packageRootBase of platformPackageRoots(cockpitRoot, platformPackage)) {
+    const packageRoot = join5(packageRootBase, "vendor", triple);
+    const current = join5(packageRoot, "bin", binaryName);
+    if (isFile(current) && isFile(join5(packageRoot, "codex-package.json"))) {
+      return { executablePath: current, pathDirs: existingDirs(join5(packageRoot, "codex-path")) };
+    }
+    const legacy = join5(packageRoot, "codex", binaryName);
+    if (isFile(legacy)) {
+      return { executablePath: legacy, pathDirs: existingDirs(join5(packageRoot, "path")) };
+    }
+  }
+  throw new Error(
+    `Codex: cannot locate ${platformPackage} under ${cockpitRoot}. Reinstall so npm fetches optional dependencies, or run: cockpit update`
+  );
+}
+function existingDirs(...dirs) {
+  return dirs.filter((d) => {
+    try {
+      return statSync2(d).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+}
+function codexPathEnvKey(env, platform = process.platform) {
+  if (platform !== "win32") return "PATH";
+  const matching = Object.keys(env).filter((k) => k.toLowerCase() === "path");
+  if (matching.includes("Path")) return "Path";
+  return matching[matching.length - 1] ?? "PATH";
+}
+function applyCodexPathDirs(env, pathDirs, platform = process.platform) {
+  if (pathDirs.length === 0) return;
+  const key = codexPathEnvKey(env, platform);
+  if (platform === "win32") {
+    for (const k of Object.keys(env)) {
+      if (k.toLowerCase() === "path" && k !== key) delete env[k];
+    }
+  }
+  const existing = (env[key] ?? "").split(delimiter).filter((entry) => entry.length > 0 && !pathDirs.includes(entry));
+  env[key] = [...pathDirs, ...existing].join(delimiter);
+}
+
+// packages/feature/agent/src/server/engines/codexAppServer/client.ts
+var CodexAppServerAborted = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CodexAppServerAborted";
+  }
+};
+var CodexAppServerError = class extends Error {
+  constructor(message, code, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "CodexAppServerError";
+  }
+};
+var CodexAppServerClient = class _CodexAppServerClient {
+  constructor(child, opts) {
+    this.opts = opts;
+    this.pending = /* @__PURE__ */ new Map();
+    this.nextId = 1;
+    this.closed = false;
+    this.exitReason = null;
+    this.child = child;
+    readLines(child.stdout, (line) => this.onLine(line));
+    readLines(child.stderr, (line) => {
+      if (line.trim()) opts.onStderr?.(line);
+    });
+    child.on("error", (err) => this.fail(err));
+    for (const pipe2 of [child.stdin, child.stdout, child.stderr]) {
+      pipe2.on("error", (err) => this.fail(err));
+    }
+    child.on("exit", (code, signal) => {
+      this.fail(
+        new CodexAppServerError(
+          `codex app-server exited (${signal ? `signal ${signal}` : `code ${code ?? "null"}`})`
+        )
+      );
+    });
+  }
+  static start(opts) {
+    const bin = resolveCodexBinary();
+    const env = { ...opts.env };
+    applyCodexPathDirs(env, bin.pathDirs);
+    const child = spawn(bin.executablePath, ["app-server"], {
+      cwd: opts.cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return new _CodexAppServerClient(child, opts);
+  }
+  /**
+   * Settle every in-flight request when the transport dies. Without this a
+   * crashed child leaves the turn awaiting a reply that can never arrive, and
+   * the run hangs rather than reporting an error.
+   */
+  fail(err) {
+    if (this.exitReason) return;
+    this.exitReason = err;
+    for (const [, p] of this.pending) p.reject(err);
+    this.pending.clear();
+    this.opts.onClosed?.(err);
+  }
+  onLine(line) {
+    if (!line.trim()) return;
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      return;
+    }
+    const id = msg.id;
+    if (typeof id === "number" && typeof msg.method === "string") {
+      this.write({ id, error: { code: -32601, message: `Unhandled server request: ${msg.method}` } });
+      return;
+    }
+    if (typeof id === "number") {
+      const p = this.pending.get(id);
+      if (!p) return;
+      this.pending.delete(id);
+      const err = msg.error;
+      if (err) p.reject(new CodexAppServerError(err.message ?? "codex app-server error", err.code, err.data));
+      else p.resolve(msg.result ?? {});
+      return;
+    }
+    if (typeof msg.method === "string") {
+      try {
+        this.opts.onNotification({
+          method: msg.method,
+          params: msg.params ?? {}
+        });
+      } catch (cause) {
+        this.fail(cause instanceof Error ? cause : new CodexAppServerError(String(cause)));
+      }
+    }
+  }
+  write(payload) {
+    if (this.closed) return;
+    this.child.stdin.write(`${JSON.stringify(payload)}
+`);
+  }
+  request(method, params) {
+    if (this.exitReason) return Promise.reject(this.exitReason);
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.write({ id, method, ...params !== void 0 ? { params } : {} });
+    });
+  }
+  notify(method, params) {
+    this.write({ method, ...params !== void 0 ? { params } : {} });
+  }
+  dispose(aborted2 = false) {
+    if (this.closed) return;
+    this.closed = true;
+    this.fail(new CodexAppServerAborted(aborted2 ? "codex run aborted" : "codex app-server client disposed"));
+    killTree(this.child);
+  }
+};
+function readLines(stream, onLine) {
+  const decoder = new StringDecoder("utf8");
+  let carry = "";
+  stream.on("data", (chunk) => {
+    carry += decoder.write(chunk);
+    let index = carry.indexOf("\n");
+    while (index !== -1) {
+      onLine(carry.slice(0, index).replace(/\r$/, ""));
+      carry = carry.slice(index + 1);
+      index = carry.indexOf("\n");
+    }
+  });
+  stream.on("end", () => {
+    carry += decoder.end();
+    if (carry) onLine(carry.replace(/\r$/, ""));
+    carry = "";
+  });
+}
+function killTree(child) {
+  if (child.pid === void 0) return;
+  if (process.platform === "win32") {
+    try {
+      spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" });
+      return;
+    } catch {
+    }
+  }
+  try {
+    child.kill();
+  } catch {
+  }
+}
+
+// packages/feature/agent/src/server/engines/codexAppServer/events.ts
+var camelToSnake = (key) => key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+var OPAQUE_VALUE_KEYS = /* @__PURE__ */ new Set([
+  "arguments",
+  // an MCP tool's own input object
+  "structuredContent",
+  // an MCP tool's own result payload
+  "result",
+  "agentsStates",
+  // keyed by agent thread id
+  "input"
+]);
+function snakeCaseKeys(value) {
+  if (Array.isArray(value)) return value.map(snakeCaseKeys);
+  if (value === null || typeof value !== "object") return value;
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    out[camelToSnake(k)] = OPAQUE_VALUE_KEYS.has(k) ? v : snakeCaseKeys(v);
+  }
+  return out;
+}
+function normalizeItem(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const item = snakeCaseKeys(raw);
+  if (typeof item.type === "string") item.type = camelToSnake(item.type);
+  if (item.type === "collab_agent_tool_call") item.type = "collab_tool_call";
+  if (item.type === "collab_tool_call" && typeof item.tool === "string") {
+    item.tool = camelToSnake(item.tool);
+  }
+  if (item.type === "file_change" && Array.isArray(item.changes)) {
+    item.changes = item.changes.map((change) => {
+      const kind = change.kind;
+      if (kind && typeof kind === "object" && typeof kind.type === "string") {
+        return { ...change, kind: kind.type };
+      }
+      return change;
+    });
+  }
+  return item;
+}
+var CodexEventShim = class {
+  constructor() {
+    this.threadId = null;
+    this.planSeq = 0;
+    /**
+     * Turns in flight, by thread. Recorded for EVERY thread including the
+     * sub-agents this shim otherwise filters out, because interrupting a run
+     * needs their ids: a parent's `turn/interrupt` does not cascade — measured,
+     * the children kept working for the twelve seconds the probe watched.
+     */
+    this.liveTurns = /* @__PURE__ */ new Map();
+  }
+  /** The turn this connection started. Its own `turn/started` arrives too, but
+   *  a stop must work even if it has not yet. */
+  noteOwnTurn(threadId, turnId) {
+    this.liveTurns.set(threadId, turnId);
+  }
+  /** Threads with a turn in flight, children first: a parent interrupted while
+   *  its children still run leaves them orphaned. */
+  activeTurns() {
+    const out = [];
+    for (const [threadId, turnId] of this.liveTurns) {
+      if (threadId !== this.threadId) out.push({ threadId, turnId });
+    }
+    const own = this.threadId && this.liveTurns.get(this.threadId);
+    if (this.threadId && own) out.push({ threadId: this.threadId, turnId: own });
+    return out;
+  }
+  /**
+   * Name the thread this turn belongs to. Everything from any other thread is
+   * dropped — see `handle`.
+   */
+  bindThread(threadId) {
+    this.threadId = threadId;
+  }
+  handle(n) {
+    const from = n.params.threadId;
+    if (typeof from === "string") {
+      if (n.method === "turn/started") {
+        const turnId = n.params.turn?.id;
+        if (turnId) this.liveTurns.set(from, turnId);
+      } else if (n.method === "turn/completed") {
+        this.liveTurns.delete(from);
+      }
+    }
+    if (this.threadId !== null && typeof from === "string" && from !== this.threadId) return [];
+    switch (n.method) {
+      case "item/agentMessage/delta": {
+        const text = typeof n.params.delta === "string" ? n.params.delta : "";
+        return text ? [{ kind: "text-delta", text }] : [];
+      }
+      case "item/started":
+      case "item/completed": {
+        const item = normalizeItem(n.params.item);
+        if (!item) return [];
+        if (item.type === "user_message") return [];
+        if (item.type === "agent_message") return [];
+        return [
+          {
+            kind: "event",
+            event: {
+              type: n.method === "item/started" ? "item.started" : "item.completed",
+              ...typeof n.params.threadId === "string" ? { thread_id: n.params.threadId } : {},
+              item
+            }
+          }
+        ];
+      }
+      /**
+       * The plan. There is no `todoList` item type in this protocol — the
+       * bubble the adapter still knows how to draw is fed by a notification
+       * instead, so without this a Codex turn simply loses its todo list.
+       *
+       * A fresh id per update mirrors what the exec transport did (one item per
+       * plan revision, one bubble each) rather than inventing an update-in-place
+       * the renderer has no path for.
+       */
+      case "turn/plan/updated": {
+        const plan = n.params.plan;
+        if (!plan?.length) return [];
+        this.planSeq += 1;
+        const turnId = typeof n.params.turnId === "string" ? n.params.turnId : "turn";
+        return [
+          {
+            kind: "event",
+            event: {
+              type: "item.completed",
+              item: {
+                type: "todo_list",
+                id: `plan-${turnId}-${this.planSeq}`,
+                // Three states, carried through: the checklist renders
+                // in-progress differently from not-yet-started.
+                items: plan.map((s) => ({
+                  text: s.step ?? "",
+                  status: camelToSnake(s.status ?? "pending")
+                }))
+              }
+            }
+          }
+        ];
+      }
+      case "thread/tokenUsage/updated": {
+        const usage = n.params.tokenUsage?.total;
+        if (usage) {
+          this.lastUsage = {
+            input_tokens: usage.inputTokens ?? 0,
+            output_tokens: usage.outputTokens ?? 0,
+            cached_input_tokens: usage.cachedInputTokens ?? 0,
+            cache_write_input_tokens: usage.cacheWriteInputTokens ?? 0
+          };
+        }
+        return [];
+      }
+      /**
+       * There is no `turn/failed` notification — the protocol has exactly one
+       * terminal, and failure rides on it as `turn.status`. Reading only the
+       * method name (as this did) reports a failed or interrupted turn as a
+       * clean success: the run ends, the spinner stops, and nothing anywhere
+       * says why.
+       */
+      case "turn/completed": {
+        const turn = n.params.turn;
+        const status = turn?.status;
+        if (status === "failed") {
+          const detail = turn?.error?.additionalDetails;
+          const message = [turn?.error?.message, detail].filter(Boolean).join(" \u2014 ") || "Codex turn failed";
+          return [{ kind: "event", event: { type: "turn.failed", error: { message } } }];
+        }
+        return [{ kind: "event", event: { type: "turn.completed", ...this.lastUsage ? { usage: this.lastUsage } : {} } }];
+      }
+      /**
+       * `{ error: { message, additionalDetails }, willRetry }` — the message is
+       * NESTED, and reading a top-level `message` (as this did) always fell
+       * through to a generic string.
+       *
+       * `willRetry` is the load-bearing half: the server is about to try again,
+       * so surfacing this as an error would both lie to the user and — because
+       * the adapter latches `terminated` on an error — go deaf to the retry's
+       * events, leaving the turn to hang until it is aborted by hand.
+       */
+      case "error": {
+        if (n.params.willRetry === true) return [];
+        const error48 = n.params.error;
+        const message = [error48?.message, error48?.additionalDetails].filter(Boolean).join(" \u2014 ") || "Codex error";
+        return [{ kind: "event", event: { type: "error", message } }];
+      }
+      default:
+        return [];
+    }
+  }
+};
+
 // packages/feature/agent/src/server/engines/codex.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { writeFileSync as writeFileSync3, unlinkSync, mkdirSync as mkdirSync3, existsSync as existsSync2, statSync as statSync2, openSync, readSync, closeSync } from "fs";
-import { StringDecoder } from "string_decoder";
-import { join as join5 } from "path";
+import { writeFileSync as writeFileSync3, unlinkSync, mkdirSync as mkdirSync3, existsSync as existsSync2, statSync as statSync3, openSync, readSync, closeSync } from "fs";
+import { StringDecoder as StringDecoder2 } from "string_decoder";
+import { join as join6 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 
 // packages/feature/agent/src/server/api/session/codexTools.ts
@@ -15445,7 +15887,9 @@ var CODEX_TOOL_NAMES = {
   /** `update_plan` / live `todo_list` → the checklist MessageBubble already renders. */
   todo: "TodoWrite",
   webSearch: "WebSearch",
-  webFetch: "WebFetch"
+  webFetch: "WebFetch",
+  /** `image_generation` writes a file, so it reads as a Write in the timeline. */
+  imageGeneration: "Write"
 };
 var CODEX_MCP_NAMESPACE_PREFIX = "mcp__";
 var codexMcpToolName = (server, tool2) => `${CODEX_MCP_NAMESPACE_PREFIX}${server}__${tool2}`;
@@ -15453,12 +15897,10 @@ var CODEX_SPAWN_FN_NAME = "spawn_agent";
 var CODEX_SUB_AGENT_ACTIVITY_TYPE = "sub_agent_activity";
 var CODEX_SUB_AGENT_ACTIVITY_ITEM_TYPE = "SubAgentActivity";
 var CODEX_AGENT_MESSAGE_TYPE = "agent_message";
-var CODEX_PATCH_FN_NAME = "apply_patch";
-var CODEX_EXEC_SCRIPT_FN_NAME = "exec";
 function codexTodoInput(items) {
   return {
     todos: (items ?? []).flatMap(
-      (i) => typeof i?.text === "string" ? [{ content: i.text, status: i.completed ? "completed" : "pending" }] : []
+      (i) => typeof i?.text === "string" ? [{ content: i.text, status: i.status || (i.completed ? "completed" : "pending") }] : []
     )
   };
 }
@@ -15475,196 +15917,32 @@ function codexWebSearchCall(query2, action) {
   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.
+    /**
+     * The queries, not the hits — deliberately.
+     *
+     * A web_search item does carry `results`, but the protocol types it as
+     * `Array<Unknown>` and says why: "These stay as opaque JSON at the
+     * extension/app-server boundary so new result fields and result types can
+     * pass through without a Codex release." Rendering it would mean inventing
+     * a shape upstream has explicitly refused to fix, and finding out it moved
+     * the way every other spelling mismatch here has been found — by a bubble
+     * silently going blank.
+     *
+     * Showing the queries beats an empty result, which reads as 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 JS_STRING_LITERAL_RE = /"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`/g;
-var JS_SIMPLE_ESCAPES = {
-  n: "\n",
-  r: "\r",
-  t: "	",
-  b: "\b",
-  f: "\f",
-  v: "\v",
-  "0": "\0"
-};
-function decodeJsStringLiteral(literal2) {
-  if (literal2.startsWith('"')) {
-    try {
-      return JSON.parse(literal2);
-    } catch {
-    }
+  if (typeof item.result === "string") return item.result;
+  const content = item.result.content;
+  if (Array.isArray(content)) {
+    const text = content.filter((b) => !!b && typeof b === "object").filter((b) => typeof b.text === "string").map((b) => b.text).join("");
+    if (text) return text;
   }
-  return literal2.slice(1, -1).replace(
-    /\\(u\{[0-9a-fA-F]+\}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}|[\s\S])/g,
-    (_full, esc2) => {
-      if (esc2.startsWith("u{")) return String.fromCodePoint(parseInt(esc2.slice(2, -1), 16));
-      if (esc2.startsWith("u") || esc2.startsWith("x")) return String.fromCharCode(parseInt(esc2.slice(1), 16));
-      return JS_SIMPLE_ESCAPES[esc2] ?? esc2;
-    }
-  );
-}
-function extractPatchLiteral(script) {
-  JS_STRING_LITERAL_RE.lastIndex = 0;
-  let m;
-  while (m = JS_STRING_LITERAL_RE.exec(script)) {
-    const value = decodeJsStringLiteral(m[0]);
-    if (value.includes("*** Begin Patch")) return value;
-  }
-  return null;
-}
-var JS_IDENT_RE = /^[A-Za-z_$][A-Za-z0-9_$]*/;
-var JS_SCALAR_RE = /^(-?\d[\d_]*(?:\.\d*)?(?:[eE][+-]?\d+)?|true|false|null|undefined)/;
-var skipJsWs = (c) => {
-  while (c.i < c.s.length && /\s/.test(c.s[c.i])) c.i++;
-};
-function readJsString(c) {
-  const q = c.s[c.i];
-  if (q !== '"' && q !== "'" && q !== "`") return null;
-  const start = c.i;
-  c.i++;
-  while (c.i < c.s.length) {
-    const ch = c.s[c.i];
-    if (ch === "\\") {
-      c.i += 2;
-      continue;
-    }
-    if (ch === q) {
-      c.i++;
-      return decodeJsStringLiteral(c.s.slice(start, c.i));
-    }
-    c.i++;
-  }
-  return null;
-}
-function readJsValue(c) {
-  skipJsWs(c);
-  const ch = c.s[c.i];
-  if (ch === void 0) return null;
-  if (ch === '"' || ch === "'" || ch === "`") {
-    const str = readJsString(c);
-    return str === null ? null : { v: str };
-  }
-  if (ch === "{") return readJsObject(c);
-  if (ch === "[") return readJsArray(c);
-  const m = JS_SCALAR_RE.exec(c.s.slice(c.i));
-  if (!m) return null;
-  c.i += m[0].length;
-  const raw = m[0];
-  if (raw === "true") return { v: true };
-  if (raw === "false") return { v: false };
-  if (raw === "null" || raw === "undefined") return { v: null };
-  const n = Number(raw.replace(/_/g, ""));
-  return Number.isNaN(n) ? null : { v: n };
-}
-function readJsArray(c) {
-  if (c.s[c.i] !== "[") return null;
-  c.i++;
-  const out = [];
-  for (; ; ) {
-    skipJsWs(c);
-    if (c.s[c.i] === "]") {
-      c.i++;
-      return { v: out };
-    }
-    if (c.i >= c.s.length) return null;
-    const item = readJsValue(c);
-    if (!item) return null;
-    out.push(item.v);
-    skipJsWs(c);
-    if (c.s[c.i] === ",") {
-      c.i++;
-      continue;
-    }
-    if (c.s[c.i] === "]") {
-      c.i++;
-      return { v: out };
-    }
-    return null;
-  }
-}
-function readJsObject(c) {
-  if (c.s[c.i] !== "{") return null;
-  c.i++;
-  const out = {};
-  for (; ; ) {
-    skipJsWs(c);
-    if (c.s[c.i] === "}") {
-      c.i++;
-      return { v: out };
-    }
-    if (c.i >= c.s.length) return null;
-    let key = null;
-    const ch = c.s[c.i];
-    if (ch === '"' || ch === "'" || ch === "`") {
-      key = readJsString(c);
-    } else {
-      const m = JS_IDENT_RE.exec(c.s.slice(c.i));
-      if (m) {
-        key = m[0];
-        c.i += m[0].length;
-      }
-    }
-    if (key === null) return null;
-    skipJsWs(c);
-    if (c.s[c.i] !== ":") return null;
-    c.i++;
-    const val = readJsValue(c);
-    if (!val) return null;
-    out[key] = val.v;
-    skipJsWs(c);
-    if (c.s[c.i] === ",") {
-      c.i++;
-      continue;
-    }
-    if (c.s[c.i] === "}") {
-      c.i++;
-      return { v: out };
-    }
-    return null;
-  }
-}
-function readToolArgsAt(script, from) {
-  const open = script.indexOf("{", from);
-  if (open === -1) return null;
-  const read = readJsObject({ s: script, i: open });
-  if (!read || !read.v || typeof read.v !== "object") return null;
-  return read.v;
-}
-function extractExecArgs(script) {
-  const call = script.indexOf("tools.exec_command(");
-  if (call === -1) return null;
-  return readToolArgsAt(script, call);
-}
-var TOOL_CALL_RE = /tools\.([A-Za-z_$][A-Za-z0-9_$]*)\s*\(/g;
-function extractOtherToolCall(script) {
-  TOOL_CALL_RE.lastIndex = 0;
-  let m;
-  while (m = TOOL_CALL_RE.exec(script)) {
-    const tool2 = m[1];
-    if (tool2 === "exec_command" || tool2 === "apply_patch") continue;
-    const args = readToolArgsAt(script, m.index);
-    if (args) return { tool: tool2, args };
-  }
-  return null;
-}
-function parseCodexExecScript(script) {
-  const patch = extractPatchLiteral(script);
-  if (patch) return { kind: "patch", patch };
-  const args = extractExecArgs(script);
-  if (args) {
-    return { kind: "exec", command: typeof args.cmd === "string" ? args.cmd : "", args };
-  }
-  const other = extractOtherToolCall(script);
-  if (other) return { kind: "other", tool: other.tool, args: other.args };
-  return { kind: "unknown" };
+  return JSON.stringify(item.result, null, 2);
 }
 var CODEX_AGENT_DONE = /* @__PURE__ */ new Set(["completed", "errored", "interrupted", "not_found", "failed"]);
 function parseCodexSpawnInput(args, extra) {
@@ -15755,6 +16033,110 @@ function parseCodexAgentsStates(states) {
 function codexAgentResultText(state) {
   return state.message || `(agent ${state.status})`;
 }
+function codexItemToolUseId(item) {
+  return item.call_id || item.id || "";
+}
+function codexItemKind(type) {
+  if (!type) return "";
+  return type.replace(/^([A-Z])/, (c) => c.toLowerCase()).replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+function codexCommandText(command) {
+  if (typeof command === "string") return command;
+  if (!Array.isArray(command)) return "";
+  return command.map((a) => {
+    const arg = String(a);
+    return /[\s"'$`\\|&;<>()]/.test(arg) ? `'${arg.replace(/'/g, `'\\''`)}'` : arg;
+  }).join(" ");
+}
+var patchChanges = (item) => {
+  const raw = item.changes;
+  if (!raw) return [];
+  const kindOf = (v) => {
+    if (typeof v === "string") return v;
+    const o = v;
+    const tag = (o?.kind && typeof o.kind === "object" ? o.kind.type : o?.kind) ?? o?.type;
+    return typeof tag === "string" ? tag : "update";
+  };
+  if (Array.isArray(raw)) {
+    return raw.map((c) => ({ path: c?.path || "", kind: kindOf(c) }));
+  }
+  return Object.entries(raw).map(([path, v]) => ({ path, kind: kindOf(v) }));
+};
+var patchResultText = (item) => {
+  const cs = patchChanges(item);
+  if (cs.length === 0) return "apply_patch";
+  return cs.map((c) => `${c.kind} ${c.path}`.trim()).join("\n");
+};
+function codexItemBubble(item) {
+  const id = codexItemToolUseId(item);
+  if (!id) return null;
+  switch (codexItemKind(item.type)) {
+    case "command_execution":
+      return {
+        id,
+        name: CODEX_TOOL_NAMES.bash,
+        input: { command: codexCommandText(item.command) },
+        // An empty result spins forever in the UI, so a bare exit code stands
+        // in for a command that printed nothing.
+        result: item.aggregated_output || `(exit code: ${item.exit_code ?? "unknown"})`
+      };
+    case "file_change":
+      return {
+        id,
+        name: CODEX_TOOL_NAMES.applyPatch,
+        input: { changes: patchChanges(item) },
+        result: patchResultText(item)
+      };
+    case "mcp_tool_call":
+      return {
+        id,
+        name: codexMcpToolName(item.server || "mcp", item.tool || "tool"),
+        input: item.arguments || {},
+        result: codexMcpResultText(item) || `(${item.status || "completed"})`
+      };
+    case "web_search": {
+      const { name, input, result } = codexWebSearchCall(item.query, item.action);
+      return { id, name, input, result };
+    }
+    case "todo_list": {
+      const input = codexTodoInput(item.items);
+      return { id, name: CODEX_TOOL_NAMES.todo, input, result: codexTodoResultText(input.todos) };
+    }
+    // Reading an image back. The result is deliberately the placeholder and not
+    // the image: inlining a screenshot's data URL used to push ~600KB of base64
+    // through the API, React state and the DOM for one bubble.
+    case "image_view":
+      return {
+        id,
+        name: CODEX_TOOL_NAMES.read,
+        input: { file_path: item.path || "" },
+        result: CODEX_IMAGE_ONLY_TEXT
+      };
+    /**
+     * Generating an image. It writes a file, so it belongs in the timeline like
+     * any other write — it was grouped with `sleep` and the review-mode markers
+     * by mistake, which left a generated image invisible on both sides.
+     */
+    case "image_generation":
+      return {
+        id,
+        name: CODEX_TOOL_NAMES.imageGeneration,
+        input: { file_path: item.savedPath || "", ...item.revisedPrompt ? { prompt: item.revisedPrompt } : {} },
+        result: item.savedPath || `(${item.status || "completed"})`
+      };
+    // A tool reached through codex's dynamic namespace rather than a fixed one.
+    // Named like an MCP call because that is what it is from the reader's side.
+    case "dynamic_tool_call":
+      return {
+        id,
+        name: codexMcpToolName(item.namespace || "tool", item.tool || "call"),
+        input: item.arguments || {},
+        result: codexMcpResultText(item) || `(${item.status || "completed"})`
+      };
+    default:
+      return null;
+  }
+}
 
 // packages/feature/agent/src/server/engines/codex.ts
 var MEDIA_EXT = {
@@ -15764,11 +16146,11 @@ var MEDIA_EXT = {
   "image/gif": ".gif"
 };
 function writeImagesToTemp(images) {
-  const dir = join5(tmpdir2(), "cockpit-codex-images");
+  const dir = join6(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}`);
+    const filePath = join6(dir, `img-${Date.now()}-${i}${ext}`);
     writeFileSync3(filePath, Buffer.from(img.data, "base64"));
     return filePath;
   });
@@ -15776,15 +16158,7 @@ function writeImagesToTemp(images) {
 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, reports) {
+function parseCallLines(text, spawns, reports) {
   for (const line of text.split("\n")) {
     if (!line.trim()) continue;
     let entry;
@@ -15795,26 +16169,7 @@ function parseCallLines(text, exec2, patch, spawns, mcps, reports) {
     }
     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 === CODEX_PATCH_FN_NAME) {
-      patch.push({ callId: p.call_id, files: parsePatchFiles(p.input || "") });
-    } else if (p.type === "custom_tool_call" && p.name === CODEX_EXEC_SCRIPT_FN_NAME) {
-      const script = parseCodexExecScript(p.input || "");
-      if (script.kind === "exec") exec2.push({ callId: p.call_id, cmd: script.command });
-      else if (script.kind === "patch") patch.push({ callId: p.call_id, files: parsePatchFiles(script.patch) });
-    } 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) {
+    if (p.type === "function_call" && p.name === CODEX_SPAWN_FN_NAME) {
       let args = {};
       try {
         args = JSON.parse(p.arguments || "{}");
@@ -15849,29 +16204,23 @@ function createRolloutCallReader() {
   let boundPath = null;
   let offset = 0;
   let carry = "";
-  let decoder = new StringDecoder("utf8");
-  const exec2 = [];
-  const patch = [];
+  let decoder = new StringDecoder2("utf8");
   const spawns = [];
-  const mcps = [];
   const reports = [];
-  const snapshot = () => ({ exec: exec2, patch, spawn: spawns, mcp: mcps, reports });
+  const snapshot = () => ({ spawn: spawns, reports });
   const reset = (p) => {
     boundPath = p;
     offset = 0;
     carry = "";
-    decoder = new StringDecoder("utf8");
-    exec2.length = 0;
-    patch.length = 0;
+    decoder = new StringDecoder2("utf8");
     spawns.length = 0;
-    mcps.length = 0;
     reports.length = 0;
   };
   return (rolloutPath) => {
     if (rolloutPath !== boundPath) reset(rolloutPath);
     let size = 0;
     try {
-      size = statSync2(rolloutPath).size;
+      size = statSync3(rolloutPath).size;
     } catch {
       return snapshot();
     }
@@ -15899,38 +16248,10 @@ function createRolloutCallReader() {
       return snapshot();
     }
     carry = data.slice(lastNl + 1);
-    parseCallLines(data.slice(0, lastNl), exec2, patch, spawns, mcps, reports);
+    parseCallLines(data.slice(0, lastNl), spawns, reports);
     return snapshot();
   };
 }
-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);
@@ -15939,12 +16260,6 @@ function resolveCodexSpawnCall(spawnCalls, index, agentId) {
   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;
@@ -15953,30 +16268,17 @@ function createCodexEventAdapter(ctx) {
   const pendingToolCalls = /* @__PURE__ */ new Map();
   const progressItems = /* @__PURE__ */ new Set();
   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;
   let reportBase = 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();
   let basesReady = false;
   const initBases = () => {
     if (basesReady || !rolloutPath) return;
     basesReady = true;
     const c = readRollout(rolloutPath);
-    execBase = c.exec.length;
-    patchBase = c.patch.length;
     spawnBase = c.spawn.length;
-    mcpBase = c.mcp.length;
     reportBase = c.reports.length;
   };
   if (sessionId) {
@@ -15987,53 +16289,13 @@ function createCodexEventAdapter(ctx) {
       rolloutPath = null;
     }
   }
-  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 bindRollout = (path) => {
+    if (!path || path === rolloutPath) return;
+    rolloutPath = path;
+    basesReady = false;
+    initBases();
   };
+  const toolUseIdFor = codexToolUseId;
   const spawnEmitted = /* @__PURE__ */ new Set();
   const agentPathToolUseIds = /* @__PURE__ */ new Map();
   const emitSpawnBubble = (toolUseId, input, agentPath) => {
@@ -16047,10 +16309,10 @@ function createCodexEventAdapter(ctx) {
   };
   const emitSpawn = (item) => {
     const agentIds = item.receiver_thread_ids ?? [];
-    const path = ensureRolloutPath();
+    const path = rolloutPath;
     const entry = path ? resolveCodexSpawnCall(readRollout(path).spawn, spawnBase + spawnSeen, agentIds[0]) : null;
     spawnSeen += 1;
-    const toolUseId = entry?.callId || codexToolUseId(item);
+    const toolUseId = toolUseIdFor(item);
     if (spawnEmitted.has(toolUseId)) return;
     const args = entry?.args && Object.keys(entry.args).length > 0 ? entry.args : { message: item.prompt || "" };
     const input = parseCodexSpawnInput(args, {
@@ -16061,11 +16323,11 @@ function createCodexEventAdapter(ctx) {
     emitSpawnBubble(toolUseId, input, entry?.agentPath);
   };
   const syncSubAgents = (flushPending = false) => {
-    const path = ensureRolloutPath();
+    const path = rolloutPath;
     if (!path) return;
-    const { spawn, reports } = readRollout(path);
-    for (let i = spawnBase; i < spawn.length; i += 1) {
-      const s = spawn[i];
+    const { spawn: spawn2, reports } = readRollout(path);
+    for (let i = spawnBase; i < spawn2.length; i += 1) {
+      const s = spawn2[i];
       if (!s.callId || spawnEmitted.has(s.callId)) continue;
       if (!s.agentId && !flushPending) continue;
       emitSpawnBubble(
@@ -16096,58 +16358,6 @@ function createCodexEventAdapter(ctx) {
       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);
@@ -16169,24 +16379,13 @@ function createCodexEventAdapter(ctx) {
     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();
-        if (sessionId) initBases();
         break;
       }
       case "item.completed": {
         const item = event.item;
         if (!item) break;
-        if (item.type === "agent_message" && item.text) {
-          emitOutputProgress(item.text);
-          ctx.emit({ type: "assistant", message: { content: [{ type: "text", text: item.text }] } });
-        }
-        if (item.type === "error" && (item.message || item.text)) {
-          emitOutputProgress(item.message || item.text || "");
-          ctx.emit({ type: "error", error: item.message || item.text });
-        }
         if (item.type === "reasoning" && item.text) {
           emitOutputProgress(item.text);
           ctx.emit({
@@ -16198,73 +16397,37 @@ ${item.text}
 </details>` }] }
           });
         }
-        if (item.type === "command_execution") {
-          const toolUseId = resolveExecToolUseId(item);
-          if (!pendingToolCalls.has(toolUseId)) {
-            emitOutputProgress(item.command || CODEX_TOOL_NAMES.bash, `command-start:${toolUseId}`);
+        const bubble = codexItemBubble(item);
+        if (bubble) {
+          if (!pendingToolCalls.has(bubble.id)) {
+            emitOutputProgress(bubble.input.command || bubble.name, `tool-start:${bubble.id}`);
             ctx.emit({
               type: "assistant",
-              message: { content: [{ type: "tool_use", id: toolUseId, name: CODEX_TOOL_NAMES.bash, input: { command: item.command || "" } }] }
+              message: { content: [{ type: "tool_use", id: bubble.id, name: bubble.name, input: bubble.input }] }
             });
           }
-          emitOutputProgress(item.aggregated_output || `(exit code: ${item.exit_code ?? "unknown"})`, `command-result:${toolUseId}`);
+          emitOutputProgress(bubble.result, `tool-result:${bubble.id}`);
           ctx.emit({
             type: "user",
-            message: { content: [{ tool_use_id: toolUseId, content: item.aggregated_output || `(exit code: ${item.exit_code ?? "unknown"})` }] }
+            message: { content: [{ tool_use_id: bubble.id, content: bubble.result }] }
           });
-          pendingToolCalls.delete(toolUseId);
+          pendingToolCalls.delete(bubble.id);
         }
         if (item.type === "collab_tool_call") handleCollabItem(item);
-        if (item.type === "mcp_tool_call") {
-          emitOutputProgress(`${item.server || "mcp"} ${item.tool || ""} ${JSON.stringify(item.result ?? item.error ?? "")}`);
-          emitMcpCall(item, true);
-        }
-        if (item.type === "web_search") {
-          emitOutputProgress(JSON.stringify(item.action || item.query || "web_search"));
-          emitWebSearch(item);
-        }
-        if (item.type === "todo_list") {
-          emitOutputProgress(JSON.stringify(item.items || []));
-          emitTodoList(item);
-        }
-        if (item.type === "file_change") {
-          const toolUseId = resolvePatchToolUseId(item);
-          if (!pendingToolCalls.has(toolUseId)) {
-            emitOutputProgress(patchResultText(item), `patch-start:${toolUseId}`);
-            ctx.emit({
-              type: "assistant",
-              message: { content: [{ type: "tool_use", id: toolUseId, name: CODEX_TOOL_NAMES.applyPatch, input: patchInput(item) }] }
-            });
-          }
-          emitOutputProgress(patchResultText(item), `patch-result:${toolUseId}`);
-          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);
-          emitOutputProgress(item.command, `command-start:${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);
-          emitOutputProgress(patchResultText(item), `patch-start:${toolUseId}`);
-          ctx.emit({
-            type: "assistant",
-            message: { content: [{ type: "tool_use", id: toolUseId, name: CODEX_TOOL_NAMES.applyPatch, input: patchInput(item) }] }
-          });
+        if (item) {
+          const started = codexItemBubble(item);
+          if (started && !pendingToolCalls.has(started.id)) {
+            pendingToolCalls.set(started.id, started.id);
+            emitOutputProgress(started.input.command || started.name, `tool-start:${started.id}`);
+            ctx.emit({
+              type: "assistant",
+              message: { content: [{ type: "tool_use", id: started.id, name: started.name, input: started.input }] }
+            });
+          }
         }
         break;
       }
@@ -16298,6 +16461,11 @@ ${item.text}
   };
   return {
     handle,
+    bindRollout,
+    noteAssistantText(text) {
+      if (terminated) return;
+      emitOutputProgress(text);
+    },
     assertSuccess() {
       if (failure) throw failure;
     }
@@ -16311,22 +16479,20 @@ function cleanupImageFiles(imageFiles) {
     }
   }
 }
-function codexSdkInput(prompt, imageFiles) {
-  if (imageFiles.length === 0) return prompt;
+function codexTurnInput(prompt, imageFiles) {
   return [
-    { type: "text", text: prompt || CODEX_IMAGE_ONLY_TEXT },
-    ...imageFiles.map((path) => ({ type: "local_image", path }))
+    { type: "text", text: imageFiles.length > 0 ? prompt || CODEX_IMAGE_ONLY_TEXT : prompt },
+    ...imageFiles.map((path) => ({ type: "localImage", path }))
   ];
 }
-function codexThreadOptions(ctx) {
+function codexThreadParams(ctx) {
   const effort = resolveCodexReasoningEffort(ctx.params.codexReasoningEffort);
   return {
     ...ctx.params.model ? { model: ctx.params.model } : {},
-    ...effort ? { modelReasoningEffort: effort } : {},
-    ...ctx.cwd ? { workingDirectory: ctx.cwd } : {},
-    sandboxMode: "danger-full-access",
-    approvalPolicy: "never",
-    skipGitRepoCheck: true
+    ...effort ? { effort } : {},
+    ...ctx.cwd ? { cwd: ctx.cwd } : {},
+    sandbox: "danger-full-access",
+    approvalPolicy: "never"
   };
 }
 function resolveCodexReasoningEffort(value) {
@@ -16343,28 +16509,116 @@ function resolveCodexReasoningEffort(value) {
       return void 0;
   }
 }
-async function runCodexSdk(ctx) {
+var INTERRUPT_TIMEOUT_MS = 3e3;
+async function interruptTurns(client, shim) {
+  const turns = shim.activeTurns();
+  if (turns.length === 0) return;
+  await Promise.race([
+    Promise.allSettled(
+      turns.map((t) => client.request("turn/interrupt", { threadId: t.threadId, turnId: t.turnId }))
+    ),
+    new Promise((resolve) => setTimeout(resolve, INTERRUPT_TIMEOUT_MS))
+  ]);
+}
+async function runCodexAppServer(ctx) {
   const imageFiles = ctx.images && ctx.images.length > 0 ? writeImagesToTemp(ctx.images) : [];
   const adapter = createCodexEventAdapter(ctx);
+  const shim = new CodexEventShim();
+  let terminal = null;
+  let settle = null;
+  const finished = new Promise((resolve) => {
+    settle = resolve;
+  });
+  const onNotification = (n) => {
+    for (const out of shim.handle(n)) {
+      if (out.kind === "text-delta") {
+        adapter.noteAssistantText(out.text);
+        ctx.emit({
+          type: "stream_event",
+          event: { type: "content_block_delta", delta: { type: "text_delta", text: out.text } }
+        });
+        continue;
+      }
+      adapter.handle(out.event);
+      if (out.event.type === "turn.completed") terminal = "completed";
+      if (out.event.type === "turn.failed") terminal = "failed";
+    }
+    if (terminal) settle?.();
+  };
+  let closedReason = null;
+  let client;
   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;
-      console.error(
-        "[codex] bundled CLI binary is missing \u2014 falling back to `codex` on PATH. That build is not the version this SDK was pinned against. Repair with: cockpit update"
-      );
-      codex = new Codex({ codexPathOverride: "codex", env });
+    client = CodexAppServerClient.start({
+      env: sanitizedSpawnEnv({}),
+      ...ctx.cwd ? { cwd: ctx.cwd } : {},
+      onNotification,
+      // Permitted `console.error` under EFFECT.md §0 (subprocess IPC adapter gateway).
+      onStderr: (line) => console.error(`[codex app-server] ${line}`),
+      onClosed: (err) => {
+        closedReason = err;
+        settle?.();
+      }
+    });
+  } catch (error48) {
+    cleanupImageFiles(imageFiles);
+    throw error48;
+  }
+  try {
+    await client.request("initialize", {
+      clientInfo: { name: "cockpit", title: "Cockpit", version: "1" },
+      capabilities: { experimentalApi: true }
+    });
+    client.notify("initialized");
+    const params = codexThreadParams(ctx);
+    let opened;
+    let resumeFailure = null;
+    if (ctx.sessionId) {
+      try {
+        opened = await client.request("thread/resume", { threadId: ctx.sessionId, ...params });
+      } catch (error48) {
+        resumeFailure = error48 instanceof Error ? error48.message : String(error48);
+        console.error(
+          `[codex app-server] thread/resume failed for ${ctx.sessionId} \u2014 starting a fresh thread (history not carried over): ${resumeFailure}`
+        );
+        opened = await client.request("thread/start", params);
+      }
+    } else {
+      opened = await client.request("thread/start", params);
+    }
+    const thread = opened.thread;
+    const threadId = thread?.id;
+    if (!threadId) throw new Error("codex app-server returned no thread id");
+    adapter.bindRollout(thread?.path);
+    shim.bindThread(threadId);
+    adapter.handle({ type: "thread.started", thread_id: threadId });
+    if (resumeFailure) {
+      ctx.emit({
+        type: "system",
+        subtype: "notice",
+        notice: "codex_resume_failed",
+        previous_session_id: ctx.sessionId,
+        session_id: threadId,
+        error: resumeFailure
+      });
     }
-    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);
+    const startedTurn = await client.request("turn/start", {
+      threadId,
+      input: codexTurnInput(ctx.prompt ?? "", imageFiles)
+    });
+    const turnId = startedTurn.turn?.id;
+    if (turnId) shim.noteOwnTurn(threadId, turnId);
+    await Promise.race([
+      finished,
+      new Promise((resolve) => {
+        if (ctx.signal.aborted) return resolve();
+        ctx.signal.addEventListener("abort", () => resolve(), { once: true });
+      })
+    ]);
+    if (ctx.signal.aborted) await interruptTurns(client, shim);
     adapter.assertSuccess();
+    if (closedReason && !ctx.signal.aborted && !terminal) throw closedReason;
   } finally {
+    client.dispose();
     cleanupImageFiles(imageFiles);
   }
 }
@@ -16374,13 +16628,13 @@ var codexSpec = {
   runner: {
     async run(ctx) {
       if (ctx.params.noHistory !== true || !ctx.sessionId) {
-        await runCodexSdk(ctx);
+        await runCodexAppServer(ctx);
         return;
       }
       const sessionPath = findCodexSessionPath(ctx.sessionId);
       const stashed = sessionPath ? stashCodexRollout(sessionPath) : false;
       try {
-        await runCodexSdk(ctx);
+        await runCodexAppServer(ctx);
       } finally {
         if (stashed && sessionPath) mergeStashedCodexRollout(sessionPath);
       }
@@ -16550,6 +16804,8 @@ var en_default2 = {
     sendToPeerFailed: "Failed to send to the other pane",
     forkFailed: "Failed to fork session",
     excerptFailed: "Failed to excerpt this turn",
+    turnDeleted: "Turn deleted",
+    deleteTurnFailed: "Failed to delete this turn",
     copiedUrl: "URL copied",
     copiedOutput: "Output copied",
     copiedCmd: "Command copied",
@@ -16929,17 +17185,34 @@ var en_default2 = {
     jumpToLatest: "Jump to latest",
     jumpToPrevUserMessage: "Previous user message",
     jumpToNextUserMessage: "Next user message",
+    recentUserMessages: "Recent user messages",
+    moreUserMessages: "More",
+    userMessage: "User message",
+    recentUserMessageNumber: "Recent user message {{index}} of {{total}}",
+    imageMessage: "Image message",
     copyMessage: "Copy message",
     copyImage: "Copy image",
     copiedImage: "Image copied",
     forkSession: "Fork session from here",
     excerptTurn: "Excerpt this turn to a new session",
+    newSession: "New session",
+    continueFromHere: "Continue from here",
+    continueFromHereDesc: "Keep all context through this turn",
+    onlyThisTurn: "Only this turn",
+    onlyThisTurnDesc: "Keep only this question and answer",
+    deleteTurn: "Delete turn",
+    deletingTurn: "Deleting\u2026",
+    deleteTurnConfirm: "Delete this question, answer, and its tool records? This cannot be undone.",
+    deleteTurnConfirmAction: "Delete turn",
+    deleteTurnWhileRunning: "A turn cannot be deleted while the session is running",
     sendToPeerPane: "Send this message to the other pane",
     imageN: "Image {{index}}",
     imagePreview: "Image preview",
     toolCalls: "{{count}} tool calls",
     collapse: "\u25B2 Collapse",
     expand: "\u25BC Expand",
+    showMore: "Show more",
+    showLess: "Show less",
     subagent: "Subagent",
     subagentEmpty: "No subagent transcript found",
     subagentViewTitle: "View subagent transcript",
@@ -16954,6 +17227,9 @@ var en_default2 = {
     requestFailed: "Request failed",
     cannotReadStream: "Cannot read response stream",
     errorRetry: "An error occurred, please retry",
+    codexResumeFailed: "Previous session is in use by another Codex client \u2014 started a new session; history was not carried over",
+    codexResumeFailedPrevious: "Previous session",
+    codexResumeFailedNew: "New session",
     placeholder: "Type a message, Enter to send (Shift+Enter for new line, paste images; start a line with / (main session) or @ (subagent) for commands, multiple allowed)",
     placeholderDisabled: "Generating... you can keep typing (ESC to cancel; if stuck, cancel and resend 'continue')",
     imageSizeLimit: "Image size exceeds limit (max 5MB), current: {{size}}MB",
@@ -16962,13 +17238,25 @@ var en_default2 = {
     userMessages: "User messages",
     projectNotes: "Project Notes",
     scheduledTasks: "Scheduled Tasks",
-    quickPrompts: "Quick Prompts",
-    globalPrompts: "Global Prompts",
-    projectPrompts: "Project Prompts",
-    noQuickPrompts: "No quick prompts yet",
-    addQuickPrompt: "Add quick prompt",
-    quickPromptPlaceholder: "One-line prompt \u2014 Enter to save, Esc to cancel",
-    insertQuickPrompt: "Insert into input (without sending)",
+    quickInstructions: "Quick Instructions",
+    globalInstructions: "Global Instructions",
+    projectInstructions: "Project Instructions",
+    noQuickInstructions: "No quick instructions yet",
+    addQuickInstruction: "Add quick instruction",
+    quickInstructionPlaceholder: "One-line instruction \u2014 Enter to save, Esc to cancel",
+    insertQuickInstruction: "Insert into input (without sending)",
+    addInstructionGroup: "New group",
+    instructionGroupNamePlaceholder: "Group name \u2014 Enter to save, Esc to cancel",
+    instructionGroupLabel: "Group",
+    instructionGroupNone: "No group",
+    deleteInstructionGroupConfirm: 'Deleting "{{name}}" also deletes the {{count}} instruction(s) inside it. Continue?',
+    editGlobalInstructions: "Edit global instructions",
+    editProjectInstructions: "Edit project instructions",
+    quickInstructionsMarkdownHint: "One top-level entry per line. Add lines beginning with \u201C- \u201D after a group name for its instructions.",
+    quickInstructionsMarkdownPlaceholder: "Continue\nDraw with text\n- Draw a login flow\n- Draw a system architecture",
+    quickInstructionsMarkdownError: "Invalid format on line {{line}}.",
+    savingQuickInstructions: "Saving...",
+    saveQuickInstructionsFailed: "Could not save. Your edits are still here; please try again.",
     context: "Context",
     output: "Output",
     copiedCommandTooltip: "Copied!",
@@ -16989,17 +17277,19 @@ var en_default2 = {
     quotaResetAt: "Resets {{time}}",
     openProviderConsole: "Open the provider console",
     planMode: "Plan mode",
-    planModeDesc: "read-only \xB7 plan first, no edits",
+    planModeDesc: "read-only, plans first without edits",
     planModeOn: "Plan mode on \u2014 read-only; send a task to get a plan",
     planModeOff: "Plan mode off",
     planModeHint: "Plan mode: read-only exploration that produces a plan without editing. Uncheck and resend to implement.",
-    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.",
+    noHistory: "No history context",
+    noHistoryDesc: "each prompt is independent",
+    noHistoryHint: "No history context: each message is sent to the model on its own, with no prior conversation. The transcript above still records everything.",
     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.",
+    maximizePane: "Maximize this pane",
+    restorePane: "Restore both panes",
     closePane: "Close this pane",
     singlePane: "Single pane",
     splitPane: "Split into two panes"
@@ -17829,6 +18119,8 @@ var zh_default = {
     sendToPeerFailed: "\u53D1\u9001\u5230\u53E6\u4E00\u680F\u5931\u8D25",
     forkFailed: "\u5206\u53C9\u4F1A\u8BDD\u5931\u8D25",
     excerptFailed: "\u6458\u5F55\u672C\u8F6E\u5931\u8D25",
+    turnDeleted: "\u5DF2\u5220\u9664\u672C\u8F6E",
+    deleteTurnFailed: "\u5220\u9664\u672C\u8F6E\u5931\u8D25",
     copiedUrl: "\u5DF2\u590D\u5236\u7F51\u5740",
     copiedOutput: "\u5DF2\u590D\u5236\u8F93\u51FA",
     copiedCmd: "\u5DF2\u590D\u5236\u547D\u4EE4",
@@ -18208,17 +18500,34 @@ var zh_default = {
     jumpToLatest: "\u8DF3\u8F6C\u5230\u6700\u65B0",
     jumpToPrevUserMessage: "\u4E0A\u4E00\u6761\u7528\u6237\u6D88\u606F",
     jumpToNextUserMessage: "\u4E0B\u4E00\u6761\u7528\u6237\u6D88\u606F",
+    recentUserMessages: "\u6700\u8FD1\u7684\u7528\u6237\u6D88\u606F",
+    moreUserMessages: "\u66F4\u591A",
+    userMessage: "\u7528\u6237\u6D88\u606F",
+    recentUserMessageNumber: "\u6700\u8FD1\u7528\u6237\u6D88\u606F {{index}}/{{total}}",
+    imageMessage: "\u56FE\u7247\u6D88\u606F",
     copyMessage: "\u590D\u5236\u6D88\u606F",
     copyImage: "\u590D\u5236\u56FE\u7247",
     copiedImage: "\u5DF2\u590D\u5236\u56FE\u7247",
     forkSession: "\u4ECE\u6B64\u5904\u5206\u53C9\u4F1A\u8BDD",
     excerptTurn: "\u6458\u5F55\u672C\u8F6E\u5230\u65B0\u4F1A\u8BDD",
+    newSession: "\u65B0\u5EFA\u4F1A\u8BDD",
+    continueFromHere: "\u5EF6\u7EED\u5230\u6B64\u5904",
+    continueFromHereDesc: "\u4FDD\u7559\u622A\u81F3\u672C\u8F6E\u7684\u5168\u90E8\u4E0A\u4E0B\u6587",
+    onlyThisTurn: "\u4EC5\u63D0\u53D6\u672C\u8F6E",
+    onlyThisTurnDesc: "\u53EA\u5E26\u8FD9\u4E00\u8F6E\u95EE\u7B54",
+    deleteTurn: "\u5220\u9664\u672C\u8F6E",
+    deletingTurn: "\u6B63\u5728\u5220\u9664\u2026",
+    deleteTurnConfirm: "\u786E\u5B9A\u5220\u9664\u8FD9\u4E00\u8F6E\u7684\u95EE\u9898\u3001\u56DE\u7B54\u53CA\u5DE5\u5177\u8BB0\u5F55\u5417\uFF1F\u6B64\u64CD\u4F5C\u65E0\u6CD5\u64A4\u9500\u3002",
+    deleteTurnConfirmAction: "\u5220\u9664\u672C\u8F6E",
+    deleteTurnWhileRunning: "\u4F1A\u8BDD\u8FD0\u884C\u671F\u95F4\u4E0D\u80FD\u5220\u9664",
     sendToPeerPane: "\u53D1\u9001\u672C\u6761\u6D88\u606F\u5230\u53E6\u4E00\u680F",
     imageN: "\u56FE\u7247 {{index}}",
     imagePreview: "\u56FE\u7247\u9884\u89C8",
     toolCalls: "{{count}} \u4E2A\u5DE5\u5177\u8C03\u7528",
     collapse: "\u25B2 \u6536\u8D77",
     expand: "\u25BC \u5C55\u5F00",
+    showMore: "\u663E\u793A\u66F4\u591A",
+    showLess: "\u6536\u8D77",
     subagent: "\u5B50\u4EE3\u7406",
     subagentEmpty: "\u672A\u627E\u5230\u5B50\u4EE3\u7406\u6D88\u606F\u8BB0\u5F55",
     subagentViewTitle: "\u67E5\u770B\u5B50\u4EE3\u7406\u6267\u884C\u8FC7\u7A0B",
@@ -18233,6 +18542,9 @@ var zh_default = {
     requestFailed: "\u8BF7\u6C42\u5931\u8D25",
     cannotReadStream: "\u65E0\u6CD5\u8BFB\u53D6\u54CD\u5E94\u6D41",
     errorRetry: "\u53D1\u751F\u9519\u8BEF\uFF0C\u8BF7\u91CD\u8BD5",
+    codexResumeFailed: "\u539F\u4F1A\u8BDD\u88AB\u5176\u4ED6 Codex \u5BA2\u6237\u7AEF\u5360\u7528\uFF0C\u5DF2\u65B0\u5EFA\u4F1A\u8BDD\uFF0C\u5386\u53F2\u672A\u7EE7\u627F",
+    codexResumeFailedPrevious: "\u539F\u4F1A\u8BDD",
+    codexResumeFailedNew: "\u65B0\u4F1A\u8BDD",
     placeholder: "\u8F93\u5165\u6D88\u606F\uFF0CEnter \u53D1\u9001\uFF08Shift+Enter \u6362\u884C\uFF0C\u53EF\u7C98\u8D34\u56FE\u7247\uFF1B\u884C\u9996 /\uFF08\u4E3B\u4F1A\u8BDD\uFF09\u6216 @\uFF08\u5B50\u4EE3\u7406\uFF09\u5524\u8D77\u547D\u4EE4\uFF0C\u652F\u6301\u591A\u884C\u591A\u547D\u4EE4\uFF09",
     placeholderDisabled: "\u751F\u6210\u4E2D... \u53EF\u7EE7\u7EED\u8F93\u5165 (ESC \u53D6\u6D88;\u5361\u4F4F\u592A\u4E45\u53EF\u53D6\u6D88\u540E\u91CD\u53D1\u300C\u7EE7\u7EED\u300D)",
     imageSizeLimit: "\u56FE\u7247\u5927\u5C0F\u8D85\u8FC7\u9650\u5236\uFF08\u6700\u5927 5MB\uFF09\uFF0C\u5F53\u524D\u5927\u5C0F: {{size}}MB",
@@ -18241,13 +18553,25 @@ var zh_default = {
     userMessages: "\u7528\u6237\u6D88\u606F\u5217\u8868",
     projectNotes: "\u9879\u76EE\u7B14\u8BB0",
     scheduledTasks: "\u5B9A\u65F6\u4EFB\u52A1",
-    quickPrompts: "\u5FEB\u6377 Prompt",
-    globalPrompts: "\u5168\u5C40 Prompt",
-    projectPrompts: "\u9879\u76EE Prompt",
-    noQuickPrompts: "\u6682\u65E0\u5FEB\u6377 Prompt",
-    addQuickPrompt: "\u65B0\u589E\u5FEB\u6377 Prompt",
-    quickPromptPlaceholder: "\u8F93\u5165\u4E00\u53E5\u8BDD Prompt\uFF0CEnter \u4FDD\u5B58\uFF0CEsc \u53D6\u6D88",
-    insertQuickPrompt: "\u586B\u5165\u8F93\u5165\u6846\uFF08\u4E0D\u53D1\u9001\uFF09",
+    quickInstructions: "\u5FEB\u6377\u6307\u4EE4",
+    globalInstructions: "\u5168\u5C40\u6307\u4EE4",
+    projectInstructions: "\u9879\u76EE\u6307\u4EE4",
+    noQuickInstructions: "\u6682\u65E0\u5FEB\u6377\u6307\u4EE4",
+    addQuickInstruction: "\u65B0\u589E\u5FEB\u6377\u6307\u4EE4",
+    quickInstructionPlaceholder: "\u8F93\u5165\u4E00\u53E5\u8BDD\u6307\u4EE4\uFF0CEnter \u4FDD\u5B58\uFF0CEsc \u53D6\u6D88",
+    insertQuickInstruction: "\u586B\u5165\u8F93\u5165\u6846\uFF08\u4E0D\u53D1\u9001\uFF09",
+    addInstructionGroup: "\u65B0\u589E\u5206\u7EC4",
+    instructionGroupNamePlaceholder: "\u8F93\u5165\u5206\u7EC4\u540D\uFF0CEnter \u4FDD\u5B58\uFF0CEsc \u53D6\u6D88",
+    instructionGroupLabel: "\u6240\u5C5E\u5206\u7EC4",
+    instructionGroupNone: "\u4E0D\u5206\u7EC4",
+    deleteInstructionGroupConfirm: "\u5220\u9664\u5206\u7EC4\u300C{{name}}\u300D\u4F1A\u540C\u65F6\u5220\u9664\u7EC4\u5185 {{count}} \u6761\u6307\u4EE4\uFF0C\u786E\u5B9A\u7EE7\u7EED\uFF1F",
+    editGlobalInstructions: "\u7F16\u8F91\u5168\u5C40\u6307\u4EE4",
+    editProjectInstructions: "\u7F16\u8F91\u9879\u76EE\u6307\u4EE4",
+    quickInstructionsMarkdownHint: "\u4E00\u7EA7\u5185\u5BB9\u6BCF\u884C\u4E00\u6761\uFF1B\u5206\u7EC4\u540D\u79F0\u540E\u7684\u300C- \u300D\u5F00\u5934\u884C\u662F\u8BE5\u5206\u7EC4\u7684\u5B50\u547D\u4EE4\u3002",
+    quickInstructionsMarkdownPlaceholder: "\u6309\u63A8\u8350\u5B9E\u65BD\n\u7528\u6587\u672C\u753B\u56FE\n- \u753B\u4E00\u4E2A\u767B\u5F55\u6D41\u7A0B\n- \u753B\u4E00\u4E2A\u7CFB\u7EDF\u67B6\u6784",
+    quickInstructionsMarkdownError: "\u7B2C {{line}} \u884C\u683C\u5F0F\u4E0D\u6B63\u786E\u3002",
+    savingQuickInstructions: "\u4FDD\u5B58\u4E2D...",
+    saveQuickInstructionsFailed: "\u4FDD\u5B58\u5931\u8D25\uFF0C\u4FEE\u6539\u4ECD\u7136\u4FDD\u7559\uFF0C\u8BF7\u91CD\u8BD5\u3002",
     context: "\u4E0A\u4E0B\u6587",
     output: "\u8F93\u51FA",
     copiedCommandTooltip: "\u5DF2\u590D\u5236!",
@@ -18268,17 +18592,19 @@ var zh_default = {
     quotaResetAt: "{{time}} \u91CD\u7F6E",
     openProviderConsole: "\u6253\u5F00\u670D\u52A1\u5546\u63A7\u5236\u53F0",
     planMode: "\u8BA1\u5212\u6A21\u5F0F",
-    planModeDesc: "\u53EA\u8BFB\xB7\u5148\u51FA\u8BA1\u5212\u4E0D\u6539\u4EE3\u7801",
+    planModeDesc: "\u53EA\u8BFB\uFF0C\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",
     planModeOff: "\u5DF2\u5173\u95ED\u8BA1\u5212\u6A21\u5F0F",
     planModeHint: "\u8BA1\u5212\u6A21\u5F0F\uFF1A\u53EA\u8BFB\u63A2\u7D22\u3001\u4EA7\u51FA\u8BA1\u5212\u4F46\u4E0D\u6539\u6587\u4EF6\u3002\u53D6\u6D88\u52FE\u9009\u540E\u91CD\u53D1\u624D\u4F1A\u5B9E\u73B0\u3002",
-    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",
+    noHistory: "\u4E0D\u5E26\u5386\u53F2\u4E0A\u4E0B\u6587",
+    noHistoryDesc: "\u6BCF\u6B21\u63D0\u95EE\u5747\u72EC\u7ACB",
+    noHistoryHint: "\u4E0D\u5E26\u5386\u53F2\u4E0A\u4E0B\u6587\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",
     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",
+    maximizePane: "\u653E\u5927\u672C\u680F",
+    restorePane: "\u8FD8\u539F\u53CC\u680F",
     closePane: "\u5173\u95ED\u672C\u680F",
     singlePane: "\u5207\u56DE\u5355\u680F",
     splitPane: "\u5E76\u6392\u53CC\u680F"