codex-to-im 1.0.40 → 1.0.42

package/dist/daemon.mjs

@@ -3935,9 +3935,9 @@ var codex_provider_exports = {};
 __export(codex_provider_exports, {
   CodexProvider: () => CodexProvider
 });
-import fs14 from "node:fs";
+import fs15 from "node:fs";
 import os4 from "node:os";
-import path15 from "node:path";
+import path16 from "node:path";
 function toApprovalPolicy(permissionMode) {
   switch (permissionMode) {
     case "never":
@@ -3959,6 +3959,55 @@ function shouldRetryFreshThread(message) {
   const lower = message.toLowerCase();
   return lower.includes("resuming session with different model") || lower.includes("no such session") || lower.includes("resume") && lower.includes("session");
 }
+function normalizeCodexErrorMessage(message) {
+  const trimmed = (message || "").trim();
+  if (!trimmed) return "Codex \u6267\u884C\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
+  const lower = trimmed.toLowerCase();
+  if (lower.includes("timeout waiting for child process to exit") || lower.includes("reconnecting...")) {
+    return "Codex \u4F1A\u8BDD\u6062\u590D\u5931\u8D25\uFF0C\u4E0A\u4E00\u8F6E\u6267\u884C\u8FDB\u7A0B\u672A\u6B63\u5E38\u9000\u51FA\u3002\u8BF7\u7A0D\u540E\u91CD\u8BD5\uFF1B\u5982\u679C\u8FDE\u7EED\u5931\u8D25\uFF0C\u8BF7\u65B0\u5F00\u7EBF\u7A0B\u6216\u5207\u6362\u5230 /t 0\u3002";
+  }
+  return trimmed;
+}
+function normalizeTaskText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function mapTodoListItems(items) {
+  if (!Array.isArray(items)) return [];
+  const normalized = items.map((item) => ({
+    text: normalizeTaskText(item?.text),
+    completed: item?.completed === true
+  })).filter((item) => item.text);
+  let firstIncompleteSeen = false;
+  return normalized.map((item) => {
+    if (item.completed) {
+      return { text: item.text, status: "completed" };
+    }
+    if (!firstIncompleteSeen) {
+      firstIncompleteSeen = true;
+      return { text: item.text, status: "in_progress" };
+    }
+    return { text: item.text, status: "pending" };
+  });
+}
+function extractMcpContentText(value) {
+  if (!Array.isArray(value)) return "";
+  return value.map((block2) => {
+    if (!block2 || typeof block2 !== "object") return "";
+    const record = block2;
+    if (typeof record.text === "string") return record.text.trim();
+    if (typeof record.content === "string") return record.content.trim();
+    return "";
+  }).filter(Boolean).join("\n\n").trim();
+}
+function stringifyUnknown(value) {
+  if (typeof value === "string") return value;
+  if (value == null) return "";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
 var MIME_EXT, CodexProvider;
 var init_codex_provider = __esm({
   "src/codex-provider.ts"() {
@@ -3979,6 +4028,9 @@ var init_codex_provider = __esm({
       threadIds = /* @__PURE__ */ new Map();
       constructor(_pendingPerms) {
       }
+      clearCachedThreadId(sessionId) {
+        this.threadIds.delete(sessionId);
+      }
       /**
        * Lazily load the Codex SDK. Throws a clear error if the installation is incomplete.
        */
@@ -4032,13 +4084,13 @@ var init_codex_provider = __esm({
                     { type: "text", text: params.prompt }
                   ];
                   for (const file of imageFiles) {
-                    if (file.filePath && fs14.existsSync(file.filePath)) {
+                    if (file.filePath && fs15.existsSync(file.filePath)) {
                       parts.push({ type: "local_image", path: file.filePath });
                       continue;
                     }
                     const ext = MIME_EXT[file.type] || ".png";
-                    const tmpPath = path15.join(os4.tmpdir(), `cti-img-${Date.now()}-${Math.random().toString(36).slice(2)}${ext}`);
-                    fs14.writeFileSync(tmpPath, Buffer.from(file.data, "base64"));
+                    const tmpPath = path16.join(os4.tmpdir(), `cti-img-${Date.now()}-${Math.random().toString(36).slice(2)}${ext}`);
+                    fs15.writeFileSync(tmpPath, Buffer.from(file.data, "base64"));
                     tempFiles.push(tmpPath);
                     parts.push({ type: "local_image", path: tmpPath });
                   }
@@ -4047,6 +4099,7 @@ var init_codex_provider = __esm({
                   input = params.prompt;
                 }
                 let retryFresh = false;
+                const emittedToolStarts = /* @__PURE__ */ new Set();
                 while (true) {
                   let thread;
                   if (savedThreadId) {
@@ -4078,9 +4131,19 @@ var init_codex_provider = __esm({
                           }));
                           break;
                         }
+                        case "turn.started":
+                          break;
+                        case "item.started":
+                        case "item.updated":
                         case "item.completed": {
                           const item = event.item;
-                          self.handleCompletedItem(controller, item);
+                          self.handleItemEvent(
+                            controller,
+                            item,
+                            event.type === "item.started" ? "started" : event.type === "item.updated" ? "updated" : "completed",
+                            params.sessionId,
+                            emittedToolStarts
+                          );
                           break;
                         }
                         case "turn.completed": {
@@ -4098,17 +4161,27 @@ var init_codex_provider = __esm({
                           break;
                         }
                         case "turn.failed": {
-                          const error = event.message;
-                          controller.enqueue(sseEvent("error", error || "Turn failed"));
+                          const error = event.error?.message;
+                          self.clearCachedThreadId(params.sessionId);
+                          controller.enqueue(sseEvent("error", normalizeCodexErrorMessage(error || "Turn failed")));
                           sawTerminalEvent = true;
                           break;
                         }
                         case "error": {
                           const error = event.message;
-                          controller.enqueue(sseEvent("error", error || "Thread error"));
+                          self.clearCachedThreadId(params.sessionId);
+                          controller.enqueue(sseEvent("error", normalizeCodexErrorMessage(error || "Thread error")));
                           sawTerminalEvent = true;
                           break;
                         }
+                        default: {
+                          const exhaustiveEvent = event;
+                          console.warn(
+                            "[codex-provider] Unhandled thread event:",
+                            stringifyUnknown(exhaustiveEvent)
+                          );
+                          break;
+                        }
                       }
                       if (sawTerminalEvent) {
                         break;
@@ -4119,10 +4192,12 @@ var init_codex_provider = __esm({
                     const message = err instanceof Error ? err.message : String(err);
                     if (savedThreadId && !retryFresh && !sawAnyEvent && shouldRetryFreshThread(message)) {
                       console.warn("[codex-provider] Resume failed, retrying with a fresh thread:", message);
+                      self.clearCachedThreadId(params.sessionId);
                       savedThreadId = void 0;
                       retryFresh = true;
                       continue;
                     }
+                    self.clearCachedThreadId(params.sessionId);
                     throw err;
                   }
                 }
@@ -4130,15 +4205,16 @@ var init_codex_provider = __esm({
               } catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
                 console.error("[codex-provider] Error:", err instanceof Error ? err.stack || err.message : err);
+                self.clearCachedThreadId(params.sessionId);
                 try {
-                  controller.enqueue(sseEvent("error", message));
+                  controller.enqueue(sseEvent("error", normalizeCodexErrorMessage(message)));
                   controller.close();
                 } catch {
                 }
               } finally {
                 for (const tmp of tempFiles) {
                   try {
-                    fs14.unlinkSync(tmp);
+                    fs15.unlinkSync(tmp);
                   } catch {
                   }
                 }
@@ -4148,12 +4224,22 @@ var init_codex_provider = __esm({
         });
       }
       /**
-       * Map a completed Codex item to SSE events.
+       * Map a Codex item event to SSE events.
        */
-      handleCompletedItem(controller, item) {
+      handleItemEvent(controller, item, phase, sessionId, emittedToolStarts) {
         const itemType = item.type;
+        const ensureToolUse = (toolId, name, input) => {
+          if (emittedToolStarts.has(toolId)) return;
+          emittedToolStarts.add(toolId);
+          controller.enqueue(sseEvent("tool_use", {
+            id: toolId,
+            name,
+            input
+          }));
+        };
         switch (itemType) {
           case "agent_message": {
+            if (phase !== "completed") break;
             const text2 = item.text || "";
             if (text2) {
               controller.enqueue(sseEvent("text", text2));
@@ -4165,12 +4251,11 @@ var init_codex_provider = __esm({
             const command = item.command || "";
             const output = item.aggregated_output || "";
             const exitCode = item.exit_code;
+            const status = item.status;
             const isError = exitCode != null && exitCode !== 0;
-            controller.enqueue(sseEvent("tool_use", {
-              id: toolId,
-              name: "Bash",
-              input: { command }
-            }));
+            const terminal = phase === "completed" || status === "completed" || status === "failed";
+            ensureToolUse(toolId, "Bash", { command });
+            if (!terminal) break;
             const resultContent = output || (isError ? `Exit code: ${exitCode}` : "Done");
             controller.enqueue(sseEvent("tool_result", {
               tool_use_id: toolId,
@@ -4180,14 +4265,11 @@ var init_codex_provider = __esm({
             break;
           }
           case "file_change": {
+            if (phase !== "completed") break;
             const toolId = item.id || `tool-${Date.now()}`;
             const changes = item.changes || [];
             const summary = changes.map((c) => `${c.kind}: ${c.path}`).join("\n");
-            controller.enqueue(sseEvent("tool_use", {
-              id: toolId,
-              name: "Edit",
-              input: { files: changes }
-            }));
+            ensureToolUse(toolId, "Edit", { files: changes });
             controller.enqueue(sseEvent("tool_result", {
               tool_use_id: toolId,
               content: summary || "File changes applied",
@@ -4202,13 +4284,11 @@ var init_codex_provider = __esm({
             const args = item.arguments;
             const result = item.result;
             const error = item.error;
-            const resultContent = result?.content ?? result?.structured_content;
-            const resultText = typeof resultContent === "string" ? resultContent : resultContent ? JSON.stringify(resultContent) : void 0;
-            controller.enqueue(sseEvent("tool_use", {
-              id: toolId,
-              name: `mcp__${server}__${tool}`,
-              input: args
-            }));
+            const status = item.status;
+            const terminal = phase === "completed" || status === "completed" || status === "failed";
+            const resultText = extractMcpContentText(result?.content) || stringifyUnknown(result?.structured_content) || stringifyUnknown(result?.content);
+            ensureToolUse(toolId, `mcp__${server}__${tool}`, args);
+            if (!terminal) break;
             controller.enqueue(sseEvent("tool_result", {
               tool_use_id: toolId,
               content: error?.message || resultText || "Done",
@@ -4216,6 +4296,18 @@ var init_codex_provider = __esm({
             }));
             break;
           }
+          case "web_search": {
+            const toolId = item.id || `tool-${Date.now()}`;
+            const query2 = item.query || "";
+            ensureToolUse(toolId, "Web Search", { query: query2 });
+            if (phase !== "completed") break;
+            controller.enqueue(sseEvent("tool_result", {
+              tool_use_id: toolId,
+              content: query2 || "Search completed",
+              is_error: false
+            }));
+            break;
+          }
           case "reasoning": {
             const text2 = item.text || "";
             if (text2) {
@@ -4223,15 +4315,41 @@ var init_codex_provider = __esm({
             }
             break;
           }
+          case "todo_list": {
+            const tasks = mapTodoListItems(item.items);
+            controller.enqueue(sseEvent("task_update", {
+              session_id: sessionId,
+              sdk_session_id: this.threadIds.get(sessionId) || void 0,
+              tasks,
+              todos: tasks
+            }));
+            break;
+          }
+          case "error": {
+            this.clearCachedThreadId(sessionId);
+            controller.enqueue(sseEvent("error", normalizeCodexErrorMessage(item.message || "Codex error")));
+            break;
+          }
+          default: {
+            const exhaustiveItem = item;
+            console.warn(
+              "[codex-provider] Unhandled thread item:",
+              stringifyUnknown(exhaustiveItem)
+            );
+            break;
+          }
         }
       }
+      handleCompletedItem(controller, item) {
+        this.handleItemEvent(controller, item, "completed", "test-session", /* @__PURE__ */ new Set());
+      }
     };
   }
 });
 
 // src/main.ts
-import fs15 from "node:fs";
-import path16 from "node:path";
+import fs16 from "node:fs";
+import path17 from "node:path";
 import crypto10 from "node:crypto";
 
 // src/lib/bridge/context.ts
@@ -5515,6 +5633,14 @@ function buildToolProgressMarkdown(tools) {
   });
   return lines.join("\n");
 }
+function buildTaskProgressMarkdown(tasks) {
+  if (tasks.length === 0) return "";
+  return tasks.map((task) => {
+    const icon = task.status === "completed" ? "\u2705" : task.status === "in_progress" ? "\u{1F504}" : "\u23F3";
+    const label = task.status === "completed" ? "\u5DF2\u5B8C\u6210" : task.status === "in_progress" ? "\u6267\u884C\u4E2D" : "\u7B49\u5F85\u4E2D";
+    return `${icon} ${task.text}\uFF08${label}\uFF09`;
+  }).join("\n");
+}
 function formatElapsed(ms) {
   if (ms < 1e3) return `${ms}ms`;
   const sec = ms / 1e3;
@@ -5529,9 +5655,13 @@ function buildStreamingTextContent(text2) {
 function buildStreamingToolsContent(tools) {
   return buildToolProgressMarkdown(tools);
 }
-function buildFinalCardJson(text2, tools, footer) {
+function buildStreamingTaskContent(tasks) {
+  return buildTaskProgressMarkdown(tasks);
+}
+function buildFinalCardJson(text2, tasks, tools, footer) {
   const elements = [];
   const content = preprocessFeishuMarkdown(text2);
+  const taskMd = buildTaskProgressMarkdown(tasks);
   const toolMd = buildToolProgressMarkdown(tools);
   if (content) {
     elements.push({
@@ -5541,6 +5671,17 @@ function buildFinalCardJson(text2, tools, footer) {
       text_size: "normal"
     });
   }
+  if (taskMd) {
+    if (elements.length > 0) {
+      elements.push({ tag: "hr" });
+    }
+    elements.push({
+      tag: "markdown",
+      content: taskMd,
+      text_align: "left",
+      text_size: "normal"
+    });
+  }
   if (toolMd) {
     if (elements.length > 0) {
       elements.push({ tag: "hr" });
@@ -5626,7 +5767,9 @@ var DEDUP_MAX = 1e3;
 var MAX_FILE_SIZE = 20 * 1024 * 1024;
 var TYPING_EMOJI = "Typing";
 var CARD_THROTTLE_MS = 200;
+var CARD_REQUEST_TIMEOUT_MS = 15e3;
 var INITIAL_STREAMING_STATUS = "\u5904\u7406\u4E2D";
+var EMPTY_STREAMING_TASKS = "";
 var EMPTY_STREAMING_TOOLS = "";
 var MIME_BY_TYPE = {
   image: "image/png",
@@ -5657,6 +5800,7 @@ var FeishuAdapter = class extends BaseChannelAdapter {
   cardCreatePromises = /* @__PURE__ */ new Map();
   /** Cached tenant token for upload APIs. */
   tenantTokenCache = null;
+  cardRequestTimeoutMs = CARD_REQUEST_TIMEOUT_MS;
   constructor(instance) {
     super();
     this.channelType = instance?.id || "feishu";
@@ -5884,6 +6028,13 @@ var FeishuAdapter = class extends BaseChannelAdapter {
               text_size: "normal",
               element_id: "streaming_content"
             },
+            {
+              tag: "markdown",
+              content: EMPTY_STREAMING_TASKS,
+              text_align: "left",
+              text_size: "normal",
+              element_id: "streaming_tasks"
+            },
             {
               tag: "markdown",
               content: EMPTY_STREAMING_TOOLS,
@@ -5901,9 +6052,9 @@ var FeishuAdapter = class extends BaseChannelAdapter {
           ]
         }
       };
-      const createResp = await cardkit.card.create({
+      const createResp = await this.withFeishuRequestTimeout(cardKey, "card.create", () => cardkit.card.create({
         data: { type: "card_json", data: JSON.stringify(cardBody) }
-      });
+      }));
       const cardId = createResp?.data?.card_id;
       if (!cardId) {
         console.warn("[feishu-adapter] Card create returned no card_id");
@@ -5912,19 +6063,19 @@ var FeishuAdapter = class extends BaseChannelAdapter {
       const cardContent = JSON.stringify({ type: "card", data: { card_id: cardId } });
       let msgResp;
       if (replyToMessageId) {
-        msgResp = await this.restClient.im.message.reply({
+        msgResp = await this.withFeishuRequestTimeout(cardKey, "im.message.reply:interactive", () => this.restClient.im.message.reply({
           path: { message_id: replyToMessageId },
           data: { content: cardContent, msg_type: "interactive" }
-        });
+        }));
       } else {
-        msgResp = await this.restClient.im.message.create({
+        msgResp = await this.withFeishuRequestTimeout(cardKey, "im.message.create:interactive", () => this.restClient.im.message.create({
           params: { receive_id_type: "chat_id" },
           data: {
             receive_id: chatId,
             msg_type: "interactive",
             content: cardContent
           }
-        });
+        }));
       }
       const messageId = msgResp?.data?.message_id;
       if (!messageId) {
@@ -5937,17 +6088,25 @@ var FeishuAdapter = class extends BaseChannelAdapter {
         messageId,
         sequence: 0,
         startTime: Date.now(),
+        taskItems: [],
         toolCalls: [],
         thinking: true,
         pendingText: null,
+        pendingTasksText: EMPTY_STREAMING_TASKS,
         pendingStatusText: INITIAL_STREAMING_STATUS,
         renderedText: "\u{1F4AD} Thinking...",
+        renderedTasksText: EMPTY_STREAMING_TASKS,
         renderedToolsText: EMPTY_STREAMING_TOOLS,
         renderedStatusText: INITIAL_STREAMING_STATUS,
         lastUpdateAt: 0,
         throttleTimer: null,
         flushInFlight: null,
-        flushQueued: false
+        flushQueued: false,
+        lastFlushStartedAt: null,
+        lastSuccessfulFlushAt: null,
+        lastFlushErrorAt: null,
+        lastFlushError: null,
+        consecutiveFlushFailures: 0
       });
       console.log(`[feishu-adapter] Streaming card created: streamKey=${cardKey}, cardId=${cardId}, msgId=${messageId}`);
       return true;
@@ -5976,6 +6135,14 @@ var FeishuAdapter = class extends BaseChannelAdapter {
     state.pendingStatusText = statusText || INITIAL_STREAMING_STATUS;
     this.scheduleCardFlush(cardKey);
   }
+  updateTaskProgress(chatId, tasks, streamKey) {
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
+    const state = this.activeCards.get(cardKey);
+    if (!state) return;
+    state.taskItems = tasks;
+    state.pendingTasksText = buildStreamingTaskContent(tasks) || EMPTY_STREAMING_TASKS;
+    this.scheduleCardFlush(cardKey);
+  }
   enqueueCardFlush(streamKey) {
     const state = this.activeCards.get(streamKey);
     if (!state) return;
@@ -5983,6 +6150,7 @@ var FeishuAdapter = class extends BaseChannelAdapter {
       state.flushQueued = true;
       return;
     }
+    state.lastFlushStartedAt = Date.now();
     state.flushInFlight = this.flushCardUpdate(streamKey).catch((err) => {
       console.warn("[feishu-adapter] cardElement.content failed:", err instanceof Error ? err.message : err);
     }).finally(() => {
@@ -6023,6 +6191,7 @@ var FeishuAdapter = class extends BaseChannelAdapter {
     const cardkit = this.restClient.cardkit?.v1;
     if (!cardkit?.cardElement?.content) return;
     const content = buildStreamingTextContent(state.pendingText || "");
+    const tasksText = state.pendingTasksText || EMPTY_STREAMING_TASKS;
     const toolsText = buildStreamingToolsContent(state.toolCalls) || EMPTY_STREAMING_TOOLS;
     const statusText = state.pendingStatusText || INITIAL_STREAMING_STATUS;
     const updates = [];
@@ -6035,6 +6204,15 @@ var FeishuAdapter = class extends BaseChannelAdapter {
         }
       });
     }
+    if (tasksText !== state.renderedTasksText) {
+      updates.push({
+        elementId: "streaming_tasks",
+        content: tasksText,
+        onSuccess: () => {
+          state.renderedTasksText = tasksText;
+        }
+      });
+    }
     if (toolsText !== state.renderedToolsText) {
       updates.push({
         elementId: "streaming_tools",
@@ -6058,13 +6236,14 @@ var FeishuAdapter = class extends BaseChannelAdapter {
     for (const update of updates) {
       state.sequence++;
       try {
-        await cardkit.cardElement.content({
+        await this.withFeishuRequestTimeout(streamKey, `cardElement.content:${update.elementId}`, () => cardkit.cardElement.content({
           path: { card_id: cardId, element_id: update.elementId },
           data: { content: update.content, sequence: state.sequence }
-        });
+        }));
         update.onSuccess();
-        state.lastUpdateAt = Date.now();
+        this.markCardFlushSuccess(state);
       } catch (err) {
+        this.markCardFlushFailure(state, err);
         console.warn(
           `[feishu-adapter] cardElement.content failed for ${update.elementId}:`,
           err instanceof Error ? err.message : err
@@ -6125,13 +6304,13 @@ var FeishuAdapter = class extends BaseChannelAdapter {
     await this.awaitCardFlushCompletion(cardKey);
     try {
       state.sequence++;
-      await cardkit.card.settings({
+      await this.withFeishuRequestTimeout(cardKey, "card.settings", () => cardkit.card.settings({
         path: { card_id: state.cardId },
         data: {
           settings: JSON.stringify({ streaming_mode: false }),
           sequence: state.sequence
         }
-      });
+      }));
       const statusLabels = {
         completed: "\u2705 Completed",
         interrupted: "\u26A0\uFE0F Interrupted",
@@ -6151,15 +6330,15 @@ var FeishuAdapter = class extends BaseChannelAdapter {
 
 ${trimmedResponse}`;
       }
-      const finalCardJson = buildFinalCardJson(finalText, state.toolCalls, footer);
+      const finalCardJson = buildFinalCardJson(finalText, state.taskItems, state.toolCalls, footer);
       state.sequence++;
-      await cardkit.card.update({
+      await this.withFeishuRequestTimeout(cardKey, "card.update", () => cardkit.card.update({
         path: { card_id: state.cardId },
         data: {
           card: { type: "card_json", data: finalCardJson },
           sequence: state.sequence
         }
-      });
+      }));
       console.log(`[feishu-adapter] Card finalized: streamKey=${cardKey}, cardId=${state.cardId}, status=${status}, elapsed=${formatElapsed(elapsedMs)}`);
       return true;
     } catch (err) {
@@ -6191,6 +6370,76 @@ ${trimmedResponse}`;
   hasActiveStreamingUi(chatId, streamKey) {
     return this.hasActiveCard(chatId, streamKey);
   }
+  getStructuredStreamingUiSnapshot(chatId, streamKey) {
+    const state = this.activeCards.get(this.resolveStreamKey(chatId, streamKey));
+    if (!state) return null;
+    return {
+      active: true,
+      lastAttemptAt: state.lastFlushStartedAt,
+      lastUpdateAt: state.lastSuccessfulFlushAt ?? (state.lastUpdateAt > 0 ? state.lastUpdateAt : null),
+      lastErrorAt: state.lastFlushErrorAt,
+      lastError: state.lastFlushError,
+      flushInFlight: Boolean(state.flushInFlight),
+      flushInFlightSince: state.flushInFlight ? state.lastFlushStartedAt : null,
+      consecutiveFailures: state.consecutiveFlushFailures
+    };
+  }
+  getCardRequestTimeoutMs() {
+    return Math.max(1, this.cardRequestTimeoutMs);
+  }
+  logRequestOperation(phase, scope, target, startedAt, detail) {
+    const durationMs = Math.max(0, Date.now() - startedAt);
+    const suffix = detail ? `, detail=${detail}` : "";
+    const line = `[feishu-adapter] Request ${phase}: scope=${scope}, target=${target}, duration=${durationMs}ms${suffix}`;
+    if (phase === "start" || phase === "success") {
+      console.log(line);
+      return;
+    }
+    console.warn(line);
+  }
+  async withFeishuRequestTimeout(scope, target, operation) {
+    const startedAt = Date.now();
+    const timeoutMs = this.getCardRequestTimeoutMs();
+    this.logRequestOperation("start", scope, target, startedAt);
+    let timeoutHandle = null;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutHandle = setTimeout(() => {
+        reject(new Error(`timeout after ${timeoutMs}ms`));
+      }, timeoutMs);
+    });
+    const operationPromise = operation();
+    operationPromise.catch(() => {
+    });
+    try {
+      const result = await Promise.race([operationPromise, timeoutPromise]);
+      this.logRequestOperation("success", scope, target, startedAt);
+      return result;
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      this.logRequestOperation(
+        detail.startsWith("timeout after ") ? "timeout" : "error",
+        scope,
+        target,
+        startedAt,
+        detail
+      );
+      throw error;
+    } finally {
+      if (timeoutHandle) clearTimeout(timeoutHandle);
+    }
+  }
+  markCardFlushFailure(state, error) {
+    state.lastFlushErrorAt = Date.now();
+    state.lastFlushError = error instanceof Error ? error.message : String(error);
+    state.consecutiveFlushFailures += 1;
+  }
+  markCardFlushSuccess(state) {
+    const now2 = Date.now();
+    state.lastUpdateAt = now2;
+    state.lastSuccessfulFlushAt = now2;
+    state.lastFlushError = null;
+    state.consecutiveFlushFailures = 0;
+  }
   // ── Streaming adapter interface ────────────────────────────────
   /**
    * Called by bridge-manager on each text SSE event.
@@ -6218,8 +6467,30 @@ ${trimmedResponse}`;
   }
   onToolEvent(chatId, tools, streamKey) {
     if (!this.isStreamingEnabled()) return;
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
+    if (!this.activeCards.has(cardKey)) {
+      const messageId = this.lastIncomingMessageId.get(chatId);
+      this.createStreamingCard(chatId, messageId, cardKey).then((ok) => {
+        if (ok) this.updateToolProgress(chatId, tools, cardKey);
+      }).catch(() => {
+      });
+      return;
+    }
     this.updateToolProgress(chatId, tools, streamKey);
   }
+  onTaskEvent(chatId, tasks, streamKey) {
+    if (!this.isStreamingEnabled()) return;
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
+    if (!this.activeCards.has(cardKey)) {
+      const messageId = this.lastIncomingMessageId.get(chatId);
+      this.createStreamingCard(chatId, messageId, cardKey).then((ok) => {
+        if (ok) this.updateTaskProgress(chatId, tasks, cardKey);
+      }).catch(() => {
+      });
+      return;
+    }
+    this.updateTaskProgress(chatId, tasks, streamKey);
+  }
   onStreamStatus(chatId, statusText, streamKey) {
     if (!this.isStreamingEnabled()) return;
     const cardKey = this.resolveStreamKey(chatId, streamKey);
@@ -6369,17 +6640,17 @@ ${trimmedResponse}`;
   }
   async sendStructuredMessage(chatId, msgType, content, replyToMessageId) {
     try {
-      const res = replyToMessageId ? await this.restClient.im.message.reply({
+      const res = replyToMessageId ? await this.withFeishuRequestTimeout(chatId, `im.message.reply:${msgType}`, () => this.restClient.im.message.reply({
         path: { message_id: replyToMessageId },
         data: { msg_type: msgType, content }
-      }) : await this.restClient.im.message.create({
+      })) : await this.withFeishuRequestTimeout(chatId, `im.message.create:${msgType}`, () => this.restClient.im.message.create({
         params: { receive_id_type: "chat_id" },
         data: {
           receive_id: chatId,
           msg_type: msgType,
           content
         }
-      });
+      }));
       if (res?.data?.message_id) {
         return { ok: true, messageId: res.data.message_id };
       }
@@ -6395,14 +6666,14 @@ ${trimmedResponse}`;
   async sendAsCard(chatId, text2) {
     const cardContent = buildCardContent(text2);
     try {
-      const res = await this.restClient.im.message.create({
+      const res = await this.withFeishuRequestTimeout(chatId, "im.message.create:interactive-card", () => this.restClient.im.message.create({
         params: { receive_id_type: "chat_id" },
         data: {
           receive_id: chatId,
           msg_type: "interactive",
           content: cardContent
         }
-      });
+      }));
       if (res?.data?.message_id) {
         return { ok: true, messageId: res.data.message_id };
       }
@@ -6419,14 +6690,14 @@ ${trimmedResponse}`;
   async sendAsPost(chatId, text2) {
     const postContent = buildPostContent(text2);
     try {
-      const res = await this.restClient.im.message.create({
+      const res = await this.withFeishuRequestTimeout(chatId, "im.message.create:post", () => this.restClient.im.message.create({
         params: { receive_id_type: "chat_id" },
         data: {
           receive_id: chatId,
           msg_type: "post",
           content: postContent
         }
-      });
+      }));
       if (res?.data?.message_id) {
         return { ok: true, messageId: res.data.message_id };
       }
@@ -6438,14 +6709,14 @@ ${trimmedResponse}`;
   }
   async sendAsPlainText(chatId, text2) {
     try {
-      const res = await this.restClient.im.message.create({
+      const res = await this.withFeishuRequestTimeout(chatId, "im.message.create:text", () => this.restClient.im.message.create({
         params: { receive_id_type: "chat_id" },
         data: {
           receive_id: chatId,
           msg_type: "text",
           content: JSON.stringify({ text: text2 })
         }
-      });
+      }));
       if (res?.data?.message_id) {
         return { ok: true, messageId: res.data.message_id };
       }
@@ -6470,14 +6741,14 @@ ${trimmedResponse}`;
     if (permId) {
       const cardJson2 = buildPermissionButtonCard(mdText, permId, chatId);
       try {
-        const res = await this.restClient.im.message.create({
+        const res = await this.withFeishuRequestTimeout(chatId, "im.message.create:permission-button-card", () => this.restClient.im.message.create({
           params: { receive_id_type: "chat_id" },
           data: {
             receive_id: chatId,
             msg_type: "interactive",
             content: cardJson2
           }
-        });
+        }));
         if (res?.data?.message_id) {
           return { ok: true, messageId: res.data.message_id };
         }
@@ -6521,14 +6792,14 @@ ${trimmedResponse}`;
       }
     });
     try {
-      const res = await this.restClient.im.message.create({
+      const res = await this.withFeishuRequestTimeout(chatId, "im.message.create:permission-fallback-card", () => this.restClient.im.message.create({
         params: { receive_id_type: "chat_id" },
         data: {
           receive_id: chatId,
           msg_type: "interactive",
           content: cardJson
         }
-      });
+      }));
       if (res?.data?.message_id) {
         return { ok: true, messageId: res.data.message_id };
       }
@@ -6545,14 +6816,14 @@ ${trimmedResponse}`;
       ...permCommands
     ].join("\n");
     try {
-      const res = await this.restClient.im.message.create({
+      const res = await this.withFeishuRequestTimeout(chatId, "im.message.create:permission-fallback-text", () => this.restClient.im.message.create({
         params: { receive_id_type: "chat_id" },
         data: {
           receive_id: chatId,
           msg_type: "text",
           content: JSON.stringify({ text: plainText })
         }
-      });
+      }));
       if (res?.data?.message_id) {
         return { ok: true, messageId: res.data.message_id };
       }
@@ -6898,20 +7169,20 @@ ${trimmedResponse}`;
         buffer = Buffer.concat(chunks);
       } catch (streamErr) {
         console.warn("[feishu-adapter] Stream read failed, falling back to writeFile:", streamErr instanceof Error ? streamErr.message : streamErr);
-        const fs16 = await import("fs");
+        const fs17 = await import("fs");
         const os5 = await import("os");
-        const path17 = await import("path");
-        const tmpPath = path17.join(os5.tmpdir(), `feishu-dl-${crypto2.randomUUID()}`);
+        const path18 = await import("path");
+        const tmpPath = path18.join(os5.tmpdir(), `feishu-dl-${crypto2.randomUUID()}`);
         try {
           await res.writeFile(tmpPath);
-          buffer = fs16.readFileSync(tmpPath);
+          buffer = fs17.readFileSync(tmpPath);
           if (buffer.length > MAX_FILE_SIZE) {
             console.warn(`[feishu-adapter] Resource too large (>${MAX_FILE_SIZE} bytes), key: ${fileKey}`);
             return null;
           }
         } finally {
           try {
-            fs16.unlinkSync(tmpPath);
+            fs17.unlinkSync(tmpPath);
           } catch {
           }
         }
@@ -15028,6 +15299,54 @@ function extractNormalizedStructuredText(value) {
   collectStructuredTextParts(value, parts);
   return parts.length > 0 ? normalizeStructuredText(parts.join("\n\n")) : "";
 }
+function parseJsonSafely(value) {
+  if (!value) return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+function normalizeTaskStatus(value) {
+  const normalized = typeof value === "string" ? value.trim().toLowerCase() : "";
+  if (normalized === "in_progress" || normalized === "running" || normalized === "active") {
+    return "in_progress";
+  }
+  if (normalized === "completed" || normalized === "complete" || normalized === "done") {
+    return "completed";
+  }
+  return "pending";
+}
+function parseTaskProgressItems(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => {
+    const record = item;
+    const text2 = extractNormalizedStructuredText(record.text ?? record.step);
+    if (!text2) return null;
+    return {
+      text: text2,
+      status: normalizeTaskStatus(record.status)
+    };
+  }).filter((item) => Boolean(item));
+}
+function parseUpdatePlanTasks(argumentsJson) {
+  const parsed = parseJsonSafely(argumentsJson);
+  if (!parsed || typeof parsed !== "object") return [];
+  return parseTaskProgressItems(parsed.plan ?? parsed.tasks);
+}
+function extractToolOutputText(value) {
+  if (typeof value !== "string") return extractNormalizedFreeText(value);
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    const parsed = parseJsonSafely(trimmed);
+    if (parsed && typeof parsed === "object") {
+      const extracted = extractNormalizedFreeText(parsed.output ?? parsed);
+      if (extracted) return extracted;
+    }
+  }
+  return extractNormalizedFreeText(value);
+}
 function createDesktopEventSignature(rawLine) {
   return crypto7.createHash("sha1").update(rawLine).digest("hex");
 }
@@ -15059,6 +15378,17 @@ function isSessionMessageLine(line) {
 function isTurnContextLine(line) {
   return line.type === "turn_context";
 }
+function describeUnhandledMirrorLineKind(line) {
+  if (isSessionEventLine(line)) {
+    const payloadType = typeof line.payload?.type === "string" ? line.payload.type.trim() : "";
+    return `event_msg:${payloadType || "<unknown>"}`;
+  }
+  if (isSessionMessageLine(line)) {
+    const payloadType = typeof line.payload?.type === "string" ? line.payload.type.trim() : "";
+    return `response_item:${payloadType || "<unknown>"}`;
+  }
+  return null;
+}
 function listDesktopSessions(limit) {
   const root = getCodexSessionsRoot();
   if (!fs4.existsSync(root)) return [];
@@ -15151,81 +15481,213 @@ function pushDesktopSessionEvent(events, parsed, rawLine) {
     });
   }
 }
-function pushDesktopMirrorRecord(records, parsed, rawLine, activeTurnId) {
-  if (isSessionEventLine(parsed) && parsed.payload?.type === "task_started") {
+function pushDesktopMirrorRecord(records, parsed, rawLine, activeTurnId, activeSpecialCallIds) {
+  if (isSessionEventLine(parsed)) {
+    return pushDesktopMirrorEventRecord(records, parsed, rawLine, activeTurnId);
+  }
+  if (isSessionMessageLine(parsed)) {
+    return pushDesktopMirrorResponseRecord(records, parsed, rawLine, activeTurnId, activeSpecialCallIds);
+  }
+  return false;
+}
+function pushDesktopMirrorEventRecord(records, parsed, rawLine, activeTurnId) {
+  const signature = createDesktopEventSignature(rawLine);
+  const timestamp = parsed.timestamp || "";
+  if (parsed.payload?.type === "task_started") {
     records.push({
-      signature: createDesktopEventSignature(rawLine),
+      signature,
       type: "task_started",
       content: "",
-      timestamp: parsed.timestamp || "",
+      timestamp,
       turnId: parsed.payload.turn_id || ""
     });
-    return;
+    return true;
   }
-  if (isSessionEventLine(parsed) && parsed.payload?.type === "user_message") {
+  if (parsed.payload?.type === "turn_aborted") {
+    records.push({
+      signature,
+      type: "task_aborted",
+      content: extractNormalizedStructuredText(parsed.payload.reason),
+      timestamp,
+      ...activeTurnId ? { turnId: activeTurnId } : {}
+    });
+    return true;
+  }
+  if (parsed.payload?.type === "agent_reasoning") {
+    const text2 = extractNormalizedStructuredText(parsed.payload.text);
+    if (!text2) return true;
+    records.push({
+      signature,
+      type: "reasoning",
+      content: text2,
+      timestamp,
+      ...activeTurnId ? { turnId: activeTurnId } : {}
+    });
+    return true;
+  }
+  if (parsed.payload?.type === "web_search_end") {
+    const toolId = extractNormalizedFreeText(parsed.payload.call_id) || signature;
+    records.push({
+      signature,
+      type: "tool_finished",
+      content: extractNormalizedStructuredText(parsed.payload.query),
+      timestamp,
+      ...activeTurnId ? { turnId: activeTurnId } : {},
+      toolId,
+      toolName: "Web Search"
+    });
+    return true;
+  }
+  if (parsed.payload?.type === "mcp_tool_call_end") {
+    const toolId = extractNormalizedFreeText(parsed.payload.call_id) || signature;
+    const server = extractNormalizedFreeText(parsed.payload.invocation?.server);
+    const tool = extractNormalizedFreeText(parsed.payload.invocation?.tool);
+    const toolName = server && tool ? `mcp__${server}__${tool}` : "mcp_tool_call";
+    records.push({
+      signature,
+      type: "tool_finished",
+      content: "",
+      timestamp,
+      ...activeTurnId ? { turnId: activeTurnId } : {},
+      toolId,
+      toolName,
+      isError: false
+    });
+    return true;
+  }
+  if (parsed.payload?.type === "user_message") {
     const text2 = extractNormalizedStructuredText(parsed.payload.message);
-    if (!text2) return;
+    if (!text2) return true;
     records.push({
-      signature: createDesktopEventSignature(rawLine),
+      signature,
       type: "message",
       role: "user",
       content: text2,
-      timestamp: parsed.timestamp || "",
+      timestamp,
       ...activeTurnId ? { turnId: activeTurnId } : {}
     });
-    return;
+    return true;
   }
-  if (isSessionEventLine(parsed) && parsed.payload?.type === "task_complete") {
+  if (parsed.payload?.type === "task_complete") {
     records.push({
-      signature: createDesktopEventSignature(rawLine),
+      signature,
       type: "task_complete",
       role: "assistant",
       content: extractNormalizedStructuredText(parsed.payload.last_agent_message),
-      timestamp: parsed.timestamp || "",
+      timestamp,
       turnId: parsed.payload.turn_id || ""
     });
-    return;
+    return true;
   }
-  if (isSessionMessageLine(parsed) && parsed.payload?.type === "message" && parsed.payload.role === "assistant") {
+  return false;
+}
+function pushDesktopMirrorResponseRecord(records, parsed, rawLine, activeTurnId, activeSpecialCallIds) {
+  const signature = createDesktopEventSignature(rawLine);
+  const timestamp = parsed.timestamp || "";
+  if (parsed.payload?.type === "message" && parsed.payload.role === "assistant") {
     const text2 = extractDesktopMessageText(parsed);
-    if (!text2) return;
+    if (!text2) return true;
     records.push({
-      signature: createDesktopEventSignature(rawLine),
+      signature,
       type: "message",
       role: parsed.payload.phase === "commentary" ? "commentary" : "assistant",
       content: parsed.payload.phase === "commentary" ? text2.replace(/^\[commentary\]\n/, "") : text2,
-      timestamp: parsed.timestamp || "",
+      timestamp,
       ...activeTurnId ? { turnId: activeTurnId } : {}
     });
-    return;
+    return true;
   }
-  if (isSessionMessageLine(parsed) && parsed.payload?.type === "function_call") {
+  if (parsed.payload?.type === "function_call") {
     const toolName = extractNormalizedFreeText(parsed.payload.name);
-    const toolId = extractNormalizedFreeText(parsed.payload.call_id) || createDesktopEventSignature(rawLine);
-    if (!toolName) return;
+    const toolId = extractNormalizedFreeText(parsed.payload.call_id) || signature;
+    if (!toolName) return true;
+    if (toolName === "update_plan") {
+      const tasks = parseUpdatePlanTasks(parsed.payload.arguments);
+      activeSpecialCallIds.add(toolId);
+      records.push({
+        signature,
+        type: "plan_update",
+        content: "",
+        timestamp,
+        ...activeTurnId ? { turnId: activeTurnId } : {},
+        tasks
+      });
+      return true;
+    }
     records.push({
-      signature: createDesktopEventSignature(rawLine),
+      signature,
       type: "tool_started",
       content: "",
-      timestamp: parsed.timestamp || "",
+      timestamp,
       ...activeTurnId ? { turnId: activeTurnId } : {},
       toolId,
       toolName
     });
-    return;
+    return true;
   }
-  if (isSessionMessageLine(parsed) && parsed.payload?.type === "function_call_output") {
-    const toolId = extractNormalizedFreeText(parsed.payload.call_id) || createDesktopEventSignature(rawLine);
+  if (parsed.payload?.type === "custom_tool_call") {
+    const toolName = extractNormalizedFreeText(parsed.payload.name);
+    const toolId = extractNormalizedFreeText(parsed.payload.call_id) || signature;
+    if (!toolName) return true;
+    if (toolName === "update_plan") {
+      const tasks = parseUpdatePlanTasks(typeof parsed.payload.input === "string" ? parsed.payload.input : void 0);
+      activeSpecialCallIds.add(toolId);
+      records.push({
+        signature,
+        type: "plan_update",
+        content: "",
+        timestamp,
+        ...activeTurnId ? { turnId: activeTurnId } : {},
+        tasks
+      });
+      return true;
+    }
     records.push({
-      signature: createDesktopEventSignature(rawLine),
+      signature,
+      type: "tool_started",
+      content: "",
+      timestamp,
+      ...activeTurnId ? { turnId: activeTurnId } : {},
+      toolId,
+      toolName
+    });
+    return true;
+  }
+  if (parsed.payload?.type === "function_call_output") {
+    const toolId = extractNormalizedFreeText(parsed.payload.call_id) || signature;
+    if (activeSpecialCallIds.has(toolId)) {
+      activeSpecialCallIds.delete(toolId);
+      return true;
+    }
+    records.push({
+      signature,
       type: "tool_finished",
-      content: extractNormalizedFreeText(parsed.payload.output),
-      timestamp: parsed.timestamp || "",
+      content: extractToolOutputText(parsed.payload.output),
+      timestamp,
       ...activeTurnId ? { turnId: activeTurnId } : {},
       toolId,
       isError: parsed.payload.is_error === true
     });
+    return true;
   }
+  if (parsed.payload?.type === "custom_tool_call_output") {
+    const toolId = extractNormalizedFreeText(parsed.payload.call_id) || signature;
+    if (activeSpecialCallIds.has(toolId)) {
+      activeSpecialCallIds.delete(toolId);
+      return true;
+    }
+    records.push({
+      signature,
+      type: "tool_finished",
+      content: extractToolOutputText(parsed.payload.output),
+      timestamp,
+      ...activeTurnId ? { turnId: activeTurnId } : {},
+      toolId,
+      isError: parsed.payload.is_error === true
+    });
+    return true;
+  }
+  return false;
 }
 function parseDesktopSessionEventText(content, leadingText = "", flushTrailingText = false) {
   const combined = `${leadingText}${content}`;
@@ -15261,14 +15723,16 @@ function parseDesktopSessionEventText(content, leadingText = "", flushTrailingTe
     trailingText
   };
 }
-function parseDesktopMirrorRecordText(content, leadingText = "", flushTrailingText = false, initialTurnId = null) {
+function parseDesktopMirrorRecordText(content, leadingText = "", flushTrailingText = false, initialTurnId = null, initialSpecialCallIds = []) {
   const combined = `${leadingText}${content}`;
   if (!combined) {
     return {
       records: [],
       nextOffset: 0,
       trailingText: "",
-      nextTurnId: initialTurnId
+      nextTurnId: initialTurnId,
+      nextSpecialCallIds: [],
+      unknownKinds: []
     };
   }
   const hasTrailingNewline = combined.endsWith("\n") || combined.endsWith("\r");
@@ -15280,6 +15744,8 @@ function parseDesktopMirrorRecordText(content, leadingText = "", flushTrailingTe
   }
   const records = [];
   let activeTurnId = initialTurnId;
+  const activeSpecialCallIds = new Set(initialSpecialCallIds);
+  const unknownKinds = /* @__PURE__ */ new Set();
   for (const line of rawLines) {
     const trimmed = line.trim();
     if (!trimmed) continue;
@@ -15297,20 +15763,27 @@ function parseDesktopMirrorRecordText(content, leadingText = "", flushTrailingTe
       const eventPayload = parsed.payload;
       activeTurnId = eventPayload?.turn_id || activeTurnId;
     }
-    pushDesktopMirrorRecord(records, parsed, trimmed, activeTurnId);
-    if (isSessionEventLine(parsed) && parsed.payload?.type === "task_complete") {
+    const handled = pushDesktopMirrorRecord(records, parsed, trimmed, activeTurnId, activeSpecialCallIds);
+    if (!handled) {
+      const unknownKind = describeUnhandledMirrorLineKind(parsed);
+      if (unknownKind) unknownKinds.add(unknownKind);
+    }
+    if (isSessionEventLine(parsed) && (parsed.payload?.type === "task_complete" || parsed.payload?.type === "turn_aborted")) {
       const eventPayload = parsed.payload;
       const completedTurnId = eventPayload?.turn_id || activeTurnId;
       if (!completedTurnId || completedTurnId === activeTurnId) {
         activeTurnId = null;
       }
+      activeSpecialCallIds.clear();
     }
   }
   return {
     records,
     nextOffset: 0,
     trailingText,
-    nextTurnId: activeTurnId
+    nextTurnId: activeTurnId,
+    nextSpecialCallIds: Array.from(activeSpecialCallIds),
+    unknownKinds: Array.from(unknownKinds)
   };
 }
 function readDesktopSessionMessages(threadId, limit = 8) {
@@ -15331,7 +15804,7 @@ function readDesktopSessionEventStreamByFilePath(filePath) {
   }
   return parseDesktopSessionEventText(content, "", true).events;
 }
-function readDesktopSessionMirrorRecordDeltaByFilePath(filePath, startOffset, endOffset, trailingText = "", currentTurnId = null) {
+function readDesktopSessionMirrorRecordDeltaByFilePath(filePath, startOffset, endOffset, trailingText = "", currentTurnId = null, currentSpecialCallIds = []) {
   let content = "";
   try {
     content = readFileUtf8Range(filePath, startOffset, endOffset);
@@ -15340,15 +15813,19 @@ function readDesktopSessionMirrorRecordDeltaByFilePath(filePath, startOffset, en
       records: [],
       nextOffset: startOffset,
       trailingText,
-      nextTurnId: currentTurnId
+      nextTurnId: currentTurnId,
+      nextSpecialCallIds: Array.from(currentSpecialCallIds),
+      unknownKinds: []
     };
   }
-  const parsed = parseDesktopMirrorRecordText(content, trailingText, false, currentTurnId);
+  const parsed = parseDesktopMirrorRecordText(content, trailingText, false, currentTurnId, currentSpecialCallIds);
   return {
     records: parsed.records,
     nextOffset: Math.max(startOffset, endOffset),
     trailingText: parsed.trailingText,
-    nextTurnId: parsed.nextTurnId
+    nextTurnId: parsed.nextTurnId,
+    nextSpecialCallIds: parsed.nextSpecialCallIds,
+    unknownKinds: parsed.unknownKinds
   };
 }
 function readDesktopSessionEventStream(threadId) {
@@ -16453,6 +16930,8 @@ function formatHealthStatusLabel(healthStatus) {
       return "\u957F\u65F6\u8FD0\u884C\uFF0C\u5F85\u89C2\u5BDF";
     case "suspected_stall":
       return "\u7591\u4F3C\u5361\u4F4F";
+    case "suspected_stream_ui_stall":
+      return "\u6D41\u5F0F UI \u7591\u4F3C\u5361\u4F4F";
     case "suspected_detached":
       return "\u7591\u4F3C\u8131\u6302";
     case "completed":
@@ -16507,8 +16986,10 @@ function buildHealthCommandResponse(title, diagnosis, markdown = false) {
       ["\u5065\u5EB7\u72B6\u6001", formatHealthStatusLabel(diagnosis.healthStatus)],
       ["\u5F53\u524D\u9636\u6BB5", currentStage],
       ["\u6700\u540E\u8FDB\u5C55", formatCommandTimestamp(diagnosis.lastProgressAt)],
+      ["\u6D41\u5F0F UI \u5237\u65B0", formatCommandTimestamp(diagnosis.lastStreamUiUpdateAt)],
       ["\u5DE5\u5177\u5F00\u59CB", formatCommandTimestamp(diagnosis.activeToolStartedAt)],
       ["\u6700\u8FD1\u5DE5\u5177\u5B8C\u6210", formatCommandTimestamp(diagnosis.lastToolFinishedAt)],
+      ["\u6D41\u5F0F UI \u9519\u8BEF", diagnosis.lastStreamUiErrorAt ? `${formatCommandTimestamp(diagnosis.lastStreamUiErrorAt)}${diagnosis.lastStreamUiError ? ` \xB7 ${diagnosis.lastStreamUiError}` : ""}` : "-"],
       ["\u672C\u5730\u8FDB\u7A0B", formatHealthProcessProbe(diagnosis)]
     ],
     [diagnosis.healthReason],
@@ -16630,11 +17111,13 @@ function createMirrorTurnState(sessionId, timestamp, turnId) {
     lastActivityAt: safeTimestamp,
     lastStatusText: null,
     lastStatusAt: 0,
+    statusNote: null,
     userText: null,
     lastAssistantText: null,
     lastCommentaryText: null,
     streamedText: "",
     streamStarted: false,
+    taskItems: [],
     toolCalls: /* @__PURE__ */ new Map()
   };
 }
@@ -16682,7 +17165,7 @@ function finalizeMirrorTurn(subscription, signature, timestamp, status, preferre
     pendingTurn.lastCommentaryText
   ].map((value) => (value || "").trim()).find(Boolean) || "";
   const userText = pendingTurn.userText?.trim() || null;
-  if (!text2 && !userText && pendingTurn.toolCalls.size === 0) return null;
+  if (!text2 && !userText && pendingTurn.toolCalls.size === 0 && pendingTurn.taskItems.length === 0) return null;
   return {
     streamKey: pendingTurn.streamKey,
     userText,
@@ -16721,6 +17204,12 @@ function consumeMirrorRecords(subscription, records, hooks = {}) {
       if (completed) finalized.push(completed);
       continue;
     }
+    if (record.type === "task_aborted") {
+      ensureMirrorTurnState(subscription, record);
+      const interrupted = finalizeMirrorTurn(subscription, record.signature, record.timestamp, "interrupted");
+      if (interrupted) finalized.push(interrupted);
+      continue;
+    }
     if (record.type === "message" && record.role === "user") {
       const pendingTurn = ensureMirrorTurnState(subscription, record);
       const text2 = record.content.trim();
@@ -16749,6 +17238,20 @@ function consumeMirrorRecords(subscription, records, hooks = {}) {
       }
       continue;
     }
+    if (record.type === "reasoning") {
+      const pendingTurn = ensureMirrorTurnState(subscription, record);
+      const text2 = record.content.trim();
+      if (!text2) continue;
+      pendingTurn.statusNote = text2;
+      hooks.onStatusProgress?.(subscription, pendingTurn);
+      continue;
+    }
+    if (record.type === "plan_update") {
+      const pendingTurn = ensureMirrorTurnState(subscription, record);
+      pendingTurn.taskItems = record.tasks || [];
+      hooks.onTaskProgress?.(subscription, pendingTurn);
+      continue;
+    }
     if (record.type === "tool_started") {
       const pendingTurn = ensureMirrorTurnState(subscription, record);
       const toolId = record.toolId || record.signature;
@@ -16791,8 +17294,30 @@ function flushTimedOutMirrorTurn(subscription, idleTimeoutMs, nowMs = Date.now()
     "interrupted"
   );
 }
+function enqueuePendingMirrorDeliveries(subscription, turns) {
+  if (turns.length === 0) return;
+  const existingSignatures = new Set(subscription.pendingDeliveries.map((turn) => turn.signature));
+  for (const turn of turns) {
+    if (existingSignatures.has(turn.signature)) continue;
+    subscription.pendingDeliveries.push(turn);
+    existingSignatures.add(turn.signature);
+  }
+}
+function removePendingMirrorDeliveries(subscription, turns) {
+  if (turns.length === 0 || subscription.pendingDeliveries.length === 0) return;
+  const deliveredSignatures = new Set(turns.map((turn) => turn.signature));
+  subscription.pendingDeliveries = subscription.pendingDeliveries.filter(
+    (turn) => !deliveredSignatures.has(turn.signature)
+  );
+}
+function selectPendingMirrorDeliveries(subscription, blocked) {
+  if (!blocked) {
+    return subscription.pendingDeliveries.slice();
+  }
+  return subscription.pendingDeliveries.filter((turn) => turn.timedOut);
+}
 function hasPendingMirrorWork(subscription) {
-  return subscription.bufferedRecords.length > 0 || subscription.pendingTurn !== null;
+  return subscription.bufferedRecords.length > 0 || subscription.pendingTurn !== null || subscription.pendingDeliveries.length > 0;
 }
 function consumeBufferedMirrorTurns(subscription, idleTimeoutMs, nowMs = Date.now(), hooks = {}) {
   const bufferedRecords = subscription.bufferedRecords;
@@ -18613,7 +19138,7 @@ function buildConversationPromptText(text2, files = []) {
 
 ${attachmentSupplement}` : attachmentSupplement;
 }
-async function processMessage(binding, text2, onPermissionRequest, abortSignal, files, onPartialText, onToolEvent, onPromptPrepared) {
+async function processMessage(binding, text2, onPermissionRequest, abortSignal, files, onPartialText, onToolEvent, onTaskEvent, onStatusNote, onPromptPrepared) {
   const { store, llm } = getBridgeContext();
   const sessionId = binding.codepilotSessionId;
   const lockId = crypto8.randomBytes(8).toString("hex");
@@ -18732,14 +19257,22 @@ async function processMessage(binding, text2, onPermissionRequest, abortSignal,
         }
       }
     });
-    return await consumeStream(stream, sessionId, onPermissionRequest, onPartialText, onToolEvent);
+    return await consumeStream(
+      stream,
+      sessionId,
+      onPermissionRequest,
+      onPartialText,
+      onToolEvent,
+      onTaskEvent,
+      onStatusNote
+    );
   } finally {
     clearInterval(renewalInterval);
     store.releaseSessionLock(sessionId, lockId);
     store.setSessionRuntimeStatus(sessionId, "idle");
   }
 }
-async function consumeStream(stream, sessionId, onPermissionRequest, onPartialText, onToolEvent) {
+async function consumeStream(stream, sessionId, onPermissionRequest, onPartialText, onToolEvent, onTaskEvent, onStatusNote) {
   const { store } = getBridgeContext();
   const contentBlocks = [];
   let currentText = "";
@@ -18848,6 +19381,12 @@ async function consumeStream(stream, sessionId, onPermissionRequest, onPartialTe
             if (statusData.model) {
               store.updateSessionModel(sessionId, statusData.model);
             }
+            if (typeof statusData.reasoning === "string" && onStatusNote) {
+              try {
+                onStatusNote(statusData.reasoning);
+              } catch {
+              }
+            }
           } catch {
           }
           break;
@@ -18855,8 +19394,15 @@ async function consumeStream(stream, sessionId, onPermissionRequest, onPartialTe
         case "task_update": {
           try {
             const taskData = JSON.parse(event.data);
-            if (taskData.session_id && taskData.todos) {
-              store.syncSdkTasks(taskData.session_id, taskData.todos);
+            const tasks = Array.isArray(taskData.tasks) ? taskData.tasks : Array.isArray(taskData.todos) ? taskData.todos : null;
+            if (tasks) {
+              store.syncSdkTasks(sessionId, tasks);
+              if (onTaskEvent) {
+                try {
+                  onTaskEvent(tasks);
+                } catch {
+                }
+              }
             }
           } catch {
           }
@@ -18954,6 +19500,14 @@ function pushStreamFeedbackTools(target, tools) {
   } catch {
   }
 }
+function pushStreamFeedbackTasks(target, tasks) {
+  if (typeof target.adapter.onTaskEvent !== "function") return;
+  target.ensureStarted?.();
+  try {
+    target.adapter.onTaskEvent(target.chatId, tasks, target.streamKey);
+  } catch {
+  }
+}
 function pushStreamFeedbackStatus(target, text2) {
   if (typeof target.adapter.onStreamStatus !== "function") return;
   target.ensureStarted?.();
@@ -19032,12 +19586,15 @@ function formatRuntimeDuration(ms) {
   if (seconds === 0) return `${hours}h ${minutes}m`;
   return `${hours}h ${minutes}m ${seconds}s`;
 }
-function formatInteractiveRuntimeStatus(elapsedMs, silentMs) {
+function formatInteractiveRuntimeStatus(elapsedMs, silentMs, statusNote) {
   const parts = [elapsedMs < 1e3 ? "\u5904\u7406\u4E2D" : `\u5DF2\u8FD0\u884C ${formatRuntimeDuration(elapsedMs)}`];
   if (typeof silentMs === "number" && silentMs >= 0) {
     parts.push(`\u6700\u8FD1 ${formatRuntimeDuration(silentMs)} \u65E0\u65B0\u8F93\u51FA`);
   }
-  return parts.join("\uFF0C");
+  const runtimeText = parts.join("\uFF0C");
+  const note = (statusNote || "").trim();
+  return note ? `\u5F53\u524D\u6B65\u9AA4\uFF1A${note}
+${runtimeText}` : runtimeText;
 }
 async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
   const binding = resolve(msg.address);
@@ -19132,23 +19689,35 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     adapter,
     channelType: adapter.channelType,
     chatId: msg.address.chatId,
-    streamKey
+    streamKey,
+    ensureStarted: () => {
+      adapter.onMessageStart?.(msg.address.chatId, streamKey);
+    }
   };
   const supportsPersistentStreamStatus = hasStreamingCards && adapter.provider === "feishu" && typeof adapter.onStreamStatus === "function";
   const supportsStructuredStreamUi = supportsPersistentStreamStatus && (adapter.supportsStructuredStreamingUi?.(msg.address.chatId) ?? true);
+  let latestStatusNote = null;
+  let latestTasks = [];
   const syncStructuredStreamUiState = () => {
     if (!supportsStructuredStreamUi || taskState.structuredStreamUiActive) return;
     if (adapter.hasActiveStreamingUi?.(msg.address.chatId, streamKey)) {
       taskState.structuredStreamUiActive = true;
     }
   };
+  const syncStructuredStreamUiSnapshot = () => {
+    if (!supportsStructuredStreamUi) return;
+    syncStructuredStreamUiState();
+    const snapshot = adapter.getStructuredStreamingUiSnapshot?.(msg.address.chatId, streamKey);
+    if (!snapshot) return;
+    deps.recordInteractiveStreamUiSnapshot?.(binding.codepilotSessionId, snapshot);
+  };
   const pushRunningStatus = (silentMs) => {
     if (!supportsStructuredStreamUi || streamStatusUpdatesClosed) return;
     pushStreamFeedbackStatus(
       streamFeedbackTarget,
-      formatInteractiveRuntimeStatus(nowMs() - taskStartedAt, silentMs)
+      formatInteractiveRuntimeStatus(nowMs() - taskStartedAt, silentMs, latestStatusNote)
     );
-    syncStructuredStreamUiState();
+    syncStructuredStreamUiSnapshot();
   };
   let streamStatusHeartbeat = null;
   let streamStatusUpdatesClosed = false;
@@ -19182,7 +19751,24 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
       pushStreamFeedbackTools(streamFeedbackTarget, Array.from(toolCallTracker.values()));
     }
     pushRunningStatus(null);
-    syncStructuredStreamUiState();
+    syncStructuredStreamUiSnapshot();
+  };
+  const onTaskEvent = (tasks) => {
+    if (!deps.isCurrentInteractiveTask(binding.codepilotSessionId, taskId)) return;
+    deps.touchInteractiveTask(binding.codepilotSessionId, taskId);
+    latestTasks = tasks;
+    if (hasStreamingCards) {
+      pushStreamFeedbackTasks(streamFeedbackTarget, latestTasks);
+    }
+    pushRunningStatus(null);
+    syncStructuredStreamUiSnapshot();
+  };
+  const onStatusNote = (note) => {
+    if (!deps.isCurrentInteractiveTask(binding.codepilotSessionId, taskId)) return;
+    deps.touchInteractiveTask(binding.codepilotSessionId, taskId);
+    latestStatusNote = (note || "").trim() || null;
+    pushRunningStatus(null);
+    syncStructuredStreamUiSnapshot();
   };
   const onPartialText = (fullText) => {
     if (!deps.isCurrentInteractiveTask(binding.codepilotSessionId, taskId)) return;
@@ -19191,7 +19777,7 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     previewOnPartialText?.(fullText);
     onStreamCardText?.(fullText);
     pushRunningStatus(null);
-    syncStructuredStreamUiState();
+    syncStructuredStreamUiSnapshot();
   };
   if (supportsStructuredStreamUi) {
     pushRunningStatus(null);
@@ -19205,11 +19791,10 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
         return;
       }
       const elapsedMs = nowMs() - taskStartedAt;
-      if (elapsedMs < streamStatusIdleDetectionStartMs) return;
       const silentMs = nowMs() - taskState.lastActivityAt;
-      if (silentMs < streamStatusHeartbeatMs) return;
-      pushRunningStatus(silentMs);
-      syncStructuredStreamUiState();
+      const showSilentDuration = elapsedMs >= streamStatusIdleDetectionStartMs && silentMs >= streamStatusHeartbeatMs ? silentMs : null;
+      pushRunningStatus(showSilentDuration);
+      syncStructuredStreamUiSnapshot();
     }, streamStatusHeartbeatMs);
   }
   let finalOutcome = "failed";
@@ -19236,11 +19821,16 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
           "permission_wait",
           `\u5F53\u524D\u6B63\u5728\u7B49\u5F85\u5DE5\u5177 ${perm.toolName} \u7684\u6743\u9650\u786E\u8BA4\u3002`
         );
+        deps.touchInteractiveTask(binding.codepilotSessionId, taskId);
+        pushRunningStatus(null);
+        syncStructuredStreamUiSnapshot();
       },
       taskAbort.signal,
       attachments && attachments.length > 0 ? attachments : void 0,
       onPartialText,
       onToolEvent,
+      onTaskEvent,
+      onStatusNote,
       (preparedPrompt) => {
         if (!taskState.mirrorSuppressionId) {
           taskState.mirrorSuppressionId = deps.beginMirrorSuppression(binding.codepilotSessionId, preparedPrompt);
@@ -19263,14 +19853,16 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     }
     if (result.responseText || result.outboundAttachments.length > 0) {
       const textToDeliver = cardFinalized ? "" : result.responseText;
-      await deps.deliverResponse(
-        adapter,
-        msg.address,
-        textToDeliver,
-        binding.codepilotSessionId,
-        msg.messageId,
-        result.outboundAttachments
-      );
+      if (!cardFinalized || result.outboundAttachments.length > 0) {
+        await deps.deliverResponse(
+          adapter,
+          msg.address,
+          textToDeliver,
+          binding.codepilotSessionId,
+          msg.messageId,
+          result.outboundAttachments
+        );
+      }
     } else if (result.hasError) {
       await deps.deliverResponse(
         adapter,
@@ -19289,6 +19881,7 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     finalOutcomeDetail = result.hasError ? result.errorMessage?.trim() || void 0 : void 0;
   } finally {
     stopStructuredStreamStatusUpdates();
+    deps.recordInteractiveStreamUiSnapshot?.(binding.codepilotSessionId, { active: false });
     if (previewState) {
       if (previewState.throttleTimer) {
         clearTimeout(previewState.throttleTimer);
@@ -19504,6 +20097,7 @@ function resetMirrorReadState(subscription) {
   subscription.fileIdentity = null;
   subscription.trailingText = "";
   subscription.activeMirrorTurnId = null;
+  subscription.activeSpecialCallIds.clear();
   subscription.bufferedRecords = [];
 }
 function createMirrorSubscription(input) {
@@ -19527,8 +20121,11 @@ function createMirrorSubscription(input) {
     fileIdentity: null,
     trailingText: "",
     activeMirrorTurnId: null,
+    activeSpecialCallIds: /* @__PURE__ */ new Set(),
     bufferedRecords: [],
     pendingTurn: null,
+    pendingDeliveries: [],
+    unknownMirrorKindsSeen: /* @__PURE__ */ new Set(),
     missingThreadPolls: 0,
     consecutiveFailures: 0,
     suspendedUntil: null
@@ -19539,6 +20136,8 @@ function resetMirrorSubscriptionForThreadChange(subscription, lastDeliveredAt) {
   subscription.lastDeliveredAt = lastDeliveredAt;
   subscription.dirty = true;
   subscription.pendingTurn = null;
+  subscription.pendingDeliveries = [];
+  subscription.unknownMirrorKindsSeen.clear();
   subscription.missingThreadPolls = 0;
   subscription.consecutiveFailures = 0;
   subscription.suspendedUntil = null;
@@ -19735,6 +20334,7 @@ function isMirrorSnapshotUnchanged(subscription, snapshot) {
 }
 function readMirrorDeliverableRecords(subscription, snapshot) {
   let deliverableRecords = [];
+  let unknownKinds = [];
   const requiresFullRecover = !subscription.cursor.initialized || subscription.fileOffset === 0 || subscription.fileIdentity !== null && subscription.fileIdentity !== snapshot.identity || subscription.fileSize !== null && snapshot.size < subscription.fileOffset || subscription.fileSize !== null && snapshot.size === subscription.fileOffset && subscription.fileMtimeMs !== null && snapshot.mtimeMs !== subscription.fileMtimeMs;
   if (requiresFullRecover) {
     const previousCursor = subscription.cursor;
@@ -19743,7 +20343,8 @@ function readMirrorDeliverableRecords(subscription, snapshot) {
       0,
       snapshot.size,
       "",
-      null
+      null,
+      []
     );
     const delta = reconcileDesktopMirrorCursor(subscription.cursor, fullDelta.records);
     subscription.cursor = delta.nextCursor;
@@ -19751,6 +20352,8 @@ function readMirrorDeliverableRecords(subscription, snapshot) {
     subscription.trailingText = "";
     subscription.fileOffset = snapshot.size;
     subscription.activeMirrorTurnId = fullDelta.nextTurnId;
+    subscription.activeSpecialCallIds = new Set(fullDelta.nextSpecialCallIds);
+    unknownKinds = fullDelta.unknownKinds;
   } else if (snapshot.size > subscription.fileOffset || subscription.trailingText) {
     const previousCursor = subscription.cursor;
     const delta = readDesktopSessionMirrorRecordDeltaByFilePath(
@@ -19758,19 +20361,25 @@ function readMirrorDeliverableRecords(subscription, snapshot) {
       subscription.fileOffset,
       snapshot.size,
       subscription.trailingText,
-      subscription.activeMirrorTurnId
+      subscription.activeMirrorTurnId,
+      subscription.activeSpecialCallIds
     );
     deliverableRecords = filterDuplicateAssistantEvents(previousCursor, delta.records);
     subscription.cursor = advanceDesktopMirrorCursor(subscription.cursor, delta.records);
     subscription.trailingText = delta.trailingText;
     subscription.fileOffset = delta.nextOffset;
     subscription.activeMirrorTurnId = delta.nextTurnId;
+    subscription.activeSpecialCallIds = new Set(delta.nextSpecialCallIds);
+    unknownKinds = delta.unknownKinds;
   }
   subscription.fileSize = snapshot.size;
   subscription.fileMtimeMs = snapshot.mtimeMs;
   subscription.fileIdentity = snapshot.identity;
   subscription.dirty = false;
-  return deliverableRecords;
+  return {
+    records: deliverableRecords,
+    unknownKinds
+  };
 }
 
 // src/lib/bridge/mirror-delivery-plan.ts
@@ -19785,7 +20394,7 @@ function buildMirrorDeliveryPlan(subscription, deliverableRecords, options) {
   if (options.blocked) {
     return {
       syncReason: "mirror reconcile active task",
-      turnsToDeliver: timedOutTurn ? [timedOutTurn] : []
+      finalizedTurns: timedOutTurn ? [timedOutTurn] : []
     };
   }
   const finalizedTurns = timedOutTurn ? [timedOutTurn] : [];
@@ -19793,12 +20402,12 @@ function buildMirrorDeliveryPlan(subscription, deliverableRecords, options) {
   if (finalizedTurns.length === 0) {
     return {
       syncReason: "mirror reconcile no finalized turns",
-      turnsToDeliver: []
+      finalizedTurns: []
     };
   }
   return {
     syncReason: "mirror reconcile delivered turns",
-    turnsToDeliver: finalizedTurns
+    finalizedTurns
   };
 }
 
@@ -20022,21 +20631,36 @@ function createMirrorRuntime(getState2, options, deps) {
       deps.syncMirrorSessionStateSafe(subscription.sessionId, "mirror reconcile unchanged snapshot");
       return "processed";
     }
-    const deliverableRecords = readMirrorDeliverableRecords(subscription, snapshot);
+    const readResult = readMirrorDeliverableRecords(subscription, snapshot);
+    const deliverableRecords = readResult.records;
+    for (const kind of readResult.unknownKinds) {
+      if (subscription.unknownMirrorKindsSeen.has(kind)) continue;
+      subscription.unknownMirrorKindsSeen.add(kind);
+      console.warn(
+        `[bridge-manager] Unhandled desktop mirror event for thread ${subscription.threadId}: ${kind}`
+      );
+    }
     if (deliverableRecords.length > 0) {
       deps.observeSessionHealthRecords(subscription.sessionId, subscription.threadId, deliverableRecords);
     }
+    const blocked = getState2().activeTasks.has(subscription.sessionId) || deps.isMirrorSuppressed(subscription.sessionId);
     const deliveryPlan = buildMirrorDeliveryPlan(subscription, deliverableRecords, {
-      blocked: getState2().activeTasks.has(subscription.sessionId) || deps.isMirrorSuppressed(subscription.sessionId),
+      blocked,
       filterSuppressedRecords: deps.filterSuppressedMirrorRecords,
       flushTimedOutTurn: (currentSubscription) => deps.flushTimedOutMirrorTurn(currentSubscription),
       consumeBufferedTurns: (currentSubscription) => deps.consumeBufferedMirrorTurns(currentSubscription)
     });
-    if (deliveryPlan.turnsToDeliver.length > 0) {
-      try {
-        await deps.deliverMirrorTurns(subscription, deliveryPlan.turnsToDeliver);
-      } catch (error) {
-        subscription.dirty = true;
+    if (deliveryPlan.finalizedTurns.length > 0) {
+      enqueuePendingMirrorDeliveries(subscription, deliveryPlan.finalizedTurns);
+    }
+    const turnsToAttempt = selectPendingMirrorDeliveries(subscription, blocked);
+    if (turnsToAttempt.length > 0) {
+      const deliveryResult = await deps.deliverMirrorTurns(subscription, turnsToAttempt);
+      if (deliveryResult.deliveredCount > 0) {
+        removePendingMirrorDeliveries(subscription, turnsToAttempt.slice(0, deliveryResult.deliveredCount));
+      }
+      if (deliveryResult.error) {
+        const error = deliveryResult.error;
         console.warn("[bridge-manager] Mirror delivery failed:", error instanceof Error ? error.message : error);
       }
     }
@@ -20210,11 +20834,13 @@ var HEALTH_RECENT_PROGRESS_MS = 10 * 60 * 1e3;
 var HEALTH_SLOW_OBSERVED_MS = 30 * 60 * 1e3;
 var HEALTH_PROGRESS_PERSIST_THROTTLE_MS = 15 * 1e3;
 var HEALTH_PROCESS_PROBE_CACHE_MS = 30 * 1e3;
+var HEALTH_STREAM_UI_STALL_MS = 60 * 1e3;
 var RUNNING_HEALTH_STATUSES = /* @__PURE__ */ new Set([
   "running_active",
   "waiting_tool",
   "slow_observed",
   "suspected_stall",
+  "suspected_stream_ui_stall",
   "suspected_detached"
 ]);
 function parseIsoMs(value) {
@@ -20282,6 +20908,10 @@ function buildProgressReason(type, detail) {
       return "\u6700\u8FD1\u6536\u5230\u4E86\u65B0\u7684\u684C\u9762\u4F1A\u8BDD\u6D88\u606F\u3002";
     case "commentary":
       return "\u6700\u8FD1\u6536\u5230\u4E86\u65B0\u7684\u6267\u884C\u8FDB\u5C55\u8BF4\u660E\u3002";
+    case "reasoning":
+      return "\u6700\u8FD1\u6536\u5230\u4E86\u65B0\u7684\u601D\u8003/\u72B6\u6001\u8BF4\u660E\u3002";
+    case "plan_update":
+      return "\u6700\u8FD1\u66F4\u65B0\u4E86\u4EFB\u52A1\u8BA1\u5212\u3002";
     case "text":
       return "\u6700\u8FD1\u6536\u5230\u4E86\u65B0\u7684\u6B63\u6587\u8F93\u51FA\u3002";
     case "permission_wait":
@@ -20329,6 +20959,12 @@ function computeBaseDiagnosis(session, nowMs) {
   const activeToolName = summarizeActiveTools(activeTools) || trimOrNull(session.active_tool_name);
   const activeToolStartedAt = getActiveToolStartedAt(activeTools) || trimOrNull(session.active_tool_started_at);
   const lastToolFinishedAt = trimOrNull(session.last_tool_finished_at);
+  const lastStreamUiAttemptAt = trimOrNull(session.last_stream_ui_attempt_at);
+  const lastStreamUiUpdateAt = trimOrNull(session.last_stream_ui_update_at);
+  const streamUiFlushStartedAt = trimOrNull(session.stream_ui_flush_started_at);
+  const lastStreamUiErrorAt = trimOrNull(session.last_stream_ui_error_at);
+  const lastStreamUiError = trimOrNull(session.last_stream_ui_error);
+  const streamUiConsecutiveFailures = typeof session.stream_ui_consecutive_failures === "number" && Number.isFinite(session.stream_ui_consecutive_failures) && session.stream_ui_consecutive_failures > 0 ? session.stream_ui_consecutive_failures : 0;
   const sdkSessionId = trimOrNull(session.sdk_session_id);
   const lastProgressMs = parseIsoMs(lastProgressAt || void 0);
   const previousStatus = session.health_status || "idle";
@@ -20344,6 +20980,12 @@ function computeBaseDiagnosis(session, nowMs) {
       activeToolName,
       activeToolStartedAt,
       lastToolFinishedAt,
+      lastStreamUiAttemptAt,
+      lastStreamUiUpdateAt,
+      streamUiFlushStartedAt,
+      lastStreamUiErrorAt,
+      lastStreamUiError,
+      streamUiConsecutiveFailures,
       sdkSessionId
     };
   }
@@ -20375,6 +21017,12 @@ function computeBaseDiagnosis(session, nowMs) {
     activeToolName,
     activeToolStartedAt,
     lastToolFinishedAt,
+    lastStreamUiAttemptAt,
+    lastStreamUiUpdateAt,
+    streamUiFlushStartedAt,
+    lastStreamUiErrorAt,
+    lastStreamUiError,
+    streamUiConsecutiveFailures,
     sdkSessionId
   };
 }
@@ -20415,11 +21063,75 @@ function applyProcessProbeDiagnosis(diagnosis, processProbe) {
     processProbe
   };
 }
+function applyStreamUiDiagnosis(diagnosis, nowMs) {
+  if (!isRunningRuntimeStatus(diagnosis.runtimeStatus)) {
+    return diagnosis;
+  }
+  const lastProgressMs = parseIsoMs(diagnosis.lastProgressAt || void 0);
+  if (!lastProgressMs || nowMs - lastProgressMs > HEALTH_RECENT_PROGRESS_MS) {
+    return diagnosis;
+  }
+  const lastStreamUiUpdateMs = parseIsoMs(diagnosis.lastStreamUiUpdateAt || void 0);
+  const lastStreamUiAttemptMs = parseIsoMs(diagnosis.lastStreamUiAttemptAt || void 0);
+  const streamUiFlushStartedMs = parseIsoMs(diagnosis.streamUiFlushStartedAt || void 0);
+  const lastStreamUiErrorText = diagnosis.lastStreamUiError?.trim();
+  if (streamUiFlushStartedMs && nowMs - streamUiFlushStartedMs >= HEALTH_STREAM_UI_STALL_MS) {
+    const details = ["\u4EFB\u52A1\u4ECD\u5728\u7EE7\u7EED\uFF0C\u4F46\u6D41\u5F0F UI \u5237\u65B0\u8BF7\u6C42\u5DF2\u957F\u65F6\u95F4\u672A\u5B8C\u6210\uFF0C\u7591\u4F3C\u5361\u4F4F\u3002"];
+    if (diagnosis.streamUiConsecutiveFailures > 0) {
+      details.push(`\u6700\u8FD1\u8FDE\u7EED\u5931\u8D25 ${diagnosis.streamUiConsecutiveFailures} \u6B21\u3002`);
+    }
+    if (lastStreamUiErrorText) {
+      details.push(`\u6700\u8FD1\u9519\u8BEF\uFF1A${lastStreamUiErrorText}`);
+    }
+    return {
+      ...diagnosis,
+      healthStatus: "suspected_stream_ui_stall",
+      healthReason: details.join(" ")
+    };
+  }
+  if (lastStreamUiUpdateMs && lastProgressMs - lastStreamUiUpdateMs >= HEALTH_STREAM_UI_STALL_MS) {
+    const details = ["\u4EFB\u52A1\u4ECD\u5728\u7EE7\u7EED\uFF0C\u4F46\u6D41\u5F0F UI \u5DF2\u957F\u65F6\u95F4\u6CA1\u6709\u8DDF\u4E0A\u6700\u65B0\u6267\u884C\u8FDB\u5C55\uFF0C\u7591\u4F3C\u505C\u66F4\u3002"];
+    if (lastStreamUiErrorText) {
+      details.push(`\u6700\u8FD1\u9519\u8BEF\uFF1A${lastStreamUiErrorText}`);
+    }
+    return {
+      ...diagnosis,
+      healthStatus: "suspected_stream_ui_stall",
+      healthReason: details.join(" ")
+    };
+  }
+  if (!lastStreamUiUpdateMs && lastStreamUiAttemptMs && lastProgressMs - lastStreamUiAttemptMs >= HEALTH_STREAM_UI_STALL_MS) {
+    const details = ["\u4EFB\u52A1\u4ECD\u5728\u7EE7\u7EED\uFF0C\u4F46\u6D41\u5F0F UI \u53EA\u6709\u53D1\u9001\u5C1D\u8BD5\u3001\u6CA1\u6709\u6210\u529F\u5237\u65B0\u8BB0\u5F55\uFF0C\u7591\u4F3C\u505C\u66F4\u3002"];
+    if (lastStreamUiErrorText) {
+      details.push(`\u6700\u8FD1\u9519\u8BEF\uFF1A${lastStreamUiErrorText}`);
+    }
+    return {
+      ...diagnosis,
+      healthStatus: "suspected_stream_ui_stall",
+      healthReason: details.join(" ")
+    };
+  }
+  return diagnosis;
+}
 
 // src/lib/bridge/session-health-runtime.ts
 function createSessionHealthRuntime(deps) {
   const lastProgressPersistAt = /* @__PURE__ */ new Map();
   const processProbeCache = /* @__PURE__ */ new Map();
+  function summarizePlanUpdate(tasks) {
+    if (!Array.isArray(tasks) || tasks.length === 0) {
+      return "\u68C0\u6D4B\u5230\u684C\u9762\u7EBF\u7A0B\u66F4\u65B0\u4E86\u4EFB\u52A1\u8BA1\u5212\u3002";
+    }
+    let inProgress = 0;
+    let pending = 0;
+    let completed = 0;
+    for (const task of tasks) {
+      if (task?.status === "completed") completed += 1;
+      else if (task?.status === "in_progress") inProgress += 1;
+      else pending += 1;
+    }
+    return `\u68C0\u6D4B\u5230\u684C\u9762\u7EBF\u7A0B\u66F4\u65B0\u4E86\u4EFB\u52A1\u8BA1\u5212\uFF08\u6267\u884C\u4E2D ${inProgress} \u9879\uFF0C\u7B49\u5F85\u4E2D ${pending} \u9879\uFF0C\u5DF2\u5B8C\u6210 ${completed} \u9879\uFF09\u3002`;
+  }
   function updateSessionHealth(sessionId, updates, options) {
     const store = deps.getStore();
     const session = store.getSession(sessionId);
@@ -20462,7 +21174,13 @@ function createSessionHealthRuntime(deps) {
       active_tools_json: void 0,
       active_tool_name: void 0,
       active_tool_started_at: void 0,
-      last_tool_finished_at: void 0
+      last_tool_finished_at: void 0,
+      last_stream_ui_attempt_at: void 0,
+      last_stream_ui_update_at: void 0,
+      stream_ui_flush_started_at: void 0,
+      last_stream_ui_error_at: void 0,
+      last_stream_ui_error: void 0,
+      stream_ui_consecutive_failures: void 0
     });
   }
   function recordInteractiveProgress(sessionId, type, detail) {
@@ -20530,11 +21248,29 @@ function createSessionHealthRuntime(deps) {
       active_tools_json: void 0,
       active_tool_name: void 0,
       active_tool_started_at: void 0,
+      stream_ui_flush_started_at: void 0,
       last_health_check_at: nowIso4
     }, { force: true });
     lastProgressPersistAt.set(sessionId, Date.now());
     processProbeCache.delete(sessionId);
   }
+  function toIso(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return void 0;
+    return new Date(value).toISOString();
+  }
+  function recordStructuredStreamUi(sessionId, snapshot) {
+    const updates = {
+      stream_ui_flush_started_at: snapshot.active && snapshot.flushInFlight ? toIso(snapshot.flushInFlightSince ?? snapshot.lastAttemptAt) : void 0
+    };
+    if (snapshot.active) {
+      updates.last_stream_ui_attempt_at = toIso(snapshot.lastAttemptAt);
+      updates.last_stream_ui_update_at = toIso(snapshot.lastUpdateAt);
+      updates.last_stream_ui_error_at = toIso(snapshot.lastErrorAt);
+      updates.last_stream_ui_error = snapshot.lastError?.trim() || void 0;
+      updates.stream_ui_consecutive_failures = snapshot.consecutiveFailures && snapshot.consecutiveFailures > 0 ? snapshot.consecutiveFailures : void 0;
+    }
+    updateSessionHealth(sessionId, updates);
+  }
   function observeDesktopMirrorRecords(sessionId, _threadId, records) {
     for (const record of records) {
       if (record.type === "task_started") {
@@ -20545,6 +21281,10 @@ function createSessionHealthRuntime(deps) {
         recordInteractiveEnd(sessionId, "completed", "\u68C0\u6D4B\u5230\u684C\u9762\u7EBF\u7A0B\u5DF2\u5B8C\u6210\u5F53\u524D\u4EFB\u52A1\u3002");
         continue;
       }
+      if (record.type === "task_aborted") {
+        recordInteractiveEnd(sessionId, "aborted", "\u68C0\u6D4B\u5230\u684C\u9762\u7EBF\u7A0B\u5DF2\u505C\u6B62\u5F53\u524D\u4EFB\u52A1\u3002");
+        continue;
+      }
       if (record.type === "tool_started") {
         recordToolState(sessionId, record.toolId || record.signature, record.toolName || "tool", "running");
         continue;
@@ -20558,6 +21298,22 @@ function createSessionHealthRuntime(deps) {
         );
         continue;
       }
+      if (record.type === "reasoning") {
+        recordInteractiveProgress(
+          sessionId,
+          "reasoning",
+          "\u68C0\u6D4B\u5230\u684C\u9762\u7EBF\u7A0B\u65B0\u7684\u601D\u8003/\u72B6\u6001\u8BF4\u660E\u3002"
+        );
+        continue;
+      }
+      if (record.type === "plan_update") {
+        recordInteractiveProgress(
+          sessionId,
+          "plan_update",
+          summarizePlanUpdate(record.tasks)
+        );
+        continue;
+      }
       if (record.type === "message") {
         recordInteractiveProgress(
           sessionId,
@@ -20572,7 +21328,10 @@ function createSessionHealthRuntime(deps) {
     const store = deps.getStore();
     for (const session of store.listSessions()) {
       if (!shouldTrackSession(session)) continue;
-      const diagnosis = computeBaseDiagnosis(session, nowMs);
+      const diagnosis = applyStreamUiDiagnosis(
+        { ...computeBaseDiagnosis(session, nowMs), processProbe: null },
+        nowMs
+      );
       updateSessionHealth(session.id, {
         health_status: diagnosis.healthStatus,
         health_reason: diagnosis.healthReason
@@ -20600,7 +21359,10 @@ function createSessionHealthRuntime(deps) {
     if (!session) return null;
     const base = computeBaseDiagnosis(session, Date.now());
     const processProbe = await loadProcessProbe(session);
-    const diagnosis = applyProcessProbeDiagnosis(base, processProbe);
+    const diagnosis = applyStreamUiDiagnosis(
+      applyProcessProbeDiagnosis(base, processProbe),
+      Date.now()
+    );
     updateSessionHealth(sessionId, {
       health_status: diagnosis.healthStatus,
       health_reason: diagnosis.healthReason,
@@ -20618,6 +21380,7 @@ function createSessionHealthRuntime(deps) {
     recordInteractiveStart,
     recordInteractiveProgress,
     recordToolState,
+    recordStructuredStreamUi,
     recordInteractiveEnd,
     observeDesktopMirrorRecords,
     reconcileSessionHealth,
@@ -20871,7 +21634,8 @@ function pushMirrorStreamingStatus(subscription, turnState, options = {}) {
   }
   const statusText = formatInteractiveRuntimeStatus(
     Math.max(0, nowMs - startedAtMs),
-    options.silentMs
+    options.silentMs,
+    turnState.statusNote
   );
   if (turnState.lastStatusText === statusText) return;
   pushStreamFeedbackStatus(
@@ -20920,6 +21684,20 @@ function updateMirrorToolProgress(subscription, turnState) {
   );
   pushMirrorStreamingStatus(subscription, turnState);
 }
+function updateMirrorTaskProgress(subscription, turnState) {
+  const adapter = getMirrorStreamingAdapter(subscription);
+  if (!adapter) return;
+  pushStreamFeedbackTasks(
+    createMirrorStreamFeedbackTarget(subscription, turnState, adapter),
+    turnState.taskItems
+  );
+  pushMirrorStreamingStatus(subscription, turnState);
+}
+function updateMirrorStatusProgress(subscription, turnState) {
+  const adapter = getMirrorStreamingAdapter(subscription);
+  if (!adapter) return;
+  pushMirrorStreamingStatus(subscription, turnState);
+}
 function stopMirrorStreaming(subscription, status = "interrupted") {
   const adapter = getMirrorStreamingAdapter(subscription);
   const pendingTurn = subscription.pendingTurn;
@@ -20980,12 +21758,21 @@ async function deliverMirrorTurn(subscription, turn) {
   subscription.lastDeliveredAt = turn.timestamp || nowIso3();
 }
 async function deliverMirrorTurns(subscription, turns) {
-  for (const turn of turns.slice(-MIRROR_EVENT_BATCH_LIMIT)) {
-    await deliverMirrorTurn(subscription, turn);
+  let deliveredCount = 0;
+  for (const turn of turns.slice(0, MIRROR_EVENT_BATCH_LIMIT)) {
+    try {
+      await deliverMirrorTurn(subscription, turn);
+      deliveredCount += 1;
+    } catch (error) {
+      return { deliveredCount, error };
+    }
   }
+  return { deliveredCount };
 }
 var MIRROR_TURN_HOOKS = {
   onStreamText: updateMirrorStreaming,
+  onStatusProgress: updateMirrorStatusProgress,
+  onTaskProgress: updateMirrorTaskProgress,
   onToolProgress: updateMirrorToolProgress
 };
 function consumeMirrorRecords2(subscription, records) {
@@ -21272,6 +22059,9 @@ async function handleMessage(adapter, msg) {
       recordInteractiveHealthTool: (sessionId, toolId, toolName, status) => {
         SESSION_HEALTH_RUNTIME.recordToolState(sessionId, toolId, toolName, status);
       },
+      recordInteractiveStreamUiSnapshot: (sessionId, snapshot) => {
+        SESSION_HEALTH_RUNTIME.recordStructuredStreamUi(sessionId, snapshot);
+      },
       recordInteractiveHealthEnd: (sessionId, outcome, detail) => SESSION_HEALTH_RUNTIME.recordInteractiveEnd(sessionId, outcome, detail),
       beginMirrorSuppression: beginMirrorSuppression2,
       abortMirrorSuppression: abortMirrorSuppression2,
@@ -22424,10 +23214,87 @@ function setupLogger() {
   console.warn = (...args) => write("WARN", args);
 }
 
+// src/bridge-instance-lock.ts
+import fs14 from "node:fs";
+import path15 from "node:path";
+var runtimeDir = path15.join(CTI_HOME, "runtime");
+var bridgeInstanceLockFile = path15.join(runtimeDir, "bridge.instance.lock");
+function readJsonFile(filePath, fallback) {
+  try {
+    return JSON.parse(fs14.readFileSync(filePath, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function isProcessAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readBridgeInstanceLock(filePath = bridgeInstanceLockFile) {
+  const parsed = readJsonFile(filePath, null);
+  const pid = Number(parsed?.pid);
+  const createdAt = typeof parsed?.createdAt === "string" ? parsed.createdAt : "";
+  if (!Number.isFinite(pid) || pid <= 0 || !createdAt) return null;
+  return { pid, createdAt };
+}
+function tryAcquireBridgeInstanceLock(options = {}) {
+  const filePath = options.filePath ?? bridgeInstanceLockFile;
+  const ownerPid = options.ownerPid ?? process.pid;
+  const nowMs = options.nowMs ?? Date.now();
+  const isAlive = options.isAlive ?? isProcessAlive;
+  const payload = {
+    pid: ownerPid,
+    createdAt: new Date(nowMs).toISOString()
+  };
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      fs14.mkdirSync(path15.dirname(filePath), { recursive: true });
+      fs14.writeFileSync(filePath, JSON.stringify(payload, null, 2), { encoding: "utf-8", flag: "wx" });
+      return { acquired: true };
+    } catch (error) {
+      const code2 = error.code;
+      if (code2 !== "EEXIST") throw error;
+      const existing2 = readBridgeInstanceLock(filePath);
+      if (existing2 && existing2.pid !== ownerPid && isAlive(existing2.pid)) {
+        return { acquired: false, holderPid: existing2.pid };
+      }
+      try {
+        fs14.unlinkSync(filePath);
+      } catch {
+      }
+    }
+  }
+  const existing = readBridgeInstanceLock(filePath);
+  if (existing && existing.pid !== ownerPid && isAlive(existing.pid)) {
+    return { acquired: false, holderPid: existing.pid };
+  }
+  return existing?.pid === ownerPid ? { acquired: true } : { acquired: false, holderPid: existing?.pid };
+}
+function releaseBridgeInstanceLock(filePath = bridgeInstanceLockFile, ownerPid = process.pid) {
+  const existing = readBridgeInstanceLock(filePath);
+  if (!existing) {
+    try {
+      fs14.unlinkSync(filePath);
+    } catch {
+    }
+    return;
+  }
+  if (existing.pid !== ownerPid) return;
+  try {
+    fs14.unlinkSync(filePath);
+  } catch {
+  }
+}
+
 // src/main.ts
-var RUNTIME_DIR = path16.join(CTI_HOME, "runtime");
-var STATUS_FILE = path16.join(RUNTIME_DIR, "status.json");
-var PID_FILE = path16.join(RUNTIME_DIR, "bridge.pid");
+var RUNTIME_DIR = path17.join(CTI_HOME, "runtime");
+var STATUS_FILE = path17.join(RUNTIME_DIR, "status.json");
+var PID_FILE = path17.join(RUNTIME_DIR, "bridge.pid");
 async function resolveProvider(config2, pendingPerms) {
   const runtime = config2.runtime;
   if (runtime === "codex") {
@@ -22477,16 +23344,16 @@ async function resolveProvider(config2, pendingPerms) {
   return new SDKLLMProvider(pendingPerms, cliPath, config2.autoApprove);
 }
 function writeStatus(info) {
-  fs15.mkdirSync(RUNTIME_DIR, { recursive: true });
+  fs16.mkdirSync(RUNTIME_DIR, { recursive: true });
   let existing = {};
   try {
-    existing = JSON.parse(fs15.readFileSync(STATUS_FILE, "utf-8"));
+    existing = JSON.parse(fs16.readFileSync(STATUS_FILE, "utf-8"));
   } catch {
   }
   const merged = { ...existing, ...info };
   const tmp = STATUS_FILE + ".tmp";
-  fs15.writeFileSync(tmp, JSON.stringify(merged, null, 2), "utf-8");
-  fs15.renameSync(tmp, STATUS_FILE);
+  fs16.writeFileSync(tmp, JSON.stringify(merged, null, 2), "utf-8");
+  fs16.renameSync(tmp, STATUS_FILE);
 }
 function getRunningChannels() {
   return getStatus().adapters.map((adapter) => adapter.channelType).sort();
@@ -22495,6 +23362,24 @@ function getAdapterStatuses() {
   return getStatus().adapters;
 }
 async function main() {
+  const lockState = tryAcquireBridgeInstanceLock();
+  if (!lockState.acquired) {
+    const holderPid = lockState.holderPid;
+    writeStatus({
+      running: true,
+      ...Number.isFinite(holderPid) && holderPid ? { pid: holderPid } : {}
+    });
+    console.log(
+      `[codex-to-im] Another bridge daemon is already running${holderPid ? ` (PID: ${holderPid})` : ""}. Exiting duplicate launcher.`
+    );
+    process.exit(0);
+  }
+  let instanceLockHeld = true;
+  const releaseInstanceLock = () => {
+    if (!instanceLockHeld) return;
+    releaseBridgeInstanceLock(void 0, process.pid);
+    instanceLockHeld = false;
+  };
   const config2 = loadConfig();
   setupLogger();
   const runId = crypto10.randomUUID();
@@ -22513,8 +23398,8 @@ async function main() {
     permissions: gateway,
     lifecycle: {
       onBridgeStart: () => {
-        fs15.mkdirSync(RUNTIME_DIR, { recursive: true });
-        fs15.writeFileSync(PID_FILE, String(process.pid), "utf-8");
+        fs16.mkdirSync(RUNTIME_DIR, { recursive: true });
+        fs16.writeFileSync(PID_FILE, String(process.pid), "utf-8");
         const channels = getRunningChannels();
         writeStatus({
           running: true,
@@ -22537,6 +23422,7 @@ async function main() {
         console.log(`[codex-to-im] Active channels updated: ${channels.join(", ") || "none"}`);
       },
       onBridgeStop: () => {
+        releaseInstanceLock();
         writeStatus({ running: false, channels: [], adapters: [] });
         console.log("[codex-to-im] Bridge stopped");
       }
@@ -22551,6 +23437,7 @@ async function main() {
     console.log(`[codex-to-im] Shutting down (${reason})...`);
     pendingPerms.denyAll();
     await stop();
+    releaseInstanceLock();
     writeStatus({ running: false, lastExitReason: reason });
     process.exit(0);
   };
@@ -22563,6 +23450,7 @@ async function main() {
   });
   process.on("uncaughtException", (err) => {
     console.error("[codex-to-im] uncaughtException:", err.stack || err.message);
+    releaseInstanceLock();
     writeStatus({ running: false, lastExitReason: `uncaughtException: ${err.message}` });
     process.exit(1);
   });
@@ -22570,6 +23458,7 @@ async function main() {
     console.log(`[codex-to-im] beforeExit (code: ${code2})`);
   });
   process.on("exit", (code2) => {
+    releaseInstanceLock();
     console.log(`[codex-to-im] exit (code: ${code2})`);
   });
   setInterval(() => {
@@ -22577,6 +23466,7 @@ async function main() {
 }
 main().catch((err) => {
   console.error("[codex-to-im] Fatal error:", err instanceof Error ? err.stack || err.message : err);
+  releaseBridgeInstanceLock(void 0, process.pid);
   try {
     writeStatus({ running: false, lastExitReason: `fatal: ${err instanceof Error ? err.message : String(err)}` });
   } catch {