codex-to-im 1.0.44 → 1.0.46

package/dist/daemon.mjs

@@ -1223,14 +1223,19 @@ function buildPostContent(text2) {
 function htmlToFeishuMarkdown(html) {
   return html.replace(/<b>(.*?)<\/b>/gi, "**$1**").replace(/<strong>(.*?)<\/strong>/gi, "**$1**").replace(/<i>(.*?)<\/i>/gi, "*$1*").replace(/<em>(.*?)<\/em>/gi, "*$1*").replace(/<code>(.*?)<\/code>/gi, "`$1`").replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/\n{3,}/g, "\n\n").trim();
 }
-function buildToolProgressMarkdown(tools) {
+function normalizeToolStatusForRender(status, options) {
+  if (status !== "running" || !options.terminalStatus) return status;
+  return options.terminalStatus === "completed" ? "complete" : "error";
+}
+function buildToolProgressMarkdown(tools, options = {}) {
   if (tools.length === 0) return "";
   const grouped = /* @__PURE__ */ new Map();
   for (const tool of tools) {
     const key = tool.name || "tool";
     const bucket = grouped.get(key) || { running: 0, complete: 0, error: 0 };
-    if (tool.status === "running") bucket.running += 1;
-    else if (tool.status === "error") bucket.error += 1;
+    const status = normalizeToolStatusForRender(tool.status, options);
+    if (status === "running") bucket.running += 1;
+    else if (status === "error") bucket.error += 1;
     else bucket.complete += 1;
     grouped.set(key, bucket);
   }
@@ -1249,11 +1254,25 @@ function buildToolProgressMarkdown(tools) {
   });
   return lines.join("\n");
 }
-function buildTaskProgressMarkdown(tasks) {
+function getTaskProgressPresentation(task, options) {
+  if (!options.terminalStatus) {
+    return task.status === "completed" ? { icon: "\u2705", label: "\u5DF2\u5B8C\u6210" } : task.status === "in_progress" ? { icon: "\u{1F504}", label: "\u6267\u884C\u4E2D" } : { icon: "\u23F3", label: "\u7B49\u5F85\u4E2D" };
+  }
+  if (task.status === "completed") {
+    return { icon: "\u2705", label: "\u5DF2\u5B8C\u6210" };
+  }
+  if (options.terminalStatus === "completed") {
+    return { icon: "\u2705", label: "\u5DF2\u7ED3\u675F" };
+  }
+  if (options.terminalStatus === "interrupted") {
+    return task.status === "pending" ? { icon: "\u26A0\uFE0F", label: "\u672A\u6267\u884C" } : { icon: "\u26A0\uFE0F", label: "\u5DF2\u505C\u6B62" };
+  }
+  return task.status === "pending" ? { icon: "\u274C", label: "\u672A\u6267\u884C" } : { icon: "\u274C", label: "\u5DF2\u4E2D\u65AD" };
+}
+function buildTaskProgressMarkdown(tasks, options = {}) {
   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";
+    const { icon, label } = getTaskProgressPresentation(task, options);
     return `${icon} ${task.text}\uFF08${label}\uFF09`;
   }).join("\n");
 }
@@ -1274,11 +1293,12 @@ function buildStreamingToolsContent(tools) {
 function buildStreamingTaskContent(tasks) {
   return buildTaskProgressMarkdown(tasks);
 }
-function buildFinalCardJson(text2, tasks, tools, footer) {
+function buildFinalCardJson(text2, tasks, tools, footer, terminalStatus) {
   const elements = [];
   const content = preprocessFeishuMarkdown(text2);
-  const taskMd = buildTaskProgressMarkdown(tasks);
-  const toolMd = buildToolProgressMarkdown(tools);
+  const renderOptions = { terminalStatus };
+  const taskMd = buildTaskProgressMarkdown(tasks, renderOptions);
+  const toolMd = buildToolProgressMarkdown(tools, renderOptions);
   if (content) {
     elements.push({
       tag: "markdown",
@@ -1384,9 +1404,53 @@ var MAX_FILE_SIZE = 20 * 1024 * 1024;
 var TYPING_EMOJI = "Typing";
 var CARD_THROTTLE_MS = 1e3;
 var CARD_REQUEST_TIMEOUT_MS = 15e3;
+var CARD_FINALIZE_FLUSH_WAIT_EXTRA_MS = 1e3;
+var CARD_FULL_REFRESH_INTERVAL_MS = 5 * 6e4;
 var INITIAL_STREAMING_STATUS = "\u5904\u7406\u4E2D";
 var EMPTY_STREAMING_TASKS = "";
 var EMPTY_STREAMING_TOOLS = "";
+function buildStreamingCardBody(content, tasksText, toolsText, statusText) {
+  return {
+    schema: "2.0",
+    config: {
+      streaming_mode: true,
+      wide_screen_mode: true,
+      summary: { content: "\u601D\u8003\u4E2D..." }
+    },
+    body: {
+      elements: [
+        {
+          tag: "markdown",
+          content,
+          text_align: "left",
+          text_size: "normal",
+          element_id: "streaming_content"
+        },
+        {
+          tag: "markdown",
+          content: tasksText,
+          text_align: "left",
+          text_size: "normal",
+          element_id: "streaming_tasks"
+        },
+        {
+          tag: "markdown",
+          content: toolsText,
+          text_align: "left",
+          text_size: "normal",
+          element_id: "streaming_tools"
+        },
+        {
+          tag: "markdown",
+          content: statusText,
+          text_align: "left",
+          text_size: "notation",
+          element_id: "streaming_status"
+        }
+      ]
+    }
+  };
+}
 var MIME_BY_TYPE = {
   image: "image/png",
   file: "application/octet-stream",
@@ -1421,6 +1485,8 @@ var FeishuAdapter = class extends BaseChannelAdapter {
   /** Cached tenant token for upload APIs. */
   tenantTokenCache = null;
   cardRequestTimeoutMs = CARD_REQUEST_TIMEOUT_MS;
+  cardFinalizeFlushWaitExtraMs = CARD_FINALIZE_FLUSH_WAIT_EXTRA_MS;
+  cardFullRefreshIntervalMs = CARD_FULL_REFRESH_INTERVAL_MS;
   constructor(instance) {
     super();
     this.channelType = instance?.id || "feishu";
@@ -1654,46 +1720,12 @@ var FeishuAdapter = class extends BaseChannelAdapter {
       return false;
     }
     try {
-      const cardBody = {
-        schema: "2.0",
-        config: {
-          streaming_mode: true,
-          wide_screen_mode: true,
-          summary: { content: "\u601D\u8003\u4E2D..." }
-        },
-        body: {
-          elements: [
-            {
-              tag: "markdown",
-              content: "\u{1F4AD} Thinking...",
-              text_align: "left",
-              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,
-              text_align: "left",
-              text_size: "normal",
-              element_id: "streaming_tools"
-            },
-            {
-              tag: "markdown",
-              content: INITIAL_STREAMING_STATUS,
-              text_align: "left",
-              text_size: "notation",
-              element_id: "streaming_status"
-            }
-          ]
-        }
-      };
+      const cardBody = buildStreamingCardBody(
+        "\u{1F4AD} Thinking...",
+        EMPTY_STREAMING_TASKS,
+        EMPTY_STREAMING_TOOLS,
+        INITIAL_STREAMING_STATUS
+      );
       const createResp = await this.withFeishuRequestTimeout(cardKey, "card.create", () => cardkit.card.create({
         data: { type: "card_json", data: JSON.stringify(cardBody) }
       }));
@@ -1724,12 +1756,13 @@ var FeishuAdapter = class extends BaseChannelAdapter {
         console.warn("[feishu-adapter] Card message send returned no message_id");
         return false;
       }
+      const now2 = Date.now();
       this.activeCards.set(cardKey, {
         chatId,
         cardId,
         messageId,
         sequence: 0,
-        startTime: Date.now(),
+        startTime: now2,
         taskItems: [],
         toolCalls: [],
         thinking: true,
@@ -1748,7 +1781,9 @@ var FeishuAdapter = class extends BaseChannelAdapter {
         lastSuccessfulFlushAt: null,
         lastFlushErrorAt: null,
         lastFlushError: null,
-        consecutiveFlushFailures: 0
+        consecutiveFlushFailures: 0,
+        lastFullRefreshAttemptAt: now2,
+        lastSuccessfulFullRefreshAt: null
       });
       console.log(`[feishu-adapter] Streaming card created: streamKey=${cardKey}, cardId=${cardId}, msgId=${messageId}`);
       return true;
@@ -1837,6 +1872,17 @@ var FeishuAdapter = class extends BaseChannelAdapter {
     const toolsText = buildStreamingToolsContent(state.toolCalls) || EMPTY_STREAMING_TOOLS;
     const statusText = state.pendingStatusText || INITIAL_STREAMING_STATUS;
     const updates = [];
+    if (this.shouldFullRefreshCard(state, Date.now())) {
+      const refreshed = await this.flushFullCardRefresh(
+        streamKey,
+        state,
+        content,
+        tasksText,
+        toolsText,
+        statusText
+      );
+      if (refreshed) return;
+    }
     if (content !== state.renderedText) {
       updates.push({
         elementId: "streaming_content",
@@ -1903,24 +1949,33 @@ var FeishuAdapter = class extends BaseChannelAdapter {
     state.toolCalls = tools;
     this.scheduleCardFlush(cardKey);
   }
-  async awaitCardFlushCompletion(streamKey) {
+  async awaitCardFlushCompletion(streamKey, timeoutMs = this.getCardRequestTimeoutMs() + Math.max(0, this.cardFinalizeFlushWaitExtraMs)) {
+    const deadline = Date.now() + Math.max(0, timeoutMs);
     while (true) {
       const state = this.activeCards.get(streamKey);
-      if (!state) return;
+      if (!state) return true;
       const inFlight = state.flushInFlight;
       if (inFlight) {
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) return false;
+        const timedOut = Symbol("flush-timeout");
         try {
-          await inFlight;
+          const result = await Promise.race([
+            inFlight.then(() => null),
+            new Promise((resolve2) => setTimeout(() => resolve2(timedOut), remainingMs))
+          ]);
+          if (result === timedOut) return false;
         } catch {
         }
         continue;
       }
+      if (Date.now() >= deadline) return false;
       if (state.flushQueued) {
         state.flushQueued = false;
         this.enqueueCardFlush(streamKey);
         continue;
       }
-      return;
+      return true;
     }
   }
   /**
@@ -1943,7 +1998,12 @@ var FeishuAdapter = class extends BaseChannelAdapter {
       clearTimeout(state.throttleTimer);
       state.throttleTimer = null;
     }
-    await this.awaitCardFlushCompletion(cardKey);
+    const flushed = await this.awaitCardFlushCompletion(cardKey);
+    if (!flushed) {
+      console.warn(`[feishu-adapter] Card finalize proceeding after flush wait timeout: streamKey=${cardKey}`);
+      state.flushInFlight = null;
+      state.flushQueued = false;
+    }
     try {
       state.sequence++;
       await this.withFeishuRequestTimeout(cardKey, "card.settings", () => cardkit.card.settings({
@@ -1972,7 +2032,7 @@ var FeishuAdapter = class extends BaseChannelAdapter {
 
 ${trimmedResponse}`;
       }
-      const finalCardJson = buildFinalCardJson(finalText, state.taskItems, state.toolCalls, footer);
+      const finalCardJson = buildFinalCardJson(finalText, state.taskItems, state.toolCalls, footer, status);
       state.sequence++;
       await this.withFeishuRequestTimeout(cardKey, "card.update", () => cardkit.card.update({
         path: { card_id: state.cardId },
@@ -2026,6 +2086,44 @@ ${trimmedResponse}`;
       consecutiveFailures: state.consecutiveFlushFailures
     };
   }
+  shouldFullRefreshCard(state, now2) {
+    const interval = Math.max(0, this.cardFullRefreshIntervalMs);
+    if (interval <= 0) return false;
+    if (!Number.isFinite(now2)) return false;
+    return now2 - state.lastFullRefreshAttemptAt >= interval;
+  }
+  async flushFullCardRefresh(streamKey, state, content, tasksText, toolsText, statusText) {
+    state.lastFullRefreshAttemptAt = Date.now();
+    const cardkit = this.restClient?.cardkit?.v1;
+    if (!cardkit?.card?.update) return false;
+    try {
+      state.sequence++;
+      await this.withFeishuRequestTimeout(streamKey, "card.update:streaming_refresh", () => cardkit.card.update({
+        path: { card_id: state.cardId },
+        data: {
+          card: {
+            type: "card_json",
+            data: JSON.stringify(buildStreamingCardBody(content, tasksText, toolsText, statusText))
+          },
+          sequence: state.sequence
+        }
+      }));
+      state.renderedText = content;
+      state.renderedTasksText = tasksText;
+      state.renderedToolsText = toolsText;
+      state.renderedStatusText = statusText;
+      state.lastSuccessfulFullRefreshAt = Date.now();
+      this.markCardFlushSuccess(state);
+      return true;
+    } catch (err) {
+      this.markCardFlushFailure(state, err);
+      console.warn(
+        "[feishu-adapter] card.update streaming refresh failed:",
+        err instanceof Error ? err.message : err
+      );
+      return false;
+    }
+  }
   getCardRequestTimeoutMs() {
     return Math.max(1, this.cardRequestTimeoutMs);
   }
@@ -10473,6 +10571,18 @@ function readDesktopSessionEventStream(threadId) {
   return readDesktopSessionEventStreamByFilePath(session.filePath);
 }
 
+// src/lib/bridge/turns/turn-classifier.ts
+function normalizeThreadId(value) {
+  const normalized = value?.trim();
+  return normalized || void 0;
+}
+function getCodexThreadId(session, binding) {
+  return normalizeThreadId(session?.codex_thread_id) || normalizeThreadId(binding?.sdkSessionId) || normalizeThreadId(session?.sdk_session_id);
+}
+function getExplicitDesktopThreadId(session) {
+  return normalizeThreadId(session?.desktop_thread_id) || (session?.thread_origin === "desktop" ? normalizeThreadId(session.sdk_session_id) : void 0);
+}
+
 // src/session-bindings.ts
 function asChannelProvider(value) {
   return value === "feishu" || value === "weixin" ? value : void 0;
@@ -10518,15 +10628,31 @@ function assertBindingTargetAvailable(store, current, opts) {
 function getSessionMode(store, session) {
   return session.preferred_mode || store.getSetting("bridge_default_mode") || "code";
 }
+function getBindingResumeThreadId(session) {
+  return getCodexThreadId(session) || "";
+}
+function markSessionAsDesktopBacked(store, sessionId, desktopThreadId) {
+  store.updateSdkSessionId(sessionId, desktopThreadId);
+  store.updateSession(sessionId, {
+    sdk_session_id: desktopThreadId,
+    codex_thread_id: desktopThreadId,
+    desktop_thread_id: desktopThreadId,
+    thread_origin: "desktop"
+  });
+}
 function bindStoreToSession(store, channelType, chatId, sessionId, chatMeta) {
   const session = store.getSession(sessionId);
   if (!session) return null;
   assertBindingTargetAvailable(
     store,
     { channelType, chatId },
-    { sessionId: session.id, sdkSessionId: session.sdk_session_id || void 0 }
+    {
+      sessionId: session.id,
+      sdkSessionId: getCodexThreadId(session) || getExplicitDesktopThreadId(session)
+    }
   );
   const meta = resolveChannelMeta(channelType);
+  const sdkSessionId = getBindingResumeThreadId(session);
   return store.upsertChannelBinding({
     channelType,
     channelProvider: meta.provider,
@@ -10535,7 +10661,7 @@ function bindStoreToSession(store, channelType, chatId, sessionId, chatMeta) {
     chatUserId: chatMeta?.chatUserId,
     chatDisplayName: chatMeta?.chatDisplayName,
     codepilotSessionId: session.id,
-    sdkSessionId: session.sdk_session_id || "",
+    sdkSessionId,
     workingDirectory: session.working_directory,
     model: session.model,
     mode: getSessionMode(store, session)
@@ -10550,6 +10676,7 @@ function bindStoreToSdkSession(store, channelType, chatId, sdkSessionId, opts) {
   const meta = resolveChannelMeta(channelType);
   const existing = store.findSessionBySdkSessionId(sdkSessionId);
   if (existing) {
+    markSessionAsDesktopBacked(store, existing.id, sdkSessionId);
     return store.upsertChannelBinding({
       channelType,
       channelProvider: meta.provider,
@@ -10574,7 +10701,7 @@ function bindStoreToSdkSession(store, channelType, chatId, sdkSessionId, opts) {
     workingDirectory,
     "code"
   );
-  store.updateSdkSessionId(session.id, sdkSessionId);
+  markSessionAsDesktopBacked(store, session.id, sdkSessionId);
   return store.upsertChannelBinding({
     channelType,
     channelProvider: meta.provider,
@@ -10947,15 +11074,17 @@ async function deliver(adapter, message, opts) {
     } catch {
     }
   }
-  try {
-    store.insertAuditLog({
-      channelType: adapter.channelType,
-      chatId: message.address.chatId,
-      direction: "outbound",
-      messageId: lastMessageId || "",
-      summary: message.text.slice(0, 200)
-    });
-  } catch {
+  if (opts?.audit !== false) {
+    try {
+      store.insertAuditLog({
+        channelType: adapter.channelType,
+        chatId: message.address.chatId,
+        direction: "outbound",
+        messageId: lastMessageId || "",
+        summary: message.text.slice(0, 200)
+      });
+    } catch {
+    }
   }
   return { ok: true, messageId: lastMessageId };
 }
@@ -11552,7 +11681,6 @@ function buildHealthCommandResponse(title, diagnosis, markdown = false) {
     title,
     [
       ["Session", diagnosis.sessionId],
-      ["\u68C0\u67E5\u65F6\u95F4", formatCommandTimestamp(diagnosis.checkedAt)],
       ["\u8FD0\u884C\u72B6\u6001", formatRuntimeStatus({ runtime_status: diagnosis.runtimeStatus, queued_count: 0 })],
       ["\u5065\u5EB7\u72B6\u6001", formatHealthStatusLabel(diagnosis.healthStatus)],
       ["\u5F53\u524D\u9636\u6BB5", currentStage],
@@ -11573,7 +11701,6 @@ function buildHealthListResponse(diagnoses, markdown = false) {
     diagnoses.map((diagnosis) => ({
       heading: diagnosis.sessionId,
       details: [
-        `\u68C0\u67E5\u65F6\u95F4\uFF1A${formatCommandTimestamp(diagnosis.checkedAt)}`,
         `\u5065\u5EB7\u72B6\u6001\uFF1A${formatHealthStatusLabel(diagnosis.healthStatus)}`,
         `\u5F53\u524D\u9636\u6BB5\uFF1A${diagnosis.activeToolName ? `\u5DE5\u5177 \xB7 ${diagnosis.activeToolName}` : diagnosis.lastProgressType || "-"}`,
         `\u6700\u540E\u8FDB\u5C55\uFF1A${formatCommandTimestamp(diagnosis.lastProgressAt)}`,
@@ -11681,6 +11808,8 @@ function createMirrorTurnState(sessionId, timestamp, turnId) {
     streamKey: buildMirrorStreamKey(sessionId, turnId || null, safeTimestamp),
     startedAt: safeTimestamp,
     lastActivityAt: safeTimestamp,
+    lastContentResponseAt: null,
+    lastResponseAt: null,
     lastStatusText: null,
     lastStatusAt: 0,
     statusNote: null,
@@ -11727,8 +11856,14 @@ function ensureMirrorTurnState(subscription, record) {
   }
   return subscription.pendingTurn;
 }
-function markMirrorResponse(turnState, timestamp) {
-  turnState.lastResponseAt = timestamp || nowIso2();
+function markMirrorActivity(turnState, timestamp) {
+  turnState.lastActivityAt = timestamp || nowIso2();
+}
+function markMirrorContentResponse(turnState, timestamp) {
+  const responseAt = timestamp || nowIso2();
+  markMirrorActivity(turnState, responseAt);
+  turnState.lastContentResponseAt = responseAt;
+  turnState.lastResponseAt = responseAt;
 }
 function finalizeMirrorTurn(subscription, signature, timestamp, status, preferredText) {
   const pendingTurn = subscription.pendingTurn;
@@ -11801,7 +11936,7 @@ function consumeMirrorRecords(subscription, records, hooks = {}) {
         if (text2) {
           pendingTurn.lastAssistantText = text2;
           appendMirrorStreamText(pendingTurn, text2);
-          markMirrorResponse(pendingTurn, record.timestamp);
+          markMirrorContentResponse(pendingTurn, record.timestamp);
           hooks.onStreamText?.(subscription, pendingTurn);
         }
       } else if (record.role === "commentary") {
@@ -11809,7 +11944,7 @@ function consumeMirrorRecords(subscription, records, hooks = {}) {
         if (text2) {
           pendingTurn.lastCommentaryText = text2;
           appendMirrorStreamText(pendingTurn, text2);
-          markMirrorResponse(pendingTurn, record.timestamp);
+          markMirrorContentResponse(pendingTurn, record.timestamp);
           hooks.onStreamText?.(subscription, pendingTurn);
         }
       }
@@ -11820,14 +11955,14 @@ function consumeMirrorRecords(subscription, records, hooks = {}) {
       const text2 = record.content.trim();
       if (!text2) continue;
       pendingTurn.statusNote = text2;
-      markMirrorResponse(pendingTurn, record.timestamp);
+      markMirrorActivity(pendingTurn, record.timestamp);
       hooks.onStatusProgress?.(subscription, pendingTurn);
       continue;
     }
     if (record.type === "plan_update") {
       const pendingTurn = ensureMirrorTurnState(subscription, record);
       pendingTurn.taskItems = record.tasks || [];
-      markMirrorResponse(pendingTurn, record.timestamp);
+      markMirrorActivity(pendingTurn, record.timestamp);
       hooks.onTaskProgress?.(subscription, pendingTurn);
       continue;
     }
@@ -11840,7 +11975,7 @@ function consumeMirrorRecords(subscription, records, hooks = {}) {
         name: toolName,
         status: "running"
       });
-      markMirrorResponse(pendingTurn, record.timestamp);
+      markMirrorActivity(pendingTurn, record.timestamp);
       hooks.onToolProgress?.(subscription, pendingTurn);
       continue;
     }
@@ -11853,7 +11988,7 @@ function consumeMirrorRecords(subscription, records, hooks = {}) {
         name: existing?.name || record.toolName || "tool",
         status: record.isError ? "error" : "complete"
       });
-      markMirrorResponse(pendingTurn, record.timestamp);
+      markMirrorActivity(pendingTurn, record.timestamp);
       hooks.onToolProgress?.(subscription, pendingTurn);
       continue;
     }
@@ -12022,9 +12157,6 @@ function abortMirrorSuppression(store, sessionId, config2, suppressionId, nowMs
   }
   target.until = nowMs + config2.suppressionWindowMs;
 }
-function isMirrorSuppressed(store, sessionId, nowMs = Date.now()) {
-  return getMirrorSuppressionStates(store, sessionId, nowMs).length > 0;
-}
 function filterSuppressedMirrorRecords(store, sessionId, records, config2, nowMs = Date.now()) {
   const suppressions = getMirrorSuppressionStates(store, sessionId, nowMs);
   const ignoredTurnIds = cleanupIgnoredMirrorTurns(store, sessionId, nowMs);
@@ -12661,7 +12793,7 @@ function supportsOutboundArtifacts(provider) {
 }
 
 // src/lib/bridge/feedback-delivery.ts
-async function deliverTextResponse(adapter, address, responseText, sessionId, replyToMessageId) {
+async function deliverTextResponse(adapter, address, responseText, sessionId, replyToMessageId, options) {
   if (!responseText.trim()) return { ok: true };
   const parseMode = getFeedbackParseMode(adapter.channelType);
   const renderedText = renderFeedbackText(responseText, parseMode);
@@ -12671,14 +12803,14 @@ async function deliverTextResponse(adapter, address, responseText, sessionId, re
       text: responseText,
       parseMode: "Markdown",
       replyToMessageId
-    }, { sessionId });
+    }, { sessionId, audit: options?.audit });
   }
   return deliver(adapter, {
     address,
     text: parseMode === "Markdown" ? responseText : renderedText,
     parseMode,
     replyToMessageId
-  }, { sessionId });
+  }, { sessionId, audit: options?.audit });
 }
 async function deliverBridgeNotice(adapter, address, text2, options) {
   return deliverTextResponse(
@@ -12686,7 +12818,8 @@ async function deliverBridgeNotice(adapter, address, text2, options) {
     address,
     text2,
     options?.sessionId,
-    options?.replyToMessageId
+    options?.replyToMessageId,
+    { audit: options?.audit }
   );
 }
 async function deliverResponse(adapter, address, responseText, sessionId, replyToMessageId, attachments = []) {
@@ -12802,6 +12935,7 @@ async function handleBridgeCommand(adapter, msg, text2, deps) {
   }
   let response = "";
   let responseParseMode = getFeedbackParseMode(adapter.channelType);
+  let auditResponse = true;
   const currentBinding = store.getChannelBinding(msg.address.channelType, msg.address.chatId);
   switch (command) {
     case "/start":
@@ -13134,6 +13268,7 @@ async function handleBridgeCommand(adapter, msg, text2, deps) {
         break;
       }
       if (!args) {
+        const desktopThreadId = getExplicitDesktopThreadId(session);
         const currentModel = resolveDisplayedModel(
           binding,
           session,
@@ -13145,14 +13280,14 @@ async function handleBridgeCommand(adapter, msg, text2, deps) {
           [["\u6A21\u578B", formatDisplayedModel(currentModel)]],
           [
             getAvailableModelChoicesText(),
-            binding.sdkSessionId ? "\u5F53\u524D\u662F\u5171\u4EAB\u684C\u9762\u7EBF\u7A0B\uFF0C\u53EA\u652F\u6301\u67E5\u770B\u6A21\u578B\uFF1B\u5982\u9700\u5207\u6362\uFF0C\u8BF7\u5148\u7528 `/new` \u65B0\u5EFA\u4E00\u4E2A IM \u4F1A\u8BDD\u7EBF\u7A0B\u3002" : "\u53D1\u9001 `/model gpt-5.4` \u53EF\u5207\u6362\uFF1B\u53D1\u9001 `/model default` \u53EF\u56DE\u9000\u5230\u9ED8\u8BA4\u6A21\u578B\u3002",
+            desktopThreadId ? "\u5F53\u524D\u662F\u5171\u4EAB\u684C\u9762\u7EBF\u7A0B\uFF0C\u53EA\u652F\u6301\u67E5\u770B\u6A21\u578B\uFF1B\u5982\u9700\u5207\u6362\uFF0C\u8BF7\u5148\u7528 `/new` \u65B0\u5EFA\u4E00\u4E2A IM \u4F1A\u8BDD\u7EBF\u7A0B\u3002" : "\u53D1\u9001 `/model gpt-5.4` \u53EF\u5207\u6362\uFF1B\u53D1\u9001 `/model default` \u53EF\u56DE\u9000\u5230\u9ED8\u8BA4\u6A21\u578B\u3002",
             "\u6A21\u578B\u5207\u6362\u53EA\u5F71\u54CD\u540E\u7EED\u4ECE IM \u53D1\u8D77\u7684 Codex CLI \u8BF7\u6C42\u3002"
           ],
           responseParseMode === "Markdown"
         );
         break;
       }
-      if (binding.sdkSessionId) {
+      if (getExplicitDesktopThreadId(session)) {
         response = "\u5F53\u524D\u662F\u5171\u4EAB\u684C\u9762\u7EBF\u7A0B\uFF0C\u4E0D\u652F\u6301\u76F4\u63A5\u5207\u6362\u6A21\u578B\u3002\u8BF7\u5148\u7528 `/new` \u65B0\u5EFA\u4E00\u4E2A\u7EBF\u7A0B\uFF0C\u518D\u6267\u884C `/model ...`\u3002";
         break;
       }
@@ -13203,9 +13338,32 @@ async function handleBridgeCommand(adapter, msg, text2, deps) {
       break;
     }
     case "/status": {
-      const binding = resolve(msg.address);
+      auditResponse = false;
+      const binding = currentBinding;
+      if (!binding) {
+        response = buildCommandFields(
+          "\u5F53\u524D\u4F1A\u8BDD",
+          [],
+          ["\u5F53\u524D\u804A\u5929\u8FD8\u6CA1\u6709\u7ED1\u5B9A\u4F1A\u8BDD\u3002\u53EF\u5148\u53D1\u9001 `/t` \u67E5\u770B\u6700\u8FD1\u684C\u9762\u4F1A\u8BDD\uFF0C\u518D\u7528 `/t 1` \u63A5\u7BA1\uFF1B\u6216\u53D1\u9001 `/new proj1` / `/new \u7EDD\u5BF9\u8DEF\u5F84` \u521B\u5EFA\u9879\u76EE\u4F1A\u8BDD\u3002"],
+          responseParseMode === "Markdown"
+        );
+        break;
+      }
       const session = store.getSession(binding.codepilotSessionId);
-      const threadTitle = getDesktopThreadTitle(binding.sdkSessionId);
+      if (!session) {
+        response = buildCommandFields(
+          "\u5F53\u524D\u4F1A\u8BDD",
+          [
+            ["Session", binding.codepilotSessionId],
+            ["\u76EE\u5F55", formatCommandPath(binding.workingDirectory)]
+          ],
+          ["\u5F53\u524D\u804A\u5929\u7ED1\u5B9A\u7684\u4F1A\u8BDD\u5DF2\u7ECF\u4E0D\u5B58\u5728\u3002\u53EF\u7528 `/t` \u63A5\u7BA1\u684C\u9762\u4F1A\u8BDD\uFF0C\u6216\u7528 `/new proj1` / `/new \u7EDD\u5BF9\u8DEF\u5F84` \u521B\u5EFA\u65B0\u4F1A\u8BDD\u3002"],
+          responseParseMode === "Markdown"
+        );
+        break;
+      }
+      const desktopThreadId = getExplicitDesktopThreadId(session);
+      const threadTitle = getDesktopThreadTitle(desktopThreadId);
       const sandboxMode = resolveEffectiveSandboxMode();
       const reasoningEffort = resolveEffectiveReasoningEffort(session);
       const currentModel = resolveDisplayedModel(
@@ -13229,21 +13387,25 @@ async function handleBridgeCommand(adapter, msg, text2, deps) {
           ["\u601D\u8003\u7EA7\u522B", formatReasoningEffort(reasoningEffort)]
         ],
         [
-          binding.sdkSessionId ? "\u5F53\u524D\u804A\u5929\u5DF2\u7ED1\u5B9A\u5230\u4E00\u6761\u5171\u4EAB\u4F1A\u8BDD\uFF0C\u76F4\u63A5\u53D1\u9001\u6D88\u606F\u5373\u53EF\u7EE7\u7EED\u3002" : session?.session_type === "draft" ? "\u5F53\u524D\u804A\u5929\u6B63\u5728\u4F7F\u7528\u4E34\u65F6\u8349\u7A3F\u7EBF\u7A0B\uFF08\u7B49\u540C `/t 0`\uFF09\u3002\u53EF\u76F4\u63A5\u53D1\u9001\u6D88\u606F\uFF0C\u6216\u7528 `/t` / `/new proj1` / `/new \u7EDD\u5BF9\u8DEF\u5F84` \u5207\u6362\u5230\u6B63\u5F0F\u4F1A\u8BDD\u3002" : "\u5F53\u524D\u804A\u5929\u8FD8\u6CA1\u6709\u7ED1\u5B9A\u684C\u9762\u4F1A\u8BDD\u3002\u53EF\u5148\u53D1\u9001 `/t`\uFF0C\u518D\u7528 `/t 1` \u63A5\u7BA1\u3002"
+          desktopThreadId ? "\u5F53\u524D\u804A\u5929\u5DF2\u7ED1\u5B9A\u5230\u4E00\u6761\u5171\u4EAB\u4F1A\u8BDD\uFF0C\u76F4\u63A5\u53D1\u9001\u6D88\u606F\u5373\u53EF\u7EE7\u7EED\u3002" : session?.session_type === "draft" ? "\u5F53\u524D\u804A\u5929\u6B63\u5728\u4F7F\u7528\u4E34\u65F6\u8349\u7A3F\u7EBF\u7A0B\uFF08\u7B49\u540C `/t 0`\uFF09\u3002\u53EF\u76F4\u63A5\u53D1\u9001\u6D88\u606F\uFF0C\u6216\u7528 `/t` / `/new proj1` / `/new \u7EDD\u5BF9\u8DEF\u5F84` \u5207\u6362\u5230\u6B63\u5F0F\u4F1A\u8BDD\u3002" : "\u5F53\u524D\u804A\u5929\u8FD8\u6CA1\u6709\u7ED1\u5B9A\u684C\u9762\u4F1A\u8BDD\u3002\u53EF\u5148\u53D1\u9001 `/t`\uFF0C\u518D\u7528 `/t 1` \u63A5\u7BA1\u3002"
         ],
         responseParseMode === "Markdown"
       );
       break;
     }
     case "/health": {
+      auditResponse = false;
       if (args === "all") {
         const diagnoses = await deps.diagnoseAllActiveSessions();
         response = diagnoses.length > 0 ? buildHealthListResponse(diagnoses, responseParseMode === "Markdown") : "\u5F53\u524D\u6CA1\u6709\u68C0\u6D4B\u5230\u8FD0\u884C\u4E2D\u7684\u4F1A\u8BDD\u3002";
         break;
       }
-      const binding = currentBinding || resolve(msg.address);
       const explicitTargetSessionId = args.trim();
-      const targetSessionId = explicitTargetSessionId || binding.codepilotSessionId;
+      const targetSessionId = explicitTargetSessionId || currentBinding?.codepilotSessionId;
+      if (!targetSessionId) {
+        response = "\u5F53\u524D\u804A\u5929\u8FD8\u6CA1\u6709\u7ED1\u5B9A\u4F1A\u8BDD\u3002\u5148\u53D1\u9001\u6D88\u606F\u521B\u5EFA\u4F1A\u8BDD\uFF0C\u6216\u5148\u7528 `/t 1` \u63A5\u7BA1\u684C\u9762\u4F1A\u8BDD\u3002";
+        break;
+      }
       const diagnosis = await deps.diagnoseSessionHealth(targetSessionId);
       if (!diagnosis) {
         response = `\u6CA1\u6709\u627E\u5230\u4F1A\u8BDD ${targetSessionId}\u3002`;
@@ -13262,15 +13424,16 @@ async function handleBridgeCommand(adapter, msg, text2, deps) {
         break;
       }
       const limit = getHistoryMessageLimit();
-      const desktopMessages = currentBinding.sdkSessionId ? readDesktopSessionMessages(currentBinding.sdkSessionId, limit) : [];
+      const session = store.getSession(currentBinding.codepilotSessionId);
+      const desktopThreadId = getExplicitDesktopThreadId(session);
+      const desktopMessages = desktopThreadId ? readDesktopSessionMessages(desktopThreadId, limit) : [];
       const { messages: storedMessages } = store.getMessages(currentBinding.codepilotSessionId, { limit });
       const messages = desktopMessages.length > 0 ? desktopMessages : storedMessages;
       if (messages.length === 0) {
         response = "\u5F53\u524D\u4F1A\u8BDD\u8FD8\u6CA1\u6709\u5386\u53F2\u6D88\u606F\u3002";
         break;
       }
-      const threadTitle = getDesktopThreadTitle(currentBinding.sdkSessionId);
-      const session = store.getSession(currentBinding.codepilotSessionId);
+      const threadTitle = getDesktopThreadTitle(desktopThreadId);
       const header = buildCommandFields(
         "\u6700\u8FD1\u5BF9\u8BDD\uFF08raw\uFF09",
         [
@@ -13295,10 +13458,27 @@ ${truncateHistoryContent(formatStoredMessageContent(message.content))}`;
     }
     case "/stop": {
       const binding = resolve(msg.address);
+      const session = store.getSession(binding.codepilotSessionId);
       const task = deps.getActiveTask(binding.codepilotSessionId);
-      if (task) {
-        task.abortController.abort();
-        response = "\u6B63\u5728\u505C\u6B62\u5F53\u524D\u4EFB\u52A1...";
+      const runningHealthStatuses = /* @__PURE__ */ new Set([
+        "running_active",
+        "waiting_tool",
+        "slow_observed",
+        "suspected_stall",
+        "suspected_stream_ui_stall",
+        "suspected_detached"
+      ]);
+      const looksRunning = session?.runtime_status === "running" || session?.runtime_status === "queued" || runningHealthStatuses.has(session?.health_status || "");
+      if (task || looksRunning) {
+        const taskName = getSessionDisplayName(session, binding.workingDirectory);
+        const detail = "\u7528\u6237\u6267\u884C /stop\uFF0C\u5DF2\u505C\u6B62\u5F53\u524D\u4EFB\u52A1\u3002";
+        if (deps.forceStopSession) {
+          await deps.forceStopSession(binding.codepilotSessionId, detail);
+        } else if (task) {
+          task.abortController.abort();
+        }
+        deps.recordInteractiveHealthEnd?.(binding.codepilotSessionId, "aborted", detail);
+        response = `\u65E7\u4F1A\u8BDD\u300C${taskName}\u300D\u4EFB\u52A1\u5DF2\u505C\u6B62\uFF0C\u53EF\u7EE7\u7EED\u53D1\u9001\u6D88\u606F\u6062\u590D\u8BE5\u7EBF\u7A0B\u3002`;
       } else {
         response = "\u5F53\u524D\u6CA1\u6709\u6B63\u5728\u8FD0\u884C\u7684\u4EFB\u52A1\u3002";
       }
@@ -13402,7 +13582,8 @@ ${truncateHistoryContent(formatStoredMessageContent(message.content))}`;
   }
   if (response) {
     await deliverBridgeNotice(adapter, msg.address, response, {
-      replyToMessageId: msg.messageId
+      replyToMessageId: msg.messageId,
+      audit: auditResponse
     });
   }
 }
@@ -13414,6 +13595,39 @@ import path13 from "node:path";
 import fs8 from "fs";
 import path12 from "path";
 import crypto5 from "crypto";
+
+// src/lib/bridge/turns/final-response-artifacts.ts
+function attachmentKey(attachment) {
+  return [
+    attachment.kind,
+    attachment.path,
+    attachment.caption || "",
+    attachment.name || ""
+  ].join("\0");
+}
+function dedupeOutboundAttachments(attachments) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const attachment of attachments) {
+    const key = attachmentKey(attachment);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(attachment);
+  }
+  return deduped;
+}
+function collectFinalResponseArtifacts(text2, attachments = []) {
+  const parsed = parseOutboundArtifacts(text2 || "");
+  return {
+    text: parsed.cleanText,
+    attachments: dedupeOutboundAttachments([
+      ...attachments,
+      ...parsed.attachments
+    ])
+  };
+}
+
+// src/lib/bridge/conversation-engine.ts
 init_runtime_options();
 
 // src/lib/bridge/sse-stream-decoder.ts
@@ -13792,8 +14006,8 @@ async function consumeStream(stream, sessionId, onPermissionRequest, onPartialTe
     if (contentBlocks.length > 0) {
       for (const block2 of contentBlocks) {
         if (block2.type !== "text") continue;
-        const parsed = parseOutboundArtifacts(block2.text);
-        block2.text = parsed.cleanText;
+        const parsed = collectFinalResponseArtifacts(block2.text);
+        block2.text = parsed.text;
         outboundAttachments.push(...parsed.attachments);
       }
       const hasToolBlocks = contentBlocks.some(
@@ -13807,7 +14021,7 @@ async function consumeStream(stream, sessionId, onPermissionRequest, onPartialTe
     const responseText = contentBlocks.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
     return {
       responseText,
-      outboundAttachments,
+      outboundAttachments: dedupeOutboundAttachments(outboundAttachments),
       tokenUsage,
       hasError,
       errorMessage,
@@ -13840,6 +14054,42 @@ async function consumeStream(stream, sessionId, onPermissionRequest, onPartialTe
   }
 }
 
+// src/lib/bridge/turns/response-assembler.ts
+function assembleFinalResponse(source, input) {
+  const parsed = collectFinalResponseArtifacts(input.text, input.attachments);
+  return {
+    text: parsed.text,
+    attachments: parsed.attachments,
+    hasError: input.hasError,
+    errorMessage: input.errorMessage,
+    source
+  };
+}
+function assembleSdkFinalResponse(input) {
+  return assembleFinalResponse("sdk_result", input);
+}
+function assembleDesktopFinalResponse(input) {
+  return assembleFinalResponse("desktop_task_complete", input);
+}
+function hasFinalResponsePayload(response) {
+  return Boolean(response.text || response.attachments.length > 0);
+}
+function mergeFinalResponses(primary, fallback) {
+  return {
+    text: primary.text || fallback.text,
+    attachments: dedupeOutboundAttachments([
+      ...fallback.attachments,
+      ...primary.attachments
+    ]),
+    hasError: primary.hasError ?? fallback.hasError,
+    errorMessage: primary.errorMessage || fallback.errorMessage,
+    source: primary.source
+  };
+}
+function stripFinalOnlyBlocksForStreaming(text2) {
+  return stripOutboundArtifactBlocksForStreaming(text2);
+}
+
 // src/lib/bridge/stream-feedback-controller.ts
 function pushStreamFeedbackText(target, text2) {
   if (typeof target.adapter.onStreamText !== "function") return;
@@ -13868,13 +14118,15 @@ function pushStreamFeedbackTasks(target, tasks) {
   }
 }
 function pushStreamFeedbackStatus(target, text2) {
-  if (typeof target.adapter.onStreamStatus !== "function") return;
+  if (typeof target.adapter.onStreamStatus !== "function") return false;
   target.ensureStarted?.();
   const rendered = renderFeedbackTextForChannel(target.channelType, text2);
-  if (!rendered) return;
+  if (!rendered) return false;
   try {
     target.adapter.onStreamStatus(target.chatId, rendered, target.streamKey);
+    return true;
   } catch {
+    return false;
   }
 }
 async function finalizeStreamFeedback(target, status, text2) {
@@ -13887,6 +14139,118 @@ async function finalizeStreamFeedback(target, status, text2) {
   }
 }
 
+// src/lib/bridge/turns/delivery-pipeline.ts
+function normalizeUnknownSendResult(result) {
+  if (result && typeof result === "object" && "ok" in result) {
+    return result;
+  }
+  return { ok: true };
+}
+async function deliverFinalResponse(context, response, options = {}) {
+  let lastResult = { ok: true };
+  const deliverResponse2 = context.deliverResponse || deliverResponse;
+  if (!options.skipText && response.text.trim()) {
+    if (context.deliverText) {
+      lastResult = await context.deliverText(response.text);
+    } else {
+      lastResult = normalizeUnknownSendResult(await deliverResponse2(
+        context.adapter,
+        context.address,
+        response.text,
+        context.sessionId,
+        context.replyToMessageId,
+        []
+      ));
+    }
+    if (!lastResult.ok) return lastResult;
+  }
+  if (response.attachments.length > 0) {
+    lastResult = normalizeUnknownSendResult(await deliverResponse2(
+      context.adapter,
+      context.address,
+      "",
+      context.sessionId,
+      context.replyToMessageId,
+      response.attachments
+    ));
+    if (!lastResult.ok) return lastResult;
+  }
+  return lastResult;
+}
+async function finalizeStreamingUi(target, status, response) {
+  return finalizeStreamFeedback(target, status, response.text);
+}
+
+// src/lib/bridge/turns/stream-state.ts
+function createStreamState(startedAtMs) {
+  const safeStartedAtMs = Number.isFinite(startedAtMs) ? startedAtMs : Date.now();
+  return {
+    startedAtMs: safeStartedAtMs,
+    lastActivityAtMs: safeStartedAtMs,
+    lastContentResponseAtMs: null,
+    statusNote: null,
+    lastStatusText: null,
+    lastStatusAtMs: 0
+  };
+}
+function recordStreamActivity(state, nowMs) {
+  if (!Number.isFinite(nowMs)) return;
+  state.lastActivityAtMs = Math.max(state.lastActivityAtMs, nowMs);
+}
+function recordStreamContentResponse(state, nowMs) {
+  if (!Number.isFinite(nowMs)) return;
+  recordStreamActivity(state, nowMs);
+  state.lastContentResponseAtMs = nowMs;
+}
+function updateStreamStatusNote(state, note, nowMs) {
+  state.statusNote = (note || "").trim() || null;
+  if (state.statusNote) {
+    recordStreamActivity(state, nowMs);
+  }
+}
+function formatRuntimeDuration(ms) {
+  const totalSeconds = Math.max(0, Math.floor(ms / 1e3));
+  const seconds = totalSeconds % 60;
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  const minutes = totalMinutes % 60;
+  const hours = Math.floor(totalMinutes / 60);
+  const parts = [];
+  if (hours > 0) parts.push(`${hours}\u5C0F\u65F6`);
+  if (minutes > 0) parts.push(`${minutes}\u5206`);
+  if (seconds > 0 || parts.length === 0) parts.push(`${seconds}\u79D2`);
+  return parts.join("");
+}
+function formatStreamRuntimeStatus(elapsedMs, lastContentResponseAgeMs, statusNote) {
+  const parts = [elapsedMs < 1e3 ? "\u5904\u7406\u4E2D" : `\u5DF2\u8FD0\u884C ${formatRuntimeDuration(elapsedMs)}`];
+  if (typeof lastContentResponseAgeMs === "number" && lastContentResponseAgeMs >= 0) {
+    parts.push(`\u4E0A\u6B21\u54CD\u5E94\u8DDD\u4ECA ${formatRuntimeDuration(lastContentResponseAgeMs)}`);
+  }
+  const runtimeText = parts.join("\uFF0C");
+  const note = (statusNote || "").trim();
+  return note ? `\u5F53\u524D\u6B65\u9AA4\uFF1A${note}
+${runtimeText}` : runtimeText;
+}
+function getStreamLastContentResponseAgeMs(state, nowMs, options = {}) {
+  const fallbackToStart = options.fallbackToStart !== false;
+  const base = state.lastContentResponseAtMs ?? (fallbackToStart ? state.startedAtMs : null);
+  if (base == null || !Number.isFinite(base) || !Number.isFinite(nowMs)) return null;
+  return Math.max(0, nowMs - base);
+}
+function shouldShowStreamLastContentResponseAge(state, nowMs, config2) {
+  if (!Number.isFinite(nowMs)) return false;
+  const elapsedMs = nowMs - state.startedAtMs;
+  if (elapsedMs < Math.max(0, config2.idleStartMs)) return false;
+  const ageMs = getStreamLastContentResponseAgeMs(state, nowMs);
+  return ageMs != null && ageMs >= Math.max(1e3, config2.heartbeatMs);
+}
+function buildStreamRuntimeStatus(state, nowMs, options = {}) {
+  return formatStreamRuntimeStatus(
+    Math.max(0, nowMs - state.startedAtMs),
+    options.includeLastContentResponseAge ? getStreamLastContentResponseAgeMs(state, nowMs) : null,
+    state.statusNote
+  );
+}
+
 // src/lib/bridge/interactive-message-runner.ts
 function generateDraftId() {
   return Math.floor(Math.random() * 2147483646) + 1;
@@ -13930,18 +14294,6 @@ function flushPreview(adapter, state, config2) {
   }).catch(() => {
   });
 }
-function formatRuntimeDuration(ms) {
-  const totalSeconds = Math.max(0, Math.floor(ms / 1e3));
-  const seconds = totalSeconds % 60;
-  const totalMinutes = Math.floor(totalSeconds / 60);
-  const minutes = totalMinutes % 60;
-  const hours = Math.floor(totalMinutes / 60);
-  const parts = [];
-  if (hours > 0) parts.push(`${hours}\u5C0F\u65F6`);
-  if (minutes > 0) parts.push(`${minutes}\u5206`);
-  if (seconds > 0 || parts.length === 0) parts.push(`${seconds}\u79D2`);
-  return parts.join("");
-}
 function pathBaseName(value) {
   return value.includes("\\") ? path13.win32.basename(value) : path13.basename(value);
 }
@@ -13963,18 +14315,10 @@ function buildStaleTaskCompletionNotice(address, binding) {
   const taskName = formatTaskDisplayName(binding);
   return `\u65E7\u4F1A\u8BDD\u300C${taskName}\u300D\u4EFB\u52A1\u5DF2\u7ED3\u675F\uFF0C\u4F46\u5F53\u524D\u804A\u5929\u5DF2\u5207\u6362\u5230\u5176\u4ED6\u4F1A\u8BDD\uFF0C\u56DE\u590D\u5DF2\u8DF3\u8FC7\u3002`;
 }
-function formatInteractiveRuntimeStatus(elapsedMs, lastResponseAgeMs, statusNote) {
-  const parts = [elapsedMs < 1e3 ? "\u5904\u7406\u4E2D" : `\u5DF2\u8FD0\u884C ${formatRuntimeDuration(elapsedMs)}`];
-  if (typeof lastResponseAgeMs === "number" && lastResponseAgeMs >= 0) {
-    parts.push(`\u4E0A\u6B21\u54CD\u5E94\u8DDD\u4ECA ${formatRuntimeDuration(lastResponseAgeMs)}`);
-  }
-  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);
+  const initialSession = getBridgeContext().store.getSession(binding.codepilotSessionId);
+  const desktopThreadId = getExplicitDesktopThreadId(initialSession);
   const streamKey = buildInteractiveStreamKey(binding.codepilotSessionId, msg.messageId);
   const nowMs = deps.nowMs ?? (() => Date.now());
   const setIntervalFn = deps.setIntervalFn ?? ((callback, intervalMs) => setInterval(callback, intervalMs));
@@ -14000,11 +14344,14 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
   const taskAbort = new AbortController();
   const taskId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
   const taskStartedAt = nowMs();
+  const streamState = createStreamState(taskStartedAt);
   let externalTerminalRequest = null;
+  let desktopTerminalFinalExpected = false;
   let resolveExternalTerminal = null;
   const externalTerminalPromise = new Promise((resolve2) => {
     resolveExternalTerminal = resolve2;
   });
+  let processResultSettled = false;
   let resolveExternalTerminalCompletion = null;
   let externalTerminalCompletionSettled = false;
   const externalTerminalCompletion = new Promise((resolve2) => {
@@ -14028,6 +14375,7 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     structuredStreamUiActive: false,
     lastActivityAt: taskStartedAt,
     lastResponseAt: null,
+    lastContentResponseAt: null,
     streamFinalized: false,
     uiEnded: false,
     mirrorSuppressionId: null,
@@ -14036,13 +14384,26 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
       if (!deps.isCurrentInteractiveTask(binding.codepilotSessionId, taskId)) return false;
       externalTerminalRequest = { outcome, detail, finalText };
       resolveExternalTerminal?.(externalTerminalRequest);
-      if (!taskAbort.signal.aborted) {
+      if (!processResultSettled && !taskAbort.signal.aborted) {
         taskAbort.abort();
       }
       return externalTerminalCompletion;
     }
   };
   deps.registerInteractiveTask(taskState);
+  deps.registerBridgeTurn?.({
+    id: taskId,
+    sessionId: binding.codepilotSessionId,
+    kind: desktopThreadId ? "im_desktop_reuse" : "im_sdk",
+    origin: "im",
+    progressSource: "sdk_stream",
+    finalSource: desktopThreadId ? "desktop_task_complete" : "sdk_result",
+    codexThreadId: binding.sdkSessionId || initialSession?.codex_thread_id || initialSession?.sdk_session_id || void 0,
+    desktopThreadId,
+    requestMessageId: msg.messageId,
+    streamKey,
+    startedAt: taskStartedAt
+  });
   deps.recordInteractiveHealthStart(binding.codepilotSessionId);
   let previewState = null;
   const caps = adapter.getPreviewCapabilities?.(msg.address.chatId) ?? null;
@@ -14062,7 +14423,7 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     const ps = previewState;
     const cfg = streamCfg;
     if (ps.degraded) return;
-    const sanitizedText = stripOutboundArtifactBlocksForStreaming(fullText);
+    const sanitizedText = stripFinalOnlyBlocksForStreaming(fullText);
     ps.pendingText = sanitizedText.length > cfg.maxChars ? sanitizedText.slice(0, cfg.maxChars) + "..." : sanitizedText;
     const delta = ps.pendingText.length - ps.lastSentText.length;
     const elapsed = Date.now() - ps.lastSentAt;
@@ -14104,7 +14465,6 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
   };
   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;
@@ -14123,12 +14483,22 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     if (!supportsStructuredStreamUi || streamStatusUpdatesClosed) return;
     pushStreamFeedbackStatus(
       streamFeedbackTarget,
-      formatInteractiveRuntimeStatus(nowMs() - taskStartedAt, lastResponseAgeMs, latestStatusNote)
+      lastResponseAgeMs == null ? buildStreamRuntimeStatus(streamState, nowMs()) : formatStreamRuntimeStatus(nowMs() - taskStartedAt, lastResponseAgeMs, streamState.statusNote)
     );
     syncStructuredStreamUiSnapshot();
   };
-  const markSuccessfulResponse = () => {
-    taskState.lastResponseAt = nowMs();
+  const markActivity = () => {
+    const now2 = nowMs();
+    recordStreamActivity(streamState, now2);
+    taskState.lastActivityAt = streamState.lastActivityAtMs;
+    deps.touchInteractiveTask(binding.codepilotSessionId, taskId);
+  };
+  const markContentResponse = () => {
+    const now2 = nowMs();
+    recordStreamContentResponse(streamState, now2);
+    taskState.lastActivityAt = streamState.lastActivityAtMs;
+    taskState.lastResponseAt = streamState.lastContentResponseAtMs;
+    taskState.lastContentResponseAt = streamState.lastContentResponseAtMs;
     deps.touchInteractiveTask(binding.codepilotSessionId, taskId);
   };
   let streamStatusHeartbeat = null;
@@ -14167,10 +14537,10 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     endPreviewOnce();
     if (hasStreamingCards && !streamUiFinalizeAttempted) {
       streamUiFinalizeAttempted = true;
-      taskState.streamFinalized = await finalizeStreamFeedback(
+      taskState.streamFinalized = await finalizeStreamingUi(
         streamFeedbackTarget,
         status,
-        responseText
+        assembleDesktopFinalResponse({ text: responseText })
       );
     }
     return taskState.streamFinalized;
@@ -14184,12 +14554,12 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     if (!deps.isCurrentInteractiveTask(binding.codepilotSessionId, taskId)) return;
     pushStreamFeedbackText(
       streamFeedbackTarget,
-      stripOutboundArtifactBlocksForStreaming(fullText)
+      stripFinalOnlyBlocksForStreaming(fullText)
     );
   } : void 0;
   const onToolEvent = (toolId, toolName, status) => {
     if (!deps.isCurrentInteractiveTask(binding.codepilotSessionId, taskId)) return;
-    markSuccessfulResponse();
+    markActivity();
     deps.recordInteractiveHealthTool(binding.codepilotSessionId, toolId, toolName, status);
     if (toolName) {
       toolCallTracker.set(toolId, { id: toolId, name: toolName, status });
@@ -14205,7 +14575,7 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
   };
   const onTaskEvent = (tasks) => {
     if (!deps.isCurrentInteractiveTask(binding.codepilotSessionId, taskId)) return;
-    markSuccessfulResponse();
+    markActivity();
     latestTasks = tasks;
     if (hasStreamingCards) {
       pushStreamFeedbackTasks(streamFeedbackTarget, latestTasks);
@@ -14215,17 +14585,15 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
   };
   const onStatusNote = (note) => {
     if (!deps.isCurrentInteractiveTask(binding.codepilotSessionId, taskId)) return;
-    latestStatusNote = (note || "").trim() || null;
-    if (latestStatusNote) {
-      markSuccessfulResponse();
-    }
+    updateStreamStatusNote(streamState, note, nowMs());
+    if (streamState.statusNote) markActivity();
     pushRunningStatus(null);
     syncStructuredStreamUiSnapshot();
   };
   const onPartialText = (fullText) => {
     if (!deps.isCurrentInteractiveTask(binding.codepilotSessionId, taskId)) return;
     if (fullText.trim()) {
-      markSuccessfulResponse();
+      markContentResponse();
     }
     deps.recordInteractiveHealthProgress(binding.codepilotSessionId, "text");
     previewOnPartialText?.(fullText);
@@ -14233,6 +14601,34 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     pushRunningStatus(null);
     syncStructuredStreamUiSnapshot();
   };
+  const waitForDesktopTerminalFinalization = async () => {
+    if (externalTerminalRequest) return externalTerminalRequest;
+    const timeoutMs = Math.max(0, deps.desktopTerminalFinalizationTimeoutMs ?? 0);
+    if (!desktopThreadId || !desktopTerminalFinalExpected || timeoutMs <= 0) return null;
+    if (taskAbort.signal.aborted) return null;
+    return new Promise((resolve2) => {
+      let settled = false;
+      let timer = null;
+      const finish = (terminal) => {
+        if (settled) return;
+        settled = true;
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        taskAbort.signal.removeEventListener("abort", onAbort);
+        resolve2(terminal);
+      };
+      const onAbort = () => finish(null);
+      timer = setTimeout(() => finish(null), timeoutMs);
+      taskAbort.signal.addEventListener("abort", onAbort, { once: true });
+      externalTerminalPromise.then((terminal) => {
+        finish(terminal);
+      }, () => {
+        finish(null);
+      });
+    });
+  };
   if (supportsStructuredStreamUi) {
     pushRunningStatus(null);
     streamStatusHeartbeat = setIntervalFn(() => {
@@ -14245,8 +14641,10 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
         return;
       }
       const elapsedMs = nowMs() - taskStartedAt;
-      const lastResponseAgeMs = taskState.lastResponseAt == null ? null : nowMs() - taskState.lastResponseAt;
-      const showLastResponseAge = elapsedMs >= streamStatusIdleDetectionStartMs && lastResponseAgeMs != null && lastResponseAgeMs >= streamStatusHeartbeatMs ? lastResponseAgeMs : null;
+      const showLastResponseAge = shouldShowStreamLastContentResponseAge(streamState, nowMs(), {
+        idleStartMs: streamStatusIdleDetectionStartMs,
+        heartbeatMs: streamStatusHeartbeatMs
+      }) ? getStreamLastContentResponseAgeMs(streamState, nowMs()) : null;
       pushRunningStatus(showLastResponseAge);
       syncStructuredStreamUiSnapshot();
     }, streamStatusHeartbeatMs);
@@ -14254,6 +14652,22 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
   let finalOutcome = "failed";
   let finalOutcomeDetail;
   let shouldRecordHealthEnd = true;
+  let forceStopStarted = false;
+  taskState.forceStop = async (detail = "\u4EFB\u52A1\u5DF2\u6536\u5230\u505C\u6B62\u8BF7\u6C42\u3002") => {
+    if (forceStopStarted) return true;
+    forceStopStarted = true;
+    finalOutcome = "aborted";
+    finalOutcomeDetail = detail;
+    taskAbort.abort();
+    stopStructuredStreamStatusUpdates();
+    endPreviewOnce();
+    try {
+      await finalizeStreamUiOnce("interrupted", detail);
+    } catch {
+    }
+    endMessageUiOnce();
+    return true;
+  };
   try {
     const promptText = text2 || (attachments && attachments.length > 0 ? "Describe this image." : "");
     const processPromise = processMessageImpl(
@@ -14275,7 +14689,7 @@ 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`
         );
-        markSuccessfulResponse();
+        markActivity();
         pushRunningStatus(null);
         syncStructuredStreamUiSnapshot();
       },
@@ -14286,7 +14700,10 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
       onTaskEvent,
       onStatusNote,
       (preparedPrompt) => {
-        if (!taskState.mirrorSuppressionId) {
+        if (desktopThreadId) {
+          desktopTerminalFinalExpected = true;
+        }
+        if (desktopThreadId && !taskState.mirrorSuppressionId) {
           taskState.mirrorSuppressionId = deps.beginMirrorSuppression(binding.codepilotSessionId, preparedPrompt);
         }
       }
@@ -14308,73 +14725,87 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
       finalOutcomeDetail = raced.terminal.detail;
       const streamEndStatus = raced.terminal.outcome === "completed" ? "completed" : raced.terminal.outcome === "aborted" ? "interrupted" : "error";
       const staleTaskNotice2 = buildStaleTaskCompletionNotice(msg.address, binding);
-      const terminalText = staleTaskNotice2 || raced.terminal.finalText || "";
-      const cardFinalized2 = await finalizeStreamUiOnce(streamEndStatus, terminalText);
-      if (!cardFinalized2 && terminalText) {
-        await deps.deliverResponse(
+      const terminalResponse2 = assembleDesktopFinalResponse({
+        text: staleTaskNotice2 || raced.terminal.finalText || ""
+      });
+      const cardFinalized2 = await finalizeStreamUiOnce(streamEndStatus, terminalResponse2.text);
+      if (hasFinalResponsePayload(terminalResponse2)) {
+        await deliverFinalResponse({
           adapter,
-          msg.address,
-          terminalText,
-          binding.codepilotSessionId,
-          msg.messageId,
-          []
-        );
+          address: msg.address,
+          sessionId: binding.codepilotSessionId,
+          replyToMessageId: msg.messageId,
+          deliverResponse: deps.deliverResponse
+        }, terminalResponse2, { skipText: cardFinalized2 });
       }
       return;
     }
     const result = raced.result;
+    processResultSettled = true;
     if (!deps.isCurrentInteractiveTask(binding.codepilotSessionId, taskId)) {
       shouldRecordHealthEnd = false;
       return;
     }
+    const terminalAfterProcess = await waitForDesktopTerminalFinalization();
+    const terminalResponse = terminalAfterProcess?.outcome === "completed" ? assembleDesktopFinalResponse({ text: terminalAfterProcess.finalText || "" }) : null;
+    const sdkResponse = assembleSdkFinalResponse({
+      text: result.responseText,
+      attachments: result.outboundAttachments,
+      hasError: result.hasError,
+      errorMessage: result.errorMessage
+    });
+    const terminalHasFinalPayload = Boolean(
+      terminalResponse && hasFinalResponsePayload(terminalResponse)
+    );
+    const effectiveResponse = terminalResponse && terminalHasFinalPayload ? mergeFinalResponses(terminalResponse, sdkResponse) : sdkResponse;
     let cardFinalized = false;
     const staleTaskNotice = buildStaleTaskCompletionNotice(msg.address, binding);
+    const staleResponse = staleTaskNotice ? assembleDesktopFinalResponse({ text: staleTaskNotice }) : null;
     if (hasStreamingCards) {
-      const streamEndStatus = taskAbort.signal.aborted ? "interrupted" : result.hasError ? "error" : "completed";
+      const streamEndStatus = terminalAfterProcess ? terminalAfterProcess.outcome === "completed" ? "completed" : terminalAfterProcess.outcome === "aborted" ? "interrupted" : "error" : taskAbort.signal.aborted ? "interrupted" : result.hasError ? "error" : "completed";
       cardFinalized = await finalizeStreamUiOnce(
         streamEndStatus,
-        staleTaskNotice || (streamEndStatus === "interrupted" ? "" : result.responseText)
+        staleResponse?.text || (streamEndStatus === "interrupted" ? "" : effectiveResponse.text)
       );
     }
-    if (staleTaskNotice) {
-      if (!cardFinalized) {
-        await deps.deliverResponse(
-          adapter,
-          msg.address,
-          staleTaskNotice,
-          binding.codepilotSessionId,
-          msg.messageId,
-          []
-        );
-      }
-    } else if (result.responseText || result.outboundAttachments.length > 0) {
-      const textToDeliver = cardFinalized ? "" : result.responseText;
-      if (!cardFinalized || result.outboundAttachments.length > 0) {
-        await deps.deliverResponse(
-          adapter,
-          msg.address,
-          textToDeliver,
-          binding.codepilotSessionId,
-          msg.messageId,
-          result.outboundAttachments
-        );
-      }
-    } else if (result.hasError && !taskAbort.signal.aborted) {
-      await deps.deliverResponse(
+    if (staleResponse) {
+      await deliverFinalResponse({
         adapter,
-        msg.address,
-        `**Error:** ${result.errorMessage}`,
-        binding.codepilotSessionId,
-        msg.messageId,
-        []
+        address: msg.address,
+        sessionId: binding.codepilotSessionId,
+        replyToMessageId: msg.messageId,
+        deliverResponse: deps.deliverResponse
+      }, staleResponse, { skipText: cardFinalized });
+    } else if (hasFinalResponsePayload(effectiveResponse)) {
+      await deliverFinalResponse({
+        adapter,
+        address: msg.address,
+        sessionId: binding.codepilotSessionId,
+        replyToMessageId: msg.messageId,
+        deliverResponse: deps.deliverResponse
+      }, effectiveResponse, { skipText: cardFinalized });
+    } else if (result.hasError && !taskAbort.signal.aborted) {
+      await deliverFinalResponse(
+        {
+          adapter,
+          address: msg.address,
+          sessionId: binding.codepilotSessionId,
+          replyToMessageId: msg.messageId,
+          deliverResponse: deps.deliverResponse
+        },
+        assembleSdkFinalResponse({
+          text: `**Error:** ${result.errorMessage}`,
+          hasError: true,
+          errorMessage: result.errorMessage
+        })
       );
     }
     try {
       deps.persistSdkSessionUpdate(binding.codepilotSessionId, result.sdkSessionId, result.hasError);
     } catch {
     }
-    finalOutcome = result.hasError ? "failed" : "completed";
-    finalOutcomeDetail = result.hasError ? result.errorMessage?.trim() || void 0 : void 0;
+    finalOutcome = terminalAfterProcess?.outcome || (result.hasError ? "failed" : "completed");
+    finalOutcomeDetail = terminalAfterProcess?.detail || (result.hasError ? result.errorMessage?.trim() || void 0 : void 0);
   } finally {
     await finalizeStreamUiOnce(
       taskAbort.signal.aborted ? "interrupted" : finalOutcome === "completed" ? "completed" : "error",
@@ -14391,11 +14822,12 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     if (shouldRecordHealthEnd) {
       if (taskAbort.signal.aborted && !externalTerminalRequest) {
         finalOutcome = "aborted";
-        finalOutcomeDetail = "\u4EFB\u52A1\u5DF2\u6536\u5230\u505C\u6B62\u8BF7\u6C42\u3002";
+        finalOutcomeDetail = finalOutcomeDetail || "\u4EFB\u52A1\u5DF2\u6536\u5230\u505C\u6B62\u8BF7\u6C42\u3002";
       }
       deps.recordInteractiveHealthEnd(binding.codepilotSessionId, finalOutcome, finalOutcomeDetail);
     }
     deps.releaseInteractiveTask(binding.codepilotSessionId, taskId);
+    deps.releaseBridgeTurn?.(binding.codepilotSessionId, taskId);
     endMessageUiOnce();
     settleExternalTerminalCompletion(taskState.streamFinalized || !hasStreamingCards);
   }
@@ -14410,13 +14842,14 @@ var TERMINAL_SESSION_HEALTH_STATUSES = /* @__PURE__ */ new Set([
 function isTerminalSessionHealthStatus(status) {
   return Boolean(status && TERMINAL_SESSION_HEALTH_STATUSES.has(status));
 }
-function terminalOutcomeFromHealthStatus(status) {
-  if (status === "completed") return "completed";
-  if (status === "failed") return "failed";
-  if (status === "aborted") return "aborted";
-  return null;
-}
 function createInteractiveRuntime(getState2, deps) {
+  const sessionLockVersions = /* @__PURE__ */ new Map();
+  function getSessionLockVersion(sessionId) {
+    return sessionLockVersions.get(sessionId) || 0;
+  }
+  function invalidateSessionLockQueue(sessionId) {
+    sessionLockVersions.set(sessionId, getSessionLockVersion(sessionId) + 1);
+  }
   function getQueuedCount(sessionId) {
     return getState2().queuedCounts.get(sessionId) || 0;
   }
@@ -14463,18 +14896,28 @@ function createInteractiveRuntime(getState2, deps) {
     if (!task?.finalizeFromExternalTerminal) return false;
     return task.finalizeFromExternalTerminal(outcome, detail, finalText);
   }
+  async function forceStopSession(sessionId, detail) {
+    const state = getState2();
+    const task = state.activeTasks.get(sessionId);
+    let handled = false;
+    if (task?.forceStop) {
+      handled = await task.forceStop(detail);
+    } else if (task) {
+      task.abortController.abort();
+      handled = true;
+    }
+    state.activeTasks.delete(sessionId);
+    state.queuedCounts.delete(sessionId);
+    state.sessionLocks.delete(sessionId);
+    invalidateSessionLockQueue(sessionId);
+    syncSessionRuntimeState(sessionId);
+    return handled;
+  }
   async function reconcileTerminalSessionRuntimeState() {
     const store = deps.getStore();
     for (const session of store.listSessions()) {
       if (!isTerminalSessionHealthStatus(session.health_status)) continue;
-      const activeTask = getState2().activeTasks.get(session.id);
-      if (activeTask) {
-        const outcome = terminalOutcomeFromHealthStatus(session.health_status);
-        if (outcome) {
-          await finalizeTerminalActiveTask(session.id, outcome, session.health_reason || void 0);
-        }
-        continue;
-      }
+      if (getState2().activeTasks.has(session.id)) continue;
       const queuedCount = getQueuedCount(session.id);
       const persistedQueuedCount = session.queued_count && session.queued_count > 0 ? session.queued_count : 0;
       if (queuedCount > 0) continue;
@@ -14521,6 +14964,7 @@ function createInteractiveRuntime(getState2, deps) {
     const state = getState2();
     const prev = state.sessionLocks.get(sessionId) || Promise.resolve();
     const queued = state.sessionLocks.has(sessionId);
+    const lockVersion = getSessionLockVersion(sessionId);
     if (queued) {
       incrementQueuedCount(sessionId);
     }
@@ -14528,6 +14972,7 @@ function createInteractiveRuntime(getState2, deps) {
       if (queued) {
         decrementQueuedCount(sessionId);
       }
+      if (getSessionLockVersion(sessionId) !== lockVersion) return;
       await fn();
     };
     const current = prev.then(wrapped, wrapped);
@@ -14549,6 +14994,7 @@ function createInteractiveRuntime(getState2, deps) {
     releaseInteractiveTask,
     syncSessionRuntimeState,
     finalizeTerminalActiveTask,
+    forceStopSession,
     reconcileTerminalSessionRuntimeState,
     resetPersistedInteractiveRuntimeState,
     processWithSessionLock
@@ -14887,7 +15333,7 @@ function buildMirrorSubscriptionRegistryPlan(bindings, activeChannelTypes, exist
     if (binding.active === false) return false;
     if (!activeChannels.has(binding.channelType)) return false;
     const session = getSession(binding.codepilotSessionId);
-    return Boolean(binding.sdkSessionId || session?.sdk_session_id);
+    return Boolean(session?.desktop_thread_id || (session?.thread_origin === "desktop" ? session.sdk_session_id : null));
   });
   const desiredIds = new Set(upsertBindings.map((binding) => binding.id));
   const removeBindingIds = Array.from(existingBindingIds).filter((bindingId) => !desiredIds.has(bindingId));
@@ -14981,11 +15427,17 @@ function createMirrorRuntime(getState2, options, deps) {
   function clearDanglingMirrorThread(subscription, reason) {
     const { store } = getBridgeContext();
     const session = store.getSession(subscription.sessionId);
-    const currentThreadId = session?.sdk_session_id || subscription.threadId;
+    const currentThreadId = getExplicitDesktopThreadId(session) || subscription.threadId;
     console.warn(
       `[bridge-manager] Clearing dangling desktop thread ${currentThreadId} for session ${subscription.sessionId}: ${reason}`
     );
     store.updateSdkSessionId(subscription.sessionId, "");
+    store.updateSession(subscription.sessionId, {
+      sdk_session_id: "",
+      codex_thread_id: void 0,
+      desktop_thread_id: void 0,
+      thread_origin: void 0
+    });
     removeMirrorSubscription(subscription.bindingId);
   }
   function upsertMirrorSubscription(binding) {
@@ -14996,7 +15448,7 @@ function createMirrorRuntime(getState2, options, deps) {
       removeMirrorSubscription(binding.id);
       return;
     }
-    const threadId = binding.sdkSessionId || session.sdk_session_id || "";
+    const threadId = getExplicitDesktopThreadId(session) || "";
     if (!threadId) {
       removeMirrorSubscription(binding.id);
       return;
@@ -15109,11 +15561,13 @@ function createMirrorRuntime(getState2, options, deps) {
         `[bridge-manager] Unhandled desktop mirror event for thread ${subscription.threadId}: ${kind}`
       );
     }
-    if (deliverableRecords.length > 0) {
-      deps.observeSessionHealthRecords(subscription.sessionId, subscription.threadId, deliverableRecords);
+    const routeResult = deliverableRecords.length > 0 && deps.routeDesktopRecords ? await deps.routeDesktopRecords(subscription.sessionId, subscription.threadId, deliverableRecords) : { claimed: [], unclaimed: deliverableRecords, terminalClaimed: false };
+    const mirrorRecords = routeResult.unclaimed;
+    if (mirrorRecords.length > 0) {
+      deps.observeSessionHealthRecords(subscription.sessionId, subscription.threadId, mirrorRecords);
     }
-    const blocked = getState2().activeTasks.has(subscription.sessionId) || deps.isMirrorSuppressed(subscription.sessionId);
-    const deliveryPlan = buildMirrorDeliveryPlan(subscription, deliverableRecords, {
+    const blocked = getState2().activeTasks.has(subscription.sessionId);
+    const deliveryPlan = buildMirrorDeliveryPlan(subscription, mirrorRecords, {
       blocked,
       filterSuppressedRecords: deps.filterSuppressedMirrorRecords,
       flushTimedOutTurn: (currentSubscription) => deps.flushTimedOutMirrorTurn(currentSubscription),
@@ -15210,6 +15664,241 @@ function createMirrorRuntime(getState2, options, deps) {
   };
 }
 
+// src/lib/bridge/mirror-feedback-controller.ts
+function createMirrorStreamFeedbackTarget(subscription, turnState, adapter, startMirrorStreaming) {
+  return {
+    adapter,
+    channelType: subscription.channelType,
+    chatId: subscription.chatId,
+    streamKey: turnState.streamKey,
+    ensureStarted: () => {
+      startMirrorStreaming(subscription, turnState);
+    }
+  };
+}
+function createMirrorFeedbackController(deps) {
+  function getMirrorStreamingAdapter(subscription) {
+    const adapter = deps.getAdapter(subscription.channelType);
+    if (!adapter || !adapter.isRunning()) return null;
+    if (getChannelProviderKey(subscription.channelType) !== "feishu") return null;
+    if (typeof adapter.onStreamText !== "function" || typeof adapter.onStreamEnd !== "function") {
+      return null;
+    }
+    return adapter;
+  }
+  function getMirrorStreamingText(subscription, turnState) {
+    const title = deps.getThreadTitle(subscription.threadId)?.trim() || "\u684C\u9762\u7EBF\u7A0B";
+    const markdown = getFeedbackParseMode(subscription.channelType) === "Markdown";
+    const rendered = formatMirrorMessage(
+      title,
+      turnState.userText,
+      stripOutboundArtifactBlocksForStreaming(turnState.streamedText),
+      markdown,
+      true
+    );
+    return rendered || buildMirrorTitle(title, markdown);
+  }
+  function startMirrorStreaming(subscription, turnState) {
+    const adapter = getMirrorStreamingAdapter(subscription);
+    if (!adapter || turnState.streamStarted) return;
+    try {
+      adapter.onMirrorStreamStart?.(subscription.chatId, turnState.streamKey);
+      if (!adapter.onMirrorStreamStart) {
+        adapter.onStreamText?.(subscription.chatId, "", turnState.streamKey);
+      }
+      turnState.streamStarted = true;
+    } catch {
+    }
+  }
+  function createStreamTarget(subscription, turnState, adapter) {
+    return createMirrorStreamFeedbackTarget(subscription, turnState, adapter, startMirrorStreaming);
+  }
+  function pushMirrorStreamingStatus(subscription, turnState, options = {}) {
+    const adapter = getMirrorStreamingAdapter(subscription);
+    if (!adapter || typeof adapter.onStreamStatus !== "function") return;
+    if (!(adapter.supportsStructuredStreamingUi?.(subscription.chatId) ?? true)) return;
+    const startedAtMs = Date.parse(turnState.startedAt);
+    if (!Number.isFinite(startedAtMs)) return;
+    const nowMs = options.nowMs ?? Date.now();
+    const minIntervalMs = Math.max(0, options.minIntervalMs ?? 0);
+    if (minIntervalMs > 0 && turnState.lastStatusAt > 0 && nowMs - turnState.lastStatusAt < minIntervalMs) {
+      return;
+    }
+    const statusText = formatStreamRuntimeStatus(
+      Math.max(0, nowMs - startedAtMs),
+      options.lastResponseAgeMs,
+      turnState.statusNote
+    );
+    if (turnState.lastStatusText === statusText) return;
+    const pushed = pushStreamFeedbackStatus(
+      createStreamTarget(subscription, turnState, adapter),
+      statusText
+    );
+    if (!pushed) return;
+    turnState.lastStatusText = statusText;
+    turnState.lastStatusAt = nowMs;
+  }
+  function refreshMirrorStreamingStatus2(subscription, nowMs = Date.now(), config2) {
+    const pendingTurn = subscription.pendingTurn;
+    if (!pendingTurn?.streamStarted) return;
+    const startedAtMs = Date.parse(pendingTurn.startedAt);
+    if (!Number.isFinite(startedAtMs)) return;
+    const lastContentResponseAtMs = pendingTurn.lastContentResponseAt ? Date.parse(pendingTurn.lastContentResponseAt) : pendingTurn.lastResponseAt ? Date.parse(pendingTurn.lastResponseAt) : null;
+    const streamState = {
+      startedAtMs,
+      lastContentResponseAtMs: Number.isFinite(lastContentResponseAtMs) ? lastContentResponseAtMs : null
+    };
+    if (!shouldShowStreamLastContentResponseAge(streamState, nowMs, config2)) return;
+    pushMirrorStreamingStatus(subscription, pendingTurn, {
+      nowMs,
+      lastResponseAgeMs: getStreamLastContentResponseAgeMs(streamState, nowMs),
+      minIntervalMs: config2.heartbeatMs
+    });
+  }
+  function updateMirrorStreaming(subscription, turnState) {
+    const adapter = getMirrorStreamingAdapter(subscription);
+    if (!adapter) return;
+    pushStreamFeedbackText(
+      createStreamTarget(subscription, turnState, adapter),
+      getMirrorStreamingText(subscription, turnState)
+    );
+    pushMirrorStreamingStatus(subscription, turnState);
+  }
+  function updateMirrorToolProgress(subscription, turnState) {
+    const adapter = getMirrorStreamingAdapter(subscription);
+    if (!adapter) return;
+    pushStreamFeedbackTools(
+      createStreamTarget(subscription, turnState, adapter),
+      Array.from(turnState.toolCalls.values())
+    );
+    pushMirrorStreamingStatus(subscription, turnState);
+  }
+  function updateMirrorTaskProgress(subscription, turnState) {
+    const adapter = getMirrorStreamingAdapter(subscription);
+    if (!adapter) return;
+    pushStreamFeedbackTasks(
+      createStreamTarget(subscription, turnState, adapter),
+      turnState.taskItems
+    );
+    pushMirrorStreamingStatus(subscription, turnState);
+  }
+  function updateMirrorStatusProgress(subscription, turnState) {
+    const adapter = getMirrorStreamingAdapter(subscription);
+    if (!adapter) return;
+    pushMirrorStreamingStatus(subscription, turnState);
+  }
+  function stopMirrorStreaming2(subscription, status = "interrupted") {
+    const adapter = getMirrorStreamingAdapter(subscription);
+    const pendingTurn = subscription.pendingTurn;
+    if (!adapter || !pendingTurn?.streamStarted) return;
+    void finalizeStreamFeedback(
+      createStreamTarget(subscription, pendingTurn, adapter),
+      status,
+      getMirrorStreamingText(subscription, pendingTurn)
+    );
+  }
+  async function deliverMirrorTurn(subscription, turn) {
+    const adapter = deps.getAdapter(subscription.channelType);
+    if (!adapter || !adapter.isRunning()) return;
+    const title = deps.getThreadTitle(subscription.threadId)?.trim() || "\u684C\u9762\u7EBF\u7A0B";
+    const responseParseMode = getFeedbackParseMode(subscription.channelType);
+    const markdown = responseParseMode === "Markdown";
+    const rawFinalResponse = assembleDesktopFinalResponse({ text: turn.text });
+    const attachments = rawFinalResponse.attachments;
+    const cleanTurnText = rawFinalResponse.text;
+    const renderedTextBase = formatMirrorMessage(title, turn.userText, cleanTurnText, markdown);
+    const renderedStreamTextBase = formatMirrorMessage(title, turn.userText, cleanTurnText, markdown, true);
+    const renderedText = turn.timedOut ? appendMirrorTimeoutNotice(renderedTextBase || buildMirrorTitle(title, markdown), markdown) : renderedTextBase;
+    const renderedStreamText = turn.timedOut ? appendMirrorTimeoutNotice(renderedStreamTextBase || buildMirrorTitle(title, markdown), markdown) : renderedStreamTextBase;
+    const text2 = renderedText ? renderFeedbackText(renderedText, responseParseMode) : "";
+    const streamText = renderFeedbackText(
+      renderedStreamText || buildMirrorTitle(title, markdown),
+      responseParseMode
+    );
+    const address = {
+      channelType: subscription.channelType,
+      chatId: subscription.chatId
+    };
+    if (getChannelProviderKey(subscription.channelType) === "feishu" && typeof adapter.onStreamEnd === "function") {
+      try {
+        const finalized = await adapter.onStreamEnd(
+          subscription.chatId,
+          turn.status,
+          streamText,
+          turn.streamKey
+        );
+        if (finalized) {
+          if (attachments.length > 0) {
+            const attachmentResult = await deliverFinalResponse(
+              {
+                adapter,
+                address,
+                sessionId: subscription.sessionId,
+                deliverResponse: deps.deliverResponse
+              },
+              assembleDesktopFinalResponse({ attachments }),
+              { skipText: true }
+            );
+            if (!attachmentResult.ok) {
+              throw new Error(attachmentResult.error || "mirror attachment delivery failed");
+            }
+          }
+          subscription.lastDeliveredAt = turn.timestamp || deps.nowIso();
+          return;
+        }
+      } catch (error) {
+        console.warn("[bridge-manager] Mirror stream finalize failed:", error instanceof Error ? error.message : error);
+      }
+    }
+    const finalResponse = assembleDesktopFinalResponse({
+      text: text2,
+      attachments
+    });
+    if (!finalResponse.text && finalResponse.attachments.length === 0) return;
+    const response = await deliverFinalResponse({
+      adapter,
+      address,
+      sessionId: subscription.sessionId,
+      deliverResponse: deps.deliverResponse,
+      deliverText: async (messageText) => deliver(adapter, {
+        address,
+        text: messageText,
+        parseMode: responseParseMode
+      }, {
+        sessionId: subscription.sessionId,
+        dedupKey: `mirror:${subscription.bindingId}:${turn.signature}`
+      })
+    }, finalResponse);
+    if (!response.ok) {
+      throw new Error(response.error || "mirror delivery failed");
+    }
+    subscription.lastDeliveredAt = turn.timestamp || deps.nowIso();
+  }
+  async function deliverMirrorTurns2(subscription, turns) {
+    let deliveredCount = 0;
+    for (const turn of turns.slice(0, deps.eventBatchLimit)) {
+      try {
+        await deliverMirrorTurn(subscription, turn);
+        deliveredCount += 1;
+      } catch (error) {
+        return { deliveredCount, error };
+      }
+    }
+    return { deliveredCount };
+  }
+  return {
+    hooks: {
+      onStreamText: updateMirrorStreaming,
+      onStatusProgress: updateMirrorStatusProgress,
+      onTaskProgress: updateMirrorTaskProgress,
+      onToolProgress: updateMirrorToolProgress
+    },
+    refreshMirrorStreamingStatus: refreshMirrorStreamingStatus2,
+    stopMirrorStreaming: stopMirrorStreaming2,
+    deliverMirrorTurns: deliverMirrorTurns2
+  };
+}
+
 // src/lib/bridge/session-health-process.ts
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -15302,7 +15991,6 @@ async function probeCodexThreadProcess(threadId) {
 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",
@@ -15435,14 +16123,34 @@ function computeBaseDiagnosis(session, nowMs) {
   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 checkedAt = trimOrNull(session.last_health_check_at);
   const lastProgressMs = parseIsoMs(lastProgressAt || void 0);
   const previousStatus = session.health_status || "idle";
+  if (!isRunningRuntimeStatus(runtimeStatus) && isRunningHealthStatus(previousStatus)) {
+    return {
+      sessionId: session.id,
+      checkedAt: null,
+      runtimeStatus,
+      healthStatus: "idle",
+      healthReason: "\u5F53\u524D\u6CA1\u6709\u8FD0\u884C\u4E2D\u7684\u4EFB\u52A1\u3002",
+      lastProgressAt,
+      lastProgressType,
+      activeToolName,
+      activeToolStartedAt,
+      lastToolFinishedAt,
+      lastStreamUiAttemptAt,
+      lastStreamUiUpdateAt,
+      streamUiFlushStartedAt,
+      lastStreamUiErrorAt,
+      lastStreamUiError,
+      streamUiConsecutiveFailures,
+      sdkSessionId
+    };
+  }
   if (!lastProgressMs) {
     const fallbackStatus = isRunningRuntimeStatus(runtimeStatus) ? "running_active" : previousStatus;
     return {
       sessionId: session.id,
-      checkedAt,
+      checkedAt: null,
       runtimeStatus,
       healthStatus: fallbackStatus,
       healthReason: session.health_reason?.trim() || (fallbackStatus === "idle" ? "\u5F53\u524D\u6CA1\u6709\u8BB0\u5F55\u5230\u8FD0\u884C\u4E2D\u7684\u4EFB\u52A1\u3002" : "\u4EFB\u52A1\u6B63\u5728\u8FD0\u884C\uFF0C\u4F46\u8FD8\u6CA1\u6709\u8BB0\u5F55\u5230\u8BE6\u7EC6\u8FDB\u5C55\u3002"),
@@ -15470,17 +16178,17 @@ function computeBaseDiagnosis(session, nowMs) {
     );
   } else if (idleMs <= HEALTH_RECENT_PROGRESS_MS) {
     healthStatus = activeToolName ? "waiting_tool" : "running_active";
-    healthReason = activeToolName ? `\u5F53\u524D\u6B63\u5728\u7B49\u5F85\u5DE5\u5177 ${activeToolName}\u3002` : "\u6700\u8FD1 10 \u5206\u949F\u5185\u4ECD\u6709\u65B0\u8FDB\u5C55\u3002";
+    healthReason = activeToolName ? `\u5F53\u524D\u6B63\u5728\u7B49\u5F85\u5DE5\u5177 ${activeToolName}\u3002` : "\u8FD1\u671F\u4ECD\u6709\u65B0\u8FDB\u5C55\u3002";
   } else if (idleMs <= HEALTH_SLOW_OBSERVED_MS) {
     healthStatus = activeToolName ? "waiting_tool" : "slow_observed";
-    healthReason = activeToolName ? `\u5DE5\u5177 ${activeToolName} \u5DF2\u8FD0\u884C\u8F83\u4E45\uFF0C\u4F46\u4ECD\u5728\u89C2\u5BDF\u7A97\u53E3\u5185\u3002` : "\u6700\u8FD1 10 \u5230 30 \u5206\u949F\u5185\u6CA1\u6709\u65B0\u8FDB\u5C55\uFF0C\u5148\u6807\u8BB0\u4E3A\u5F85\u89C2\u5BDF\u3002";
+    healthReason = activeToolName ? `\u5DE5\u5177 ${activeToolName} \u5DF2\u8FD0\u884C\u8F83\u4E45\uFF0C\u4F46\u4ECD\u5728\u89C2\u5BDF\u7A97\u53E3\u5185\u3002` : "\u8FD1\u671F\u6CA1\u6709\u65B0\u7684\u6267\u884C\u8FDB\u5C55\uFF0C\u5148\u6807\u8BB0\u4E3A\u5F85\u89C2\u5BDF\u3002";
   } else {
     healthStatus = "suspected_stall";
     healthReason = activeToolName ? `\u5DE5\u5177 ${activeToolName} \u5DF2\u957F\u65F6\u95F4\u6CA1\u6709\u65B0\u8FDB\u5C55\uFF0C\u7591\u4F3C\u5361\u4F4F\u3002` : "\u5DF2\u7ECF\u8D85\u8FC7 30 \u5206\u949F\u6CA1\u6709\u65B0\u7684\u6267\u884C\u8FDB\u5C55\uFF0C\u7591\u4F3C\u5361\u4F4F\u3002";
   }
   return {
     sessionId: session.id,
-    checkedAt,
+    checkedAt: null,
     runtimeStatus,
     healthStatus,
     healthReason,
@@ -15540,9 +16248,6 @@ function applyStreamUiDiagnosis(diagnosis, nowMs) {
     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);
@@ -15561,7 +16266,21 @@ function applyStreamUiDiagnosis(diagnosis, nowMs) {
       healthReason: details.join(" ")
     };
   }
-  if (lastStreamUiUpdateMs && lastProgressMs - lastStreamUiUpdateMs >= HEALTH_STREAM_UI_STALL_MS) {
+  if (lastStreamUiAttemptMs && (!lastStreamUiUpdateMs || lastStreamUiAttemptMs - lastStreamUiUpdateMs >= HEALTH_STREAM_UI_STALL_MS)) {
+    const details = ["\u4EFB\u52A1\u4ECD\u5728\u7EE7\u7EED\uFF0C\u4F46\u6D41\u5F0F UI \u6709\u5237\u65B0\u5C1D\u8BD5\u672A\u6210\u529F\u8DDF\u8FDB\uFF0C\u7591\u4F3C\u505C\u66F4\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 (lastProgressMs && 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}`);
@@ -15572,7 +16291,7 @@ function applyStreamUiDiagnosis(diagnosis, nowMs) {
       healthReason: details.join(" ")
     };
   }
-  if (!lastStreamUiUpdateMs && lastStreamUiAttemptMs && lastProgressMs - lastStreamUiAttemptMs >= HEALTH_STREAM_UI_STALL_MS) {
+  if (lastProgressMs && !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}`);
@@ -15583,13 +16302,30 @@ function applyStreamUiDiagnosis(diagnosis, nowMs) {
       healthReason: details.join(" ")
     };
   }
+  const lastStreamUiActivityMs = Math.max(
+    lastStreamUiAttemptMs || 0,
+    lastStreamUiUpdateMs || 0,
+    streamUiFlushStartedMs || 0
+  );
+  if (lastStreamUiActivityMs > 0 && nowMs - lastStreamUiActivityMs >= HEALTH_STREAM_UI_STALL_MS) {
+    return {
+      ...diagnosis,
+      healthStatus: "suspected_stream_ui_stall",
+      healthReason: "\u4EFB\u52A1\u4ECD\u5728\u7EE7\u7EED\uFF0C\u4F46\u6D41\u5F0F UI \u72B6\u6001\u5237\u65B0\u5DF2\u505C\u6B62\uFF0C\u7591\u4F3C\u505C\u66F4\u3002"
+    };
+  }
   return diagnosis;
 }
 
 // src/lib/bridge/session-health-runtime.ts
 function createSessionHealthRuntime(deps) {
   const lastProgressPersistAt = /* @__PURE__ */ new Map();
-  const processProbeCache = /* @__PURE__ */ new Map();
+  function isTerminalHealthStatus(status) {
+    return status === "completed" || status === "failed" || status === "aborted";
+  }
+  function shouldIgnoreNonStartProgress(session) {
+    return isTerminalHealthStatus(session.health_status);
+  }
   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";
@@ -15657,6 +16393,8 @@ function createSessionHealthRuntime(deps) {
   }
   function recordInteractiveProgress(sessionId, type, detail) {
     const nowIso4 = deps.nowIso();
+    const session = deps.getStore().getSession(sessionId);
+    if (!session || shouldIgnoreNonStartProgress(session)) return;
     maybePersistProgress(sessionId, {
       health_status: type === "permission_wait" ? "waiting_tool" : "running_active",
       health_reason: buildProgressReason(type, detail),
@@ -15669,6 +16407,7 @@ function createSessionHealthRuntime(deps) {
     const store = deps.getStore();
     const session = store.getSession(sessionId);
     if (!session) return;
+    if (shouldIgnoreNonStartProgress(session)) return;
     const activeTools = new Map(
       parseActiveToolsJson(session.active_tools_json).map((tool) => [tool.id, tool])
     );
@@ -15725,11 +16464,9 @@ function createSessionHealthRuntime(deps) {
       last_stream_ui_update_at: void 0,
       last_stream_ui_error_at: void 0,
       last_stream_ui_error: void 0,
-      stream_ui_consecutive_failures: void 0,
-      last_health_check_at: nowIso4
+      stream_ui_consecutive_failures: void 0
     }, { 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;
@@ -15824,17 +16561,7 @@ function createSessionHealthRuntime(deps) {
   async function loadProcessProbe(session) {
     const threadId = session.sdk_session_id?.trim();
     if (!threadId || !deps.probeThreadProcess) return null;
-    const cached = processProbeCache.get(session.id);
-    const nowMs = Date.now();
-    if (cached && nowMs - cached.checkedAtMs < HEALTH_PROCESS_PROBE_CACHE_MS) {
-      return cached.result;
-    }
-    const result = await deps.probeThreadProcess(threadId);
-    processProbeCache.set(session.id, {
-      checkedAtMs: nowMs,
-      result
-    });
-    return result;
+    return deps.probeThreadProcess(threadId);
   }
   async function diagnoseSessionHealth(sessionId) {
     const store = deps.getStore();
@@ -15842,21 +16569,10 @@ function createSessionHealthRuntime(deps) {
     if (!session) return null;
     const base = computeBaseDiagnosis(session, Date.now());
     const processProbe = await loadProcessProbe(session);
-    const checkedAt = deps.nowIso();
-    const diagnosis = applyStreamUiDiagnosis(
+    return applyStreamUiDiagnosis(
       applyProcessProbeDiagnosis(base, processProbe),
       Date.now()
     );
-    const checkedDiagnosis = {
-      ...diagnosis,
-      checkedAt
-    };
-    updateSessionHealth(sessionId, {
-      health_status: checkedDiagnosis.healthStatus,
-      health_reason: checkedDiagnosis.healthReason,
-      last_health_check_at: checkedAt
-    }, { touch: false });
-    return checkedDiagnosis;
   }
   async function diagnoseAllActiveSessions() {
     const store = deps.getStore();
@@ -15877,6 +16593,100 @@ function createSessionHealthRuntime(deps) {
   };
 }
 
+// src/lib/bridge/turns/desktop-terminal-router.ts
+function isTerminalRecord(record) {
+  return record.type === "task_complete" || record.type === "task_aborted";
+}
+function toTerminalRecord(sessionId, desktopThreadId, record) {
+  return {
+    sessionId,
+    desktopThreadId,
+    turnId: record.turnId,
+    text: record.content,
+    outcome: record.type === "task_aborted" ? "aborted" : "completed",
+    timestamp: record.timestamp
+  };
+}
+async function routeDesktopRecords(sessionId, desktopThreadId, records, coordinator) {
+  let terminalRecord = null;
+  for (let index = records.length - 1; index >= 0; index -= 1) {
+    if (!isTerminalRecord(records[index])) continue;
+    terminalRecord = records[index];
+    break;
+  }
+  if (!terminalRecord) {
+    return {
+      claimed: [],
+      unclaimed: records,
+      terminalClaimed: false
+    };
+  }
+  const claim = await coordinator.claimDesktopTerminal(
+    toTerminalRecord(sessionId, desktopThreadId, terminalRecord)
+  );
+  if (!claim.claimed) {
+    return {
+      claimed: [],
+      unclaimed: records,
+      terminalClaimed: false
+    };
+  }
+  const claimedTurnId = terminalRecord.turnId;
+  const claimed = claimedTurnId ? records.filter((record) => record.turnId === claimedTurnId) : [terminalRecord];
+  const claimedSet = new Set(claimed.map((record) => record.signature));
+  return {
+    claimed,
+    unclaimed: records.filter((record) => !claimedSet.has(record.signature)),
+    terminalClaimed: true
+  };
+}
+
+// src/lib/bridge/turns/turn-coordinator.ts
+function createTurnCoordinator(deps = {}) {
+  const activeTurnsBySession = /* @__PURE__ */ new Map();
+  function registerInteractiveTurn(turn) {
+    activeTurnsBySession.set(turn.sessionId, turn);
+  }
+  function getActiveTurn(sessionId) {
+    return activeTurnsBySession.get(sessionId);
+  }
+  async function claimDesktopTerminal(terminal) {
+    const turn = activeTurnsBySession.get(terminal.sessionId);
+    if (!turn || turn.kind !== "im_desktop_reuse") {
+      return { claimed: false };
+    }
+    if (turn.desktopThreadId && turn.desktopThreadId !== terminal.desktopThreadId) {
+      return { claimed: false };
+    }
+    const finalized = await deps.finalizeTerminalTurn?.(turn, terminal);
+    return finalized ? { claimed: true, turn } : { claimed: false, turn };
+  }
+  function releaseTurn(turnId) {
+    for (const [sessionId, turn] of activeTurnsBySession) {
+      if (turn.id !== turnId) continue;
+      activeTurnsBySession.delete(sessionId);
+      return;
+    }
+  }
+  function releaseSessionTurn(sessionId, turnId) {
+    const turn = activeTurnsBySession.get(sessionId);
+    if (!turn) return;
+    if (turnId && turn.id !== turnId) return;
+    activeTurnsBySession.delete(sessionId);
+  }
+  function clear() {
+    activeTurnsBySession.clear();
+  }
+  return {
+    registerInteractiveTurn,
+    getActiveTurn,
+    claimDesktopTerminal,
+    releaseTurn,
+    releaseSessionTurn,
+    clear
+  };
+}
+
 // src/lib/bridge/bridge-manager.ts
 var GLOBAL_KEY = "__bridge_manager__";
 var DANGLING_MIRROR_THREAD_RETRY_LIMIT = 3;
@@ -15887,9 +16697,10 @@ var MIRROR_WATCH_DEBOUNCE_MS = 350;
 var MIRROR_EVENT_BATCH_LIMIT = 8;
 var MIRROR_SUPPRESSION_WINDOW_MS = 4e3;
 var MIRROR_PROMPT_MATCH_GRACE_MS = 12e4;
+var DESKTOP_TERMINAL_FINALIZATION_TIMEOUT_MS = 3e4;
 var MIRROR_STREAM_STATUS_IDLE_START_MS = 18e4;
 var MIRROR_STREAM_STATUS_HEARTBEAT_MS = 1e4;
-var MIRROR_TURN_BUFFER_TIMEOUT_MS = 6e5;
+var MIRROR_TURN_BUFFER_TIMEOUT_MS = 10 * 6e4;
 function describeUnknownError(error) {
   if (error instanceof Error) {
     return error.stack || `${error.name}: ${error.message}`;
@@ -15974,6 +16785,23 @@ var INTERACTIVE_RUNTIME = createInteractiveRuntime(getState, {
   getStore: () => getBridgeContext().store,
   nowIso: nowIso3
 });
+function formatDesktopTerminalDetail(terminal) {
+  if (terminal.outcome === "aborted") {
+    return "\u68C0\u6D4B\u5230\u684C\u9762\u7EBF\u7A0B\u5DF2\u505C\u6B62\u5F53\u524D\u4EFB\u52A1\u3002";
+  }
+  if (terminal.outcome === "failed") {
+    return "\u68C0\u6D4B\u5230\u684C\u9762\u7EBF\u7A0B\u5F53\u524D\u4EFB\u52A1\u6267\u884C\u5931\u8D25\u3002";
+  }
+  return "\u68C0\u6D4B\u5230\u684C\u9762\u7EBF\u7A0B\u5DF2\u5B8C\u6210\u5F53\u524D\u4EFB\u52A1\u3002";
+}
+var TURN_COORDINATOR = createTurnCoordinator({
+  finalizeTerminalTurn: (turn, terminal) => INTERACTIVE_RUNTIME.finalizeTerminalActiveTask(
+    turn.sessionId,
+    terminal.outcome,
+    formatDesktopTerminalDetail(terminal),
+    terminal.text
+  )
+});
 var SESSION_HEALTH_RUNTIME = createSessionHealthRuntime({
   getStore: () => getBridgeContext().store,
   nowIso: nowIso3,
@@ -16010,9 +16838,6 @@ function settleMirrorSuppression2(sessionId, suppressionId, durationMs = MIRROR_
     durationMs
   );
 }
-function isMirrorSuppressed2(sessionId) {
-  return isMirrorSuppressed(getMirrorSuppressionStore(), sessionId);
-}
 function filterSuppressedMirrorRecords2(sessionId, records) {
   return filterSuppressedMirrorRecords(
     getMirrorSuppressionStore(),
@@ -16046,28 +16871,6 @@ function syncMirrorSessionStateSafe(sessionId, context) {
     );
   }
 }
-function getMirrorStreamingAdapter(subscription) {
-  const state = getState();
-  const adapter = state.adapters.get(subscription.channelType);
-  if (!adapter || !adapter.isRunning()) return null;
-  if (getChannelProviderKey(subscription.channelType) !== "feishu") return null;
-  if (typeof adapter.onStreamText !== "function" || typeof adapter.onStreamEnd !== "function") {
-    return null;
-  }
-  return adapter;
-}
-function getMirrorStreamingText(subscription, turnState) {
-  const title = getDesktopThreadTitle(subscription.threadId)?.trim() || "\u684C\u9762\u7EBF\u7A0B";
-  const markdown = getFeedbackParseMode(subscription.channelType) === "Markdown";
-  const rendered = formatMirrorMessage(
-    title,
-    turnState.userText,
-    turnState.streamedText,
-    markdown,
-    true
-  );
-  return rendered || buildMirrorTitle(title, markdown);
-}
 function getMirrorStructuredStreamStatusConfig() {
   const { store } = getBridgeContext();
   const idleStartSeconds = parseInt(store.getSetting("bridge_stream_status_idle_start_seconds") || "", 10);
@@ -16083,216 +16886,43 @@ function getMirrorStructuredStreamStatusConfig() {
     )
   };
 }
-function startMirrorStreaming(subscription, turnState) {
-  const adapter = getMirrorStreamingAdapter(subscription);
-  if (!adapter || turnState.streamStarted) return;
-  try {
-    adapter.onMirrorStreamStart?.(subscription.chatId, turnState.streamKey);
-    if (!adapter.onMirrorStreamStart) {
-      adapter.onStreamText?.(subscription.chatId, "", turnState.streamKey);
-    }
-    turnState.streamStarted = true;
-  } catch {
-  }
-}
-function createMirrorStreamFeedbackTarget(subscription, turnState, adapter) {
-  return {
-    adapter,
-    channelType: subscription.channelType,
-    chatId: subscription.chatId,
-    streamKey: turnState.streamKey,
-    ensureStarted: () => {
-      startMirrorStreaming(subscription, turnState);
-    }
-  };
-}
-function pushMirrorStreamingStatus(subscription, turnState, options = {}) {
-  const adapter = getMirrorStreamingAdapter(subscription);
-  if (!adapter || typeof adapter.onStreamStatus !== "function") return;
-  if (!(adapter.supportsStructuredStreamingUi?.(subscription.chatId) ?? true)) return;
-  const startedAtMs = Date.parse(turnState.startedAt);
-  if (!Number.isFinite(startedAtMs)) return;
-  const nowMs = options.nowMs ?? Date.now();
-  const minIntervalMs = Math.max(0, options.minIntervalMs ?? 0);
-  if (minIntervalMs > 0 && turnState.lastStatusAt > 0 && nowMs - turnState.lastStatusAt < minIntervalMs) {
-    return;
-  }
-  const statusText = formatInteractiveRuntimeStatus(
-    Math.max(0, nowMs - startedAtMs),
-    options.lastResponseAgeMs,
-    turnState.statusNote
-  );
-  if (turnState.lastStatusText === statusText) return;
-  pushStreamFeedbackStatus(
-    createMirrorStreamFeedbackTarget(subscription, turnState, adapter),
-    statusText
-  );
-  turnState.lastStatusText = statusText;
-  turnState.lastStatusAt = nowMs;
-}
+var MIRROR_FEEDBACK = createMirrorFeedbackController({
+  getAdapter: (channelType) => getState().adapters.get(channelType) || null,
+  getThreadTitle: (threadId) => getDesktopThreadTitle(threadId),
+  nowIso: nowIso3,
+  eventBatchLimit: MIRROR_EVENT_BATCH_LIMIT,
+  deliverResponse
+});
 function refreshMirrorStreamingStatus(subscription, nowMs = Date.now(), config2 = getMirrorStructuredStreamStatusConfig()) {
-  const pendingTurn = subscription.pendingTurn;
-  if (!pendingTurn?.streamStarted) return;
-  const startedAtMs = Date.parse(pendingTurn.startedAt);
-  if (!Number.isFinite(startedAtMs)) return;
-  const elapsedMs = nowMs - startedAtMs;
-  if (elapsedMs < config2.idleStartMs) return;
-  const lastResponseAtMs = pendingTurn.lastResponseAt ? Date.parse(pendingTurn.lastResponseAt) : NaN;
-  const lastResponseAgeMs = Number.isFinite(lastResponseAtMs) ? nowMs - lastResponseAtMs : null;
-  if (lastResponseAgeMs != null && lastResponseAgeMs < config2.heartbeatMs) return;
-  pushMirrorStreamingStatus(subscription, pendingTurn, {
-    nowMs,
-    lastResponseAgeMs,
-    minIntervalMs: config2.heartbeatMs
-  });
+  MIRROR_FEEDBACK.refreshMirrorStreamingStatus(subscription, nowMs, config2);
 }
 function refreshActiveMirrorStreamingStatuses(nowMs = Date.now()) {
   for (const subscription of getState().mirrorSubscriptions.values()) {
     refreshMirrorStreamingStatus(subscription, nowMs);
   }
 }
-function updateMirrorStreaming(subscription, turnState) {
-  const adapter = getMirrorStreamingAdapter(subscription);
-  if (!adapter) return;
-  pushStreamFeedbackText(
-    createMirrorStreamFeedbackTarget(subscription, turnState, adapter),
-    getMirrorStreamingText(subscription, turnState)
-  );
-  pushMirrorStreamingStatus(subscription, turnState);
-}
-function updateMirrorToolProgress(subscription, turnState) {
-  const adapter = getMirrorStreamingAdapter(subscription);
-  if (!adapter) return;
-  pushStreamFeedbackTools(
-    createMirrorStreamFeedbackTarget(subscription, turnState, adapter),
-    Array.from(turnState.toolCalls.values())
-  );
-  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;
-  if (!adapter || !pendingTurn?.streamStarted) return;
-  void finalizeStreamFeedback(
-    createMirrorStreamFeedbackTarget(subscription, pendingTurn, adapter),
-    status,
-    getMirrorStreamingText(subscription, pendingTurn)
-  );
-}
-async function deliverMirrorTurn(subscription, turn) {
-  const state = getState();
-  const adapter = state.adapters.get(subscription.channelType);
-  if (!adapter || !adapter.isRunning()) return;
-  const title = getDesktopThreadTitle(subscription.threadId)?.trim() || "\u684C\u9762\u7EBF\u7A0B";
-  const responseParseMode = getFeedbackParseMode(subscription.channelType);
-  const markdown = responseParseMode === "Markdown";
-  const renderedTextBase = formatMirrorMessage(title, turn.userText, turn.text, markdown);
-  const renderedStreamTextBase = formatMirrorMessage(title, turn.userText, turn.text, markdown, true);
-  const renderedText = turn.timedOut ? appendMirrorTimeoutNotice(renderedTextBase || buildMirrorTitle(title, markdown), markdown) : renderedTextBase;
-  const renderedStreamText = turn.timedOut ? appendMirrorTimeoutNotice(renderedStreamTextBase || buildMirrorTitle(title, markdown), markdown) : renderedStreamTextBase;
-  const text2 = renderedText ? renderFeedbackText(renderedText, responseParseMode) : "";
-  const streamText = renderFeedbackText(
-    renderedStreamText || buildMirrorTitle(title, markdown),
-    responseParseMode
-  );
-  if (getChannelProviderKey(subscription.channelType) === "feishu" && typeof adapter.onStreamEnd === "function") {
-    try {
-      const finalized = await adapter.onStreamEnd(
-        subscription.chatId,
-        turn.status,
-        streamText,
-        turn.streamKey
-      );
-      if (finalized) {
-        subscription.lastDeliveredAt = turn.timestamp || nowIso3();
-        return;
-      }
-    } catch (error) {
-      console.warn("[bridge-manager] Mirror stream finalize failed:", error instanceof Error ? error.message : error);
-    }
-  }
-  if (!text2) return;
-  const response = await deliver(adapter, {
-    address: {
-      channelType: subscription.channelType,
-      chatId: subscription.chatId
-    },
-    text: text2,
-    parseMode: responseParseMode
-  }, {
-    sessionId: subscription.sessionId,
-    dedupKey: `mirror:${subscription.bindingId}:${turn.signature}`
-  });
-  if (!response.ok) {
-    throw new Error(response.error || "mirror delivery failed");
-  }
-  subscription.lastDeliveredAt = turn.timestamp || nowIso3();
+  MIRROR_FEEDBACK.stopMirrorStreaming(subscription, status);
 }
 async function deliverMirrorTurns(subscription, turns) {
-  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 };
+  return MIRROR_FEEDBACK.deliverMirrorTurns(subscription, turns);
 }
-var MIRROR_TURN_HOOKS = {
-  onStreamText: updateMirrorStreaming,
-  onStatusProgress: updateMirrorStatusProgress,
-  onTaskProgress: updateMirrorTaskProgress,
-  onToolProgress: updateMirrorToolProgress
-};
+var MIRROR_TURN_HOOKS = MIRROR_FEEDBACK.hooks;
 function consumeMirrorRecords2(subscription, records) {
   return consumeMirrorRecords(subscription, records, MIRROR_TURN_HOOKS);
 }
 function flushTimedOutMirrorTurn2(subscription, nowMs = Date.now()) {
+  if (subscription.pendingTurn?.streamStarted) {
+    return null;
+  }
   return flushTimedOutMirrorTurn(subscription, MIRROR_TURN_BUFFER_TIMEOUT_MS, nowMs);
 }
 function hasPendingMirrorWork2(subscription) {
   return hasPendingMirrorWork(subscription);
 }
 function consumeBufferedMirrorTurns2(subscription, nowMs = Date.now()) {
-  return consumeBufferedMirrorTurns(subscription, MIRROR_TURN_BUFFER_TIMEOUT_MS, nowMs, MIRROR_TURN_HOOKS);
-}
-function finalizeInteractiveTaskFromMirrorRecords(sessionId, records) {
-  let terminalRecord = null;
-  for (let index = records.length - 1; index >= 0; index -= 1) {
-    const record = records[index];
-    if (record.type === "task_complete" || record.type === "task_aborted") {
-      terminalRecord = record;
-      break;
-    }
-  }
-  if (!terminalRecord) return Promise.resolve(false);
-  const outcome = terminalRecord.type === "task_complete" ? "completed" : "aborted";
-  const detail = terminalRecord.type === "task_complete" ? "\u68C0\u6D4B\u5230\u684C\u9762\u7EBF\u7A0B\u5DF2\u5B8C\u6210\u5F53\u524D\u4EFB\u52A1\u3002" : "\u68C0\u6D4B\u5230\u684C\u9762\u7EBF\u7A0B\u5DF2\u505C\u6B62\u5F53\u524D\u4EFB\u52A1\u3002";
-  return INTERACTIVE_RUNTIME.finalizeTerminalActiveTask(
-    sessionId,
-    outcome,
-    detail,
-    terminalRecord.content
-  ).catch((error) => {
-    console.error("[bridge-manager] Failed to finalize terminal interactive task:", describeUnknownError(error));
-    return false;
-  });
+  const timeoutMs = subscription.pendingTurn?.streamStarted ? Number.POSITIVE_INFINITY : MIRROR_TURN_BUFFER_TIMEOUT_MS;
+  return consumeBufferedMirrorTurns(subscription, timeoutMs, nowMs, MIRROR_TURN_HOOKS);
 }
 var MIRROR_RUNTIME = createMirrorRuntime(getState, {
   watchDebounceMs: MIRROR_WATCH_DEBOUNCE_MS,
@@ -16304,12 +16934,16 @@ var MIRROR_RUNTIME = createMirrorRuntime(getState, {
   describeUnknownError,
   getDesktopSessionByThreadIdSafe,
   syncMirrorSessionStateSafe,
-  isMirrorSuppressed: isMirrorSuppressed2,
   filterSuppressedMirrorRecords: filterSuppressedMirrorRecords2,
   observeSessionHealthRecords: (sessionId, threadId, records) => {
     SESSION_HEALTH_RUNTIME.observeDesktopMirrorRecords(sessionId, threadId, records);
-    void finalizeInteractiveTaskFromMirrorRecords(sessionId, records);
   },
+  routeDesktopRecords: (sessionId, threadId, records) => routeDesktopRecords(
+    sessionId,
+    threadId,
+    records,
+    TURN_COORDINATOR
+  ),
   consumeMirrorRecords: consumeMirrorRecords2,
   flushTimedOutMirrorTurn: (subscription) => flushTimedOutMirrorTurn2(subscription),
   hasPendingMirrorWork: hasPendingMirrorWork2,
@@ -16557,6 +17191,7 @@ async function handleMessage(adapter, msg) {
   try {
     await runInteractiveMessage(adapter, msg, text2, hasAttachments ? msg.attachments : void 0, {
       registerInteractiveTask: (task) => INTERACTIVE_RUNTIME.registerInteractiveTask(task),
+      registerBridgeTurn: (turn) => TURN_COORDINATOR.registerInteractiveTurn(turn),
       resetMirrorSessionForInteractiveRun,
       isCurrentInteractiveTask: (sessionId, taskId) => INTERACTIVE_RUNTIME.isCurrentInteractiveTask(sessionId, taskId),
       touchInteractiveTask: (sessionId, taskId) => INTERACTIVE_RUNTIME.touchInteractiveTask(sessionId, taskId),
@@ -16573,8 +17208,10 @@ async function handleMessage(adapter, msg) {
       abortMirrorSuppression: abortMirrorSuppression2,
       settleMirrorSuppression: settleMirrorSuppression2,
       releaseInteractiveTask: (sessionId, taskId) => INTERACTIVE_RUNTIME.releaseInteractiveTask(sessionId, taskId),
+      releaseBridgeTurn: (sessionId, taskId) => TURN_COORDINATOR.releaseSessionTurn(sessionId, taskId),
       deliverResponse,
-      persistSdkSessionUpdate
+      persistSdkSessionUpdate,
+      desktopTerminalFinalizationTimeoutMs: DESKTOP_TERMINAL_FINALIZATION_TIMEOUT_MS
     });
   } finally {
     ack();
@@ -16583,6 +17220,8 @@ async function handleMessage(adapter, msg) {
 async function handleCommand(adapter, msg, text2) {
   await handleBridgeCommand(adapter, msg, text2, {
     getActiveTask: (sessionId) => INTERACTIVE_RUNTIME.getActiveTask(sessionId),
+    forceStopSession: (sessionId, detail) => INTERACTIVE_RUNTIME.forceStopSession(sessionId, detail),
+    recordInteractiveHealthEnd: (sessionId, outcome, detail) => SESSION_HEALTH_RUNTIME.recordInteractiveEnd(sessionId, outcome, detail),
     diagnoseSessionHealth: (sessionId) => SESSION_HEALTH_RUNTIME.diagnoseSessionHealth(sessionId),
     diagnoseAllActiveSessions: () => SESSION_HEALTH_RUNTIME.diagnoseAllActiveSessions()
   });
@@ -16886,7 +17525,7 @@ var JsonFileStore = class {
   findSessionBySdkSessionId(sdkSessionId) {
     this.reloadSessions();
     for (const session of this.sessions.values()) {
-      if (session.sdk_session_id === sdkSessionId) {
+      if (session.sdk_session_id === sdkSessionId || session.codex_thread_id === sdkSessionId || session.desktop_thread_id === sdkSessionId) {
         return session;
       }
     }
@@ -17020,6 +17659,15 @@ var JsonFileStore = class {
     const s = this.sessions.get(sessionId);
     if (s) {
       s.sdk_session_id = sdkSessionId;
+      if (sdkSessionId) {
+        s.codex_thread_id = sdkSessionId;
+        s.thread_origin = s.thread_origin || "bridge";
+      } else {
+        delete s.codex_thread_id;
+        if (s.thread_origin !== "desktop") {
+          delete s.thread_origin;
+        }
+      }
       s.updated_at = now();
       this.persistSessions();
     }