codex-to-im 1.0.43 → 1.0.45

package/dist/daemon.mjs

@@ -1408,8 +1408,12 @@ var FeishuAdapter = class extends BaseChannelAdapter {
   botIds = /* @__PURE__ */ new Set();
   /** Track last incoming message ID per chat for typing indicator. */
   lastIncomingMessageId = /* @__PURE__ */ new Map();
-  /** Track active typing reaction IDs per chat for cleanup. */
+  /** Track active typing reaction IDs per stream key for cleanup. */
   typingReactions = /* @__PURE__ */ new Map();
+  /** Track in-flight typing reaction creates so repeated status updates stay idempotent. */
+  typingReactionCreatePromises = /* @__PURE__ */ new Map();
+  /** Track streams that ended before the async reaction create finished. */
+  typingReactionCleanupRequested = /* @__PURE__ */ new Set();
   /** Active streaming card state per stream key. */
   activeCards = /* @__PURE__ */ new Map();
   /** In-flight card creation promises per stream key — prevents duplicate creation. */
@@ -1515,6 +1519,8 @@ var FeishuAdapter = class extends BaseChannelAdapter {
     this.seenMessageIds.clear();
     this.lastIncomingMessageId.clear();
     this.typingReactions.clear();
+    this.typingReactionCreatePromises.clear();
+    this.typingReactionCleanupRequested.clear();
     console.log("[feishu-adapter] Stopped");
   }
   isRunning() {
@@ -1531,25 +1537,38 @@ var FeishuAdapter = class extends BaseChannelAdapter {
    */
   onMessageStart(chatId, streamKey) {
     const messageId = this.lastIncomingMessageId.get(chatId);
+    const reactionKey = this.resolveStreamKey(chatId, streamKey);
     if (messageId && this.isStreamingEnabled()) {
       this.createStreamingCard(chatId, messageId, streamKey).catch(() => {
       });
     }
     if (!messageId || !this.restClient) return;
-    this.restClient.im.messageReaction.create({
+    if (this.typingReactions.has(reactionKey) || this.typingReactionCreatePromises.has(reactionKey)) {
+      return;
+    }
+    const createPromise = this.restClient.im.messageReaction.create({
       path: { message_id: messageId },
       data: { reaction_type: { emoji_type: TYPING_EMOJI } }
     }).then((res) => {
       const reactionId = res?.data?.reaction_id;
       if (reactionId) {
-        this.typingReactions.set(chatId, reactionId);
+        this.typingReactions.set(reactionKey, { messageId, reactionId });
+        if (this.typingReactionCleanupRequested.delete(reactionKey)) {
+          this.removeTypingReaction(reactionKey);
+        }
       }
     }).catch((err) => {
       const code2 = err?.code;
       if (code2 !== 99991400 && code2 !== 99991403) {
         console.warn("[feishu-adapter] Typing indicator failed:", err instanceof Error ? err.message : err);
       }
+    }).finally(() => {
+      this.typingReactionCreatePromises.delete(reactionKey);
+      if (!this.typingReactions.has(reactionKey)) {
+        this.typingReactionCleanupRequested.delete(reactionKey);
+      }
     });
+    this.typingReactionCreatePromises.set(reactionKey, createPromise);
   }
   /**
    * Remove the "Typing" emoji reaction and clean up card state.
@@ -1557,12 +1576,19 @@ var FeishuAdapter = class extends BaseChannelAdapter {
    */
   onMessageEnd(chatId, streamKey) {
     this.cleanupCard(chatId, streamKey);
-    const reactionId = this.typingReactions.get(chatId);
-    const messageId = this.lastIncomingMessageId.get(chatId);
-    if (!reactionId || !messageId || !this.restClient) return;
-    this.typingReactions.delete(chatId);
+    const reactionKey = this.resolveStreamKey(chatId, streamKey);
+    if (this.typingReactionCreatePromises.has(reactionKey) && !this.typingReactions.has(reactionKey)) {
+      this.typingReactionCleanupRequested.add(reactionKey);
+      return;
+    }
+    this.removeTypingReaction(reactionKey);
+  }
+  removeTypingReaction(reactionKey) {
+    const reaction = this.typingReactions.get(reactionKey);
+    if (!reaction || !this.restClient) return;
+    this.typingReactions.delete(reactionKey);
     this.restClient.im.messageReaction.delete({
-      path: { message_id: messageId, reaction_id: reactionId }
+      path: { message_id: reaction.messageId, reaction_id: reaction.reactionId }
     }).catch(() => {
     });
   }
@@ -10447,6 +10473,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;
@@ -10492,15 +10530,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,
@@ -10509,7 +10563,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)
@@ -10524,6 +10578,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,
@@ -10548,7 +10603,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,
@@ -10921,15 +10976,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 };
 }
@@ -11653,6 +11710,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,
@@ -11699,8 +11758,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;
@@ -11773,7 +11838,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") {
@@ -11781,7 +11846,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);
         }
       }
@@ -11792,14 +11857,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;
     }
@@ -11812,7 +11877,7 @@ function consumeMirrorRecords(subscription, records, hooks = {}) {
         name: toolName,
         status: "running"
       });
-      markMirrorResponse(pendingTurn, record.timestamp);
+      markMirrorActivity(pendingTurn, record.timestamp);
       hooks.onToolProgress?.(subscription, pendingTurn);
       continue;
     }
@@ -11825,7 +11890,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;
     }
@@ -11994,9 +12059,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);
@@ -12633,7 +12695,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);
@@ -12643,14 +12705,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(
@@ -12658,7 +12720,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 = []) {
@@ -12774,6 +12837,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":
@@ -13106,6 +13170,7 @@ async function handleBridgeCommand(adapter, msg, text2, deps) {
         break;
       }
       if (!args) {
+        const desktopThreadId = getExplicitDesktopThreadId(session);
         const currentModel = resolveDisplayedModel(
           binding,
           session,
@@ -13117,14 +13182,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;
       }
@@ -13175,9 +13240,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(
@@ -13201,27 +13289,32 @@ 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 targetSessionId = args.trim() || binding.codepilotSessionId;
+      const explicitTargetSessionId = args.trim();
+      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`;
         break;
       }
       response = buildHealthCommandResponse(
-        "\u5F53\u524D\u4F1A\u8BDD\u5065\u5EB7\u68C0\u67E5",
+        explicitTargetSessionId ? "\u6307\u5B9A\u4F1A\u8BDD\u5065\u5EB7\u68C0\u67E5" : "\u5F53\u524D\u4F1A\u8BDD\u5065\u5EB7\u68C0\u67E5",
         diagnosis,
         responseParseMode === "Markdown"
       );
@@ -13233,15 +13326,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",
         [
@@ -13373,7 +13467,8 @@ ${truncateHistoryContent(formatStoredMessageContent(message.content))}`;
   }
   if (response) {
     await deliverBridgeNotice(adapter, msg.address, response, {
-      replyToMessageId: msg.messageId
+      replyToMessageId: msg.messageId,
+      audit: auditResponse
     });
   }
 }
@@ -13385,6 +13480,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
@@ -13763,8 +13891,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(
@@ -13778,7 +13906,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,
@@ -13811,6 +13939,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;
@@ -13839,13 +14003,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) {
@@ -13858,6 +14024,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;
@@ -13901,18 +14179,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);
 }
@@ -13934,18 +14200,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));
@@ -13961,10 +14219,34 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     1e3,
     deps.streamStatusHeartbeatMs ?? structuredStreamStatusConfig.heartbeatMs
   );
-  adapter.onMessageStart?.(msg.address.chatId, streamKey);
+  let messageStartCalled = false;
+  const ensureMessageStarted = () => {
+    if (messageStartCalled) return;
+    adapter.onMessageStart?.(msg.address.chatId, streamKey);
+    messageStartCalled = true;
+  };
+  ensureMessageStarted();
   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) => {
+    resolveExternalTerminalCompletion = resolve2;
+  });
+  const settleExternalTerminalCompletion = (finalized) => {
+    if (!externalTerminalRequest || externalTerminalCompletionSettled) return;
+    externalTerminalCompletionSettled = true;
+    resolveExternalTerminalCompletion?.(finalized);
+  };
   deps.resetMirrorSessionForInteractiveRun(binding.codepilotSessionId);
   const taskState = {
     id: taskId,
@@ -13978,12 +14260,35 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     structuredStreamUiActive: false,
     lastActivityAt: taskStartedAt,
     lastResponseAt: null,
-    idleReminderSent: false,
+    lastContentResponseAt: null,
     streamFinalized: false,
     uiEnded: false,
-    mirrorSuppressionId: null
+    mirrorSuppressionId: null,
+    finalizeFromExternalTerminal: async (outcome, detail, finalText) => {
+      if (externalTerminalRequest) return externalTerminalCompletion;
+      if (!deps.isCurrentInteractiveTask(binding.codepilotSessionId, taskId)) return false;
+      externalTerminalRequest = { outcome, detail, finalText };
+      resolveExternalTerminal?.(externalTerminalRequest);
+      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;
@@ -14003,7 +14308,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;
@@ -14040,12 +14345,11 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     chatId: msg.address.chatId,
     streamKey,
     ensureStarted: () => {
-      adapter.onMessageStart?.(msg.address.chatId, streamKey);
+      ensureMessageStarted();
     }
   };
   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;
@@ -14064,12 +14368,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;
@@ -14083,16 +14397,54 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     streamStatusUpdatesClosed = true;
     clearStreamStatusHeartbeat();
   };
+  let structuredStreamInactiveRecorded = false;
+  const recordStructuredStreamInactiveOnce = () => {
+    if (structuredStreamInactiveRecorded) return;
+    structuredStreamInactiveRecorded = true;
+    taskState.structuredStreamUiActive = false;
+    deps.recordInteractiveStreamUiSnapshot?.(binding.codepilotSessionId, { active: false });
+  };
+  let previewEnded = false;
+  const endPreviewOnce = () => {
+    if (previewEnded) return;
+    previewEnded = true;
+    if (!previewState) return;
+    if (previewState.throttleTimer) {
+      clearTimeout(previewState.throttleTimer);
+      previewState.throttleTimer = null;
+    }
+    adapter.endPreview?.(msg.address.chatId, previewState.draftId);
+  };
+  let streamUiFinalizeAttempted = false;
+  const finalizeStreamUiOnce = async (status, responseText) => {
+    stopStructuredStreamStatusUpdates();
+    recordStructuredStreamInactiveOnce();
+    endPreviewOnce();
+    if (hasStreamingCards && !streamUiFinalizeAttempted) {
+      streamUiFinalizeAttempted = true;
+      taskState.streamFinalized = await finalizeStreamingUi(
+        streamFeedbackTarget,
+        status,
+        assembleDesktopFinalResponse({ text: responseText })
+      );
+    }
+    return taskState.streamFinalized;
+  };
+  const endMessageUiOnce = () => {
+    if (taskState.uiEnded) return;
+    adapter.onMessageEnd?.(msg.address.chatId, streamKey);
+    taskState.uiEnded = true;
+  };
   const onStreamCardText = hasStreamingCards ? (fullText) => {
     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 });
@@ -14108,7 +14460,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);
@@ -14118,17 +14470,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);
@@ -14136,6 +14486,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(() => {
@@ -14148,8 +14526,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);
@@ -14159,7 +14539,7 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
   let shouldRecordHealthEnd = true;
   try {
     const promptText = text2 || (attachments && attachments.length > 0 ? "Describe this image." : "");
-    const result = await processMessageImpl(
+    const processPromise = processMessageImpl(
       binding,
       promptText,
       async (perm) => {
@@ -14178,7 +14558,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();
       },
@@ -14189,85 +14569,119 @@ 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);
         }
       }
     );
+    let raced;
+    try {
+      raced = await Promise.race([
+        processPromise.then((result2) => ({ kind: "process", result: result2 })),
+        externalTerminalPromise.then((terminal) => ({ kind: "external", terminal }))
+      ]);
+    } catch (error) {
+      if (!externalTerminalRequest) throw error;
+      raced = { kind: "external", terminal: externalTerminalRequest };
+    }
+    if (raced.kind === "external") {
+      processPromise.catch(() => {
+      });
+      finalOutcome = raced.terminal.outcome;
+      finalOutcomeDetail = raced.terminal.detail;
+      const streamEndStatus = raced.terminal.outcome === "completed" ? "completed" : raced.terminal.outcome === "aborted" ? "interrupted" : "error";
+      const staleTaskNotice2 = buildStaleTaskCompletionNotice(msg.address, binding);
+      const terminalResponse2 = assembleDesktopFinalResponse({
+        text: staleTaskNotice2 || raced.terminal.finalText || ""
+      });
+      const cardFinalized2 = await finalizeStreamUiOnce(streamEndStatus, terminalResponse2.text);
+      if (hasFinalResponsePayload(terminalResponse2)) {
+        await deliverFinalResponse({
+          adapter,
+          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) {
-      stopStructuredStreamStatusUpdates();
-      const streamEndStatus = taskAbort.signal.aborted ? "interrupted" : result.hasError ? "error" : "completed";
-      cardFinalized = await finalizeStreamFeedback(
-        streamFeedbackTarget,
+      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)
       );
-      taskState.streamFinalized = cardFinalized;
     }
-    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 {
-    stopStructuredStreamStatusUpdates();
-    deps.recordInteractiveStreamUiSnapshot?.(binding.codepilotSessionId, { active: false });
-    if (previewState) {
-      if (previewState.throttleTimer) {
-        clearTimeout(previewState.throttleTimer);
-        previewState.throttleTimer = null;
-      }
-      adapter.endPreview?.(msg.address.chatId, previewState.draftId);
-    }
-    if (hasStreamingCards && taskAbort.signal.aborted && !taskState.streamFinalized) {
-      taskState.streamFinalized = await finalizeStreamFeedback(
-        streamFeedbackTarget,
-        "interrupted",
-        ""
-      );
-    }
+    await finalizeStreamUiOnce(
+      taskAbort.signal.aborted ? "interrupted" : finalOutcome === "completed" ? "completed" : "error",
+      ""
+    );
     if (taskState.mirrorSuppressionId) {
-      if (taskAbort.signal.aborted) {
+      if (finalOutcome === "aborted") {
         deps.abortMirrorSuppression(binding.codepilotSessionId, taskState.mirrorSuppressionId);
       } else {
         deps.settleMirrorSuppression(binding.codepilotSessionId, taskState.mirrorSuppressionId);
@@ -14275,17 +14689,16 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
       taskState.mirrorSuppressionId = null;
     }
     if (shouldRecordHealthEnd) {
-      if (taskAbort.signal.aborted) {
+      if (taskAbort.signal.aborted && !externalTerminalRequest) {
         finalOutcome = "aborted";
         finalOutcomeDetail = "\u4EFB\u52A1\u5DF2\u6536\u5230\u505C\u6B62\u8BF7\u6C42\u3002";
       }
       deps.recordInteractiveHealthEnd(binding.codepilotSessionId, finalOutcome, finalOutcomeDetail);
     }
     deps.releaseInteractiveTask(binding.codepilotSessionId, taskId);
-    if (!taskState.uiEnded) {
-      adapter.onMessageEnd?.(msg.address.chatId, streamKey);
-      taskState.uiEnded = true;
-    }
+    deps.releaseBridgeTurn?.(binding.codepilotSessionId, taskId);
+    endMessageUiOnce();
+    settleExternalTerminalCompletion(taskState.streamFinalized || !hasStreamingCards);
   }
 }
 
@@ -14298,16 +14711,7 @@ var TERMINAL_SESSION_HEALTH_STATUSES = /* @__PURE__ */ new Set([
 function isTerminalSessionHealthStatus(status) {
   return Boolean(status && TERMINAL_SESSION_HEALTH_STATUSES.has(status));
 }
-function buildInteractiveIdleReminderNotice() {
-  return [
-    "\u63D0\u9192\uFF1A\u8FD9\u8F6E\u4EFB\u52A1\u4ECD\u5728\u8FD0\u884C\uFF0C\u4F46\u5DF2\u7ECF\u8D85\u8FC7 10 \u5206\u949F\u6CA1\u6709\u65B0\u7684\u6267\u884C\u8F93\u51FA\u3002",
-    "\u7CFB\u7EDF\u4E0D\u4F1A\u81EA\u52A8\u7EC8\u6B62\u5B83\uFF1B\u5982\u679C\u4F60\u4ECD\u5728\u5BF9\u5E94\u7EBF\u7A0B\uFF0C\u53EF\u53D1\u9001 `/stop` \u4E3B\u52A8\u505C\u6B62\uFF1B\u5982\u679C\u5DF2\u7ECF\u5207\u5230\u522B\u7684\u7EBF\u7A0B\uFF0C\u9700\u8981\u5148\u5207\u56DE\u5BF9\u5E94\u7EBF\u7A0B\u3002"
-  ].join("\n");
-}
-function shouldSkipIdleReminder(task) {
-  return task.adapter.provider === "feishu" && task.structuredStreamUiActive;
-}
-function createInteractiveRuntime(getState2, options, deps) {
+function createInteractiveRuntime(getState2, deps) {
   function getQueuedCount(sessionId) {
     return getState2().queuedCounts.get(sessionId) || 0;
   }
@@ -14341,7 +14745,6 @@ function createInteractiveRuntime(getState2, options, deps) {
     const task = getState2().activeTasks.get(sessionId);
     if (task?.id !== taskId) return;
     task.lastActivityAt = Date.now();
-    task.idleReminderSent = false;
   }
   function releaseInteractiveTask(sessionId, taskId) {
     const state = getState2();
@@ -14350,35 +14753,19 @@ function createInteractiveRuntime(getState2, options, deps) {
     state.activeTasks.delete(sessionId);
     syncSessionRuntimeState(sessionId);
   }
-  async function remindIdleInteractiveTask(task) {
-    if (!isCurrentInteractiveTask(task.sessionId, task.id) || task.idleReminderSent) return;
-    task.idleReminderSent = true;
-    try {
-      await deliverBridgeNotice(task.adapter, task.address, buildInteractiveIdleReminderNotice(), {
-        sessionId: task.sessionId,
-        replyToMessageId: task.requestMessageId
-      });
-    } catch {
-    }
-  }
-  async function reconcileIdleInteractiveTasks() {
-    const now2 = Date.now();
-    const tasks = Array.from(getState2().activeTasks.values());
-    for (const task of tasks) {
-      if (shouldSkipIdleReminder(task)) continue;
-      if (task.idleReminderSent) continue;
-      if (now2 - task.lastActivityAt < options.idleReminderMs) continue;
-      await remindIdleInteractiveTask(task);
-    }
+  async function finalizeTerminalActiveTask(sessionId, outcome, detail, finalText) {
+    const task = getState2().activeTasks.get(sessionId);
+    if (!task?.finalizeFromExternalTerminal) return false;
+    return task.finalizeFromExternalTerminal(outcome, detail, finalText);
   }
-  function reconcileTerminalSessionRuntimeState() {
+  async function reconcileTerminalSessionRuntimeState() {
     const store = deps.getStore();
     for (const session of store.listSessions()) {
+      if (!isTerminalSessionHealthStatus(session.health_status)) 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;
-      const hasActiveTask = getState2().activeTasks.has(session.id);
-      if (hasActiveTask || queuedCount > 0) continue;
-      if (!isTerminalSessionHealthStatus(session.health_status)) continue;
+      if (queuedCount > 0) continue;
       if (persistedQueuedCount === 0 && session.runtime_status !== "running" && session.runtime_status !== "queued") {
         continue;
       }
@@ -14449,7 +14836,7 @@ function createInteractiveRuntime(getState2, options, deps) {
     touchInteractiveTask,
     releaseInteractiveTask,
     syncSessionRuntimeState,
-    reconcileIdleInteractiveTasks,
+    finalizeTerminalActiveTask,
     reconcileTerminalSessionRuntimeState,
     resetPersistedInteractiveRuntimeState,
     processWithSessionLock
@@ -14788,7 +15175,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));
@@ -14882,11 +15269,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) {
@@ -14897,7 +15290,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;
@@ -15010,11 +15403,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),
@@ -15111,6 +15506,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";
@@ -15203,7 +15833,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",
@@ -15342,6 +15971,7 @@ function computeBaseDiagnosis(session, nowMs) {
     const fallbackStatus = isRunningRuntimeStatus(runtimeStatus) ? "running_active" : previousStatus;
     return {
       sessionId: session.id,
+      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"),
@@ -15379,6 +16009,7 @@ function computeBaseDiagnosis(session, nowMs) {
   }
   return {
     sessionId: session.id,
+    checkedAt: null,
     runtimeStatus,
     healthStatus,
     healthReason,
@@ -15487,7 +16118,6 @@ function applyStreamUiDiagnosis(diagnosis, nowMs) {
 // src/lib/bridge/session-health-runtime.ts
 function createSessionHealthRuntime(deps) {
   const lastProgressPersistAt = /* @__PURE__ */ new Map();
-  const processProbeCache = /* @__PURE__ */ new Map();
   function summarizePlanUpdate(tasks) {
     if (!Array.isArray(tasks) || tasks.length === 0) {
       return "\u68C0\u6D4B\u5230\u684C\u9762\u7EBF\u7A0B\u66F4\u65B0\u4E86\u4EFB\u52A1\u8BA1\u5212\u3002";
@@ -15516,7 +16146,7 @@ function createSessionHealthRuntime(deps) {
       }
     }
     if (!changed) return;
-    store.updateSession(sessionId, next);
+    store.updateSession(sessionId, next, { touch: options?.touch });
   }
   function maybePersistProgress(sessionId, updates, progressType) {
     const nowMs = Date.now();
@@ -15619,10 +16249,13 @@ function createSessionHealthRuntime(deps) {
       active_tool_name: void 0,
       active_tool_started_at: void 0,
       stream_ui_flush_started_at: void 0,
-      last_health_check_at: nowIso4
+      last_stream_ui_attempt_at: void 0,
+      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
     }, { 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;
@@ -15638,6 +16271,12 @@ function createSessionHealthRuntime(deps) {
       updates.last_stream_ui_error_at = toIso(snapshot.lastErrorAt);
       updates.last_stream_ui_error = snapshot.lastError?.trim() || void 0;
       updates.stream_ui_consecutive_failures = snapshot.consecutiveFailures && snapshot.consecutiveFailures > 0 ? snapshot.consecutiveFailures : void 0;
+    } else {
+      updates.last_stream_ui_attempt_at = void 0;
+      updates.last_stream_ui_update_at = void 0;
+      updates.last_stream_ui_error_at = void 0;
+      updates.last_stream_ui_error = void 0;
+      updates.stream_ui_consecutive_failures = void 0;
     }
     updateSessionHealth(sessionId, updates);
   }
@@ -15705,23 +16344,13 @@ function createSessionHealthRuntime(deps) {
       updateSessionHealth(session.id, {
         health_status: diagnosis.healthStatus,
         health_reason: diagnosis.healthReason
-      });
+      }, { touch: false });
     }
   }
   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();
@@ -15729,16 +16358,10 @@ function createSessionHealthRuntime(deps) {
     if (!session) return null;
     const base = computeBaseDiagnosis(session, Date.now());
     const processProbe = await loadProcessProbe(session);
-    const diagnosis = applyStreamUiDiagnosis(
+    return applyStreamUiDiagnosis(
       applyProcessProbeDiagnosis(base, processProbe),
       Date.now()
     );
-    updateSessionHealth(sessionId, {
-      health_status: diagnosis.healthStatus,
-      health_reason: diagnosis.healthReason,
-      last_health_check_at: deps.nowIso()
-    });
-    return diagnosis;
   }
   async function diagnoseAllActiveSessions() {
     const store = deps.getStore();
@@ -15759,6 +16382,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;
@@ -15769,10 +16486,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 INTERACTIVE_IDLE_REMINDER_MS = 6e5;
+var DESKTOP_TERMINAL_FINALIZATION_TIMEOUT_MS = 3e4;
 var MIRROR_STREAM_STATUS_IDLE_START_MS = 18e4;
 var MIRROR_STREAM_STATUS_HEARTBEAT_MS = 1e4;
-var MIRROR_IDLE_TIMEOUT_MS = 6e5;
+var MIRROR_TURN_BUFFER_TIMEOUT_MS = 6e5;
 function describeUnknownError(error) {
   if (error instanceof Error) {
     return error.stack || `${error.name}: ${error.message}`;
@@ -15854,11 +16571,26 @@ function getState() {
   return g[GLOBAL_KEY];
 }
 var INTERACTIVE_RUNTIME = createInteractiveRuntime(getState, {
-  idleReminderMs: INTERACTIVE_IDLE_REMINDER_MS
-}, {
   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,
@@ -15895,9 +16627,6 @@ function settleMirrorSuppression2(sessionId, suppressionId, durationMs = MIRROR_
     durationMs
   );
 }
-function isMirrorSuppressed2(sessionId) {
-  return isMirrorSuppressed(getMirrorSuppressionStore(), sessionId);
-}
 function filterSuppressedMirrorRecords2(sessionId, records) {
   return filterSuppressedMirrorRecords(
     getMirrorSuppressionStore(),
@@ -15931,28 +16660,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);
@@ -15968,194 +16675,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()) {
-  return flushTimedOutMirrorTurn(subscription, MIRROR_IDLE_TIMEOUT_MS, nowMs);
+  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_IDLE_TIMEOUT_MS, nowMs, MIRROR_TURN_HOOKS);
+  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,
@@ -16167,11 +16723,16 @@ var MIRROR_RUNTIME = createMirrorRuntime(getState, {
   describeUnknownError,
   getDesktopSessionByThreadIdSafe,
   syncMirrorSessionStateSafe,
-  isMirrorSuppressed: isMirrorSuppressed2,
   filterSuppressedMirrorRecords: filterSuppressedMirrorRecords2,
   observeSessionHealthRecords: (sessionId, threadId, records) => {
     SESSION_HEALTH_RUNTIME.observeDesktopMirrorRecords(sessionId, threadId, records);
   },
+  routeDesktopRecords: (sessionId, threadId, records) => routeDesktopRecords(
+    sessionId,
+    threadId,
+    records,
+    TURN_COORDINATOR
+  ),
   consumeMirrorRecords: consumeMirrorRecords2,
   flushTimedOutMirrorTurn: (subscription) => flushTimedOutMirrorTurn2(subscription),
   hasPendingMirrorWork: hasPendingMirrorWork2,
@@ -16229,15 +16790,14 @@ async function start() {
     void ADAPTER_RUNTIME.syncConfiguredAdapters({ startLoops: true }).catch((err) => {
       console.error("[bridge-manager] Adapter reconcile failed:", err);
     });
-    void INTERACTIVE_RUNTIME.reconcileIdleInteractiveTasks().catch((err) => {
-      console.error("[bridge-manager] Interactive idle reminder reconcile failed:", err);
-    });
     try {
       SESSION_HEALTH_RUNTIME.reconcileSessionHealth();
-      INTERACTIVE_RUNTIME.reconcileTerminalSessionRuntimeState();
     } catch (err) {
       console.error("[bridge-manager] Session health reconcile failed:", describeUnknownError(err));
     }
+    void INTERACTIVE_RUNTIME.reconcileTerminalSessionRuntimeState().catch((err) => {
+      console.error("[bridge-manager] Terminal interactive reconcile failed:", describeUnknownError(err));
+    });
   }, 5e3);
   state.mirrorPollTimer = setInterval(() => {
     void reconcileMirrorSubscriptions().catch((err) => {
@@ -16420,6 +16980,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),
@@ -16436,8 +16997,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();
@@ -16749,7 +17312,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;
       }
     }
@@ -16786,7 +17349,7 @@ var JsonFileStore = class {
       this.persistSessions();
     }
   }
-  updateSession(sessionId, updates) {
+  updateSession(sessionId, updates, options) {
     this.reloadSessions();
     const session = this.sessions.get(sessionId);
     if (!session) return;
@@ -16794,7 +17357,7 @@ var JsonFileStore = class {
       ...session,
       ...updates,
       id: session.id,
-      updated_at: now()
+      updated_at: options?.touch === false ? session.updated_at : now()
     };
     this.sessions.set(sessionId, next);
     this.persistSessions();
@@ -16883,6 +17446,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();
     }