@linzumi/cli 0.0.80-beta → 0.0.81-beta

package/dist/index.js

@@ -770,6 +770,47 @@ async function pushOk(kandan, topic, event, payload) {
     `kandan push failed: ${event}: ${JSON.stringify(reply).slice(0, 500)}`
   );
 }
+async function prepareCommanderCompletedPushPayload(runtime, event, payload) {
+  switch (event) {
+    case "session:post_thread_message":
+    case "session:stream_thread_message":
+    case "session:edit_thread_message":
+      break;
+    default:
+      return payload;
+  }
+  const isEdit = event === "session:edit_thread_message";
+  const structured = isEdit ? objectValue(payload.structured) : objectValue(objectValue(payload.payload)?.structured);
+  const body = typeof payload.body === "string" ? payload.body : void 0;
+  if (structured === void 0 || body === void 0 || stringValue(structured.stream_state) !== "completed") {
+    return payload;
+  }
+  const uploadedFileIds = await uploadedFileIdsForCommanderOutput(
+    runtime,
+    body,
+    structured
+  );
+  const displayBody = displayBodyForCommanderOutput(body, uploadedFileIds);
+  const displayStructured = structuredWithAssistantContent(
+    structured,
+    displayBody
+  );
+  if (displayBody === body && uploadedFileIds.length === 0) {
+    return payload;
+  }
+  const base = {
+    ...payload,
+    body: displayBody,
+    ...uploadedFileIds.length === 0 ? {} : { uploaded_file_ids: uploadedFileIds }
+  };
+  return isEdit ? { ...base, structured: displayStructured } : {
+    ...base,
+    payload: {
+      ...objectValue(payload.payload) ?? {},
+      structured: displayStructured
+    }
+  };
+}
 var commanderAttachmentUploadExtensions;
 var init_commanderAttachments = __esm({
   "src/commanderAttachments.ts"() {
@@ -1845,8 +1886,8 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url, protoc
     if (state.resolveReady !== void 0) {
       return;
     }
-    state.ready = new Promise((resolve11, reject) => {
-      state.resolveReady = resolve11;
+    state.ready = new Promise((resolve12, reject) => {
+      state.resolveReady = resolve12;
       state.rejectReady = reject;
     });
     state.ready.catch(() => void 0);
@@ -2079,13 +2120,13 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url, protoc
     const joinRef = event === "phx_join" ? ref : topicJoinRefs.get(topic) ?? null;
     const frame = [joinRef, ref, topic, event, payload];
     const replyBudgetMs = Math.max(0, Math.ceil(timeoutMs));
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       const timer = setTimeout(() => {
         if (pending.delete(ref)) {
           reject(phoenixPushErrors.replyTimeout(replyBudgetMs, event));
         }
       }, replyBudgetMs);
-      pending.set(ref, { event, timer, resolve: resolve11, reject });
+      pending.set(ref, { event, timer, resolve: resolve12, reject });
       websocket.send(JSON.stringify(frame));
     });
   };
@@ -2252,7 +2293,7 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url, protoc
   resetReady();
   void openSocket();
   await state.ready;
-  const awaitReady = (event, deadlineMs) => new Promise((resolve11, reject) => {
+  const awaitReady = (event, deadlineMs) => new Promise((resolve12, reject) => {
     const timer = setTimeout(
       () => {
         reject(phoenixPushErrors.connectionWaitTimeout(pushTimeoutMs, event));
@@ -2262,7 +2303,7 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url, protoc
     state.ready.then(
       () => {
         clearTimeout(timer);
-        resolve11();
+        resolve12();
       },
       (error) => {
         clearTimeout(timer);
@@ -2396,8 +2437,8 @@ function isControlBacklogEntry(value) {
   return isJsonObject(value) && typeof value.event === "string" && isJsonObject(value.payload) && (value.control_seq === void 0 || typeof value.control_seq === "number" && Number.isInteger(value.control_seq));
 }
 function waitForOpen(websocket) {
-  return new Promise((resolve11, reject) => {
-    websocket.addEventListener("open", () => resolve11(), { once: true });
+  return new Promise((resolve12, reject) => {
+    websocket.addEventListener("open", () => resolve12(), { once: true });
     websocket.addEventListener(
       "error",
       () => reject(new Error("websocket open failed")),
@@ -3097,15 +3138,15 @@ function createThreadOutbox(options) {
     }
     pushLatencyNextIndex = (pushLatencyNextIndex + 1) % outboxPushLatencyWindowSize;
   };
-  const sleep2 = (ms) => new Promise((resolve11) => {
+  const sleep2 = (ms) => new Promise((resolve12) => {
     const timer = setTimeout(() => {
       wakeSleep = void 0;
-      resolve11();
+      resolve12();
     }, ms);
     wakeSleep = () => {
       clearTimeout(timer);
       wakeSleep = void 0;
-      resolve11();
+      resolve12();
     };
   });
   const drainHeadEntry = async (pending) => {
@@ -3235,10 +3276,10 @@ function createThreadOutbox(options) {
     if (head === void 0 || head.entry.entrySeq > upToSeq) {
       return Promise.resolve();
     }
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       const waiter = {
         upToSeq,
-        resolve: resolve11,
+        resolve: resolve12,
         reject,
         timer: void 0
       };
@@ -3416,8 +3457,8 @@ function nearestRank(sortedAscending, quantile) {
   return sortedAscending[rank - 1] ?? 0;
 }
 function sleepUncancellable(ms) {
-  return new Promise((resolve11) => {
-    setTimeout(resolve11, ms);
+  return new Promise((resolve12) => {
+    setTimeout(resolve12, ms);
   });
 }
 function toError(value) {
@@ -5349,8 +5390,8 @@ function isConnectionWaitPushError(error) {
   return isPhoenixConnectionWaitError(error);
 }
 function sleep(ms) {
-  return new Promise((resolve11) => {
-    setTimeout(resolve11, ms);
+  return new Promise((resolve12) => {
+    setTimeout(resolve12, ms);
   });
 }
 var defaultSnapshotRetryDelaysMs, toolCallOutputTypes, toolCallItemTypes;
@@ -7301,22 +7342,8 @@ async function pipelinePush(args, state, event, payload) {
   }
 }
 async function preparePipelinePushPayload(args, event, payload) {
-  switch (event) {
-    case "session:post_thread_message":
-    case "session:stream_thread_message":
-    case "session:edit_thread_message":
-      break;
-    default:
-      return payload;
-  }
-  const isEdit = event === "session:edit_thread_message";
-  const structured = isEdit ? objectValue(payload.structured) : objectValue(objectValue(payload.payload)?.structured);
-  const body = typeof payload.body === "string" ? payload.body : void 0;
-  if (structured === void 0 || body === void 0 || stringValue(structured.stream_state) !== "completed") {
-    return payload;
-  }
   const session = args.options.channelSession;
-  const uploadedFileIds = await uploadedFileIdsForCommanderOutput(
+  return prepareCommanderCompletedPushPayload(
     {
       kandan: args.kandan,
       topic: args.topic,
@@ -7327,29 +7354,9 @@ async function preparePipelinePushPayload(args, event, payload) {
       token: args.options.token,
       fetch: args.options.fetch
     },
-    body,
-    structured
+    event,
+    payload
   );
-  const displayBody = displayBodyForCommanderOutput(body, uploadedFileIds);
-  const displayStructured = structuredWithAssistantContent(
-    structured,
-    displayBody
-  );
-  if (displayBody === body && uploadedFileIds.length === 0) {
-    return payload;
-  }
-  const base = {
-    ...payload,
-    body: displayBody,
-    ...uploadedFileIds.length === 0 ? {} : { uploaded_file_ids: uploadedFileIds }
-  };
-  return isEdit ? { ...base, structured: displayStructured } : {
-    ...base,
-    payload: {
-      ...objectValue(payload.payload) ?? {},
-      structured: displayStructured
-    }
-  };
 }
 async function resolvePipelineSnapshot(args, state, turnId) {
   const codexThreadId = state.codexThreadId;
@@ -9417,12 +9424,12 @@ async function requestKandanApproval(args, state, request, turnId, payloadContex
       reason: "awaiting approval",
       approval
     };
-    const approvalPromise = new Promise((resolve11, reject) => {
+    const approvalPromise = new Promise((resolve12, reject) => {
       const pendingRequest = {
         requestId: approval.requestId,
         sourceSeq,
         turnId,
-        resolve: resolve11,
+        resolve: resolve12,
         reject
       };
       state.pendingApprovalRequests.set(
@@ -9514,8 +9521,8 @@ async function mirrorLocalTuiInputFromNotification(args, state, turnId, params,
   }
 }
 function sleepMs(ms) {
-  return new Promise((resolve11) => {
-    setTimeout(resolve11, ms);
+  return new Promise((resolve12) => {
+    setTimeout(resolve12, ms);
   });
 }
 async function mirrorLocalTuiInputMessage(args, state, turnId, message, payloadContext) {
@@ -10255,8 +10262,547 @@ var init_channelSession = __esm({
   }
 });
 
+// src/claudeCodePipeline.ts
+import { existsSync } from "node:fs";
+import { isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
+function createClaudeCodeSessionPipeline(host) {
+  const sourceSeqByTurn = /* @__PURE__ */ new Map();
+  const snapshotsByTurn = /* @__PURE__ */ new Map();
+  const snapshotOrder = [];
+  const openTurnIds = /* @__PURE__ */ new Set();
+  const turnSettlementWaiters = [];
+  let activeTurn;
+  let interruptPending = false;
+  let turnCounter = 0;
+  let lastSourceSeq;
+  let lastUsage;
+  let pipeline2;
+  const push = async (event, payload, timeoutMs) => {
+    const prepared = host.preparePush === void 0 ? payload : await host.preparePush(event, payload);
+    try {
+      return await host.push(event, prepared, timeoutMs);
+    } catch (error) {
+      if (isConnectionLostPushError(error)) {
+        pipeline2.pause();
+      }
+      throw error;
+    }
+  };
+  pipeline2 = createSessionPipeline({
+    instanceId: host.instanceId,
+    threadKey: host.threadKey,
+    persistDir: host.persistDir,
+    push,
+    wire: host.wire,
+    runnerPayload: (eventType, claudeSessionId, sourceMessageSeq, extra) => host.runnerPayload(eventType, claudeSessionId, sourceMessageSeq, {
+      ...extra ?? {},
+      agent_provider: "claude-code",
+      claude_session_id: claudeSessionId
+    }),
+    sourceSeqForTurn: (turnId) => sourceSeqByTurn.get(turnId),
+    resolveSnapshot: (turnId) => {
+      const items = snapshotsByTurn.get(turnId);
+      if (items === void 0) {
+        return Promise.reject(
+          new Error(`no retained claude snapshot for turn ${turnId}`)
+        );
+      }
+      return Promise.resolve({ items: [...items] });
+    },
+    onTurnTerminal: (turnId, outcome, reason) => {
+      openTurnIds.delete(turnId);
+      if (openTurnIds.size === 0) {
+        for (const waiter of turnSettlementWaiters.splice(0)) {
+          waiter();
+        }
+      }
+      host.onTurnTerminal(turnId, outcome, reason);
+    },
+    log: host.log,
+    outboxRetryDelaysMs: host.outboxRetryDelaysMs,
+    snapshotRetryDelaysMs: host.snapshotRetryDelaysMs,
+    statsIntervalMs: host.statsIntervalMs,
+    turnStalledThresholdMs: host.turnStalledThresholdMs
+  });
+  const submit = (method, params) => {
+    pipeline2.submitNotification(method, params);
+  };
+  const ensureTurn = () => {
+    if (activeTurn !== void 0) {
+      return activeTurn;
+    }
+    interruptPending = false;
+    turnCounter += 1;
+    const turnId = `claude:${host.instanceId}:turn:${turnCounter}`;
+    const sourceSeq = host.currentSourceSeq() ?? lastSourceSeq ?? host.wire().rootSeq;
+    if (sourceSeq === void 0) {
+      host.log("claude_pipeline.turn_without_source_seq", {
+        thread_key: host.threadKey,
+        turn_id: turnId
+      });
+    } else {
+      lastSourceSeq = sourceSeq;
+      sourceSeqByTurn.set(turnId, sourceSeq);
+    }
+    activeTurn = {
+      turnId,
+      sourceSeq: sourceSeq ?? 0,
+      itemOrder: [],
+      itemsByKey: /* @__PURE__ */ new Map(),
+      pendingTools: /* @__PURE__ */ new Map()
+    };
+    openTurnIds.add(turnId);
+    submit("turn/started", { turnId });
+    pipeline2.notifyTurnMappingReady(turnId);
+    return activeTurn;
+  };
+  const recordItem = (turn, item) => {
+    const key = stringValue(item.id) ?? `item:${turn.itemOrder.length}`;
+    if (!turn.itemsByKey.has(key)) {
+      turn.itemOrder.push(key);
+    }
+    turn.itemsByKey.set(key, item);
+  };
+  const appendRawText = (turn, itemId, type, delta) => {
+    const existing = turn.itemsByKey.get(itemId);
+    const previous = existing === void 0 ? "" : rawItemText(existing, type);
+    recordItem(turn, rawTextItem(type, itemId, `${previous}${delta}`));
+  };
+  const setRawText = (turn, itemId, type, text2) => {
+    recordItem(turn, rawTextItem(type, itemId, text2));
+  };
+  const frozenSnapshotItems = (turn) => turn.itemOrder.flatMap((key) => {
+    const item = turn.itemsByKey.get(key);
+    return item === void 0 ? [] : [item];
+  });
+  const finishTurn = (turn, finalBody) => {
+    const bodyAlreadyRecorded = turn.itemOrder.some((key) => {
+      const item = turn.itemsByKey.get(key);
+      return item !== void 0 && stringValue(item.type) === "agentMessage" && rawItemText(item, "agentMessage").trim() === finalBody.trim();
+    });
+    if (!bodyAlreadyRecorded && finalBody.trim() !== "") {
+      setRawText(turn, `result:${turn.turnId}`, "agentMessage", finalBody);
+    }
+    snapshotsByTurn.set(turn.turnId, frozenSnapshotItems(turn));
+    snapshotOrder.push(turn.turnId);
+    while (snapshotOrder.length > maxRetainedSnapshots) {
+      const evicted = snapshotOrder.shift();
+      if (evicted !== void 0) {
+        snapshotsByTurn.delete(evicted);
+      }
+    }
+    submit("turn/completed", { turnId: turn.turnId });
+    activeTurn = void 0;
+  };
+  const handleToolResult = (turn, event) => {
+    const pending = turn.pendingTools.get(event.itemKey);
+    turn.pendingTools.delete(event.itemKey);
+    const toolName2 = pending?.toolName ?? event.toolName ?? "tool";
+    const input = pending?.input ?? {};
+    const itemId = `tool:${event.itemKey}`;
+    if (!event.isError && isFileChangeTool(toolName2)) {
+      const patchText = claudeFileChangePatchText(toolName2, input, {
+        targetExistedAtCall: pending?.targetExistedAtCall
+      });
+      if (patchText !== void 0) {
+        const item2 = {
+          type: "fileChange",
+          id: itemId,
+          status: "completed",
+          patchText
+        };
+        recordItem(turn, item2);
+        submit("item/completed", { turnId: turn.turnId, item: item2 });
+        return;
+      }
+    }
+    if (isWebSearchTool(toolName2)) {
+      const query = stringValue(input.query) ?? stringValue(input.url) ?? toolName2;
+      const item2 = {
+        type: "web_search_call",
+        id: `web:${event.itemKey}`,
+        query,
+        status: "completed"
+      };
+      recordItem(turn, item2);
+      submit("item/completed", { turnId: turn.turnId, item: item2 });
+      return;
+    }
+    if (!event.isError && toolName2 === "TodoWrite") {
+      const plan = claudePlanItem(itemId, input);
+      if (plan !== void 0) {
+        recordItem(turn, plan);
+        submit("item/completed", { turnId: turn.turnId, item: plan });
+        return;
+      }
+    }
+    const item = {
+      type: "commandExecution",
+      id: itemId,
+      command: claudeToolCommandLabel(toolName2, input),
+      aggregatedOutput: event.content,
+      status: event.isError ? "failed" : "completed"
+    };
+    recordItem(turn, item);
+    submit("item/completed", { turnId: turn.turnId, item });
+  };
+  const handleTranscriptEvent = (event) => {
+    switch (event.type) {
+      case "session_started":
+        return;
+      case "assistant_delta": {
+        const turn = ensureTurn();
+        const itemId = claudeAssistantPipelineItemId(event.itemKey);
+        appendRawText(turn, itemId, "agentMessage", event.delta);
+        submit("item/agentMessage/delta", {
+          turnId: turn.turnId,
+          itemId,
+          delta: event.delta
+        });
+        return;
+      }
+      case "reasoning_delta": {
+        const turn = ensureTurn();
+        const itemId = claudeAssistantPipelineItemId(event.itemKey);
+        appendRawText(turn, itemId, "reasoning", event.delta);
+        submit("item/reasoning/textDelta", {
+          turnId: turn.turnId,
+          itemId,
+          delta: event.delta
+        });
+        return;
+      }
+      case "assistant_message": {
+        const turn = ensureTurn();
+        const itemId = claudeAssistantPipelineItemId(event.itemKey);
+        setRawText(turn, itemId, "agentMessage", event.content);
+        submit("item/completed", {
+          turnId: turn.turnId,
+          item: rawTextItem("agentMessage", itemId, event.content)
+        });
+        return;
+      }
+      case "reasoning_message": {
+        const turn = ensureTurn();
+        const itemId = claudeAssistantPipelineItemId(event.itemKey);
+        setRawText(turn, itemId, "reasoning", event.content);
+        submit("item/completed", {
+          turnId: turn.turnId,
+          item: rawTextItem("reasoning", itemId, event.content)
+        });
+        return;
+      }
+      case "tool_call": {
+        const turn = ensureTurn();
+        turn.pendingTools.set(event.itemKey, {
+          toolName: event.toolName,
+          input: event.input,
+          targetExistedAtCall: fileChangeTargetExists(
+            event.toolName,
+            event.input,
+            host.cwd
+          )
+        });
+        if (isWebSearchTool(event.toolName)) {
+          const query = stringValue(event.input.query) ?? stringValue(event.input.url) ?? event.toolName;
+          submit("item/started", {
+            turnId: turn.turnId,
+            item: {
+              type: "web_search_call",
+              id: `web:${event.itemKey}`,
+              query
+            }
+          });
+        }
+        return;
+      }
+      case "tool_result": {
+        handleToolResult(ensureTurn(), event);
+        return;
+      }
+      case "command_output": {
+        const turn = ensureTurn();
+        const item = {
+          type: "commandExecution",
+          id: `local:${event.itemKey}`,
+          command: "Claude Code local command",
+          aggregatedOutput: event.content,
+          status: "completed"
+        };
+        recordItem(turn, item);
+        submit("item/completed", { turnId: turn.turnId, item });
+        return;
+      }
+      case "usage":
+        lastUsage = event.usage;
+        return;
+      case "unknown":
+        host.log("claude_pipeline.unknown_event", {
+          thread_key: host.threadKey,
+          item_key: event.itemKey,
+          summary: event.summary
+        });
+        return;
+      case "turn_interrupted": {
+        interruptPending = false;
+        if (activeTurn !== void 0) {
+          submit("turn/aborted", {
+            turnId: activeTurn.turnId,
+            reason: "Claude Code turn interrupted"
+          });
+          activeTurn = void 0;
+        }
+        return;
+      }
+      case "turn_completed": {
+        if (activeTurn === void 0 && interruptPending) {
+          interruptPending = false;
+          host.log("claude_pipeline.turn_completed_after_interrupt", {
+            thread_key: host.threadKey
+          });
+          return;
+        }
+        const turn = ensureTurn();
+        lastUsage = event.usage ?? lastUsage;
+        finishTurn(turn, event.body);
+        return;
+      }
+      case "session_completed": {
+        if (activeTurn === void 0) {
+          interruptPending = false;
+          return;
+        }
+        lastUsage = event.usage ?? lastUsage;
+        finishTurn(activeTurn, event.body);
+        return;
+      }
+      case "session_failed": {
+        if (activeTurn === void 0) {
+          interruptPending = false;
+          host.log("claude_pipeline.session_failed_without_turn", {
+            thread_key: host.threadKey,
+            reason: event.reason
+          });
+          return;
+        }
+        submit("turn/failed", {
+          turnId: activeTurn.turnId,
+          reason: event.reason
+        });
+        activeTurn = void 0;
+        return;
+      }
+    }
+  };
+  return {
+    handleTranscriptEvent,
+    interruptActiveTurn: (reason) => {
+      if (activeTurn === void 0) {
+        return false;
+      }
+      submit("turn/aborted", { turnId: activeTurn.turnId, reason });
+      activeTurn = void 0;
+      interruptPending = true;
+      return true;
+    },
+    submitLifecycle: (kind, reason) => {
+      pipeline2.submitLifecycle(kind, reason);
+    },
+    awaitTurnsSettled: (timeoutMs = 3e4) => {
+      if (openTurnIds.size === 0) {
+        return Promise.resolve();
+      }
+      return new Promise((resolve12) => {
+        const timer = setTimeout(() => {
+          host.log("claude_pipeline.turn_settlement_timeout", {
+            thread_key: host.threadKey,
+            open_turn_ids: [...openTurnIds]
+          });
+          resolve12();
+        }, timeoutMs);
+        turnSettlementWaiters.push(() => {
+          clearTimeout(timer);
+          resolve12();
+        });
+      });
+    },
+    activeTurnId: () => activeTurn?.turnId,
+    lastUsage: () => lastUsage,
+    flush: (timeoutMs) => pipeline2.flushOutbox(timeoutMs),
+    metrics: () => pipeline2.metrics(),
+    close: (timeoutMs) => pipeline2.close(timeoutMs)
+  };
+}
+function rawTextItem(type, id, text2) {
+  return type === "agentMessage" ? { type, id, content: [{ type: "text", text: text2 }] } : { type, id, content: [text2], summary: [] };
+}
+function rawItemText(item, type) {
+  const content = Array.isArray(item.content) ? item.content : [];
+  if (type === "reasoning") {
+    return content.filter((part) => typeof part === "string").join("");
+  }
+  return content.flatMap((part) => {
+    const text2 = stringValue(objectValue(part)?.text);
+    return text2 === void 0 ? [] : [text2];
+  }).join("");
+}
+function claudeAssistantPipelineItemId(itemKey) {
+  const streamIndex = itemKey.match(/^assistant-stream-(\d+)$/)?.[1];
+  return streamIndex === void 0 ? itemKey : `content-block-${streamIndex}`;
+}
+function isFileChangeTool(toolName2) {
+  switch (toolName2) {
+    case "Edit":
+    case "MultiEdit":
+    case "Write":
+    case "NotebookEdit":
+      return true;
+    default:
+      return false;
+  }
+}
+function isWebSearchTool(toolName2) {
+  return toolName2 === "WebSearch" || toolName2 === "WebFetch";
+}
+function fileChangeTargetExists(toolName2, input, sessionCwd) {
+  if (!isFileChangeTool(toolName2)) {
+    return void 0;
+  }
+  const path2 = stringValue(input.file_path) ?? stringValue(input.filePath) ?? stringValue(input.notebook_path);
+  if (path2 === void 0 || path2.trim() === "") {
+    return void 0;
+  }
+  try {
+    return existsSync(isAbsolute2(path2) ? path2 : resolve2(sessionCwd, path2));
+  } catch (_error) {
+    return void 0;
+  }
+}
+function claudeFileChangePatchText(toolName2, input, options = {}) {
+  const path2 = stringValue(input.file_path) ?? stringValue(input.filePath) ?? stringValue(input.notebook_path);
+  if (path2 === void 0 || path2.trim() === "") {
+    return void 0;
+  }
+  switch (toolName2) {
+    case "Write": {
+      const header = options.targetExistedAtCall === false ? `*** Add File: ${path2}` : `*** Update File: ${path2}`;
+      const content = stringValue(input.content) ?? "";
+      return wrapPatch(header, prefixLines(content, "+"));
+    }
+    case "Edit": {
+      const oldString = stringValue(input.old_string) ?? "";
+      const newString = stringValue(input.new_string) ?? "";
+      return wrapPatch(
+        `*** Update File: ${path2}`,
+        editHunk(oldString, newString)
+      );
+    }
+    case "MultiEdit": {
+      const edits = Array.isArray(input.edits) ? input.edits : [];
+      const hunks = edits.flatMap((edit) => {
+        const value = objectValue(edit);
+        if (value === void 0) {
+          return [];
+        }
+        return [
+          editHunk(
+            stringValue(value.old_string) ?? "",
+            stringValue(value.new_string) ?? ""
+          )
+        ];
+      });
+      return hunks.length === 0 ? void 0 : wrapPatch(`*** Update File: ${path2}`, hunks.join("\n@@\n"));
+    }
+    case "NotebookEdit": {
+      const source = stringValue(input.new_source) ?? "";
+      return wrapPatch(`*** Update File: ${path2}`, prefixLines(source, "+"));
+    }
+    default:
+      return void 0;
+  }
+}
+function editHunk(oldString, newString) {
+  const removed = oldString === "" ? [] : [prefixLines(oldString, "-")];
+  const added = newString === "" ? [] : [prefixLines(newString, "+")];
+  return [...removed, ...added].join("\n");
+}
+function prefixLines(text2, prefix) {
+  return text2.split("\n").map((line) => `${prefix}${line}`).join("\n");
+}
+function wrapPatch(header, body) {
+  return `*** Begin Patch
+${header}
+${body}
+*** End Patch
+`;
+}
+function claudePlanItem(itemId, input) {
+  const todos = Array.isArray(input.todos) ? input.todos : [];
+  const lines = todos.flatMap((todo) => {
+    const value = objectValue(todo);
+    if (value === void 0) {
+      return [];
+    }
+    const label = stringValue(value.content) ?? stringValue(value.subject) ?? stringValue(value.activeForm);
+    if (label === void 0 || label.trim() === "") {
+      return [];
+    }
+    const glyph = todoStatusGlyphs[stringValue(value.status) ?? "pending"] ?? "[ ]";
+    return [`${glyph} ${label}`];
+  });
+  if (lines.length === 0) {
+    return void 0;
+  }
+  return {
+    type: "reasoning",
+    id: `plan:${itemId}`,
+    content: [["Plan", ...lines].join("\n")],
+    summary: ["Plan", ...lines]
+  };
+}
+function claudeToolCommandLabel(toolName2, input) {
+  const mcpMatch = toolName2.match(/^mcp__([^_]+(?:_[^_]+)*?)__(.+)$/);
+  if (mcpMatch !== void 0 && mcpMatch !== null) {
+    const summary2 = claudeToolInputSummary(input);
+    const label = `mcp: ${mcpMatch[1]}.${mcpMatch[2]}`;
+    return summary2 === void 0 ? label : `${label} ${summary2}`;
+  }
+  if (toolName2 === "Bash") {
+    return stringValue(input.command) ?? "Bash";
+  }
+  const summary = claudeToolInputSummary(input);
+  return summary === void 0 ? toolName2 : `${toolName2} ${summary}`;
+}
+function claudeToolInputSummary(input) {
+  const direct = stringValue(input.command) ?? stringValue(input.file_path) ?? stringValue(input.notebook_path) ?? stringValue(input.path) ?? stringValue(input.pattern) ?? stringValue(input.query) ?? stringValue(input.url) ?? stringValue(input.description) ?? stringValue(input.prompt);
+  const trimmed = direct?.trim();
+  if (trimmed !== void 0 && trimmed !== "") {
+    return trimmed.length > 200 ? `${trimmed.slice(0, 200)}\u2026` : trimmed;
+  }
+  try {
+    const preview = JSON.stringify(input);
+    return preview === "{}" ? void 0 : preview.slice(0, 200);
+  } catch (_error) {
+    return void 0;
+  }
+}
+var maxRetainedSnapshots, todoStatusGlyphs;
+var init_claudeCodePipeline = __esm({
+  "src/claudeCodePipeline.ts"() {
+    "use strict";
+    init_json();
+    init_integration();
+    maxRetainedSnapshots = 8;
+    todoStatusGlyphs = {
+      completed: "[x]",
+      in_progress: "[>]",
+      pending: "[ ]"
+    };
+  }
+});
+
 // src/claudeCodeSession.ts
-import { existsSync, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { join as join4 } from "node:path";
 function claudeCodeSettingSources() {
@@ -10267,7 +10813,7 @@ async function probeClaudeCodeAvailability(args) {
     cwd: args.cwd,
     homeDir: homedir3(),
     platform: process.platform,
-    fileExists: existsSync,
+    fileExists: existsSync2,
     readTextFile: readTextFileIfPresent
   })) {
     return false;
@@ -10281,11 +10827,19 @@ async function probeClaudeCodeAvailability(args) {
         settingSources: claudeCodeSettingSources(),
         tools: []
       },
-      initializeTimeoutMs: 1e3
+      // Cold SDK startup spawns the Claude Code subprocess; a fresh npx
+      // install routinely needs several seconds on first launch, and a
+      // too-tight probe silently demotes the runner to codex-only until
+      // the next restart. This runs once at runner startup, so a generous
+      // deadline costs nothing in steady state.
+      initializeTimeoutMs: 15e3
     });
     warmQuery.close();
     return true;
-  } catch (_error) {
+  } catch (error) {
+    console.error(
+      `claude code availability probe failed: ${error instanceof Error ? error.message : String(error)}`
+    );
     return false;
   }
 }
@@ -10417,6 +10971,21 @@ async function startClaudeCodeSession(options) {
         }
         break;
       }
+      case "interrupted": {
+        state.completedTurnCount += 1;
+        if (state.sessionId !== void 0) {
+          await options.onTranscriptEvent?.({
+            type: "turn_interrupted",
+            sessionId: state.sessionId
+          });
+        }
+        if (options.streamingInput !== void 0) {
+          await options.onTurnCompleted?.();
+          resetClaudeAssistantAggregate(state);
+          state.resultText = void 0;
+        }
+        break;
+      }
       case "error":
         return await failClaudeCodeSession(
           options,
@@ -10447,14 +11016,14 @@ async function emitClaudeCodeTurnCompleted(options, state) {
 async function completeClaudeCodeSession(options, state) {
   const body = state.resultText ?? nonEmptyText(claudeAssistantAggregateText(state));
   if (body === void 0) {
-    await failClaudeCodeSession(
+    return await failClaudeCodeSession(
       options,
       state.sessionId,
       "Claude Code completed without a text response"
     );
   }
   if (state.sessionId === void 0) {
-    await failClaudeCodeSession(
+    return await failClaudeCodeSession(
       options,
       void 0,
       "Claude Code completed without a session id"
@@ -10537,8 +11106,9 @@ async function failClaudeCodeSession(options, sessionId, reason) {
 }
 async function* defaultClaudeCodeRunner(options) {
   const sdk = await import("@anthropic-ai/claude-agent-sdk");
+  const prompt = options.streamingInput?.messages ?? options.prompt;
   const query = sdk.query({
-    prompt: options.streamingInput?.messages ?? options.prompt,
+    prompt,
     options: {
       cwd: options.cwd,
       persistSession: true,
@@ -10552,8 +11122,27 @@ async function* defaultClaudeCodeRunner(options) {
         preset: "claude_code",
         ...options.developerInstructions === void 0 ? {} : { append: options.developerInstructions }
       },
+      ...options.mcpServers === void 0 ? {} : {
+        mcpServers: options.mcpServers
+      },
+      ...options.allowedTools === void 0 ? {} : { allowedTools: [...options.allowedTools] },
+      ...options.env === void 0 ? {} : { env: options.env },
       ...options.canUseTool === void 0 ? { hooks: claudeCodePolicyDeferHooks() } : { canUseTool: claudeCodeCanUseTool(options.canUseTool) },
       ...options.model === void 0 ? {} : { model: options.model }
+      // exactOptionalPropertyTypes: the conditional spreads build a union the
+      // SDK's Options cannot absorb verbatim; the shape is correct field-wise.
+    }
+  });
+  const handle = query;
+  options.onSessionControls?.({
+    interrupt: async () => {
+      await handle.interrupt?.call(query);
+    },
+    setModel: async (model) => {
+      await handle.setModel?.call(query, model);
+    },
+    setPermissionMode: async (mode) => {
+      await handle.setPermissionMode?.call(query, mode);
     }
   });
   try {
@@ -10676,6 +11265,9 @@ function extractClaudeResultOutcome(message) {
   }
   const subtype = stringValue(messageObject?.subtype);
   const isError = messageObject?.is_error === true;
+  if (subtype === "interrupt" || subtype === "error_interrupted" || messageObject?.is_interrupt === true) {
+    return { type: "interrupted" };
+  }
   if (isError || subtype === "error_max_turns" || subtype === "error_during_execution") {
     return {
       type: "error",
@@ -10720,8 +11312,12 @@ function streamTranscriptEvents(message, sessionId) {
   switch (stringValue(event?.type)) {
     case "content_block_delta": {
       const delta = objectValue(event?.delta);
-      const text2 = typeof delta?.text === "string" ? nonEmptyStreamDelta(delta.text) : void 0;
       const itemKey = streamItemKey(event, message);
+      if (stringValue(delta?.type) === "thinking_delta") {
+        const thinking = typeof delta?.thinking === "string" ? nonEmptyStreamDelta(delta.thinking) : void 0;
+        return thinking === void 0 ? [] : [{ type: "reasoning_delta", sessionId, itemKey, delta: thinking }];
+      }
+      const text2 = typeof delta?.text === "string" ? nonEmptyStreamDelta(delta.text) : void 0;
       return text2 === void 0 ? [] : [{ type: "assistant_delta", sessionId, itemKey, delta: text2 }];
     }
     case "content_block_start": {
@@ -10816,47 +11412,27 @@ function transcriptEventsForContentBlock(block, sessionId, itemKey) {
         }
       ];
     }
+    case "thinking": {
+      const content = nonEmptyText(stringValue(block?.thinking));
+      return content === void 0 ? [] : [{ type: "reasoning_message", sessionId, itemKey, content }];
+    }
     case "tool_use": {
       const toolName2 = stringValue(block?.name) ?? "tool";
       const input = objectValue(block?.input) ?? {};
-      const toolCall = {
-        type: "tool_call",
-        sessionId,
-        itemKey,
-        toolName: toolName2,
-        input
-      };
-      const fileChange = fileChangeEventForToolUse(
-        sessionId,
-        itemKey,
-        toolName2,
-        input
-      );
-      return fileChange === void 0 ? [toolCall] : [toolCall, fileChange];
+      return [
+        {
+          type: "tool_call",
+          sessionId,
+          itemKey,
+          toolName: toolName2,
+          input
+        }
+      ];
     }
     default:
       return [];
   }
 }
-function fileChangeEventForToolUse(sessionId, itemKey, toolName2, input) {
-  switch (toolName2) {
-    case "Edit":
-    case "MultiEdit":
-    case "Write":
-    case "NotebookEdit": {
-      const path2 = stringValue(input.file_path) ?? stringValue(input.filePath) ?? stringValue(input.notebook_path);
-      return {
-        type: "file_change",
-        sessionId,
-        itemKey: `file:${itemKey}`,
-        path: path2,
-        summary: `${toolName2}${path2 === void 0 ? "" : ` ${path2}`}`
-      };
-    }
-    default:
-      return void 0;
-  }
-}
 function unknownTranscriptEvent(message, sessionId) {
   const type = stringValue(message?.type);
   if (type === void 0 || type === "keep_alive") {
@@ -11095,9 +11671,9 @@ function closeStream(stream) {
   if (stream.closed || stream.destroyed) {
     return Promise.resolve();
   }
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     stream.once("error", reject);
-    stream.end(resolve11);
+    stream.end(resolve12);
   });
 }
 var sensitiveMarker, sensitiveQueryParams, sensitiveArgFlags;
@@ -11261,7 +11837,7 @@ import {
 import { createServer } from "node:net";
 import { WebSocket as NodeWebSocket } from "ws";
 async function chooseLoopbackPort() {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const server = createServer();
     server.on("error", (error) => reject(error));
     server.listen(0, "127.0.0.1", () => {
@@ -11272,7 +11848,7 @@ async function chooseLoopbackPort() {
           if (error !== void 0) {
             reject(error);
           } else {
-            resolve11(port);
+            resolve12(port);
           }
         });
       } else {
@@ -11457,7 +12033,26 @@ function codexConfigArgs(options) {
     ...options.fast === true ? ["-c", `service_tier=${JSON.stringify("fast")}`] : [],
     ...(options.mcpServers ?? []).flatMap(
       (server) => codexMcpConfigArgs(server)
-    )
+    ),
+    ...options.modelProvider === void 0 ? [] : codexModelProviderConfigArgs(options.modelProvider)
+  ];
+}
+function codexModelProviderConfigArgs(provider) {
+  return [
+    "-c",
+    `model_providers.${provider.id}.name=${JSON.stringify(provider.name)}`,
+    "-c",
+    `model_providers.${provider.id}.base_url=${JSON.stringify(provider.baseUrl)}`,
+    "-c",
+    `model_providers.${provider.id}.env_key=${JSON.stringify(provider.envKey)}`,
+    "-c",
+    `model_providers.${provider.id}.wire_api=${JSON.stringify(provider.wireApi)}`,
+    ...Object.entries(provider.httpHeaders ?? {}).flatMap(([header, value]) => [
+      "-c",
+      `model_providers.${provider.id}.http_headers.${header}=${JSON.stringify(value)}`
+    ]),
+    "-c",
+    `model_provider=${JSON.stringify(provider.id)}`
   ];
 }
 async function connectCodexAppServer(websocketUrl, socketFactory = (url) => new NodeWebSocket(url)) {
@@ -11690,14 +12285,14 @@ function sendRequest(websocket, pending, message) {
   if (websocket.readyState !== WebSocket.OPEN) {
     return Promise.reject(new Error("codex app-server websocket is not open"));
   }
-  return new Promise((resolve11, reject) => {
-    pending.set(message.id, { resolve: resolve11, reject });
+  return new Promise((resolve12, reject) => {
+    pending.set(message.id, { resolve: resolve12, reject });
     websocket.send(JSON.stringify(message));
   });
 }
 function waitForOpen2(websocket) {
-  return new Promise((resolve11, reject) => {
-    websocket.addEventListener("open", () => resolve11(), { once: true });
+  return new Promise((resolve12, reject) => {
+    websocket.addEventListener("open", () => resolve12(), { once: true });
     websocket.addEventListener(
       "error",
       () => reject(new Error("websocket open failed")),
@@ -11710,7 +12305,7 @@ function waitForOpen2(websocket) {
 function waitForReadyz(websocketUrl, child, timeoutMs = 1e4) {
   const readyzUrl = readyzUrlForWebsocket(websocketUrl);
   const deadline = Date.now() + timeoutMs;
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     let settled = false;
     let timer;
     const finish = (result) => {
@@ -11723,7 +12318,7 @@ function waitForReadyz(websocketUrl, child, timeoutMs = 1e4) {
       }
       child.off("exit", onExit2);
       if (result === "ready") {
-        resolve11();
+        resolve12();
       } else {
         reject(result);
       }
@@ -11782,19 +12377,19 @@ var init_codexAppServer = __esm({
 
 // src/codexProjectTrust.ts
 import {
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   mkdirSync as mkdirSync3,
   readFileSync as readFileSync4,
   realpathSync,
   writeFileSync
 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { join as join6, resolve as resolve2 } from "node:path";
+import { join as join6, resolve as resolve3 } from "node:path";
 function ensureCodexProjectTrusted(projectPath, options = {}) {
-  const trustedPath = realpathSync(resolve2(projectPath));
+  const trustedPath = realpathSync(resolve3(projectPath));
   const configHome = options.configHome ?? process.env.CODEX_HOME ?? join6(homedir5(), ".codex");
   const configPath = join6(configHome, "config.toml");
-  const currentConfig = existsSync2(configPath) ? readFileSync4(configPath, "utf8") : "";
+  const currentConfig = existsSync3(configPath) ? readFileSync4(configPath, "utf8") : "";
   const nextConfig = codexConfigWithTrustedProject(currentConfig, trustedPath);
   if (nextConfig !== currentConfig) {
     mkdirSync3(configHome, { recursive: true });
@@ -12144,7 +12739,7 @@ var init_codexNotificationConsoleStats = __esm({
 // src/localCapabilities.ts
 import { realpathSync as realpathSync2 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve3 } from "node:path";
+import { isAbsolute as isAbsolute3, relative as relative2, resolve as resolve4 } from "node:path";
 function parseAllowedCwdList(value) {
   if (value === void 0) {
     return [];
@@ -12172,7 +12767,7 @@ function parseAllowedPortList(value) {
 function assertConfiguredAllowedCwds(paths) {
   const allowed = paths.flatMap((path2) => {
     try {
-      const absolutePath = resolve3(expandUserPath(path2));
+      const absolutePath = resolve4(expandUserPath(path2));
       const realPath = realpathSync2(absolutePath);
       return realPath === absolutePath ? [realPath] : [realPath, absolutePath];
     } catch (_error) {
@@ -12186,7 +12781,7 @@ function expandUserPath(pathValue) {
     return currentHomeDirectory();
   }
   if (pathValue.startsWith("~/")) {
-    return resolve3(currentHomeDirectory(), pathValue.slice(2));
+    return resolve4(currentHomeDirectory(), pathValue.slice(2));
   }
   return pathValue;
 }
@@ -12203,7 +12798,7 @@ function resolveAllowedCwd(requestedCwd, allowedRoots) {
   }
   let cwd;
   try {
-    cwd = realpathSync2(resolve3(requestedCwd));
+    cwd = realpathSync2(resolve4(requestedCwd));
   } catch (_error) {
     return { ok: false, reason: "cwd_not_found" };
   }
@@ -12219,7 +12814,7 @@ function relativePathIsInsideRoot(pathRelativeToRoot) {
   return pathRelativeToRoot === "" || !pathLooksAbsolute(pathRelativeToRoot) && pathRelativeToRoot !== ".." && !pathRelativeToRoot.startsWith("../") && !pathRelativeToRoot.startsWith("..\\") && !pathRelativeToRoot.includes("/../") && !pathRelativeToRoot.includes("\\..\\");
 }
 function pathLooksAbsolute(pathValue) {
-  return isAbsolute2(pathValue) || /^[A-Za-z]:[\\/]/.test(pathValue) || pathValue.startsWith("\\\\");
+  return isAbsolute3(pathValue) || /^[A-Za-z]:[\\/]/.test(pathValue) || pathValue.startsWith("\\\\");
 }
 var init_localCapabilities = __esm({
   "src/localCapabilities.ts"() {
@@ -12431,7 +13026,7 @@ function stringBodyField(body, key) {
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
 }
 function startCallbackServer(args) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     let resolveCallback;
     let rejectCallback;
     const callbackPromise = new Promise((callbackResolve, callbackReject) => {
@@ -12487,7 +13082,7 @@ function startCallbackServer(args) {
         );
         return;
       }
-      resolve11({
+      resolve12({
         redirectUri: `http://${args.host}:${address.port}/callback`,
         waitForCallback: () => callbackPromise,
         close: () => {
@@ -12540,7 +13135,7 @@ function escapeHtml(value) {
 function openBrowser(url) {
   const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
   const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     writeCliAuditEvent("process.spawn", {
       command,
       args,
@@ -12553,10 +13148,10 @@ function openBrowser(url) {
       pid: child.pid,
       purpose: "oauth.open_browser"
     });
-    child.on("error", () => resolve11());
+    child.on("error", () => resolve12());
     child.on("spawn", () => {
       child.unref();
-      resolve11();
+      resolve12();
     });
   });
 }
@@ -12571,7 +13166,7 @@ var init_oauth = __esm({
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   chmodSync,
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   linkSync,
   mkdirSync as mkdirSync4,
   readFileSync as readFileSync5,
@@ -12580,10 +13175,10 @@ import {
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { basename as basename3, dirname as dirname3, join as join7, resolve as resolve4 } from "node:path";
+import { basename as basename3, dirname as dirname3, join as join7, resolve as resolve5 } from "node:path";
 function localConfigPath(env = process.env) {
   const override = env.LINZUMI_CONFIG_FILE;
-  return override !== void 0 && override.trim() !== "" ? resolve4(expandUserPath(override)) : resolve4(homedir7(), ".linzumi", "config.json");
+  return override !== void 0 && override.trim() !== "" ? resolve5(expandUserPath(override)) : resolve5(homedir7(), ".linzumi", "config.json");
 }
 function localConfigScopeKey(linzumiUrl) {
   const normalizedUrl = kandanHttpBaseUrl(linzumiUrl);
@@ -12689,7 +13284,7 @@ function readConfiguredAllowedCwdDetailsFromConfig(config) {
   const allowedCwds = [];
   const missingAllowedCwds = [];
   for (const cwd of config.allowedCwds) {
-    const absolutePath = resolve4(expandUserPath(cwd));
+    const absolutePath = resolve5(expandUserPath(cwd));
     try {
       const realPath = realpathSync3(absolutePath);
       allowedCwds.push(
@@ -12719,7 +13314,7 @@ function replaceAllowedCwdsForLinzumiUrl(pathValues, linzumiUrl, path2 = localCo
   const allowedCwds = uniqueStrings(
     pathValues.flatMap((pathValue) => {
       const trimmedPath = pathValue.trim();
-      return trimmedPath === "" ? [] : [realpathOrResolved(resolve4(expandUserPath(trimmedPath)))];
+      return trimmedPath === "" ? [] : [realpathOrResolved(resolve5(expandUserPath(trimmedPath)))];
     })
   );
   writeLocalConfigSection(
@@ -12730,7 +13325,7 @@ function replaceAllowedCwdsForLinzumiUrl(pathValues, linzumiUrl, path2 = localCo
   return allowedCwds;
 }
 function addAllowedCwdToConfig(pathValue, path2, linzumiUrl) {
-  const normalizedPath = realpathSync3(resolve4(expandUserPath(pathValue)));
+  const normalizedPath = realpathSync3(resolve5(expandUserPath(pathValue)));
   const config = readLocalConfigSection(path2, linzumiUrl);
   const allowedCwds = uniqueStrings([...config.allowedCwds, normalizedPath]);
   writeLocalConfigSection(
@@ -12747,7 +13342,7 @@ function removeAllowedCwdForLinzumiUrl(pathValue, linzumiUrl, path2 = localConfi
   return removeAllowedCwdFromConfig(pathValue, path2, linzumiUrl);
 }
 function removeAllowedCwdFromConfig(pathValue, path2, linzumiUrl) {
-  const requestedPath = resolve4(expandUserPath(pathValue));
+  const requestedPath = resolve5(expandUserPath(pathValue));
   const normalizedRequest = realpathOrResolved(requestedPath);
   const config = readLocalConfigSection(path2, linzumiUrl);
   const allowedCwds = config.allowedCwds.filter((cwd) => {
@@ -12813,7 +13408,7 @@ function writeLocalSignupAuth(auth, path2 = localConfigPath()) {
   return signupAuthFromJson(nextSignupAuth);
 }
 function writeLocalConfigJson(path2, payload) {
-  if (existsSync3(path2)) {
+  if (existsSync4(path2)) {
     chmodSync(path2, localConfigFileMode);
   }
   writeFileSync2(path2, `${JSON.stringify(payload, null, 2)}
@@ -12840,7 +13435,7 @@ function writeLocalSignupCompletion(completion, path2 = localConfigPath()) {
   return writeLocalSignupAuth(completion, path2);
 }
 function readLocalConfigFile(path2) {
-  if (!existsSync3(path2)) {
+  if (!existsSync4(path2)) {
     return { version: 1, allowedCwds: [] };
   }
   const parsed = JSON.parse(readFileSync5(path2, "utf8"));
@@ -12940,7 +13535,7 @@ function runnerIdValid(value) {
 }
 function ensureLocalMachineIdSeed(configPath, createMachineId, linzumiUrl) {
   const seedPath = localMachineIdSeedPath(configPath, linzumiUrl);
-  if (existsSync3(seedPath)) {
+  if (existsSync4(seedPath)) {
     return readMachineIdSeed(seedPath);
   }
   const machineId = createMachineId();
@@ -12968,7 +13563,7 @@ function ensureLocalMachineIdSeed(configPath, createMachineId, linzumiUrl) {
 }
 function ensureLocalRunnerIdSeed(configPath, createRunnerId, linzumiUrl) {
   const seedPath = localRunnerIdSeedPath(configPath, linzumiUrl);
-  if (existsSync3(seedPath)) {
+  if (existsSync4(seedPath)) {
     return readRunnerIdSeed(seedPath);
   }
   const runnerId = createRunnerId();
@@ -13026,9 +13621,9 @@ function isNodeErrorCode(error, code) {
 }
 function realpathOrResolved(pathValue) {
   try {
-    return realpathSync3(resolve4(expandUserPath(pathValue)));
+    return realpathSync3(resolve5(expandUserPath(pathValue)));
   } catch (_error) {
-    return resolve4(expandUserPath(pathValue));
+    return resolve5(expandUserPath(pathValue));
   }
 }
 var localConfigFileMode, prodConfigScope;
@@ -13189,10 +13784,10 @@ function runSandboxRunnerWithTimeout(sandboxRunner, request, parentAbortSignal)
     }
     throw error;
   });
-  const timeoutPromise = new Promise((resolve11) => {
+  const timeoutPromise = new Promise((resolve12) => {
     timeout = setTimeout(() => {
       timedOut = true;
-      resolve11(timeoutResult);
+      resolve12(timeoutResult);
       abortController.abort();
     }, request.timeoutMs);
   });
@@ -13301,8 +13896,8 @@ var init_remoteCodexExecutionContext = __esm({
 });
 
 // src/helloLinzumiProject.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync6, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname4, join as join8, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync6, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname4, join as join8, resolve as resolve6 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function createHelloLinzumiProject(input = {}) {
   const options = typeof input === "string" ? { rootPath: input } : input;
@@ -13328,10 +13923,10 @@ function resolveHelloProjectRoot(options) {
     throw new Error("linzumi init-hello-linzumi-demo-app accepts either --dir or --parent-dir/--name, not both");
   }
   if (options.rootPath !== void 0) {
-    return resolve5(options.rootPath);
+    return resolve6(options.rootPath);
   }
   const name = normalizeProjectName(options.name ?? defaultHelloLinzumiProjectName);
-  return resolve5(options.parentDir ?? defaultHelloLinzumiParentDir, name);
+  return resolve6(options.parentDir ?? defaultHelloLinzumiParentDir, name);
 }
 function normalizeProjectName(value) {
   const name = value.trim();
@@ -13354,11 +13949,11 @@ function assertTcpPort(port) {
   throw new Error("--port must be a TCP port from 1 to 65535");
 }
 function assertWritableDemoRoot(root, reset) {
-  if (!existsSync4(root)) {
+  if (!existsSync5(root)) {
     return;
   }
   const markerPath = join8(root, markerFile);
-  const isDemoRoot = existsSync4(markerPath) && readFileSync6(markerPath, "utf8").trim() === "hello-linzumi";
+  const isDemoRoot = existsSync5(markerPath) && readFileSync6(markerPath, "utf8").trim() === "hello-linzumi";
   if (isDemoRoot && reset) {
     rmSync(root, { recursive: true, force: true });
     return;
@@ -14194,7 +14789,7 @@ import { spawn as spawn3 } from "node:child_process";
 import {
   copyFileSync,
   cpSync,
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync6,
   mkdtempSync,
   readFileSync as readFileSync7,
@@ -14523,9 +15118,9 @@ function ensureCodeServerBrowserExtensionAssets(runtime) {
   ];
   repairs.forEach(({ source, target, required: required3 }) => {
     switch (true) {
-      case existsSync5(target):
+      case existsSync6(target):
         return;
-      case (!required3 && !existsSync5(source)):
+      case (!required3 && !existsSync6(source)):
         return;
       default:
         mkdirSync6(dirname5(target), { recursive: true });
@@ -14543,7 +15138,7 @@ function codeServerVscodeRoot(runtime) {
     )
   ]);
   const rootWithRequiredAssets = roots.find(
-    (root) => codeServerBrowserAssetSources(root).every((source) => existsSync5(source))
+    (root) => codeServerBrowserAssetSources(root).every((source) => existsSync6(source))
   );
   const fallbackRoot = roots[0];
   if (fallbackRoot === void 0) {
@@ -14692,7 +15287,7 @@ function resolveCodeServerExecutable(command, envPath) {
       continue;
     }
     const candidate = join9(directory, command);
-    if (!existsSync5(candidate)) {
+    if (!existsSync6(candidate)) {
       continue;
     }
     const realpath2 = realpathSync4(candidate);
@@ -14920,7 +15515,7 @@ function sameCollaboration(running, requested) {
   return running.editorSessionId === requested.editorSessionId && running.runtimeSessionId === requested.runtimeSessionId && running.roomId === requested.roomId;
 }
 function runProcess(command, args) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     writeCliAuditEvent("process.spawn", {
       command,
       args,
@@ -14946,7 +15541,7 @@ function runProcess(command, args) {
         purpose: "local_editor.install_process"
       });
       if (code === 0) {
-        resolve11();
+        resolve12();
       } else {
         reject(new Error(`${command} exited with ${code ?? "unknown"}`));
       }
@@ -14954,7 +15549,7 @@ function runProcess(command, args) {
   });
 }
 function waitForCodeServerExit(child) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     let settled = false;
     const cleanup = () => {
       child.off("exit", onDone);
@@ -14966,7 +15561,7 @@ function waitForCodeServerExit(child) {
       }
       settled = true;
       cleanup();
-      resolve11();
+      resolve12();
     };
     child.once("exit", onDone);
     child.once("close", onDone);
@@ -14978,7 +15573,7 @@ function waitForCodeServerExit(child) {
 function waitForCodeServerReady(port, exited, timeoutMs = 1e4) {
   const deadline = Date.now() + timeoutMs;
   const readyUrl = `http://127.0.0.1:${port}/`;
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     let settled = false;
     let timer;
     const finish = (result) => {
@@ -14989,7 +15584,7 @@ function waitForCodeServerReady(port, exited, timeoutMs = 1e4) {
       if (timer !== void 0) {
         clearTimeout(timer);
       }
-      resolve11(result);
+      resolve12(result);
     };
     const scheduleCheck = () => {
       timer = setTimeout(checkReady, 50);
@@ -15018,7 +15613,7 @@ function waitForCodeServerReady(port, exited, timeoutMs = 1e4) {
 function waitForCollaborationServerReady(port, exited, timeoutMs = 1e4) {
   const deadline = Date.now() + timeoutMs;
   const readyUrl = `http://127.0.0.1:${port}/api/login/initial`;
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     let settled = false;
     let timer;
     const finish = (result) => {
@@ -15029,7 +15624,7 @@ function waitForCollaborationServerReady(port, exited, timeoutMs = 1e4) {
       if (timer !== void 0) {
         clearTimeout(timer);
       }
-      resolve11(result);
+      resolve12(result);
     };
     const scheduleCheck = () => {
       timer = setTimeout(checkReady, 50);
@@ -15056,7 +15651,7 @@ function waitForCollaborationServerReady(port, exited, timeoutMs = 1e4) {
   });
 }
 function waitForCodeServerSpawn(child) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     let settled = false;
     const cleanup = () => {
       child.off("spawn", onSpawn);
@@ -15068,7 +15663,7 @@ function waitForCodeServerSpawn(child) {
       }
       settled = true;
       cleanup();
-      resolve11("spawned");
+      resolve12("spawned");
     };
     const onError = () => {
       if (settled) {
@@ -15076,7 +15671,7 @@ function waitForCodeServerSpawn(child) {
       }
       settled = true;
       cleanup();
-      resolve11("failed");
+      resolve12("failed");
     };
     child.once("spawn", onSpawn);
     child.once("error", onError);
@@ -15102,7 +15697,7 @@ import { createHash as createHash4 } from "node:crypto";
 import {
   createReadStream,
   createWriteStream as createWriteStream2,
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   mkdirSync as mkdirSync7,
   mkdtempSync as mkdtempSync2,
   readFileSync as readFileSync8,
@@ -15111,7 +15706,7 @@ import {
   writeFileSync as writeFileSync5
 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname6, join as join10, resolve as resolve6 } from "node:path";
+import { dirname as dirname6, join as join10, resolve as resolve7 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 async function resolveEditorRuntime(options) {
@@ -15305,7 +15900,7 @@ function installedRuntime(cacheRoot, manifest) {
   const manifestPath = join10(runtimeRoot, manifest.manifestPath);
   const codeServerBin = join10(runtimeRoot, manifest.codeServerBinPath);
   const assets = verifiedRuntimeAssetPaths(runtimeRoot, manifest);
-  if (!existsSync6(manifestPath) || !existsSync6(codeServerBin) || assets === void 0) {
+  if (!existsSync7(manifestPath) || !existsSync7(codeServerBin) || assets === void 0) {
     return { ok: false };
   }
   try {
@@ -15358,7 +15953,7 @@ async function installRuntime(args) {
     const manifestPath = join10(extractRoot, args.manifest.manifestPath);
     const codeServerBin = join10(extractRoot, args.manifest.codeServerBinPath);
     const assets = verifiedRuntimeAssetPaths(extractRoot, args.manifest);
-    if (!existsSync6(codeServerBin) || assets === void 0) {
+    if (!existsSync7(codeServerBin) || assets === void 0) {
       return { ok: false, reason: "invalid_archive" };
     }
     mkdirSync7(dirname6(manifestPath), { recursive: true });
@@ -15516,7 +16111,7 @@ function fileSha256(path2) {
   });
 }
 function runtimeInstallRoot(cacheRoot, manifest) {
-  return resolve6(cacheRoot, manifest.platform, manifest.archiveSha256);
+  return resolve7(cacheRoot, manifest.platform, manifest.archiveSha256);
 }
 function verifiedRuntimeAssetPaths(runtimeRoot, manifest) {
   const collaborationExtensionTarball = join10(
@@ -15572,14 +16167,14 @@ function verifiedRuntimeAssetPaths(runtimeRoot, manifest) {
       return void 0;
     }
     const absolutePath = join10(runtimeRoot, relativePath);
-    if (!existsSync6(absolutePath)) {
+    if (!existsSync7(absolutePath)) {
       return void 0;
     }
     if (expectedSha256 !== void 0 && fileSha256Sync(absolutePath) !== expectedSha256) {
       return void 0;
     }
   }
-  if (!existsSync6(collaborationExtensionTarball) || !existsSync6(collaborationServerTarball)) {
+  if (!existsSync7(collaborationExtensionTarball) || !existsSync7(collaborationServerTarball)) {
     return void 0;
   }
   return {
@@ -15625,7 +16220,7 @@ var init_localEditorRuntime = __esm({
 import { spawn as spawn5, spawnSync as spawnSync3 } from "node:child_process";
 import { delimiter as delimiter2, dirname as dirname7, join as join11 } from "node:path";
 function probeTool(command, cwd) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const args = ["--version"];
     writeCliAuditEvent("process.spawn", {
       command,
@@ -15654,7 +16249,7 @@ function probeTool(command, cwd) {
       }
       resolved = true;
       clearTimeout(timeout);
-      resolve11(status);
+      resolve12(status);
     };
     const timeout = setTimeout(() => {
       killDependencyProbe(child.pid);
@@ -15901,7 +16496,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.80-beta";
+    linzumiCliVersion = "0.0.81-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -15909,7 +16504,7 @@ var init_version = __esm({
 // src/runnerLock.ts
 import {
   closeSync,
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   mkdirSync as mkdirSync8,
   openSync as openSync2,
   readFileSync as readFileSync9,
@@ -15972,7 +16567,7 @@ function rejectLiveLegacyProductionRunnerLock(machineId, configPath, linzumiUrl,
     throw new Error(activeRunnerLockMessage(legacyPath, existing));
   }
   withStaleReplacementLock(legacyPath, isPidAlive, () => {
-    const latest = existsSync7(legacyPath) ? readRunnerLock(legacyPath) : void 0;
+    const latest = existsSync8(legacyPath) ? readRunnerLock(legacyPath) : void 0;
     if (latest !== void 0 && isPidAlive(latest.pid)) {
       throw new Error(activeRunnerLockMessage(legacyPath, latest));
     }
@@ -16000,7 +16595,7 @@ function writeLockOrHandleExisting(path2, record, isPidAlive, beforeReadExisting
   }
   beforeReplaceStaleLock?.();
   withStaleReplacementLock(path2, isPidAlive, () => {
-    const latest = existsSync7(path2) ? readRunnerLock(path2) : void 0;
+    const latest = existsSync8(path2) ? readRunnerLock(path2) : void 0;
     if (latest !== void 0 && isPidAlive(latest.pid)) {
       throw new Error(activeRunnerLockMessage(path2, latest));
     }
@@ -16098,7 +16693,7 @@ function readRunnerLockForRelease(path2) {
   }
 }
 function readRunnerLockIfPresent(path2) {
-  if (!existsSync7(path2)) {
+  if (!existsSync8(path2)) {
     return void 0;
   }
   try {
@@ -17655,111 +18250,6 @@ var init_runnerConsoleReporter = __esm({
   }
 });
 
-// src/streamDeltaQueue.ts
-function createStreamDeltaQueue() {
-  return {
-    pending: [],
-    timer: void 0,
-    chain: Promise.resolve(),
-    retryAttempts: 0,
-    retryTimer: void 0
-  };
-}
-function enqueueStreamDelta(queue, delta, runtime) {
-  queue.pending.push(delta);
-  scheduleStreamDeltaFlush(queue, runtime);
-}
-function flushStreamDeltaQueue(queue, runtime) {
-  clearStreamDeltaFlushTimer(queue);
-  if (queue.retryTimer !== void 0) {
-    return;
-  }
-  const pending = queue.pending;
-  if (pending.length === 0) {
-    return;
-  }
-  queue.pending = [];
-  const deltas = runtime.coalesce(pending);
-  const previous = queue.chain;
-  const next = previous.catch(() => void 0).then(() => forwardCoalescedStreamDeltas(queue, runtime, deltas));
-  queue.chain = next.catch((error) => {
-    runtime.logFailure(runtime.firstTurnId(deltas), error);
-  });
-}
-async function forwardCoalescedStreamDeltas(queue, runtime, deltas) {
-  for (let index = 0; index < deltas.length; index += 1) {
-    const delta = deltas[index];
-    if (delta === void 0) {
-      continue;
-    }
-    try {
-      await runtime.forward(delta);
-    } catch (error) {
-      handleStreamDeltaForwardFailure(queue, runtime, deltas.slice(index), error);
-      return;
-    }
-  }
-  queue.retryAttempts = 0;
-}
-function handleStreamDeltaForwardFailure(queue, runtime, unsent, error) {
-  runtime.logFailure(runtime.firstTurnId(unsent), error);
-  queue.retryAttempts += 1;
-  const maxRetries = runtime.maxFlushRetries ?? defaultMaxFlushRetries;
-  if (queue.retryAttempts > maxRetries) {
-    queue.retryAttempts = 0;
-    runtime.onPermanentFailure?.(unsent, error);
-    clearStreamDeltaRetryTimer(queue);
-    if (queue.pending.length > 0) {
-      scheduleStreamDeltaFlush(queue, runtime);
-    }
-    return;
-  }
-  queue.pending = [...unsent, ...queue.pending];
-  const retryAttempt = queue.retryAttempts;
-  queue.retryTimer = setTimeout(() => {
-    queue.retryTimer = void 0;
-    flushStreamDeltaQueue(queue, runtime);
-  }, streamDeltaRetryDelayMs(runtime, retryAttempt));
-}
-function streamDeltaRetryDelayMs(runtime, retryAttempt) {
-  if (runtime.retryDelayMs !== void 0) {
-    return runtime.retryDelayMs(retryAttempt);
-  }
-  return Math.min(500 * 2 ** (retryAttempt - 1), 1e4);
-}
-function clearStreamDeltaFlushTimer(queue) {
-  if (queue.timer !== void 0) {
-    clearTimeout(queue.timer);
-    queue.timer = void 0;
-  }
-}
-function clearStreamDeltaRetryTimer(queue) {
-  if (queue.retryTimer !== void 0) {
-    clearTimeout(queue.retryTimer);
-    queue.retryTimer = void 0;
-  }
-}
-function scheduleStreamDeltaFlush(queue, runtime) {
-  if (queue.timer !== void 0 || queue.retryTimer !== void 0) {
-    return;
-  }
-  if (runtime.flushIntervalMs <= 0) {
-    flushStreamDeltaQueue(queue, runtime);
-    return;
-  }
-  queue.timer = setTimeout(() => {
-    queue.timer = void 0;
-    flushStreamDeltaQueue(queue, runtime);
-  }, runtime.flushIntervalMs);
-}
-var defaultMaxFlushRetries;
-var init_streamDeltaQueue = __esm({
-  "src/streamDeltaQueue.ts"() {
-    "use strict";
-    defaultMaxFlushRetries = 5;
-  }
-});
-
 // src/telemetry.ts
 import { mkdirSync as mkdirSync9, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "node:fs";
 import { dirname as dirname9, basename as basename5, join as join13 } from "node:path";
@@ -18004,7 +18494,7 @@ var init_linzumiApiClient = __esm({
 // src/onboardingConversationDiscovery.ts
 import {
   closeSync as closeSync2,
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   openSync as openSync3,
   readdirSync as readdirSync2,
   readFileSync as readFileSync11,
@@ -18115,7 +18605,7 @@ function candidateFromRecord(record) {
   }
 }
 function listJsonlFiles(root) {
-  if (!existsSync8(root)) {
+  if (!existsSync9(root)) {
     return [];
   }
   const walk = (directory) => {
@@ -18136,7 +18626,7 @@ function listJsonlFiles(root) {
   return walk(root);
 }
 function existingPathCount(paths) {
-  return paths.filter((path2) => existsSync8(path2)).length;
+  return paths.filter((path2) => existsSync9(path2)).length;
 }
 function codexCandidateFromPath(path2, activityAt) {
   const lines = boundedJsonLines(path2);
@@ -18507,7 +18997,7 @@ var init_onboardingConversationDiscovery = __esm({
 // src/onboardingProjectDiscovery.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
 import { homedir as homedir10 } from "node:os";
-import { existsSync as existsSync9, readdirSync as readdirSync3, readFileSync as readFileSync12, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync10, readdirSync as readdirSync3, readFileSync as readFileSync12, statSync as statSync2 } from "node:fs";
 import { basename as basename7, dirname as dirname10, join as join15 } from "node:path";
 function discoverCurrentGitProject(args) {
   const startedAtMs = args.nowMs ?? Date.now();
@@ -18672,7 +19162,7 @@ function discoverGitWorktreesInSourceRoot(sourceRoot) {
   }
 }
 function isGitWorktreeRoot(path2) {
-  return existsSync9(join15(path2, ".git"));
+  return existsSync10(join15(path2, ".git"));
 }
 function defaultLocalProjectSourceRoots(cwd) {
   return uniqueStrings2([
@@ -18766,7 +19256,7 @@ function gitWorktrees(cwd) {
   );
 }
 function readmeProjectName(projectPath) {
-  const readmePath = ["README.md", "README.markdown", "readme.md"].map((fileName) => join15(projectPath, fileName)).find((path2) => existsSync9(path2));
+  const readmePath = ["README.md", "README.markdown", "readme.md"].map((fileName) => join15(projectPath, fileName)).find((path2) => existsSync10(path2));
   if (readmePath === void 0) {
     return void 0;
   }
@@ -18795,14 +19285,14 @@ var init_onboardingProjectDiscovery = __esm({
 });
 
 // src/authCache.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync7 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
 import { dirname as dirname11, join as join16 } from "node:path";
 function defaultAuthFilePath() {
   return join16(homedir11(), ".linzumi", "auth.json");
 }
 function readCachedLocalRunnerToken(kandanUrl, authFilePath = defaultAuthFilePath()) {
-  if (!existsSync10(authFilePath)) {
+  if (!existsSync11(authFilePath)) {
     return void 0;
   }
   const authFile = parseAuthFile(readFileSync13(authFilePath, "utf8"));
@@ -18822,7 +19312,7 @@ function readCachedLocalRunnerToken(kandanUrl, authFilePath = defaultAuthFilePat
   };
 }
 function readPersonalAgentDelegationToken(authFilePath) {
-  if (!existsSync10(authFilePath)) {
+  if (!existsSync11(authFilePath)) {
     throw new Error(
       `missing personal-agent delegation auth file: ${authFilePath}`
     );
@@ -18845,7 +19335,7 @@ function readPersonalAgentDelegationToken(authFilePath) {
 }
 function writeCachedLocalRunnerToken(args) {
   const authFilePath = args.authFilePath ?? defaultAuthFilePath();
-  const existing = existsSync10(authFilePath) ? parseAuthFile(readFileSync13(authFilePath, "utf8")) : { version: 1 };
+  const existing = existsSync11(authFilePath) ? parseAuthFile(readFileSync13(authFilePath, "utf8")) : { version: 1 };
   const kandanBaseUrl = kandanHttpBaseUrl(args.kandanUrl);
   const issuedAt = /* @__PURE__ */ new Date();
   const expiresAt = args.expiresInSeconds === void 0 ? void 0 : new Date(
@@ -19017,10 +19507,10 @@ function bindThreadCodexWorkerIpc(codex, ipc = process) {
     });
   });
   codex.onRequest(
-    (request) => new Promise((resolve11, reject) => {
+    (request) => new Promise((resolve12, reject) => {
       const id = state.nextServerRequestId;
       state.nextServerRequestId += 1;
-      pendingServerRequests.set(id, { resolve: resolve11, reject });
+      pendingServerRequests.set(id, { resolve: resolve12, reject });
       send({
         type: "linzumi_thread_codex_worker_server_request",
         id,
@@ -19109,10 +19599,10 @@ function connectThreadCodexWorkerIpc(child) {
   child.once("exit", onClosed);
   child.once("disconnect", onClosed);
   return {
-    request: (method, params) => new Promise((resolve11, reject) => {
+    request: (method, params) => new Promise((resolve12, reject) => {
       const id = state.nextRequestId;
       state.nextRequestId += 1;
-      pendingRequests.set(id, { resolve: resolve11, reject });
+      pendingRequests.set(id, { resolve: resolve12, reject });
       try {
         send({
           type: "linzumi_thread_codex_worker_request",
@@ -19526,8 +20016,8 @@ var init_signupTaskSuggestions = __esm({
 
 // src/remoteCodexSandboxRunner.ts
 import { spawn as spawn7 } from "node:child_process";
-import { existsSync as existsSync11, realpathSync as realpathSync5 } from "node:fs";
-import { dirname as dirname12, isAbsolute as isAbsolute3 } from "node:path";
+import { existsSync as existsSync12, realpathSync as realpathSync5 } from "node:fs";
+import { dirname as dirname12, isAbsolute as isAbsolute4 } from "node:path";
 function createConfiguredRemoteCodexSandboxRunner(args) {
   const kind = normalizedSandboxKind(args.env.LINZUMI_REMOTE_CODEX_SANDBOX);
   if (kind === void 0) {
@@ -19546,7 +20036,7 @@ function createConfiguredRemoteCodexSandboxRunner(args) {
       }
       break;
   }
-  if (!existsSync11(sandboxBin)) {
+  if (!existsSync12(sandboxBin)) {
     throw new Error(`remote Codex sandbox binary not found: ${sandboxBin}`);
   }
   return createRemoteCodexSandboxRunner({
@@ -19557,7 +20047,7 @@ function createConfiguredRemoteCodexSandboxRunner(args) {
 function createRemoteCodexSandboxRunner(config, deps = {}) {
   const resolvedDeps = {
     platform: deps.platform ?? process.platform,
-    exists: deps.exists ?? existsSync11,
+    exists: deps.exists ?? existsSync12,
     spawnProcess: deps.spawnProcess ?? spawn7
   };
   return (request) => runSandboxInvocation(
@@ -19591,7 +20081,7 @@ function buildRemoteCodexSandboxInvocation(config, request, deps) {
   }
 }
 function runSandboxInvocation(invocation, request, spawnProcess) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const child = spawnProcess(invocation.command, invocation.args, {
       cwd: invocation.cwd,
       env: invocation.env,
@@ -19615,7 +20105,7 @@ function runSandboxInvocation(invocation, request, spawnProcess) {
     child.on("close", (exitCode, signal) => {
       if (!settled) {
         settled = true;
-        resolve11({
+        resolve12({
           exitCode,
           signal,
           stdout: stdout.value(),
@@ -19642,7 +20132,7 @@ function bubblewrapArgs(sandboxBin, request, exists) {
   ]);
   const readOnlyBindArgs = uniqueStrings3([
     ...linuxReadOnlyRoots,
-    ...isAbsolute3(request.command) ? [dirname12(request.command)] : [],
+    ...isAbsolute4(request.command) ? [dirname12(request.command)] : [],
     dirname12(sandboxBin)
   ]).flatMap((path2) => exists(path2) ? ["--ro-bind", path2, path2] : []);
   const cwdParentDirs = parentDirs(request.cwd).flatMap((path2) => [
@@ -19676,7 +20166,7 @@ function bubblewrapArgs(sandboxBin, request, exists) {
 function macosSeatbeltProfile(request, exists) {
   const readableRoots = uniqueStrings3([
     ...macosReadOnlyRoots,
-    ...isAbsolute3(request.command) ? [dirname12(request.command)] : []
+    ...isAbsolute4(request.command) ? [dirname12(request.command)] : []
   ]).filter(exists);
   const readableRules = readableRoots.map((path2) => `(allow file-read* (subpath ${sandboxString(path2)}))`).join("\n");
   const writableTempRules = macosWritableTempRoots.filter(exists).flatMap((path2) => [
@@ -19746,7 +20236,7 @@ function requiredSandboxBin(kind, env) {
   if (value === void 0 || value.trim() === "") {
     throw new Error(`LINZUMI_REMOTE_CODEX_SANDBOX_BIN is required for ${kind}`);
   }
-  if (!isAbsolute3(value)) {
+  if (!isAbsolute4(value)) {
     throw new Error("LINZUMI_REMOTE_CODEX_SANDBOX_BIN must be absolute");
   }
   return value;
@@ -19820,9 +20310,9 @@ import {
   basename as basename8,
   dirname as dirname13,
   extname as extname2,
-  isAbsolute as isAbsolute4,
+  isAbsolute as isAbsolute5,
   join as join18,
-  resolve as resolve7
+  resolve as resolve8
 } from "node:path";
 async function runLocalCodexRunner(options) {
   const log2 = makeRunnerLogger(options);
@@ -21100,6 +21590,17 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     if (workspaceSlug === void 0 || channelSlug === void 0 || kandanThreadId === void 0) {
       return void 0;
     }
+    const waferResolution = resolveControlWaferModelProvider(control);
+    if (waferResolution.type === "error") {
+      return {
+        instanceId,
+        controlType: control.type,
+        ok: false,
+        error: waferResolution.error,
+        kandanThreadId,
+        cwd
+      };
+    }
     const existing = threadRunnerProcesses.get(kandanThreadId);
     if (existing !== void 0) {
       return {
@@ -22402,6 +22903,34 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
         if (delegated !== void 0) {
           return delegated;
         }
+        if (agentProvider === "codex") {
+          const waferControlError = waferModelProviderControlError(
+            options,
+            control
+          );
+          if (waferControlError !== void 0) {
+            try {
+              await publishStartInstanceMessageState(
+                kandan,
+                topic,
+                control,
+                "failed",
+                waferControlError,
+                { instanceId }
+              );
+            } catch (error) {
+              log2("kandan.start_instance_wafer_state_push_failed", {
+                message: error instanceof Error ? error.message : String(error)
+              });
+            }
+            return {
+              instanceId,
+              controlType: control.type,
+              ok: false,
+              error: waferControlError
+            };
+          }
+        }
         if (agentProvider === "claude-code") {
           startupStage = "starting_claude_code_session";
           const result2 = await startClaudeCodeProviderInstance({
@@ -22545,6 +23074,20 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
       if (delegated !== void 0) {
         return delegated;
       }
+      if (agentProvider === "codex") {
+        const waferControlError = waferModelProviderControlError(
+          options,
+          control
+        );
+        if (waferControlError !== void 0) {
+          return {
+            instanceId,
+            controlType: control.type,
+            ok: false,
+            error: waferControlError
+          };
+        }
+      }
       if (agentProvider === "claude-code") {
         const activeSession = activeClaudeCodeSessions.get(codexThreadId);
         if (activeSession !== void 0 && workDescription !== void 0) {
@@ -22843,6 +23386,33 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
       };
     }
     case "steer_turn": {
+      const claudeSession = activeClaudeCodeSessions.get(control.threadId);
+      if (claudeSession !== void 0) {
+        const steerText = claudeSteerInputText(control.input);
+        if (steerText === void 0) {
+          return {
+            instanceId,
+            controlType: control.type,
+            agentProvider: "claude-code",
+            ok: false,
+            error: "claude_code_steer_requires_text_input"
+          };
+        }
+        await claudeSession.interruptTurn("Steered by Linzumi");
+        claudeSession.enqueueInput({
+          content: `You were interrupted mid-task. Updated guidance from the user - continue the task with this in mind:
+
+${steerText}`,
+          sourceSeq: claudeSession.currentSourceSeq()
+        });
+        return {
+          instanceId,
+          controlType: control.type,
+          agentProvider: "claude-code",
+          steered: "steered_via_restart",
+          threadId: control.threadId
+        };
+      }
       const response = await codex.request("turn/steer", {
         threadId: control.threadId,
         turnId: control.turnId,
@@ -22855,6 +23425,19 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
       };
     }
     case "interrupt_turn": {
+      const claudeSession = activeClaudeCodeSessions.get(control.threadId);
+      if (claudeSession !== void 0) {
+        const interrupted = await claudeSession.interruptTurn(
+          "Interrupted by Linzumi"
+        );
+        return {
+          instanceId,
+          controlType: control.type,
+          agentProvider: "claude-code",
+          interrupted,
+          threadId: control.threadId
+        };
+      }
       const response = await codex.request("turn/interrupt", {
         threadId: control.threadId,
         turnId: control.turnId ?? null
@@ -22888,6 +23471,7 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
           error: "claude_code_session_not_active"
         };
       }
+      await activeSession.interruptTurn("Claude Code interrupted by Linzumi");
       activeSession.abortController.abort(
         new Error("Claude Code interrupted by Linzumi")
       );
@@ -22987,11 +23571,27 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
         response
       };
     }
+    case "update_session_settings": {
+      const claudeSession = activeClaudeCodeSessions.get(control.threadId);
+      if (claudeSession === void 0) {
+        return { instanceId, controlType: control.type, skipped: true };
+      }
+      const applied = await claudeSession.updateSettings({
+        model: stringValue(control.model) ?? void 0,
+        approvalPolicy: stringValue(control.approvalPolicy) ?? void 0
+      });
+      return {
+        instanceId,
+        controlType: control.type,
+        agentProvider: "claude-code",
+        threadId: control.threadId,
+        applied
+      };
+    }
     case "stop_instance":
     case "kill_instance":
     case "resolve_port_forward_request":
     case "update_thread_interaction_access":
-    case "update_session_settings":
     case "set_port_forward_enabled":
     case "forward_http_request":
     case "forward_tcp_open":
@@ -23283,6 +23883,52 @@ function startInstanceAgentLabel(provider) {
       return "Claude Code";
   }
 }
+function resolveControlWaferModelProvider(control) {
+  const modelProvider = stringValue(control.modelProvider)?.trim();
+  if (modelProvider === void 0 || modelProvider === "") {
+    return { type: "none" };
+  }
+  if (modelProvider !== "wafer") {
+    return {
+      type: "error",
+      error: `model_provider_unsupported:${modelProvider}`
+    };
+  }
+  const llmProxy = objectValue(control.llmProxy);
+  const baseUrl = stringValue(llmProxy?.baseUrl)?.trim();
+  const token = stringValue(llmProxy?.token)?.trim();
+  if (baseUrl === void 0 || baseUrl === "" || token === void 0 || token === "") {
+    return { type: "error", error: "wafer_model_provider_missing_llm_proxy" };
+  }
+  return {
+    type: "wafer",
+    runtime: {
+      provider: "wafer",
+      llmProxyBaseUrl: baseUrl,
+      llmProxyToken: token
+    }
+  };
+}
+function waferModelProviderControlError(options, control) {
+  const resolution = resolveControlWaferModelProvider(control);
+  switch (resolution.type) {
+    case "none":
+      return void 0;
+    case "error":
+      return resolution.error;
+    case "wafer":
+      return options.codexModelProvider?.provider === "wafer" ? void 0 : "wafer_model_provider_requires_thread_worker";
+  }
+}
+function linzumiCodexModelProviderConfig(runtime) {
+  return {
+    id: "linzumi",
+    name: "Linzumi Proxy",
+    baseUrl: `${runtime.llmProxyBaseUrl.replace(/\/+$/, "")}/v1`,
+    envKey: "LINZUMI_LLM_PROXY_TOKEN",
+    wireApi: "responses"
+  };
+}
 async function startCodexProviderInstance(args) {
   if (args.options.codexUrl === void 0) {
     args.setStartupStage("checking_project_trust");
@@ -23417,8 +24063,8 @@ function createClaudeCodeInputQueue(input) {
             if (state.closed) {
               return Promise.resolve({ done: true, value: void 0 });
             }
-            return new Promise((resolve11) => {
-              waiters.push(resolve11);
+            return new Promise((resolve12) => {
+              waiters.push(resolve12);
             });
           }
         };
@@ -23465,7 +24111,7 @@ async function waitForClaudeCodeToolApproval(args) {
   }
   let completeApproval;
   const approvalPromise = new Promise(
-    (resolve11) => {
+    (resolve12) => {
       let completed = false;
       const cleanup = () => {
         args.signal.removeEventListener("abort", onAbort);
@@ -23477,7 +24123,7 @@ async function waitForClaudeCodeToolApproval(args) {
         }
         completed = true;
         cleanup();
-        resolve11(decision);
+        resolve12(decision);
       };
       const onAbort = () => {
         complete({
@@ -23648,23 +24294,124 @@ async function startClaudeCodeProviderInstance(args) {
       validator: args.options.claudeCodeSessionValidator
     });
   }
-  const transcriptForwarder = createClaudeCodeTranscriptForwarder({
+  const payloadContext = {
+    runnerIdentity: identityFromAccessToken(args.options.token),
+    codexVersion: void 0
+  };
+  const abortController = new AbortController();
+  let activeSessionId;
+  let sessionControls;
+  const adapter = createClaudeCodeSessionPipeline({
+    instanceId: args.instanceId,
+    cwd: args.cwd,
+    threadKey: `${workspace}:${channel}:${threadId}`,
+    // Injected mock runners (tests) keep the outbox in memory; the real SDK
+    // runner journals to the commander outbox dir for restart recovery.
+    persistDir: args.options.claudeCodeRunner === void 0 ? commanderOutboxPersistDir() : void 0,
+    wire: () => ({
+      workspaceSlug: workspace,
+      channelSlug: channel,
+      kandanThreadId: threadId,
+      codexThreadId: activeSessionId ?? args.resumeSessionId,
+      rootSeq
+    }),
+    push: async (event, payload) => {
+      const reply = await args.kandan.push(args.topic, event, payload);
+      if (isJsonObject(reply) && reply.status === "ok") {
+        return reply;
+      }
+      throw new Error(
+        `kandan push failed: ${event}: ${JSON.stringify(reply).slice(0, 500)}`
+      );
+    },
+    preparePush: (event, payload) => prepareCommanderCompletedPushPayload(
+      {
+        kandan: args.kandan,
+        topic: args.topic,
+        workspace,
+        channel,
+        cwd: args.cwd,
+        kandanUrl: args.options.kandanUrl,
+        token: args.options.token,
+        fetch: args.options.fetch
+      },
+      event,
+      payload
+    ),
+    runnerPayload: (eventType, claudeSessionId, sourceMessageSeq, extra) => localRunnerPayload(
+      { ...args.options, cwd: args.cwd },
+      args.instanceId,
+      eventType,
+      claudeSessionId,
+      payloadContext,
+      sourceMessageSeq,
+      extra
+    ),
+    currentSourceSeq: inputQueue.currentSourceSeq,
+    onTurnTerminal: (turnId, outcome, reason) => {
+      args.log("claude_code.turn_terminal", {
+        turn_id: turnId,
+        outcome,
+        reason: reason ?? null,
+        thread_id: threadId,
+        claude_session_id: activeSessionId ?? null
+      });
+    },
+    log: args.log
+  });
+  let mcpAuthCleanup;
+  let mcpServers;
+  try {
+    const mcpCommand = currentLinzumiCommand();
+    const mcpAuth = writeEphemeralMcpAuthFile(args.options);
+    mcpAuthCleanup = mcpAuth.cleanup;
+    const linzumiMcp = linzumiMcpServerConfig({
+      command: mcpCommand.command,
+      argsPrefix: mcpCommand.argsPrefix,
+      kandanUrl: args.options.kandanUrl,
+      authFilePath: mcpAuth.path,
+      ownerUsername: mcpOwnerUsername(args.options),
+      operatingMode: "text",
+      cwd: args.cwd,
+      threadId
+    });
+    mcpServers = {
+      [linzumiMcp.name]: {
+        type: "stdio",
+        command: linzumiMcp.command,
+        args: [...linzumiMcp.args],
+        env: { ...linzumiMcp.env }
+      }
+    };
+  } catch (error) {
+    mcpAuthCleanup?.();
+    mcpAuthCleanup = void 0;
+    args.log("claude_code.mcp_config_failed", {
+      message: error instanceof Error ? error.message : String(error),
+      thread_id: threadId
+    });
+  }
+  const mirrorArgs = {
     kandan: args.kandan,
     topic: args.topic,
-    options: args.options,
-    instanceId: args.instanceId,
     workspace,
     channel,
     threadId,
     cwd: args.cwd,
     initialPrompt: workDescription,
-    sourceSeq: inputQueue.currentSourceSeq,
     rootSeq,
     log: args.log
-  });
-  const abortController = new AbortController();
-  let activeSessionId;
+  };
   const onTranscriptEvent = async (event) => {
+    try {
+      await mirrorClaudeSessionStoreAppend(mirrorArgs, event);
+    } catch (error) {
+      args.log("claude_code.session_store_mirror_failed", {
+        session_id: event.sessionId ?? null,
+        event_type: event.type,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
     if (event.type === "session_started") {
       activeSessionId = event.sessionId;
       args.activeClaudeCodeSessions.set(event.sessionId, {
@@ -23673,7 +24420,31 @@ async function startClaudeCodeProviderInstance(args) {
         channel,
         threadId,
         currentSourceSeq: inputQueue.currentSourceSeq,
-        enqueueInput: inputQueue.enqueue
+        enqueueInput: inputQueue.enqueue,
+        interruptTurn: async (reason) => {
+          const aborted = adapter.interruptActiveTurn(reason);
+          await sessionControls?.interrupt();
+          return aborted;
+        },
+        updateSettings: async (settings) => {
+          const applied = {};
+          if (settings.model !== void 0) {
+            await sessionControls?.setModel(
+              claudeCodeModelForRuntimeModel(settings.model)
+            );
+            applied.model = settings.model;
+          }
+          if (settings.approvalPolicy !== void 0) {
+            const mode = claudePermissionModeForApprovalPolicy(
+              settings.approvalPolicy
+            );
+            if (mode !== void 0) {
+              await sessionControls?.setPermissionMode(mode);
+              applied.approval_policy = settings.approvalPolicy;
+            }
+          }
+          return applied;
+        }
       });
       args.ensureClaudeCodeForwardPortSession?.({
         sessionId: event.sessionId,
@@ -23684,7 +24455,7 @@ async function startClaudeCodeProviderInstance(args) {
         rootSeq,
         currentSourceSeq: inputQueue.currentSourceSeq
       });
-      await transcriptForwarder.forward(event);
+      adapter.handleTranscriptEvent(event);
       await args.kandan.push(args.topic, "session:bind", {
         workspace,
         channel,
@@ -23698,8 +24469,16 @@ async function startClaudeCodeProviderInstance(args) {
       });
       return;
     }
-    await transcriptForwarder.forward(event);
+    adapter.handleTranscriptEvent(event);
   };
+  const llmProxy = objectValue(args.control.llmProxy);
+  const llmProxyBaseUrl = stringValue(llmProxy?.baseUrl)?.trim();
+  const llmProxyToken = stringValue(llmProxy?.token)?.trim();
+  const sessionEnv = llmProxyBaseUrl !== void 0 && llmProxyBaseUrl !== "" && llmProxyToken !== void 0 && llmProxyToken !== "" ? claudeCodeLlmProxyEnv(
+    process.env,
+    { baseUrl: llmProxyBaseUrl, token: llmProxyToken },
+    runtimeSettings.model
+  ) : void 0;
   const canUseTool = (request, signal) => waitForClaudeCodeToolApproval({
     kandan: args.kandan,
     topic: args.topic,
@@ -23712,89 +24491,58 @@ async function startClaudeCodeProviderInstance(args) {
     request,
     signal
   });
-  const result = await (async () => {
+  let result;
+  try {
     try {
-      try {
-        return await startClaudeCodeSession({
+      result = await startClaudeCodeSession({
+        cwd: args.cwd,
+        prompt: workDescription,
+        developerInstructions: commanderDeveloperInstructions({
           cwd: args.cwd,
-          prompt: workDescription,
-          developerInstructions: commanderDeveloperInstructions({
-            cwd: args.cwd,
-            agentLabel: "Claude Code",
-            developerPrompt,
-            linzumiContext
-          }),
-          model: claudeCodeModelForRuntimeModel(runtimeSettings.model),
-          resumeSessionId: args.resumeSessionId,
-          abortController,
-          streamingInput: inputQueue,
-          runner: args.options.claudeCodeRunner,
-          canUseTool,
-          onTurnCompleted: async () => {
-            const completedSourceSeq = inputQueue.completeTurn();
-            try {
-              await publishClaudeCodeMessageState(args.kandan, args.topic, {
-                workspace,
-                channel,
-                threadId,
-                sourceSeq: completedSourceSeq,
-                status: "processed",
-                reason: "Claude Code completed",
-                sessionId: activeSessionId ?? args.resumeSessionId
-              });
-            } catch (error) {
-              args.log("kandan.claude_code_turn_state_push_failed", {
-                message: error instanceof Error ? error.message : String(error),
-                thread_id: threadId,
-                source_seq: completedSourceSeq ?? null,
-                claude_session_id: activeSessionId ?? null
-              });
-            }
-          },
-          onTranscriptEvent
-        });
-      } finally {
-        inputQueue.close();
-        if (activeSessionId !== void 0) {
-          args.activeClaudeCodeSessions.delete(activeSessionId);
-          await args.disposeClaudeCodeForwardPortSession?.(activeSessionId);
-        }
-      }
-    } catch (error) {
-      switch (isClaudeCodeOutputPostError(error)) {
-        case true:
-          args.setStartupStage("posting_claude_code_output");
-          throw error;
-        case false:
-          switch (transcriptForwarder.startedSessionId()) {
-            case void 0:
-              throw error;
-            default:
-              args.setStartupStage("claude_code_session_failed");
-              throw error;
-          }
+          agentLabel: "Claude Code",
+          developerPrompt,
+          linzumiContext
+        }),
+        model: claudeCodeModelForRuntimeModel(runtimeSettings.model),
+        resumeSessionId: args.resumeSessionId,
+        abortController,
+        streamingInput: inputQueue,
+        runner: args.options.claudeCodeRunner,
+        canUseTool,
+        ...mcpServers === void 0 ? {} : { mcpServers },
+        ...sessionEnv === void 0 ? {} : { env: sessionEnv },
+        // The built-in Linzumi MCP is trusted like the codex side: its tools
+        // run without an approval round-trip. SDK allowedTools matches MCP
+        // tools as mcp__<server>__<tool>; the __* suffix covers the server.
+        allowedTools: ["mcp__linzumi__*"],
+        onSessionControls: (controls) => {
+          sessionControls = controls;
+        },
+        onTurnCompleted: () => {
+          inputQueue.completeTurn();
+        },
+        onTranscriptEvent
+      });
+    } finally {
+      inputQueue.close();
+      mcpAuthCleanup?.();
+      if (activeSessionId !== void 0) {
+        args.activeClaudeCodeSessions.delete(activeSessionId);
+        await args.disposeClaudeCodeForwardPortSession?.(activeSessionId);
       }
     }
-  })();
-  args.setStartupStage("posting_claude_code_output");
-  try {
-    await publishClaudeCodeMessageState(args.kandan, args.topic, {
-      workspace,
-      channel,
-      threadId,
-      sourceSeq: inputQueue.currentSourceSeq(),
-      status: "processed",
-      reason: "Claude Code completed",
-      sessionId: result.sessionId
-    });
   } catch (error) {
-    args.log("kandan.claude_code_processed_state_push_failed", {
-      message: error instanceof Error ? error.message : String(error),
-      thread_id: threadId,
-      source_seq: inputQueue.currentSourceSeq() ?? null,
-      claude_session_id: result.sessionId
-    });
+    adapter.submitLifecycle(
+      "codexDied",
+      error instanceof Error ? error.message : String(error)
+    );
+    await adapter.close(5e3).catch(() => void 0);
+    args.setStartupStage("claude_code_session_failed");
+    throw error;
   }
+  args.setStartupStage("posting_claude_code_output");
+  await adapter.awaitTurnsSettled(3e4);
+  await adapter.close(3e4);
   return {
     controlResponse: {
       instanceId: args.instanceId,
@@ -23814,268 +24562,27 @@ async function startClaudeCodeProviderInstance(args) {
     }
   };
 }
-function createClaudeCodeTranscriptForwarder(args) {
-  const assistantContent = /* @__PURE__ */ new Map();
-  const assistantStreamStates = /* @__PURE__ */ new Map();
-  const assistantSourceSeqs = /* @__PURE__ */ new Map();
-  const assistantDeltaQueue = createStreamDeltaQueue();
-  let startedSessionId;
-  const assistantDeltaRuntime = {
-    flushIntervalMs: args.options.channelSession?.streamFlushMs ?? 150,
-    coalesce: coalesceClaudeAssistantDeltas,
-    forward: async (delta) => {
-      const itemKey = claudeAssistantSourceItemKey(
-        delta.itemKey,
-        delta.sourceSeq
-      );
-      const existing = assistantContent.get(itemKey) ?? "";
-      const content = `${existing}${delta.delta}`;
-      await streamClaudeCodeStructuredMessage(args, delta.sessionId, {
-        itemKey,
-        body: content,
-        structured: claudeAssistantStructured(itemKey, content, "streaming")
-      });
-      assistantContent.set(itemKey, content);
-      assistantStreamStates.set(itemKey, "streaming");
-      assistantSourceSeqs.set(itemKey, delta.sourceSeq);
-    },
-    firstTurnId: (deltas) => deltas[0]?.turnId,
-    logFailure: (turnId, error) => {
-      args.log("claude_code.assistant_delta_forward_failed", {
-        session_id: turnId ?? null,
-        message: error instanceof Error ? error.message : String(error)
-      });
-    }
-  };
-  const flushClaudeAssistantDeltas = async () => {
-    flushStreamDeltaQueue(assistantDeltaQueue, assistantDeltaRuntime);
-    await assistantDeltaQueue.chain;
-  };
-  const forward = async (event) => {
-    try {
-      await mirrorClaudeSessionStoreAppend(args, event);
-    } catch (error) {
-      args.log("claude_code.session_store_mirror_failed", {
-        session_id: claudeTranscriptSessionId(event) ?? null,
-        event_type: event.type,
-        message: error instanceof Error ? error.message : String(error)
-      });
-    }
-    switch (event.type) {
-      case "session_started":
-        startedSessionId = event.sessionId;
-        return;
-      case "assistant_delta":
-        enqueueStreamDelta(
-          assistantDeltaQueue,
-          {
-            turnId: event.sessionId,
-            sessionId: event.sessionId,
-            itemKey: event.itemKey,
-            sourceSeq: args.sourceSeq(),
-            delta: event.delta
-          },
-          assistantDeltaRuntime
-        );
-        return;
-      case "assistant_message":
-        await flushClaudeAssistantDeltas();
-        const sourceSeq = args.sourceSeq();
-        const completedItemKey = claudeAssistantSourceItemKey(
-          event.itemKey,
-          sourceSeq
-        );
-        const matchingCompletedStreamEntries = event.streamState === "completed" ? claudeAssistantCompletedStreamItemKeys(
-          event.itemKey,
-          sourceSeq
-        ).flatMap(
-          (itemKey) => assistantContent.get(itemKey) === event.content && assistantSourceSeqs.get(itemKey) === sourceSeq && (assistantStreamStates.get(itemKey) === "streaming" || assistantStreamStates.get(itemKey) === "completed") ? [[itemKey, assistantStreamStates.get(itemKey)]] : []
-        ) : [];
-        const matchingStreamingEntries = matchingCompletedStreamEntries.filter(
-          ([_itemKey, streamState]) => streamState === "streaming"
-        );
-        if (matchingCompletedStreamEntries.length > 0) {
-          for (const [itemKey] of matchingStreamingEntries) {
-            await streamClaudeCodeStructuredMessage(args, event.sessionId, {
-              itemKey,
-              body: event.content,
-              structured: claudeAssistantStructured(
-                itemKey,
-                event.content,
-                "completed"
-              )
-            });
-            assistantStreamStates.set(itemKey, "completed");
-          }
-          return;
-        }
-        await streamClaudeCodeStructuredMessage(args, event.sessionId, {
-          itemKey: completedItemKey,
-          body: event.content,
-          structured: claudeAssistantStructured(
-            completedItemKey,
-            event.content,
-            event.streamState
-          )
-        });
-        assistantContent.set(completedItemKey, event.content);
-        assistantStreamStates.set(completedItemKey, event.streamState);
-        assistantSourceSeqs.set(completedItemKey, sourceSeq);
-        return;
-      case "tool_call":
-        await flushClaudeAssistantDeltas();
-        await postClaudeCodeStructuredMessage(args, event.sessionId, {
-          itemKey: `tool:${event.itemKey}`,
-          body: claudeToolCallBody(event.toolName, event.input),
-          structured: claudeCommandStructured({
-            itemKey: `tool:${event.itemKey}`,
-            command: event.toolName,
-            output: stableJsonString(event.input),
-            status: "started"
-          })
-        });
-        return;
-      case "tool_result":
-        await flushClaudeAssistantDeltas();
-        await postClaudeCodeStructuredMessage(args, event.sessionId, {
-          itemKey: `tool-result:${event.itemKey}`,
-          body: event.content,
-          structured: claudeCommandStructured({
-            itemKey: `tool-result:${event.itemKey}`,
-            command: event.toolName ?? "tool result",
-            output: event.content,
-            status: event.isError ? "failed" : "completed"
-          })
-        });
-        return;
-      case "command_output":
-        await flushClaudeAssistantDeltas();
-        await postClaudeCodeStructuredMessage(args, event.sessionId, {
-          itemKey: `command-output:${event.itemKey}`,
-          body: event.content,
-          structured: claudeCommandStructured({
-            itemKey: `command-output:${event.itemKey}`,
-            command: "Claude Code local command",
-            output: event.content,
-            status: "completed"
-          })
-        });
-        return;
-      case "file_change":
-        await flushClaudeAssistantDeltas();
-        await postClaudeCodeStructuredMessage(args, event.sessionId, {
-          itemKey: event.itemKey,
-          body: event.summary,
-          structured: {
-            kind: "codex_file_change",
-            item_id: event.itemKey,
-            transcript_unit_id: `claude_file_change:${event.itemKey}`,
-            agent_provider: "claude-code",
-            stream_state: "completed",
-            status: "started",
-            patch_text: event.summary,
-            changes: event.path === void 0 ? [] : [{ path: event.path, diff: event.summary, kind: "modified" }]
-          }
-        });
-        return;
-      case "usage":
-        return;
-      case "unknown":
-        await flushClaudeAssistantDeltas();
-        await postClaudeCodeStructuredMessage(
-          args,
-          event.sessionId ?? "unknown",
-          {
-            itemKey: event.itemKey,
-            body: event.summary,
-            structured: {
-              kind: "codex_reasoning",
-              item_id: event.itemKey,
-              transcript_unit_id: `claude_unknown:${event.itemKey}`,
-              agent_provider: "claude-code",
-              stream_state: "completed",
-              content: event.summary,
-              summary_parts: []
-            }
-          }
-        );
-        return;
-      case "session_failed":
-        await flushClaudeAssistantDeltas();
-        await postClaudeCodeStructuredMessage(
-          args,
-          event.sessionId ?? "unknown",
-          {
-            itemKey: `session-failed:${event.sessionId ?? "unknown"}`,
-            body: event.reason,
-            structured: {
-              kind: "codex_reasoning",
-              item_id: `session-failed:${event.sessionId ?? "unknown"}`,
-              transcript_unit_id: `claude_session_failed:${event.sessionId ?? "unknown"}`,
-              agent_provider: "claude-code",
-              stream_state: "completed",
-              content: event.reason,
-              summary_parts: []
-            }
-          }
-        );
-        return;
-      case "turn_completed":
-      case "session_completed": {
-        await flushClaudeAssistantDeltas();
-        const sourceSeq2 = args.sourceSeq();
-        const duplicateEntries = Array.from(assistantContent.entries()).flatMap(
-          ([itemKey2, content]) => {
-            const streamState = assistantStreamStates.get(itemKey2);
-            const entrySourceSeq = assistantSourceSeqs.get(itemKey2);
-            if (content === event.body && entrySourceSeq === sourceSeq2 && (streamState === "streaming" || streamState === "completed")) {
-              return [[itemKey2, streamState]];
-            }
-            return [];
-          }
-        );
-        const streamingDuplicateEntries = duplicateEntries.filter(
-          ([_itemKey, streamState]) => streamState === "streaming"
-        );
-        if (duplicateEntries.length > 0) {
-          for (const [itemKey2] of streamingDuplicateEntries) {
-            await streamClaudeCodeStructuredMessage(args, event.sessionId, {
-              itemKey: itemKey2,
-              body: event.body,
-              structured: claudeAssistantStructured(
-                itemKey2,
-                event.body,
-                "completed"
-              )
-            });
-            assistantStreamStates.set(itemKey2, "completed");
-          }
-          return;
-        }
-        const itemKey = sourceSeq2 === void 0 ? `result:${event.sessionId}` : `result:${event.sessionId}:source:${sourceSeq2}`;
-        if (assistantContent.get(itemKey) === event.body && assistantStreamStates.get(itemKey) === "completed") {
-          return;
-        }
-        await streamClaudeCodeStructuredMessage(args, event.sessionId, {
-          itemKey,
-          body: event.body,
-          structured: claudeAssistantStructured(
-            itemKey,
-            event.body,
-            "completed"
-          )
-        });
-        assistantContent.set(itemKey, event.body);
-        assistantStreamStates.set(itemKey, "completed");
-        assistantSourceSeqs.set(itemKey, sourceSeq2);
-        return;
-      }
-    }
-  };
-  return {
-    forward,
-    startedSessionId: () => startedSessionId
-  };
+function claudePermissionModeForApprovalPolicy(approvalPolicy) {
+  switch (approvalPolicy) {
+    case "never":
+      return "bypassPermissions";
+    case "on-request":
+    case "untrusted":
+      return "default";
+    case "on-failure":
+      return "acceptEdits";
+    default:
+      return void 0;
+  }
+}
+function claudeSteerInputText(input) {
+  const items = arrayValue(input) ?? [];
+  const text2 = items.flatMap((item) => {
+    const value = objectValue(item);
+    const itemText = stringValue(value?.text) ?? stringValue(value?.content);
+    return itemText === void 0 ? [] : [itemText];
+  }).join("\n\n").trim();
+  return text2 === "" ? void 0 : text2;
 }
 async function mirrorClaudeSessionStoreAppend(args, event) {
   const sessionId = claudeTranscriptSessionId(event);
@@ -24147,16 +24654,17 @@ function claudeSessionStoreEntryPayload(args, event) {
         body: event.content,
         isError: event.isError
       };
-    case "command_output":
+    case "reasoning_delta":
+      return void 0;
+    case "reasoning_message":
       return {
         itemKey: event.itemKey,
         body: event.content
       };
-    case "file_change":
+    case "command_output":
       return {
         itemKey: event.itemKey,
-        path: event.path ?? null,
-        body: event.summary
+        body: event.content
       };
     case "usage":
       return { usage: event.usage };
@@ -24171,210 +24679,48 @@ function claudeSessionStoreEntryPayload(args, event) {
         body: event.body,
         usage: event.usage ?? null
       };
+    case "turn_interrupted":
+      return { body: "Claude Code turn interrupted" };
     case "session_failed":
       return { body: event.reason };
   }
 }
-function coalesceClaudeAssistantDeltas(deltas) {
-  const order = [];
-  const byKey = /* @__PURE__ */ new Map();
-  for (const delta of deltas) {
-    const key = `${delta.sessionId}:${delta.sourceSeq ?? "none"}:${delta.itemKey}`;
-    const existing = byKey.get(key);
-    if (existing === void 0) {
-      order.push(key);
-      byKey.set(key, delta);
-    } else {
-      byKey.set(key, {
-        ...existing,
-        delta: `${existing.delta}${delta.delta}`
-      });
+function claudeCodeLlmProxyEnv(baseEnv, proxy, model) {
+  const env = {};
+  for (const [key, value] of Object.entries(baseEnv)) {
+    if (value === void 0) {
+      continue;
+    }
+    if (key === "ANTHROPIC_BASE_URL" || key === "ANTHROPIC_CUSTOM_HEADERS" || key.startsWith("CLAUDE_CODE_USE_")) {
+      continue;
     }
+    env[key] = value;
   }
-  return order.flatMap((key) => {
-    const delta = byKey.get(key);
-    return delta === void 0 ? [] : [delta];
-  });
-}
-function claudeAssistantSourceItemKey(itemKey, sourceSeq) {
-  return sourceSeq === void 0 ? itemKey : `source:${sourceSeq}:${itemKey}`;
-}
-function claudeAssistantCompletedStreamItemKeys(completedItemKey, sourceSeq) {
-  const directItemKey = claudeAssistantSourceItemKey(
-    completedItemKey,
-    sourceSeq
-  );
-  const fallbackIndex = completedItemKey.match(/^content-block-(\d+)$/)?.[1];
-  const streamingItemKey = fallbackIndex === void 0 ? directItemKey : claudeAssistantSourceItemKey(
-    `assistant-stream-${fallbackIndex}`,
-    sourceSeq
-  );
-  return directItemKey === streamingItemKey ? [directItemKey] : [directItemKey, streamingItemKey];
-}
-async function streamClaudeCodeStructuredMessage(args, sessionId, message) {
-  try {
-    const streamKey = claudeCodeStreamKey(sessionId, message.itemKey);
-    const uploadedFileIds = stringValue(message.structured.stream_state) === "completed" ? await uploadedFileIdsForCommanderOutput(
-      {
-        kandan: args.kandan,
-        topic: args.topic,
-        workspace: args.workspace,
-        channel: args.channel,
-        cwd: args.cwd,
-        kandanUrl: args.options.kandanUrl,
-        token: args.options.token,
-        fetch: args.options.fetch
-      },
-      message.body,
-      message.structured
-    ) : [];
-    const displayBody = displayBodyForCommanderOutput(
-      message.body,
-      uploadedFileIds
-    );
-    const displayStructured = structuredWithAssistantContent(
-      message.structured,
-      displayBody
-    );
-    await args.kandan.push(args.topic, "session:stream_thread_message", {
-      workspace: args.workspace,
-      channel: args.channel,
-      thread_id: args.threadId,
-      stream_key: streamKey,
-      body: displayBody,
-      payload: claudeCodePayload(
-        { ...args, sourceSeq: args.sourceSeq() },
-        sessionId,
-        displayStructured
-      ),
-      ...uploadedFileIds.length === 0 ? {} : { uploaded_file_ids: uploadedFileIds },
-      client_message_id: streamKey
-    });
-  } catch (error) {
-    throw new ClaudeCodeOutputPostError(error);
+  env.ANTHROPIC_BASE_URL = proxy.baseUrl;
+  env.ANTHROPIC_CUSTOM_HEADERS = `${claudeCodeLlmProxySessionHeader}: ${proxy.token}`;
+  const routedModel = claudeCodeRoutedProxyModel(model);
+  if (routedModel !== void 0) {
+    env.ANTHROPIC_DEFAULT_OPUS_MODEL = routedModel;
+    env.ANTHROPIC_DEFAULT_SONNET_MODEL = routedModel;
+    env.ANTHROPIC_DEFAULT_HAIKU_MODEL = routedModel;
+    env.CLAUDE_CODE_SUBAGENT_MODEL = routedModel;
   }
+  return env;
 }
-async function postClaudeCodeStructuredMessage(args, sessionId, message) {
-  try {
-    const uploadedFileIds = await uploadedFileIdsForCommanderOutput(
-      {
-        kandan: args.kandan,
-        topic: args.topic,
-        workspace: args.workspace,
-        channel: args.channel,
-        cwd: args.cwd,
-        kandanUrl: args.options.kandanUrl,
-        token: args.options.token,
-        fetch: args.options.fetch
-      },
-      message.body,
-      message.structured
-    );
-    const displayBody = displayBodyForCommanderOutput(
-      message.body,
-      uploadedFileIds
-    );
-    const displayStructured = structuredWithAssistantContent(
-      message.structured,
-      displayBody
-    );
-    await args.kandan.push(args.topic, "session:post_thread_message", {
-      workspace: args.workspace,
-      channel: args.channel,
-      thread_id: args.threadId,
-      body: displayBody,
-      payload: claudeCodePayload(
-        { ...args, sourceSeq: args.sourceSeq() },
-        sessionId,
-        displayStructured
-      ),
-      ...uploadedFileIds.length === 0 ? {} : { uploaded_file_ids: uploadedFileIds },
-      client_message_id: claudeCodeMessageClientId(
-        args,
-        sessionId,
-        message.itemKey
-      )
-    });
-  } catch (error) {
-    throw new ClaudeCodeOutputPostError(error);
+function claudeCodeRoutedProxyModel(model) {
+  const trimmed = model?.trim();
+  switch (trimmed) {
+    case void 0:
+    case "":
+    case "default":
+    case "haiku":
+    case "sonnet":
+    case "opus":
+      return void 0;
+    default:
+      return trimmed.startsWith("claude") ? void 0 : trimmed;
   }
 }
-function claudeCodeMessageClientId(args, sessionId, itemKey) {
-  const sourceSeq = args.sourceSeq();
-  const replyKey = sourceSeq === void 0 ? args.rootSeq === void 0 ? "source:none" : `root:${args.rootSeq}` : `source:${sourceSeq}`;
-  return boundedClaudeCodeClientId(
-    `claude-code:${sessionId}:${replyKey}:${args.threadId}:${itemKey}`,
-    "claude-code-message"
-  );
-}
-function claudeCodeStreamKey(sessionId, itemKey) {
-  return boundedClaudeCodeClientId(
-    `claude-code:${sessionId}:${itemKey}`,
-    "claude-code-stream"
-  );
-}
-function boundedClaudeCodeClientId(candidate, prefix) {
-  return candidate.length <= 128 ? candidate : `${prefix}-${createHash5("sha256").update(candidate).digest("hex").slice(0, 32)}`;
-}
-function isClaudeCodeOutputPostError(error) {
-  return error instanceof ClaudeCodeOutputPostError;
-}
-function claudeCodePayload(args, sessionId, structured) {
-  return {
-    ...localRunnerPayload(
-      { ...args.options, cwd: args.cwd },
-      args.instanceId,
-      "codex_output",
-      sessionId,
-      {
-        runnerIdentity: identityFromAccessToken(args.options.token),
-        codexVersion: void 0
-      },
-      args.sourceSeq,
-      {
-        agent_provider: "claude-code",
-        claude_session_id: sessionId
-      }
-    ),
-    ...args.rootSeq === void 0 ? {} : { reply_to_seq: args.rootSeq },
-    structured
-  };
-}
-function claudeAssistantStructured(itemKey, content, streamState) {
-  return {
-    kind: "codex_assistant_message",
-    item_id: itemKey,
-    transcript_unit_id: `claude_assistant:${itemKey}`,
-    agent_provider: "claude-code",
-    content,
-    phase: "final_answer",
-    stream_state: streamState
-  };
-}
-function claudeCommandStructured(args) {
-  return {
-    kind: "codex_command_execution",
-    item_id: args.itemKey,
-    transcript_unit_id: `claude_command:${args.itemKey}`,
-    agent_provider: "claude-code",
-    stream_state: "completed",
-    status: args.status,
-    command: args.command,
-    cwd: "",
-    process_id: "",
-    duration_ms: null,
-    exit_code: null,
-    output: args.output
-  };
-}
-function claudeToolCallBody(toolName2, input) {
-  return `Claude Code tool: ${toolName2}
-
-${stableJsonString(input)}`;
-}
-function stableJsonString(value) {
-  return JSON.stringify(value, null, 2);
-}
 function claudeCodeModelForRuntimeModel(model) {
   const trimmed = model?.trim();
   switch (trimmed) {
@@ -24575,14 +24921,14 @@ function strictTcpPortFromEnv(rawValue, envName) {
   return port;
 }
 function listenOnLoopback(server, port) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const onError = (error) => {
       server.off("listening", onListening);
       reject(error);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve11();
+      resolve12();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -24593,13 +24939,13 @@ function closeHttpServer(server) {
   if (!server.listening) {
     return Promise.resolve();
   }
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     server.close((error) => {
       if (error !== void 0) {
         reject(error);
         return;
       }
-      resolve11();
+      resolve12();
     });
   });
 }
@@ -24659,6 +25005,7 @@ function threadRunnerOptions(args) {
     args.options,
     args.control
   );
+  const waferResolution = resolveControlWaferModelProvider(args.control);
   return {
     ...args.options,
     clientId: void 0,
@@ -24675,6 +25022,7 @@ function threadRunnerOptions(args) {
       role: "thread",
       kandanThreadId: args.kandanThreadId
     },
+    codexModelProvider: waferResolution.type === "wafer" ? waferResolution.runtime : void 0,
     spawnThreadRunner: void 0,
     threadRunnerReadyTimeoutMs: args.options.threadRunnerReadyTimeoutMs,
     runtimeDefaults: {
@@ -24715,7 +25063,10 @@ async function spawnLocalThreadRunnerProcess(options) {
     ...process.env,
     LINZUMI_THREAD_RUNNER_ROLE: "thread",
     LINZUMI_THREAD_RUNNER_KANDAN_THREAD_ID: kandanThreadId,
-    LINZUMI_THREAD_RUNNER_TOKEN: options.token
+    LINZUMI_THREAD_RUNNER_TOKEN: options.token,
+    // The LLM proxy credential travels via env (like the runner token), not
+    // argv, so the spawned worker's command line never carries it.
+    ...options.codexModelProvider === void 0 ? {} : { LINZUMI_LLM_PROXY_TOKEN: options.codexModelProvider.llmProxyToken }
   };
   writeCliAuditEvent("process.spawn", {
     command: process.execPath,
@@ -24753,7 +25104,7 @@ async function spawnLocalThreadRunnerProcess(options) {
     }
     exitListeners.clear();
   });
-  const ready2 = await new Promise((resolve11, reject) => {
+  const ready2 = await new Promise((resolve12, reject) => {
     let settled = false;
     let timeout;
     const cleanupReadyListeners = () => {
@@ -24785,7 +25136,7 @@ async function spawnLocalThreadRunnerProcess(options) {
       if (parsed === void 0) {
         return;
       }
-      settle(() => resolve11(parsed));
+      settle(() => resolve12(parsed));
     };
     const onExitBeforeReady = (code, signal) => {
       settle(
@@ -24838,7 +25189,7 @@ function threadRunnerScriptPath(scriptPath, cwd) {
       "cannot fork thread runner without current CLI script path"
     );
   }
-  return isAbsolute4(scriptPath) ? scriptPath : resolve7(cwd, scriptPath);
+  return isAbsolute5(scriptPath) ? scriptPath : resolve8(cwd, scriptPath);
 }
 function threadRunnerLoaderExecArgv(execArgv, index = 0) {
   const current = execArgv[index];
@@ -24931,13 +25282,13 @@ function providerKindValue(value) {
   }
 }
 function waitForThreadCodexWorkerStop(codexProcess) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const stop = once(() => {
       process.off("disconnect", stop);
       process.off("SIGINT", stop);
       process.off("SIGTERM", stop);
       codexProcess.off("exit", stop);
-      resolve11();
+      resolve12();
     });
     process.once("disconnect", stop);
     process.once("SIGINT", stop);
@@ -24946,7 +25297,7 @@ function waitForThreadCodexWorkerStop(codexProcess) {
   });
 }
 function withThreadRunnerReadyTimeout(promise, args) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     let settled = false;
     const timeout = setTimeout(() => {
       if (settled) {
@@ -24964,7 +25315,7 @@ function withThreadRunnerReadyTimeout(promise, args) {
         }
         settled = true;
         clearTimeout(timeout);
-        resolve11(handle);
+        resolve12(handle);
       },
       (error) => {
         if (settled) {
@@ -25016,6 +25367,12 @@ function threadRunnerCliArgs(options) {
       "--approval-policy",
       options.runtimeDefaults?.approvalPolicy
     ),
+    ...options.codexModelProvider === void 0 ? [] : [
+      "--model-provider",
+      options.codexModelProvider.provider,
+      "--llm-proxy-base-url",
+      options.codexModelProvider.llmProxyBaseUrl
+    ],
     "--allow-port-forwarding-by-default"
   ];
 }
@@ -25582,7 +25939,7 @@ async function localConversationAttachmentFile(candidatePath, attachment) {
       };
     }
     case "path": {
-      const path2 = isAbsolute4(attachment.path) ? attachment.path : resolve7(dirname13(candidatePath), attachment.path);
+      const path2 = isAbsolute5(attachment.path) ? attachment.path : resolve8(dirname13(candidatePath), attachment.path);
       try {
         const bytes = await readFile2(path2);
         return {
@@ -25910,6 +26267,17 @@ async function startOwnedCodexAppServer(options, args = { linzumiMcp: true }) {
       model: defaults.model,
       reasoningEffort: defaults.reasoningEffort,
       fast: options.fast,
+      // Wafer-routed thread workers point their owned app-server at the
+      // Kandan LLM proxy via a custom Linzumi model provider; the proxy
+      // credential rides env_key plus the session header.
+      ...options.codexModelProvider === void 0 ? {} : {
+        modelProvider: linzumiCodexModelProviderConfig(
+          options.codexModelProvider
+        ),
+        env: {
+          LINZUMI_LLM_PROXY_TOKEN: options.codexModelProvider.llmProxyToken
+        }
+      },
       mcpServers: mcpAuth === void 0 ? [] : [
         linzumiMcpServerConfig({
           command: mcpCommand.command,
@@ -26031,7 +26399,7 @@ function configuredAllowedCwds(values, options = {}) {
   const allowedCwds = [];
   const missingAllowedCwds = [];
   for (const value of normalizeAllowedCwds(values)) {
-    const absolutePath = resolve7(expandUserPath(value));
+    const absolutePath = resolve8(expandUserPath(value));
     try {
       if (options.createMissing === true) {
         mkdirSync11(absolutePath, { recursive: true });
@@ -26083,7 +26451,7 @@ function browseRunnerDirectory(control, options) {
   const requestId = stringValue(control.requestId) ?? null;
   const requestedPath = stringValue(control.path) ?? currentHomeDirectory();
   try {
-    const currentPath = realpathSync6(resolve7(expandUserPath(requestedPath)));
+    const currentPath = realpathSync6(resolve8(expandUserPath(requestedPath)));
     const stats = statSync3(currentPath);
     if (!stats.isDirectory()) {
       return {
@@ -26113,7 +26481,7 @@ function browseRunnerDirectory(control, options) {
       currentPath,
       parentPath: parent === currentPath ? null : parent,
       homePath: currentHomeDirectory(),
-      runnerCwd: resolve7(options.cwd),
+      runnerCwd: resolve8(options.cwd),
       entries,
       isGit: isGitProjectDirectory(currentPath)
     };
@@ -26298,13 +26666,14 @@ async function suggestRunnerTasks(control, options, allowedCwds) {
     };
   }
 }
-var THREAD_RUNNER_READY_TIMEOUT_MS, onboardingDiscoveryAgentStartKeys, onboardingConversationImportKeys, onboardingConversationDiscoveryReportLimit, controlCursorWriteDebounceMs, codexTurnTerminalNotificationMethods, claudeSessionStoreSequenceHighWater, ClaudeCodeOutputPostError, onboardingConversationTitleFirstMessages, onboardingConversationTitleLastMessages, onboardingConversationTitleBodyMaxLength, onboardingConversationImportMessageMaxLength, onboardingConversationImportCandidateLimit, onboardingConversationImportProgressInterval;
+var THREAD_RUNNER_READY_TIMEOUT_MS, onboardingDiscoveryAgentStartKeys, onboardingConversationImportKeys, onboardingConversationDiscoveryReportLimit, controlCursorWriteDebounceMs, codexTurnTerminalNotificationMethods, claudeSessionStoreSequenceHighWater, claudeCodeLlmProxySessionHeader, onboardingConversationTitleFirstMessages, onboardingConversationTitleLastMessages, onboardingConversationTitleBodyMaxLength, onboardingConversationImportMessageMaxLength, onboardingConversationImportCandidateLimit, onboardingConversationImportProgressInterval;
 var init_runner = __esm({
   "src/runner.ts"() {
     "use strict";
     init_channelSession();
     init_channelSessionSupport();
     init_commanderAttachments();
+    init_claudeCodePipeline();
     init_claudeCodeSession();
     init_codexAppServer();
     init_codexProjectTrust();
@@ -26327,7 +26696,6 @@ var init_runner = __esm({
     init_runnerLogger();
     init_runnerLock();
     init_runnerConsoleReporter();
-    init_streamDeltaQueue();
     init_version();
     init_telemetry();
     init_mcpConfig();
@@ -26352,13 +26720,7 @@ var init_runner = __esm({
       "turn/cancelled"
     ]);
     claudeSessionStoreSequenceHighWater = /* @__PURE__ */ new Map();
-    ClaudeCodeOutputPostError = class extends Error {
-      constructor(cause) {
-        super(cause instanceof Error ? cause.message : String(cause));
-        this.cause = cause;
-        this.name = "ClaudeCodeOutputPostError";
-      }
-    };
+    claudeCodeLlmProxySessionHeader = "x-linzumi-llm-proxy-token";
     onboardingConversationTitleFirstMessages = 4;
     onboardingConversationTitleLastMessages = 4;
     onboardingConversationTitleBodyMaxLength = 1200;
@@ -26369,7 +26731,7 @@ var init_runner = __esm({
 });
 
 // src/kandanTls.ts
-import { existsSync as existsSync12, readFileSync as readFileSync16 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync16 } from "node:fs";
 import { Agent } from "undici";
 import WsWebSocket from "ws";
 function kandanTlsTrustFromEnv() {
@@ -26380,7 +26742,7 @@ function kandanTlsTrustFromCaFile(caFile) {
     return void 0;
   }
   const trimmed = caFile.trim();
-  if (!existsSync12(trimmed)) {
+  if (!existsSync13(trimmed)) {
     throw new Error(`KANDAN_TLS_CA_FILE does not exist: ${trimmed}`);
   }
   const ca = readFileSync16(trimmed, "utf8");
@@ -27161,7 +27523,7 @@ var require_uri_all = __commonJS({
         target.fragment = relative3.fragment;
         return target;
       }
-      function resolve11(baseURI, relativeURI, options) {
+      function resolve12(baseURI, relativeURI, options) {
         var schemelessOptions = assign({ scheme: "null" }, options);
         return serialize(resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);
       }
@@ -27426,7 +27788,7 @@ var require_uri_all = __commonJS({
       exports2.removeDotSegments = removeDotSegments;
       exports2.serialize = serialize;
       exports2.resolveComponents = resolveComponents;
-      exports2.resolve = resolve11;
+      exports2.resolve = resolve12;
       exports2.normalize = normalize;
       exports2.equal = equal;
       exports2.escapeComponent = escapeComponent;
@@ -27471,9 +27833,9 @@ var require_fast_deep_equal = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/ucs2length.js
+// ../../node_modules/ajv/lib/compile/ucs2length.js
 var require_ucs2length = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/ucs2length.js"(exports, module) {
+  "../../node_modules/ajv/lib/compile/ucs2length.js"(exports, module) {
     "use strict";
     module.exports = function ucs2length(str) {
       var length = 0, len = str.length, pos = 0, value;
@@ -27490,9 +27852,9 @@ var require_ucs2length = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/util.js
+// ../../node_modules/ajv/lib/compile/util.js
 var require_util = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/util.js"(exports, module) {
+  "../../node_modules/ajv/lib/compile/util.js"(exports, module) {
     "use strict";
     module.exports = {
       copy,
@@ -27674,9 +28036,9 @@ var require_util = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/schema_obj.js
+// ../../node_modules/ajv/lib/compile/schema_obj.js
 var require_schema_obj = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/schema_obj.js"(exports, module) {
+  "../../node_modules/ajv/lib/compile/schema_obj.js"(exports, module) {
     "use strict";
     var util3 = require_util();
     module.exports = SchemaObject;
@@ -27770,27 +28132,27 @@ var require_json_schema_traverse = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/resolve.js
+// ../../node_modules/ajv/lib/compile/resolve.js
 var require_resolve = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/resolve.js"(exports, module) {
+  "../../node_modules/ajv/lib/compile/resolve.js"(exports, module) {
     "use strict";
     var URI = require_uri_all();
     var equal = require_fast_deep_equal();
     var util3 = require_util();
     var SchemaObject = require_schema_obj();
     var traverse = require_json_schema_traverse();
-    module.exports = resolve11;
-    resolve11.normalizeId = normalizeId;
-    resolve11.fullPath = getFullPath;
-    resolve11.url = resolveUrl;
-    resolve11.ids = resolveIds;
-    resolve11.inlineRef = inlineRef;
-    resolve11.schema = resolveSchema;
-    function resolve11(compile, root, ref) {
+    module.exports = resolve12;
+    resolve12.normalizeId = normalizeId;
+    resolve12.fullPath = getFullPath;
+    resolve12.url = resolveUrl;
+    resolve12.ids = resolveIds;
+    resolve12.inlineRef = inlineRef;
+    resolve12.schema = resolveSchema;
+    function resolve12(compile, root, ref) {
       var refVal = this._refs[ref];
       if (typeof refVal == "string") {
         if (this._refs[refVal]) refVal = this._refs[refVal];
-        else return resolve11.call(this, compile, root, refVal);
+        else return resolve12.call(this, compile, root, refVal);
       }
       refVal = refVal || this._schemas[ref];
       if (refVal instanceof SchemaObject) {
@@ -27991,11 +28353,11 @@ var require_resolve = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/error_classes.js
+// ../../node_modules/ajv/lib/compile/error_classes.js
 var require_error_classes = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/error_classes.js"(exports, module) {
+  "../../node_modules/ajv/lib/compile/error_classes.js"(exports, module) {
     "use strict";
-    var resolve11 = require_resolve();
+    var resolve12 = require_resolve();
     module.exports = {
       Validation: errorSubclass(ValidationError2),
       MissingRef: errorSubclass(MissingRefError)
@@ -28010,8 +28372,8 @@ var require_error_classes = __commonJS({
     };
     function MissingRefError(baseId, ref, message) {
       this.message = message || MissingRefError.message(baseId, ref);
-      this.missingRef = resolve11.url(baseId, ref);
-      this.missingSchema = resolve11.normalizeId(resolve11.fullPath(this.missingRef));
+      this.missingRef = resolve12.url(baseId, ref);
+      this.missingSchema = resolve12.normalizeId(resolve12.fullPath(this.missingRef));
     }
     function errorSubclass(Subclass) {
       Subclass.prototype = Object.create(Error.prototype);
@@ -28077,9 +28439,9 @@ var require_fast_json_stable_stringify = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/validate.js
+// ../../node_modules/ajv/lib/dotjs/validate.js
 var require_validate = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/validate.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/validate.js"(exports, module) {
     "use strict";
     module.exports = function generate_validate(it, $keyword, $ruleType) {
       var out = "";
@@ -28535,11 +28897,11 @@ var require_validate = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/index.js
+// ../../node_modules/ajv/lib/compile/index.js
 var require_compile = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/index.js"(exports, module) {
+  "../../node_modules/ajv/lib/compile/index.js"(exports, module) {
     "use strict";
-    var resolve11 = require_resolve();
+    var resolve12 = require_resolve();
     var util3 = require_util();
     var errorClasses = require_error_classes();
     var stableStringify = require_fast_json_stable_stringify();
@@ -28597,7 +28959,7 @@ var require_compile = __commonJS({
           RULES,
           validate: validateGenerator,
           util: util3,
-          resolve: resolve11,
+          resolve: resolve12,
           resolveRef,
           usePattern,
           useDefault,
@@ -28657,7 +29019,7 @@ var require_compile = __commonJS({
         return validate;
       }
       function resolveRef(baseId2, ref, isRoot) {
-        ref = resolve11.url(baseId2, ref);
+        ref = resolve12.url(baseId2, ref);
         var refIndex = refs[ref];
         var _refVal, refCode;
         if (refIndex !== void 0) {
@@ -28674,11 +29036,11 @@ var require_compile = __commonJS({
           }
         }
         refCode = addLocalRef(ref);
-        var v2 = resolve11.call(self, localCompile, root, ref);
+        var v2 = resolve12.call(self, localCompile, root, ref);
         if (v2 === void 0) {
           var localSchema = localRefs && localRefs[ref];
           if (localSchema) {
-            v2 = resolve11.inlineRef(localSchema, opts.inlineRefs) ? localSchema : compile.call(self, localSchema, root, localRefs, baseId2);
+            v2 = resolve12.inlineRef(localSchema, opts.inlineRefs) ? localSchema : compile.call(self, localSchema, root, localRefs, baseId2);
           }
         }
         if (v2 === void 0) {
@@ -28814,9 +29176,9 @@ var require_compile = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/cache.js
+// ../../node_modules/ajv/lib/cache.js
 var require_cache = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/cache.js"(exports, module) {
+  "../../node_modules/ajv/lib/cache.js"(exports, module) {
     "use strict";
     var Cache = module.exports = function Cache2() {
       this._cache = {};
@@ -28836,9 +29198,9 @@ var require_cache = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/formats.js
+// ../../node_modules/ajv/lib/compile/formats.js
 var require_formats = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/formats.js"(exports, module) {
+  "../../node_modules/ajv/lib/compile/formats.js"(exports, module) {
     "use strict";
     var util3 = require_util();
     var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
@@ -28948,9 +29310,9 @@ var require_formats = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/ref.js
+// ../../node_modules/ajv/lib/dotjs/ref.js
 var require_ref = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/ref.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/ref.js"(exports, module) {
     "use strict";
     module.exports = function generate_ref(it, $keyword, $ruleType) {
       var out = " ";
@@ -29076,9 +29438,9 @@ var require_ref = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/allOf.js
+// ../../node_modules/ajv/lib/dotjs/allOf.js
 var require_allOf = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/allOf.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/allOf.js"(exports, module) {
     "use strict";
     module.exports = function generate_allOf(it, $keyword, $ruleType) {
       var out = " ";
@@ -29122,9 +29484,9 @@ var require_allOf = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/anyOf.js
+// ../../node_modules/ajv/lib/dotjs/anyOf.js
 var require_anyOf = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/anyOf.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/anyOf.js"(exports, module) {
     "use strict";
     module.exports = function generate_anyOf(it, $keyword, $ruleType) {
       var out = " ";
@@ -29199,9 +29561,9 @@ var require_anyOf = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/comment.js
+// ../../node_modules/ajv/lib/dotjs/comment.js
 var require_comment = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/comment.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/comment.js"(exports, module) {
     "use strict";
     module.exports = function generate_comment(it, $keyword, $ruleType) {
       var out = " ";
@@ -29219,9 +29581,9 @@ var require_comment = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/const.js
+// ../../node_modules/ajv/lib/dotjs/const.js
 var require_const = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/const.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/const.js"(exports, module) {
     "use strict";
     module.exports = function generate_const(it, $keyword, $ruleType) {
       var out = " ";
@@ -29279,9 +29641,9 @@ var require_const = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/contains.js
+// ../../node_modules/ajv/lib/dotjs/contains.js
 var require_contains = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/contains.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/contains.js"(exports, module) {
     "use strict";
     module.exports = function generate_contains(it, $keyword, $ruleType) {
       var out = " ";
@@ -29361,9 +29723,9 @@ var require_contains = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/dependencies.js
+// ../../node_modules/ajv/lib/dotjs/dependencies.js
 var require_dependencies = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/dependencies.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/dependencies.js"(exports, module) {
     "use strict";
     module.exports = function generate_dependencies(it, $keyword, $ruleType) {
       var out = " ";
@@ -29526,9 +29888,9 @@ var require_dependencies = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/enum.js
+// ../../node_modules/ajv/lib/dotjs/enum.js
 var require_enum = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/enum.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/enum.js"(exports, module) {
     "use strict";
     module.exports = function generate_enum(it, $keyword, $ruleType) {
       var out = " ";
@@ -29595,9 +29957,9 @@ var require_enum = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/format.js
+// ../../node_modules/ajv/lib/dotjs/format.js
 var require_format = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/format.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/format.js"(exports, module) {
     "use strict";
     module.exports = function generate_format(it, $keyword, $ruleType) {
       var out = " ";
@@ -29746,9 +30108,9 @@ var require_format = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/if.js
+// ../../node_modules/ajv/lib/dotjs/if.js
 var require_if = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/if.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/if.js"(exports, module) {
     "use strict";
     module.exports = function generate_if(it, $keyword, $ruleType) {
       var out = " ";
@@ -29850,9 +30212,9 @@ var require_if = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/items.js
+// ../../node_modules/ajv/lib/dotjs/items.js
 var require_items = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/items.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/items.js"(exports, module) {
     "use strict";
     module.exports = function generate_items(it, $keyword, $ruleType) {
       var out = " ";
@@ -29991,9 +30353,9 @@ var require_items = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/_limit.js
+// ../../node_modules/ajv/lib/dotjs/_limit.js
 var require_limit = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/_limit.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/_limit.js"(exports, module) {
     "use strict";
     module.exports = function generate__limit(it, $keyword, $ruleType) {
       var out = " ";
@@ -30145,9 +30507,9 @@ var require_limit = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/_limitItems.js
+// ../../node_modules/ajv/lib/dotjs/_limitItems.js
 var require_limitItems = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/_limitItems.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/_limitItems.js"(exports, module) {
     "use strict";
     module.exports = function generate__limitItems(it, $keyword, $ruleType) {
       var out = " ";
@@ -30229,9 +30591,9 @@ var require_limitItems = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/_limitLength.js
+// ../../node_modules/ajv/lib/dotjs/_limitLength.js
 var require_limitLength = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/_limitLength.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/_limitLength.js"(exports, module) {
     "use strict";
     module.exports = function generate__limitLength(it, $keyword, $ruleType) {
       var out = " ";
@@ -30318,9 +30680,9 @@ var require_limitLength = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/_limitProperties.js
+// ../../node_modules/ajv/lib/dotjs/_limitProperties.js
 var require_limitProperties = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/_limitProperties.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/_limitProperties.js"(exports, module) {
     "use strict";
     module.exports = function generate__limitProperties(it, $keyword, $ruleType) {
       var out = " ";
@@ -30402,9 +30764,9 @@ var require_limitProperties = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/multipleOf.js
+// ../../node_modules/ajv/lib/dotjs/multipleOf.js
 var require_multipleOf = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/multipleOf.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/multipleOf.js"(exports, module) {
     "use strict";
     module.exports = function generate_multipleOf(it, $keyword, $ruleType) {
       var out = " ";
@@ -30486,9 +30848,9 @@ var require_multipleOf = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/not.js
+// ../../node_modules/ajv/lib/dotjs/not.js
 var require_not = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/not.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/not.js"(exports, module) {
     "use strict";
     module.exports = function generate_not(it, $keyword, $ruleType) {
       var out = " ";
@@ -30575,9 +30937,9 @@ var require_not = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/oneOf.js
+// ../../node_modules/ajv/lib/dotjs/oneOf.js
 var require_oneOf = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/oneOf.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/oneOf.js"(exports, module) {
     "use strict";
     module.exports = function generate_oneOf(it, $keyword, $ruleType) {
       var out = " ";
@@ -30650,9 +31012,9 @@ var require_oneOf = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/pattern.js
+// ../../node_modules/ajv/lib/dotjs/pattern.js
 var require_pattern = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/pattern.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/pattern.js"(exports, module) {
     "use strict";
     module.exports = function generate_pattern(it, $keyword, $ruleType) {
       var out = " ";
@@ -30729,9 +31091,9 @@ var require_pattern = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/properties.js
+// ../../node_modules/ajv/lib/dotjs/properties.js
 var require_properties = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/properties.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/properties.js"(exports, module) {
     "use strict";
     module.exports = function generate_properties(it, $keyword, $ruleType) {
       var out = " ";
@@ -31045,9 +31407,9 @@ var require_properties = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/propertyNames.js
+// ../../node_modules/ajv/lib/dotjs/propertyNames.js
 var require_propertyNames = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/propertyNames.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/propertyNames.js"(exports, module) {
     "use strict";
     module.exports = function generate_propertyNames(it, $keyword, $ruleType) {
       var out = " ";
@@ -31123,9 +31485,9 @@ var require_propertyNames = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/required.js
+// ../../node_modules/ajv/lib/dotjs/required.js
 var require_required = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/required.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/required.js"(exports, module) {
     "use strict";
     module.exports = function generate_required(it, $keyword, $ruleType) {
       var out = " ";
@@ -31383,9 +31745,9 @@ var require_required = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/uniqueItems.js
+// ../../node_modules/ajv/lib/dotjs/uniqueItems.js
 var require_uniqueItems = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/uniqueItems.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/uniqueItems.js"(exports, module) {
     "use strict";
     module.exports = function generate_uniqueItems(it, $keyword, $ruleType) {
       var out = " ";
@@ -31472,9 +31834,9 @@ var require_uniqueItems = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/index.js
+// ../../node_modules/ajv/lib/dotjs/index.js
 var require_dotjs = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/index.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/index.js"(exports, module) {
     "use strict";
     module.exports = {
       "$ref": require_ref(),
@@ -31509,9 +31871,9 @@ var require_dotjs = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/rules.js
+// ../../node_modules/ajv/lib/compile/rules.js
 var require_rules = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/rules.js"(exports, module) {
+  "../../node_modules/ajv/lib/compile/rules.js"(exports, module) {
     "use strict";
     var ruleModules = require_dotjs();
     var toHash = require_util().toHash;
@@ -31603,9 +31965,9 @@ var require_rules = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/data.js
+// ../../node_modules/ajv/lib/data.js
 var require_data = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/data.js"(exports, module) {
+  "../../node_modules/ajv/lib/data.js"(exports, module) {
     "use strict";
     var KEYWORDS = [
       "multipleOf",
@@ -31654,9 +32016,9 @@ var require_data = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/async.js
+// ../../node_modules/ajv/lib/compile/async.js
 var require_async = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/async.js"(exports, module) {
+  "../../node_modules/ajv/lib/compile/async.js"(exports, module) {
     "use strict";
     var MissingRefError = require_error_classes().MissingRef;
     module.exports = compileAsync;
@@ -31721,9 +32083,9 @@ var require_async = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/custom.js
+// ../../node_modules/ajv/lib/dotjs/custom.js
 var require_custom = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/dotjs/custom.js"(exports, module) {
+  "../../node_modules/ajv/lib/dotjs/custom.js"(exports, module) {
     "use strict";
     module.exports = function generate_custom(it, $keyword, $ruleType) {
       var out = " ";
@@ -31945,9 +32307,9 @@ var require_custom = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/refs/json-schema-draft-07.json
+// ../../node_modules/ajv/lib/refs/json-schema-draft-07.json
 var require_json_schema_draft_07 = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/refs/json-schema-draft-07.json"(exports, module) {
+  "../../node_modules/ajv/lib/refs/json-schema-draft-07.json"(exports, module) {
     module.exports = {
       $schema: "http://json-schema.org/draft-07/schema#",
       $id: "http://json-schema.org/draft-07/schema#",
@@ -32119,9 +32481,9 @@ var require_json_schema_draft_07 = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/definition_schema.js
+// ../../node_modules/ajv/lib/definition_schema.js
 var require_definition_schema = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/definition_schema.js"(exports, module) {
+  "../../node_modules/ajv/lib/definition_schema.js"(exports, module) {
     "use strict";
     var metaSchema = require_json_schema_draft_07();
     module.exports = {
@@ -32160,9 +32522,9 @@ var require_definition_schema = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/keyword.js
+// ../../node_modules/ajv/lib/keyword.js
 var require_keyword = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/keyword.js"(exports, module) {
+  "../../node_modules/ajv/lib/keyword.js"(exports, module) {
     "use strict";
     var IDENTIFIER = /^[a-z_$][a-z0-9_$-]*$/i;
     var customRuleCode = require_custom();
@@ -32260,9 +32622,9 @@ var require_keyword = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/refs/data.json
+// ../../node_modules/ajv/lib/refs/data.json
 var require_data2 = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/refs/data.json"(exports, module) {
+  "../../node_modules/ajv/lib/refs/data.json"(exports, module) {
     module.exports = {
       $schema: "http://json-schema.org/draft-07/schema#",
       $id: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#",
@@ -32283,12 +32645,12 @@ var require_data2 = __commonJS({
   }
 });
 
-// ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/ajv.js
+// ../../node_modules/ajv/lib/ajv.js
 var require_ajv = __commonJS({
-  "../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/ajv.js"(exports, module) {
+  "../../node_modules/ajv/lib/ajv.js"(exports, module) {
     "use strict";
     var compileSchema = require_compile();
-    var resolve11 = require_resolve();
+    var resolve12 = require_resolve();
     var Cache = require_cache();
     var SchemaObject = require_schema_obj();
     var stableStringify = require_fast_json_stable_stringify();
@@ -32370,7 +32732,7 @@ var require_ajv = __commonJS({
       var id = this._getId(schema);
       if (id !== void 0 && typeof id != "string")
         throw new Error("schema id must be string");
-      key = resolve11.normalizeId(key || id);
+      key = resolve12.normalizeId(key || id);
       checkUnique(this, key);
       this._schemas[key] = this._addSchema(schema, _skipValidation, _meta, true);
       return this;
@@ -32414,7 +32776,7 @@ var require_ajv = __commonJS({
       }
     }
     function _getSchemaFragment(self, ref) {
-      var res = resolve11.schema.call(self, { schema: {} }, ref);
+      var res = resolve12.schema.call(self, { schema: {} }, ref);
       if (res) {
         var schema = res.schema, root = res.root, baseId = res.baseId;
         var v = compileSchema.call(self, schema, root, void 0, baseId);
@@ -32430,7 +32792,7 @@ var require_ajv = __commonJS({
       }
     }
     function _getSchemaObj(self, keyRef) {
-      keyRef = resolve11.normalizeId(keyRef);
+      keyRef = resolve12.normalizeId(keyRef);
       return self._schemas[keyRef] || self._refs[keyRef] || self._fragments[keyRef];
     }
     function removeSchema(schemaKeyRef) {
@@ -32457,7 +32819,7 @@ var require_ajv = __commonJS({
           this._cache.del(cacheKey);
           var id = this._getId(schemaKeyRef);
           if (id) {
-            id = resolve11.normalizeId(id);
+            id = resolve12.normalizeId(id);
             delete this._schemas[id];
             delete this._refs[id];
           }
@@ -32481,13 +32843,13 @@ var require_ajv = __commonJS({
       var cached = this._cache.get(cacheKey);
       if (cached) return cached;
       shouldAddSchema = shouldAddSchema || this._opts.addUsedSchema !== false;
-      var id = resolve11.normalizeId(this._getId(schema));
+      var id = resolve12.normalizeId(this._getId(schema));
       if (id && shouldAddSchema) checkUnique(this, id);
       var willValidate = this._opts.validateSchema !== false && !skipValidation;
       var recursiveMeta;
-      if (willValidate && !(recursiveMeta = id && id == resolve11.normalizeId(schema.$schema)))
+      if (willValidate && !(recursiveMeta = id && id == resolve12.normalizeId(schema.$schema)))
         this.validateSchema(schema, true);
-      var localRefs = resolve11.ids.call(this, schema);
+      var localRefs = resolve12.ids.call(this, schema);
       var schemaObj = new SchemaObject({
         id,
         schema,
@@ -35344,13 +35706,13 @@ var init_promise_polyfill = __esm({
       // Available starting from Node 22
       // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers
       static withResolver() {
-        let resolve11;
+        let resolve12;
         let reject;
         const promise = new Promise((res, rej) => {
-          resolve11 = res;
+          resolve12 = res;
           reject = rej;
         });
-        return { promise, resolve: resolve11, reject };
+        return { promise, resolve: resolve12, reject };
       }
     };
   }
@@ -35388,7 +35750,7 @@ function createPrompt(view) {
       output
     });
     const screen = new ScreenManager(rl);
-    const { promise, resolve: resolve11, reject } = PromisePolyfill.withResolver();
+    const { promise, resolve: resolve12, reject } = PromisePolyfill.withResolver();
     const cancel = () => reject(new CancelPromptError());
     if (signal) {
       const abort = () => reject(new AbortPromptError({ cause: signal.reason }));
@@ -35415,7 +35777,7 @@ function createPrompt(view) {
       cycle(() => {
         try {
           const nextView = view(config, (value) => {
-            setImmediate(() => resolve11(value));
+            setImmediate(() => resolve12(value));
           });
           if (nextView === void 0) {
             const callerFilename = callSites[1]?.getFileName();
@@ -41268,7 +41630,7 @@ var require_lib2 = __commonJS({
       return matches;
     };
     exports.analyse = analyse;
-    var detectFile = (filepath, opts = {}) => new Promise((resolve11, reject) => {
+    var detectFile = (filepath, opts = {}) => new Promise((resolve12, reject) => {
       let fd;
       const fs = (0, node_1.default)();
       const handler = (err, buffer) => {
@@ -41278,7 +41640,7 @@ var require_lib2 = __commonJS({
         if (err) {
           reject(err);
         } else if (buffer) {
-          resolve11((0, exports.detect)(buffer));
+          resolve12((0, exports.detect)(buffer));
         } else {
           reject(new Error("No error and no buffer received"));
         }
@@ -46658,7 +47020,7 @@ __export(signupFlow_exports, {
 });
 import { spawn as spawn11, spawnSync as spawnSync7 } from "node:child_process";
 import {
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   constants as fsConstants,
   mkdirSync as mkdirSync14,
   mkdtempSync as mkdtempSync5,
@@ -46670,7 +47032,7 @@ import {
 } from "node:fs";
 import { access } from "node:fs/promises";
 import { homedir as homedir15, tmpdir as tmpdir4 } from "node:os";
-import { delimiter as delimiter3, dirname as dirname16, join as join21, resolve as resolve9 } from "node:path";
+import { delimiter as delimiter3, dirname as dirname16, join as join21, resolve as resolve10 } from "node:path";
 import { stdin as defaultStdin, stdout as defaultStdout } from "node:process";
 import { emitKeypressEvents } from "node:readline";
 function signupHelpText() {
@@ -46786,7 +47148,7 @@ function defaultSignupDraftStore(serviceUrl) {
   const path2 = defaultSignupDraftPath(serviceUrl);
   return {
     read: () => {
-      if (!existsSync15(path2)) {
+      if (!existsSync16(path2)) {
         return void 0;
       }
       let parsed;
@@ -46865,7 +47227,7 @@ function defaultSignupTaskCachePath(serviceUrl) {
   );
 }
 function readSignupTaskCache(path2) {
-  if (!existsSync15(path2)) {
+  if (!existsSync16(path2)) {
     return { version: 1, entries: {} };
   }
   let parsed;
@@ -48184,11 +48546,11 @@ async function openUrlInBrowser(url) {
     return;
   }
   const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
-  await new Promise((resolve11, reject) => {
+  await new Promise((resolve12, reject) => {
     const child = spawn11(command, args, { stdio: "ignore", detached: true });
     child.once("spawn", () => {
       child.unref();
-      resolve11();
+      resolve12();
     });
     child.once("error", reject);
   });
@@ -48403,7 +48765,7 @@ function runProjectPickerPrompt(input, output, args) {
       (answer) => answer.split(",").map((path2) => path2.trim()).filter((path2) => path2 !== "")
     );
   }
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     emitKeypressEvents(keypressInput);
     keypressInput.setRawMode?.(true);
     keypressInput.resume?.();
@@ -48467,7 +48829,7 @@ function runProjectPickerPrompt(input, output, args) {
       }
       cleanup();
       clearRenderedLines(output, renderedLines);
-      resolve11([...selectedPaths]);
+      resolve12([...selectedPaths]);
     };
     const toggleHighlighted = () => {
       const highlightedRow = rows()[highlightIndex];
@@ -49267,7 +49629,7 @@ function resolveHomePath(path2, homeDir) {
   if (path2.startsWith("~/")) {
     return join21(homeDir, path2.slice(2));
   }
-  return resolve9(path2);
+  return resolve10(path2);
 }
 function resolveCodexCommandOverride(command, homeDir) {
   const trimmed = command.trim();
@@ -49650,7 +50012,7 @@ function spawnSyncGitOutput(args, cwd) {
   }
 }
 function probeToolWithArgs(command, args, cwd) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const child = spawn11(command, [...args], {
       cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -49663,7 +50025,7 @@ function probeToolWithArgs(command, args, cwd) {
       }
       settled = true;
       clearTimeout(timeout);
-      resolve11(status);
+      resolve12(status);
     };
     const timeout = setTimeout(() => {
       child.kill("SIGKILL");
@@ -49689,7 +50051,7 @@ async function discoverCodeRoots(homeDir) {
   const candidates = ["src", "code", "projects"].map(
     (name) => join21(homeDir, name)
   );
-  return candidates.filter((path2) => existsSync15(path2)).flatMap((path2) => discoveredProjectNames(path2));
+  return candidates.filter((path2) => existsSync16(path2)).flatMap((path2) => discoveredProjectNames(path2));
 }
 function discoveredProjectNames(root) {
   try {
@@ -49793,25 +50155,25 @@ function looksLikeProject(path2) {
     "pnpm-lock.yaml",
     "yarn.lock",
     "package-lock.json"
-  ].some((name) => existsSync15(join21(path2, name)));
+  ].some((name) => existsSync16(join21(path2, name)));
 }
 function detectProjectLanguage(path2) {
-  if (existsSync15(join21(path2, "pyproject.toml")) || existsSync15(join21(path2, "requirements.txt"))) {
+  if (existsSync16(join21(path2, "pyproject.toml")) || existsSync16(join21(path2, "requirements.txt"))) {
     return "Python";
   }
-  if (existsSync15(join21(path2, "Cargo.toml"))) {
+  if (existsSync16(join21(path2, "Cargo.toml"))) {
     return "Rust";
   }
-  if (existsSync15(join21(path2, "go.mod"))) {
+  if (existsSync16(join21(path2, "go.mod"))) {
     return "Go";
   }
-  if (existsSync15(join21(path2, "mix.exs"))) {
+  if (existsSync16(join21(path2, "mix.exs"))) {
     return "Elixir";
   }
-  if (existsSync15(join21(path2, "tsconfig.json")) || packageJsonMentionsTypeScript(path2)) {
+  if (existsSync16(join21(path2, "tsconfig.json")) || packageJsonMentionsTypeScript(path2)) {
     return "TypeScript";
   }
-  if (existsSync15(join21(path2, "package.json"))) {
+  if (existsSync16(join21(path2, "package.json"))) {
     return "JavaScript";
   }
   return "Project";
@@ -49827,7 +50189,7 @@ function packageJsonMentionsTypeScript(path2) {
   }
 }
 function hasGitMetadata(path2) {
-  return existsSync15(join21(path2, ".git"));
+  return existsSync16(join21(path2, ".git"));
 }
 function childDirectories(root) {
   try {
@@ -49862,7 +50224,7 @@ function expandHomePath(path2) {
   if (path2.startsWith("~/")) {
     return join21(homedir15(), path2.slice(2));
   }
-  return resolve9(path2);
+  return resolve10(path2);
 }
 function summarizeCodeRoots(roots) {
   const first = roots[0];
@@ -49949,9 +50311,9 @@ secure mission control for all your agents on your computers
 init_runner();
 init_claudeCodeSession();
 init_authCache();
-import { existsSync as existsSync16, readFileSync as readFileSync21, realpathSync as realpathSync7 } from "node:fs";
+import { existsSync as existsSync17, readFileSync as readFileSync21, realpathSync as realpathSync7 } from "node:fs";
 import { homedir as homedir16 } from "node:os";
-import { resolve as resolve10 } from "node:path";
+import { resolve as resolve11 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // src/authResolution.ts
@@ -50012,7 +50374,7 @@ init_kandanTls();
 init_protocol();
 init_json();
 init_defaultUrls();
-import { existsSync as existsSync13, mkdirSync as mkdirSync12, readFileSync as readFileSync17, writeFileSync as writeFileSync10 } from "node:fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync12, readFileSync as readFileSync17, writeFileSync as writeFileSync10 } from "node:fs";
 import { dirname as dirname14, join as join19 } from "node:path";
 import { homedir as homedir13 } from "node:os";
 async function runAgentCliCommand(args, deps = {
@@ -50731,7 +51093,7 @@ function authorizationHeaders(token) {
   return { authorization: `Bearer ${token}` };
 }
 function readOptionalTextFile(path2) {
-  return existsSync13(path2) ? readFileSync17(path2, "utf8") : void 0;
+  return existsSync14(path2) ? readFileSync17(path2, "utf8") : void 0;
 }
 function writeTextFile(path2, content) {
   mkdirSync12(dirname14(path2), { recursive: true });
@@ -50822,7 +51184,7 @@ init_helloLinzumiProject();
 // src/commanderDaemon.ts
 init_runnerLogger();
 import {
-  existsSync as existsSync14,
+  existsSync as existsSync15,
   closeSync as closeSync3,
   mkdirSync as mkdirSync13,
   openSync as openSync4,
@@ -50831,7 +51193,7 @@ import {
   writeFileSync as writeFileSync11
 } from "node:fs";
 import { homedir as homedir14 } from "node:os";
-import { dirname as dirname15, join as join20, resolve as resolve8 } from "node:path";
+import { dirname as dirname15, join as join20, resolve as resolve9 } from "node:path";
 import { execFileSync, spawn as spawn9 } from "node:child_process";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var connectedMarkers = ["Connected to Linzumi", "Runner connected:"];
@@ -50850,7 +51212,7 @@ function commanderLogIsConnected(log2) {
 function startCommanderDaemon(options) {
   const statusDir = options.statusDir ?? commanderStatusDir();
   const statusFile = commanderStatusFile(options.runnerId, statusDir);
-  const logFile = resolve8(
+  const logFile = resolve9(
     options.logFile ?? defaultCommanderLogFile(options.runnerId)
   );
   const entrypoint = options.entrypoint ?? currentEntrypoint();
@@ -50916,7 +51278,7 @@ function startCommanderDaemon(options) {
 }
 function commanderDaemonStatus(runnerId, statusDir = commanderStatusDir(), processIdentityReader = readProcessIdentity) {
   const statusFile = commanderStatusFile(runnerId, statusDir);
-  if (!existsSync14(statusFile)) {
+  if (!existsSync15(statusFile)) {
     return { status: "missing", runnerId, statusFile };
   }
   const record = parseRecord(readFileSync18(statusFile, "utf8"));
@@ -50924,7 +51286,7 @@ function commanderDaemonStatus(runnerId, statusDir = commanderStatusDir(), proce
 }
 async function waitForCommanderDaemon(options) {
   const now = options.now ?? (() => Date.now());
-  const readTextFile = options.readTextFile ?? ((path2) => existsSync14(path2) ? readFileSync18(path2, "utf8") : void 0);
+  const readTextFile = options.readTextFile ?? ((path2) => existsSync15(path2) ? readFileSync18(path2, "utf8") : void 0);
   const statusImpl = options.statusImpl ?? commanderDaemonStatus;
   const deadline = now() + options.timeoutMs;
   while (now() <= deadline) {
@@ -51092,7 +51454,7 @@ function safeRunnerId(runnerId) {
 }
 async function waitForFileChangeOrTimeout(path2, deadline, now, ready2 = () => false) {
   const remaining = Math.max(0, deadline - now());
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     let resolved = false;
     let watcher;
     const finish = (connected) => {
@@ -51102,7 +51464,7 @@ async function waitForFileChangeOrTimeout(path2, deadline, now, ready2 = () => f
       resolved = true;
       watcher?.close();
       clearTimeout(timer);
-      resolve11(connected);
+      resolve12(connected);
     };
     const timer = setTimeout(() => finish(false), remaining);
     try {
@@ -56376,7 +56738,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken } = options !== null && options !== void 0 ? options : {};
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       var _a, _b, _c, _d, _e, _f;
       if (!this._transport) {
         reject(new Error("Not connected"));
@@ -56427,7 +56789,7 @@ var Protocol = class {
         }
         try {
           const result = resultSchema.parse(response.result);
-          resolve11(result);
+          resolve12(result);
         } catch (error) {
           reject(error);
         }
@@ -58777,12 +59139,12 @@ var StdioServerTransport = class {
     (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);
   }
   send(message) {
-    return new Promise((resolve11) => {
+    return new Promise((resolve12) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve11();
+        resolve12();
       } else {
-        this._stdout.once("drain", resolve11);
+        this._stdout.once("drain", resolve12);
       }
     });
   }
@@ -64012,9 +64374,9 @@ function remoteHarnessRunnerJoinPayload(config) {
   };
 }
 function defaultWaitUntilShutdown(cleanup) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const finish = () => {
-      cleanup().then(resolve11, reject);
+      cleanup().then(resolve12, reject);
     };
     process.once("SIGINT", finish);
     process.once("SIGTERM", finish);
@@ -64034,9 +64396,9 @@ function waitForCodexAppServerExit(child) {
       signal: child.signalCode
     });
   }
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     child.once("exit", (code, signal) => {
-      resolve11({ code, signal });
+      resolve12({ code, signal });
     });
   });
 }
@@ -64111,6 +64473,11 @@ var flagDefinitions = /* @__PURE__ */ new Map([
   ["reasoning-effort", { kind: "value" }],
   ["sandbox", { kind: "value" }],
   ["approval-policy", { kind: "value" }],
+  // Thread-worker-only flags: wafer-routed codex threads carry their model
+  // transport selector and Kandan LLM proxy base URL through the worker argv
+  // (the credential travels via LINZUMI_LLM_PROXY_TOKEN env).
+  ["model-provider", { kind: "value" }],
+  ["llm-proxy-base-url", { kind: "value" }],
   ["allow-port-forwarding-by-default", { kind: "boolean" }],
   ["stream-flush-ms", { kind: "value" }],
   ["allowed-cwd", { kind: "value" }],
@@ -64154,7 +64521,7 @@ function isMainModule() {
   if (scriptPath === void 0) {
     return false;
   }
-  return fileURLToPath4(import.meta.url) === resolve10(scriptPath);
+  return fileURLToPath4(import.meta.url) === resolve11(scriptPath);
 }
 async function main(args) {
   const parsed = parseCommand(args);
@@ -64406,7 +64773,7 @@ function runPathsCommand(args) {
       if (pathValue === void 0 || pathValue.trim() === "") {
         throw new Error("missing path for linzumi paths add");
       }
-      const trustedPath = realpathSync7(resolve10(expandUserPath(pathValue)));
+      const trustedPath = realpathSync7(resolve11(expandUserPath(pathValue)));
       if (linzumiUrl === void 0) {
         addAllowedCwd(pathValue);
       } else {
@@ -64801,7 +65168,7 @@ async function parseAgentRunnerArgs(args, deps = {
   };
 }
 function readAgentTokenTextFile(path2) {
-  return existsSync16(path2) ? readFileSync21(path2, "utf8") : void 0;
+  return existsSync17(path2) ? readFileSync21(path2, "utf8") : void 0;
 }
 function rejectAgentRunnerTargetingFlags(values) {
   const unsupportedFlags = [
@@ -65115,9 +65482,9 @@ function resolveUserPath(pathValue) {
     return homedir16();
   }
   if (pathValue.startsWith("~/")) {
-    return resolve10(homedir16(), pathValue.slice(2));
+    return resolve11(homedir16(), pathValue.slice(2));
   }
-  return resolve10(pathValue);
+  return resolve11(pathValue);
 }
 function defaultListenUserFromToken(token) {
   const username = identityFromAccessToken(token).actorUsername;
@@ -65209,9 +65576,34 @@ function parseThreadCodexWorkerArgs(args) {
       role: "thread",
       kandanThreadId
     },
+    codexModelProvider: threadRunnerCodexModelProvider(values),
     channelSession: void 0
   };
 }
+function threadRunnerCodexModelProvider(values) {
+  const modelProvider = stringValue7(values, "model-provider");
+  if (modelProvider === void 0) {
+    return void 0;
+  }
+  if (modelProvider !== "wafer") {
+    throw new Error(`unsupported --model-provider: ${modelProvider}`);
+  }
+  const llmProxyBaseUrl = stringValue7(values, "llm-proxy-base-url");
+  const llmProxyToken = process.env.LINZUMI_LLM_PROXY_TOKEN?.trim();
+  if (llmProxyBaseUrl === void 0) {
+    throw new Error("--model-provider wafer requires --llm-proxy-base-url");
+  }
+  if (llmProxyToken === void 0 || llmProxyToken === "") {
+    throw new Error(
+      "--model-provider wafer requires the LINZUMI_LLM_PROXY_TOKEN env credential"
+    );
+  }
+  return {
+    provider: "wafer",
+    llmProxyBaseUrl,
+    llmProxyToken
+  };
+}
 function requiredThreadRunnerKandanThreadId() {
   const kandanThreadId = process.env.LINZUMI_THREAD_RUNNER_KANDAN_THREAD_ID;
   if (kandanThreadId === void 0 || kandanThreadId.trim() === "") {