codex-to-im 1.0.45 → 1.0.46

package/dist/daemon.mjs

@@ -1223,14 +1223,19 @@ function buildPostContent(text2) {
 function htmlToFeishuMarkdown(html) {
   return html.replace(/<b>(.*?)<\/b>/gi, "**$1**").replace(/<strong>(.*?)<\/strong>/gi, "**$1**").replace(/<i>(.*?)<\/i>/gi, "*$1*").replace(/<em>(.*?)<\/em>/gi, "*$1*").replace(/<code>(.*?)<\/code>/gi, "`$1`").replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/\n{3,}/g, "\n\n").trim();
 }
-function buildToolProgressMarkdown(tools) {
+function normalizeToolStatusForRender(status, options) {
+  if (status !== "running" || !options.terminalStatus) return status;
+  return options.terminalStatus === "completed" ? "complete" : "error";
+}
+function buildToolProgressMarkdown(tools, options = {}) {
   if (tools.length === 0) return "";
   const grouped = /* @__PURE__ */ new Map();
   for (const tool of tools) {
     const key = tool.name || "tool";
     const bucket = grouped.get(key) || { running: 0, complete: 0, error: 0 };
-    if (tool.status === "running") bucket.running += 1;
-    else if (tool.status === "error") bucket.error += 1;
+    const status = normalizeToolStatusForRender(tool.status, options);
+    if (status === "running") bucket.running += 1;
+    else if (status === "error") bucket.error += 1;
     else bucket.complete += 1;
     grouped.set(key, bucket);
   }
@@ -1249,11 +1254,25 @@ function buildToolProgressMarkdown(tools) {
   });
   return lines.join("\n");
 }
-function buildTaskProgressMarkdown(tasks) {
+function getTaskProgressPresentation(task, options) {
+  if (!options.terminalStatus) {
+    return task.status === "completed" ? { icon: "\u2705", label: "\u5DF2\u5B8C\u6210" } : task.status === "in_progress" ? { icon: "\u{1F504}", label: "\u6267\u884C\u4E2D" } : { icon: "\u23F3", label: "\u7B49\u5F85\u4E2D" };
+  }
+  if (task.status === "completed") {
+    return { icon: "\u2705", label: "\u5DF2\u5B8C\u6210" };
+  }
+  if (options.terminalStatus === "completed") {
+    return { icon: "\u2705", label: "\u5DF2\u7ED3\u675F" };
+  }
+  if (options.terminalStatus === "interrupted") {
+    return task.status === "pending" ? { icon: "\u26A0\uFE0F", label: "\u672A\u6267\u884C" } : { icon: "\u26A0\uFE0F", label: "\u5DF2\u505C\u6B62" };
+  }
+  return task.status === "pending" ? { icon: "\u274C", label: "\u672A\u6267\u884C" } : { icon: "\u274C", label: "\u5DF2\u4E2D\u65AD" };
+}
+function buildTaskProgressMarkdown(tasks, options = {}) {
   if (tasks.length === 0) return "";
   return tasks.map((task) => {
-    const icon = task.status === "completed" ? "\u2705" : task.status === "in_progress" ? "\u{1F504}" : "\u23F3";
-    const label = task.status === "completed" ? "\u5DF2\u5B8C\u6210" : task.status === "in_progress" ? "\u6267\u884C\u4E2D" : "\u7B49\u5F85\u4E2D";
+    const { icon, label } = getTaskProgressPresentation(task, options);
     return `${icon} ${task.text}\uFF08${label}\uFF09`;
   }).join("\n");
 }
@@ -1274,11 +1293,12 @@ function buildStreamingToolsContent(tools) {
 function buildStreamingTaskContent(tasks) {
   return buildTaskProgressMarkdown(tasks);
 }
-function buildFinalCardJson(text2, tasks, tools, footer) {
+function buildFinalCardJson(text2, tasks, tools, footer, terminalStatus) {
   const elements = [];
   const content = preprocessFeishuMarkdown(text2);
-  const taskMd = buildTaskProgressMarkdown(tasks);
-  const toolMd = buildToolProgressMarkdown(tools);
+  const renderOptions = { terminalStatus };
+  const taskMd = buildTaskProgressMarkdown(tasks, renderOptions);
+  const toolMd = buildToolProgressMarkdown(tools, renderOptions);
   if (content) {
     elements.push({
       tag: "markdown",
@@ -1384,9 +1404,53 @@ var MAX_FILE_SIZE = 20 * 1024 * 1024;
 var TYPING_EMOJI = "Typing";
 var CARD_THROTTLE_MS = 1e3;
 var CARD_REQUEST_TIMEOUT_MS = 15e3;
+var CARD_FINALIZE_FLUSH_WAIT_EXTRA_MS = 1e3;
+var CARD_FULL_REFRESH_INTERVAL_MS = 5 * 6e4;
 var INITIAL_STREAMING_STATUS = "\u5904\u7406\u4E2D";
 var EMPTY_STREAMING_TASKS = "";
 var EMPTY_STREAMING_TOOLS = "";
+function buildStreamingCardBody(content, tasksText, toolsText, statusText) {
+  return {
+    schema: "2.0",
+    config: {
+      streaming_mode: true,
+      wide_screen_mode: true,
+      summary: { content: "\u601D\u8003\u4E2D..." }
+    },
+    body: {
+      elements: [
+        {
+          tag: "markdown",
+          content,
+          text_align: "left",
+          text_size: "normal",
+          element_id: "streaming_content"
+        },
+        {
+          tag: "markdown",
+          content: tasksText,
+          text_align: "left",
+          text_size: "normal",
+          element_id: "streaming_tasks"
+        },
+        {
+          tag: "markdown",
+          content: toolsText,
+          text_align: "left",
+          text_size: "normal",
+          element_id: "streaming_tools"
+        },
+        {
+          tag: "markdown",
+          content: statusText,
+          text_align: "left",
+          text_size: "notation",
+          element_id: "streaming_status"
+        }
+      ]
+    }
+  };
+}
 var MIME_BY_TYPE = {
   image: "image/png",
   file: "application/octet-stream",
@@ -1421,6 +1485,8 @@ var FeishuAdapter = class extends BaseChannelAdapter {
   /** Cached tenant token for upload APIs. */
   tenantTokenCache = null;
   cardRequestTimeoutMs = CARD_REQUEST_TIMEOUT_MS;
+  cardFinalizeFlushWaitExtraMs = CARD_FINALIZE_FLUSH_WAIT_EXTRA_MS;
+  cardFullRefreshIntervalMs = CARD_FULL_REFRESH_INTERVAL_MS;
   constructor(instance) {
     super();
     this.channelType = instance?.id || "feishu";
@@ -1654,46 +1720,12 @@ var FeishuAdapter = class extends BaseChannelAdapter {
       return false;
     }
     try {
-      const cardBody = {
-        schema: "2.0",
-        config: {
-          streaming_mode: true,
-          wide_screen_mode: true,
-          summary: { content: "\u601D\u8003\u4E2D..." }
-        },
-        body: {
-          elements: [
-            {
-              tag: "markdown",
-              content: "\u{1F4AD} Thinking...",
-              text_align: "left",
-              text_size: "normal",
-              element_id: "streaming_content"
-            },
-            {
-              tag: "markdown",
-              content: EMPTY_STREAMING_TASKS,
-              text_align: "left",
-              text_size: "normal",
-              element_id: "streaming_tasks"
-            },
-            {
-              tag: "markdown",
-              content: EMPTY_STREAMING_TOOLS,
-              text_align: "left",
-              text_size: "normal",
-              element_id: "streaming_tools"
-            },
-            {
-              tag: "markdown",
-              content: INITIAL_STREAMING_STATUS,
-              text_align: "left",
-              text_size: "notation",
-              element_id: "streaming_status"
-            }
-          ]
-        }
-      };
+      const cardBody = buildStreamingCardBody(
+        "\u{1F4AD} Thinking...",
+        EMPTY_STREAMING_TASKS,
+        EMPTY_STREAMING_TOOLS,
+        INITIAL_STREAMING_STATUS
+      );
       const createResp = await this.withFeishuRequestTimeout(cardKey, "card.create", () => cardkit.card.create({
         data: { type: "card_json", data: JSON.stringify(cardBody) }
       }));
@@ -1724,12 +1756,13 @@ var FeishuAdapter = class extends BaseChannelAdapter {
         console.warn("[feishu-adapter] Card message send returned no message_id");
         return false;
       }
+      const now2 = Date.now();
       this.activeCards.set(cardKey, {
         chatId,
         cardId,
         messageId,
         sequence: 0,
-        startTime: Date.now(),
+        startTime: now2,
         taskItems: [],
         toolCalls: [],
         thinking: true,
@@ -1748,7 +1781,9 @@ var FeishuAdapter = class extends BaseChannelAdapter {
         lastSuccessfulFlushAt: null,
         lastFlushErrorAt: null,
         lastFlushError: null,
-        consecutiveFlushFailures: 0
+        consecutiveFlushFailures: 0,
+        lastFullRefreshAttemptAt: now2,
+        lastSuccessfulFullRefreshAt: null
       });
       console.log(`[feishu-adapter] Streaming card created: streamKey=${cardKey}, cardId=${cardId}, msgId=${messageId}`);
       return true;
@@ -1837,6 +1872,17 @@ var FeishuAdapter = class extends BaseChannelAdapter {
     const toolsText = buildStreamingToolsContent(state.toolCalls) || EMPTY_STREAMING_TOOLS;
     const statusText = state.pendingStatusText || INITIAL_STREAMING_STATUS;
     const updates = [];
+    if (this.shouldFullRefreshCard(state, Date.now())) {
+      const refreshed = await this.flushFullCardRefresh(
+        streamKey,
+        state,
+        content,
+        tasksText,
+        toolsText,
+        statusText
+      );
+      if (refreshed) return;
+    }
     if (content !== state.renderedText) {
       updates.push({
         elementId: "streaming_content",
@@ -1903,24 +1949,33 @@ var FeishuAdapter = class extends BaseChannelAdapter {
     state.toolCalls = tools;
     this.scheduleCardFlush(cardKey);
   }
-  async awaitCardFlushCompletion(streamKey) {
+  async awaitCardFlushCompletion(streamKey, timeoutMs = this.getCardRequestTimeoutMs() + Math.max(0, this.cardFinalizeFlushWaitExtraMs)) {
+    const deadline = Date.now() + Math.max(0, timeoutMs);
     while (true) {
       const state = this.activeCards.get(streamKey);
-      if (!state) return;
+      if (!state) return true;
       const inFlight = state.flushInFlight;
       if (inFlight) {
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) return false;
+        const timedOut = Symbol("flush-timeout");
         try {
-          await inFlight;
+          const result = await Promise.race([
+            inFlight.then(() => null),
+            new Promise((resolve2) => setTimeout(() => resolve2(timedOut), remainingMs))
+          ]);
+          if (result === timedOut) return false;
         } catch {
         }
         continue;
       }
+      if (Date.now() >= deadline) return false;
       if (state.flushQueued) {
         state.flushQueued = false;
         this.enqueueCardFlush(streamKey);
         continue;
       }
-      return;
+      return true;
     }
   }
   /**
@@ -1943,7 +1998,12 @@ var FeishuAdapter = class extends BaseChannelAdapter {
       clearTimeout(state.throttleTimer);
       state.throttleTimer = null;
     }
-    await this.awaitCardFlushCompletion(cardKey);
+    const flushed = await this.awaitCardFlushCompletion(cardKey);
+    if (!flushed) {
+      console.warn(`[feishu-adapter] Card finalize proceeding after flush wait timeout: streamKey=${cardKey}`);
+      state.flushInFlight = null;
+      state.flushQueued = false;
+    }
     try {
       state.sequence++;
       await this.withFeishuRequestTimeout(cardKey, "card.settings", () => cardkit.card.settings({
@@ -1972,7 +2032,7 @@ var FeishuAdapter = class extends BaseChannelAdapter {
 
 ${trimmedResponse}`;
       }
-      const finalCardJson = buildFinalCardJson(finalText, state.taskItems, state.toolCalls, footer);
+      const finalCardJson = buildFinalCardJson(finalText, state.taskItems, state.toolCalls, footer, status);
       state.sequence++;
       await this.withFeishuRequestTimeout(cardKey, "card.update", () => cardkit.card.update({
         path: { card_id: state.cardId },
@@ -2026,6 +2086,44 @@ ${trimmedResponse}`;
       consecutiveFailures: state.consecutiveFlushFailures
     };
   }
+  shouldFullRefreshCard(state, now2) {
+    const interval = Math.max(0, this.cardFullRefreshIntervalMs);
+    if (interval <= 0) return false;
+    if (!Number.isFinite(now2)) return false;
+    return now2 - state.lastFullRefreshAttemptAt >= interval;
+  }
+  async flushFullCardRefresh(streamKey, state, content, tasksText, toolsText, statusText) {
+    state.lastFullRefreshAttemptAt = Date.now();
+    const cardkit = this.restClient?.cardkit?.v1;
+    if (!cardkit?.card?.update) return false;
+    try {
+      state.sequence++;
+      await this.withFeishuRequestTimeout(streamKey, "card.update:streaming_refresh", () => cardkit.card.update({
+        path: { card_id: state.cardId },
+        data: {
+          card: {
+            type: "card_json",
+            data: JSON.stringify(buildStreamingCardBody(content, tasksText, toolsText, statusText))
+          },
+          sequence: state.sequence
+        }
+      }));
+      state.renderedText = content;
+      state.renderedTasksText = tasksText;
+      state.renderedToolsText = toolsText;
+      state.renderedStatusText = statusText;
+      state.lastSuccessfulFullRefreshAt = Date.now();
+      this.markCardFlushSuccess(state);
+      return true;
+    } catch (err) {
+      this.markCardFlushFailure(state, err);
+      console.warn(
+        "[feishu-adapter] card.update streaming refresh failed:",
+        err instanceof Error ? err.message : err
+      );
+      return false;
+    }
+  }
   getCardRequestTimeoutMs() {
     return Math.max(1, this.cardRequestTimeoutMs);
   }
@@ -13360,10 +13458,27 @@ ${truncateHistoryContent(formatStoredMessageContent(message.content))}`;
     }
     case "/stop": {
       const binding = resolve(msg.address);
+      const session = store.getSession(binding.codepilotSessionId);
       const task = deps.getActiveTask(binding.codepilotSessionId);
-      if (task) {
-        task.abortController.abort();
-        response = "\u6B63\u5728\u505C\u6B62\u5F53\u524D\u4EFB\u52A1...";
+      const runningHealthStatuses = /* @__PURE__ */ new Set([
+        "running_active",
+        "waiting_tool",
+        "slow_observed",
+        "suspected_stall",
+        "suspected_stream_ui_stall",
+        "suspected_detached"
+      ]);
+      const looksRunning = session?.runtime_status === "running" || session?.runtime_status === "queued" || runningHealthStatuses.has(session?.health_status || "");
+      if (task || looksRunning) {
+        const taskName = getSessionDisplayName(session, binding.workingDirectory);
+        const detail = "\u7528\u6237\u6267\u884C /stop\uFF0C\u5DF2\u505C\u6B62\u5F53\u524D\u4EFB\u52A1\u3002";
+        if (deps.forceStopSession) {
+          await deps.forceStopSession(binding.codepilotSessionId, detail);
+        } else if (task) {
+          task.abortController.abort();
+        }
+        deps.recordInteractiveHealthEnd?.(binding.codepilotSessionId, "aborted", detail);
+        response = `\u65E7\u4F1A\u8BDD\u300C${taskName}\u300D\u4EFB\u52A1\u5DF2\u505C\u6B62\uFF0C\u53EF\u7EE7\u7EED\u53D1\u9001\u6D88\u606F\u6062\u590D\u8BE5\u7EBF\u7A0B\u3002`;
       } else {
         response = "\u5F53\u524D\u6CA1\u6709\u6B63\u5728\u8FD0\u884C\u7684\u4EFB\u52A1\u3002";
       }
@@ -14537,6 +14652,22 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
   let finalOutcome = "failed";
   let finalOutcomeDetail;
   let shouldRecordHealthEnd = true;
+  let forceStopStarted = false;
+  taskState.forceStop = async (detail = "\u4EFB\u52A1\u5DF2\u6536\u5230\u505C\u6B62\u8BF7\u6C42\u3002") => {
+    if (forceStopStarted) return true;
+    forceStopStarted = true;
+    finalOutcome = "aborted";
+    finalOutcomeDetail = detail;
+    taskAbort.abort();
+    stopStructuredStreamStatusUpdates();
+    endPreviewOnce();
+    try {
+      await finalizeStreamUiOnce("interrupted", detail);
+    } catch {
+    }
+    endMessageUiOnce();
+    return true;
+  };
   try {
     const promptText = text2 || (attachments && attachments.length > 0 ? "Describe this image." : "");
     const processPromise = processMessageImpl(
@@ -14691,7 +14822,7 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     if (shouldRecordHealthEnd) {
       if (taskAbort.signal.aborted && !externalTerminalRequest) {
         finalOutcome = "aborted";
-        finalOutcomeDetail = "\u4EFB\u52A1\u5DF2\u6536\u5230\u505C\u6B62\u8BF7\u6C42\u3002";
+        finalOutcomeDetail = finalOutcomeDetail || "\u4EFB\u52A1\u5DF2\u6536\u5230\u505C\u6B62\u8BF7\u6C42\u3002";
       }
       deps.recordInteractiveHealthEnd(binding.codepilotSessionId, finalOutcome, finalOutcomeDetail);
     }
@@ -14712,6 +14843,13 @@ function isTerminalSessionHealthStatus(status) {
   return Boolean(status && TERMINAL_SESSION_HEALTH_STATUSES.has(status));
 }
 function createInteractiveRuntime(getState2, deps) {
+  const sessionLockVersions = /* @__PURE__ */ new Map();
+  function getSessionLockVersion(sessionId) {
+    return sessionLockVersions.get(sessionId) || 0;
+  }
+  function invalidateSessionLockQueue(sessionId) {
+    sessionLockVersions.set(sessionId, getSessionLockVersion(sessionId) + 1);
+  }
   function getQueuedCount(sessionId) {
     return getState2().queuedCounts.get(sessionId) || 0;
   }
@@ -14758,6 +14896,23 @@ function createInteractiveRuntime(getState2, deps) {
     if (!task?.finalizeFromExternalTerminal) return false;
     return task.finalizeFromExternalTerminal(outcome, detail, finalText);
   }
+  async function forceStopSession(sessionId, detail) {
+    const state = getState2();
+    const task = state.activeTasks.get(sessionId);
+    let handled = false;
+    if (task?.forceStop) {
+      handled = await task.forceStop(detail);
+    } else if (task) {
+      task.abortController.abort();
+      handled = true;
+    }
+    state.activeTasks.delete(sessionId);
+    state.queuedCounts.delete(sessionId);
+    state.sessionLocks.delete(sessionId);
+    invalidateSessionLockQueue(sessionId);
+    syncSessionRuntimeState(sessionId);
+    return handled;
+  }
   async function reconcileTerminalSessionRuntimeState() {
     const store = deps.getStore();
     for (const session of store.listSessions()) {
@@ -14809,6 +14964,7 @@ function createInteractiveRuntime(getState2, deps) {
     const state = getState2();
     const prev = state.sessionLocks.get(sessionId) || Promise.resolve();
     const queued = state.sessionLocks.has(sessionId);
+    const lockVersion = getSessionLockVersion(sessionId);
     if (queued) {
       incrementQueuedCount(sessionId);
     }
@@ -14816,6 +14972,7 @@ function createInteractiveRuntime(getState2, deps) {
       if (queued) {
         decrementQueuedCount(sessionId);
       }
+      if (getSessionLockVersion(sessionId) !== lockVersion) return;
       await fn();
     };
     const current = prev.then(wrapped, wrapped);
@@ -14837,6 +14994,7 @@ function createInteractiveRuntime(getState2, deps) {
     releaseInteractiveTask,
     syncSessionRuntimeState,
     finalizeTerminalActiveTask,
+    forceStopSession,
     reconcileTerminalSessionRuntimeState,
     resetPersistedInteractiveRuntimeState,
     processWithSessionLock
@@ -15967,6 +16125,27 @@ function computeBaseDiagnosis(session, nowMs) {
   const sdkSessionId = trimOrNull(session.sdk_session_id);
   const lastProgressMs = parseIsoMs(lastProgressAt || void 0);
   const previousStatus = session.health_status || "idle";
+  if (!isRunningRuntimeStatus(runtimeStatus) && isRunningHealthStatus(previousStatus)) {
+    return {
+      sessionId: session.id,
+      checkedAt: null,
+      runtimeStatus,
+      healthStatus: "idle",
+      healthReason: "\u5F53\u524D\u6CA1\u6709\u8FD0\u884C\u4E2D\u7684\u4EFB\u52A1\u3002",
+      lastProgressAt,
+      lastProgressType,
+      activeToolName,
+      activeToolStartedAt,
+      lastToolFinishedAt,
+      lastStreamUiAttemptAt,
+      lastStreamUiUpdateAt,
+      streamUiFlushStartedAt,
+      lastStreamUiErrorAt,
+      lastStreamUiError,
+      streamUiConsecutiveFailures,
+      sdkSessionId
+    };
+  }
   if (!lastProgressMs) {
     const fallbackStatus = isRunningRuntimeStatus(runtimeStatus) ? "running_active" : previousStatus;
     return {
@@ -15999,10 +16178,10 @@ function computeBaseDiagnosis(session, nowMs) {
     );
   } else if (idleMs <= HEALTH_RECENT_PROGRESS_MS) {
     healthStatus = activeToolName ? "waiting_tool" : "running_active";
-    healthReason = activeToolName ? `\u5F53\u524D\u6B63\u5728\u7B49\u5F85\u5DE5\u5177 ${activeToolName}\u3002` : "\u6700\u8FD1 10 \u5206\u949F\u5185\u4ECD\u6709\u65B0\u8FDB\u5C55\u3002";
+    healthReason = activeToolName ? `\u5F53\u524D\u6B63\u5728\u7B49\u5F85\u5DE5\u5177 ${activeToolName}\u3002` : "\u8FD1\u671F\u4ECD\u6709\u65B0\u8FDB\u5C55\u3002";
   } else if (idleMs <= HEALTH_SLOW_OBSERVED_MS) {
     healthStatus = activeToolName ? "waiting_tool" : "slow_observed";
-    healthReason = activeToolName ? `\u5DE5\u5177 ${activeToolName} \u5DF2\u8FD0\u884C\u8F83\u4E45\uFF0C\u4F46\u4ECD\u5728\u89C2\u5BDF\u7A97\u53E3\u5185\u3002` : "\u6700\u8FD1 10 \u5230 30 \u5206\u949F\u5185\u6CA1\u6709\u65B0\u8FDB\u5C55\uFF0C\u5148\u6807\u8BB0\u4E3A\u5F85\u89C2\u5BDF\u3002";
+    healthReason = activeToolName ? `\u5DE5\u5177 ${activeToolName} \u5DF2\u8FD0\u884C\u8F83\u4E45\uFF0C\u4F46\u4ECD\u5728\u89C2\u5BDF\u7A97\u53E3\u5185\u3002` : "\u8FD1\u671F\u6CA1\u6709\u65B0\u7684\u6267\u884C\u8FDB\u5C55\uFF0C\u5148\u6807\u8BB0\u4E3A\u5F85\u89C2\u5BDF\u3002";
   } else {
     healthStatus = "suspected_stall";
     healthReason = activeToolName ? `\u5DE5\u5177 ${activeToolName} \u5DF2\u957F\u65F6\u95F4\u6CA1\u6709\u65B0\u8FDB\u5C55\uFF0C\u7591\u4F3C\u5361\u4F4F\u3002` : "\u5DF2\u7ECF\u8D85\u8FC7 30 \u5206\u949F\u6CA1\u6709\u65B0\u7684\u6267\u884C\u8FDB\u5C55\uFF0C\u7591\u4F3C\u5361\u4F4F\u3002";
@@ -16069,9 +16248,6 @@ function applyStreamUiDiagnosis(diagnosis, nowMs) {
     return diagnosis;
   }
   const lastProgressMs = parseIsoMs(diagnosis.lastProgressAt || void 0);
-  if (!lastProgressMs || nowMs - lastProgressMs > HEALTH_RECENT_PROGRESS_MS) {
-    return diagnosis;
-  }
   const lastStreamUiUpdateMs = parseIsoMs(diagnosis.lastStreamUiUpdateAt || void 0);
   const lastStreamUiAttemptMs = parseIsoMs(diagnosis.lastStreamUiAttemptAt || void 0);
   const streamUiFlushStartedMs = parseIsoMs(diagnosis.streamUiFlushStartedAt || void 0);
@@ -16090,7 +16266,21 @@ function applyStreamUiDiagnosis(diagnosis, nowMs) {
       healthReason: details.join(" ")
     };
   }
-  if (lastStreamUiUpdateMs && lastProgressMs - lastStreamUiUpdateMs >= HEALTH_STREAM_UI_STALL_MS) {
+  if (lastStreamUiAttemptMs && (!lastStreamUiUpdateMs || lastStreamUiAttemptMs - lastStreamUiUpdateMs >= HEALTH_STREAM_UI_STALL_MS)) {
+    const details = ["\u4EFB\u52A1\u4ECD\u5728\u7EE7\u7EED\uFF0C\u4F46\u6D41\u5F0F UI \u6709\u5237\u65B0\u5C1D\u8BD5\u672A\u6210\u529F\u8DDF\u8FDB\uFF0C\u7591\u4F3C\u505C\u66F4\u3002"];
+    if (diagnosis.streamUiConsecutiveFailures > 0) {
+      details.push(`\u6700\u8FD1\u8FDE\u7EED\u5931\u8D25 ${diagnosis.streamUiConsecutiveFailures} \u6B21\u3002`);
+    }
+    if (lastStreamUiErrorText) {
+      details.push(`\u6700\u8FD1\u9519\u8BEF\uFF1A${lastStreamUiErrorText}`);
+    }
+    return {
+      ...diagnosis,
+      healthStatus: "suspected_stream_ui_stall",
+      healthReason: details.join(" ")
+    };
+  }
+  if (lastProgressMs && lastStreamUiUpdateMs && lastProgressMs - lastStreamUiUpdateMs >= HEALTH_STREAM_UI_STALL_MS) {
     const details = ["\u4EFB\u52A1\u4ECD\u5728\u7EE7\u7EED\uFF0C\u4F46\u6D41\u5F0F UI \u5DF2\u957F\u65F6\u95F4\u6CA1\u6709\u8DDF\u4E0A\u6700\u65B0\u6267\u884C\u8FDB\u5C55\uFF0C\u7591\u4F3C\u505C\u66F4\u3002"];
     if (lastStreamUiErrorText) {
       details.push(`\u6700\u8FD1\u9519\u8BEF\uFF1A${lastStreamUiErrorText}`);
@@ -16101,7 +16291,7 @@ function applyStreamUiDiagnosis(diagnosis, nowMs) {
       healthReason: details.join(" ")
     };
   }
-  if (!lastStreamUiUpdateMs && lastStreamUiAttemptMs && lastProgressMs - lastStreamUiAttemptMs >= HEALTH_STREAM_UI_STALL_MS) {
+  if (lastProgressMs && !lastStreamUiUpdateMs && lastStreamUiAttemptMs && lastProgressMs - lastStreamUiAttemptMs >= HEALTH_STREAM_UI_STALL_MS) {
     const details = ["\u4EFB\u52A1\u4ECD\u5728\u7EE7\u7EED\uFF0C\u4F46\u6D41\u5F0F UI \u53EA\u6709\u53D1\u9001\u5C1D\u8BD5\u3001\u6CA1\u6709\u6210\u529F\u5237\u65B0\u8BB0\u5F55\uFF0C\u7591\u4F3C\u505C\u66F4\u3002"];
     if (lastStreamUiErrorText) {
       details.push(`\u6700\u8FD1\u9519\u8BEF\uFF1A${lastStreamUiErrorText}`);
@@ -16112,12 +16302,30 @@ function applyStreamUiDiagnosis(diagnosis, nowMs) {
       healthReason: details.join(" ")
     };
   }
+  const lastStreamUiActivityMs = Math.max(
+    lastStreamUiAttemptMs || 0,
+    lastStreamUiUpdateMs || 0,
+    streamUiFlushStartedMs || 0
+  );
+  if (lastStreamUiActivityMs > 0 && nowMs - lastStreamUiActivityMs >= HEALTH_STREAM_UI_STALL_MS) {
+    return {
+      ...diagnosis,
+      healthStatus: "suspected_stream_ui_stall",
+      healthReason: "\u4EFB\u52A1\u4ECD\u5728\u7EE7\u7EED\uFF0C\u4F46\u6D41\u5F0F UI \u72B6\u6001\u5237\u65B0\u5DF2\u505C\u6B62\uFF0C\u7591\u4F3C\u505C\u66F4\u3002"
+    };
+  }
   return diagnosis;
 }
 
 // src/lib/bridge/session-health-runtime.ts
 function createSessionHealthRuntime(deps) {
   const lastProgressPersistAt = /* @__PURE__ */ new Map();
+  function isTerminalHealthStatus(status) {
+    return status === "completed" || status === "failed" || status === "aborted";
+  }
+  function shouldIgnoreNonStartProgress(session) {
+    return isTerminalHealthStatus(session.health_status);
+  }
   function summarizePlanUpdate(tasks) {
     if (!Array.isArray(tasks) || tasks.length === 0) {
       return "\u68C0\u6D4B\u5230\u684C\u9762\u7EBF\u7A0B\u66F4\u65B0\u4E86\u4EFB\u52A1\u8BA1\u5212\u3002";
@@ -16185,6 +16393,8 @@ function createSessionHealthRuntime(deps) {
   }
   function recordInteractiveProgress(sessionId, type, detail) {
     const nowIso4 = deps.nowIso();
+    const session = deps.getStore().getSession(sessionId);
+    if (!session || shouldIgnoreNonStartProgress(session)) return;
     maybePersistProgress(sessionId, {
       health_status: type === "permission_wait" ? "waiting_tool" : "running_active",
       health_reason: buildProgressReason(type, detail),
@@ -16197,6 +16407,7 @@ function createSessionHealthRuntime(deps) {
     const store = deps.getStore();
     const session = store.getSession(sessionId);
     if (!session) return;
+    if (shouldIgnoreNonStartProgress(session)) return;
     const activeTools = new Map(
       parseActiveToolsJson(session.active_tools_json).map((tool) => [tool.id, tool])
     );
@@ -16489,7 +16700,7 @@ var MIRROR_PROMPT_MATCH_GRACE_MS = 12e4;
 var DESKTOP_TERMINAL_FINALIZATION_TIMEOUT_MS = 3e4;
 var MIRROR_STREAM_STATUS_IDLE_START_MS = 18e4;
 var MIRROR_STREAM_STATUS_HEARTBEAT_MS = 1e4;
-var MIRROR_TURN_BUFFER_TIMEOUT_MS = 6e5;
+var MIRROR_TURN_BUFFER_TIMEOUT_MS = 10 * 6e4;
 function describeUnknownError(error) {
   if (error instanceof Error) {
     return error.stack || `${error.name}: ${error.message}`;
@@ -17009,6 +17220,8 @@ async function handleMessage(adapter, msg) {
 async function handleCommand(adapter, msg, text2) {
   await handleBridgeCommand(adapter, msg, text2, {
     getActiveTask: (sessionId) => INTERACTIVE_RUNTIME.getActiveTask(sessionId),
+    forceStopSession: (sessionId, detail) => INTERACTIVE_RUNTIME.forceStopSession(sessionId, detail),
+    recordInteractiveHealthEnd: (sessionId, outcome, detail) => SESSION_HEALTH_RUNTIME.recordInteractiveEnd(sessionId, outcome, detail),
     diagnoseSessionHealth: (sessionId) => SESSION_HEALTH_RUNTIME.diagnoseSessionHealth(sessionId),
     diagnoseAllActiveSessions: () => SESSION_HEALTH_RUNTIME.diagnoseAllActiveSessions()
   });

package/docs/dev-plan.md

@@ -18,10 +18,15 @@
 
 ## 当前进度
 
-更新时间：2026-04-27
+更新时间：2026-04-28
 
 已完成：
 
+- 追加恢复任务已完成代码实现：`/stop` 改为线程级强制恢复，不重启 bridge。
+- 追加恢复任务已完成代码实现：强制停止会释放 active task、queued count、session lock，并让旧队列任务失效。
+- 追加恢复任务已完成代码实现：飞书卡片 finalize 不再无限等待卡住的流式 flush。
+- 追加恢复任务已完成代码实现：终态 session 不会再被迟到的正文/工具进展覆盖回 running。
+- 追加恢复任务已完成代码实现：健康诊断对 `runtime_status=idle` 但 `health_status=running_*` 的陈旧状态按 idle 展示，仍保持只读。
 - 阶段 1 已完成：新增 turn 类型与 turn 分类器。
 - 阶段 2 已完成主路径：新增 `TurnCoordinator` 与 Desktop terminal router，并接入 mirror runtime。
 - 阶段 3 已完成主路径：新增 `ResponseAssembler` 与 `DeliveryPipeline`，并接入 interactive final 和 mirror final。
@@ -63,10 +68,36 @@
 
 下一步：
 
-- 阶段 5 已完成；当前不建议继续大拆。
-- 后续建议进入上线前审查、全量验证、提交发布准备。
+- 运行 `npm run typecheck`、`npm test`、必要时 `npm run build`。
+- 验证通过后进入上线前审查、提交发布准备。
 - 后续任何清理仍必须保持 health/status 查询只读，不能把诊断命令当作运行态修复入口。
 
+## 追加开发任务：线程级停止与卡住恢复
+
+状态：已完成（2026-04-28）
+
+任务清单：
+
+- `/stop` 不重启 bridge，只针对当前绑定 session 执行强制停止。
+- `/stop` 对内存中没有 active task、但持久化 health 仍显示 running/stall 的 session 也能恢复。
+- 强制停止需要释放 `activeTasks`、`queuedCounts`、`sessionLocks`，并让停止前排队的旧 work 不再继续执行。
+- 强制停止需要写入 `health_status=aborted`，避免出现 `runtime_status=idle` 但 health 仍是 running/stall。
+- 飞书流式卡片收尾前等待 in-flight flush，但等待必须有上限；超时后继续 finalize，避免 IM 卡片永久不结束。
+- 健康检查和线程状态查询继续保持只读，不承担任何修复动作。
+
+测试清单：
+
+- `session-health-runtime.test.ts`：终态 session 不被迟到 progress/tool 覆盖；陈旧 idle+running health 诊断为 idle 且不落盘。
+- `interactive-runtime.test.ts`：`forceStopSession` 清理运行态；旧排队 work 在 force stop 后不再执行。
+- `command-dispatch.test.ts`：`/stop` 能恢复没有 active task 的疑似卡住 session。
+- `feishu-adapter.test.ts`：卡片 finalize 不会被卡住的 flush 永久阻塞。
+
+验证结果：
+
+- `npm run typecheck` 通过。
+- `npm test -- --test-name-pattern="session-health-runtime|interactive-runtime|command-dispatch|feishu-adapter|bridge-manager stop handling"` 实际执行全量 359 个测试，全部通过。
+- `npm run build` 通过。
+
 ## 目标
 
 - 明确建模三类 turn：`im_sdk`、`im_desktop_reuse`、`desktop_mirror`。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-to-im",
-  "version": "1.0.45",
+  "version": "1.0.46",
   "description": "Installable Codex-to-IM bridge with local setup UI and background service",
   "license": "MIT",
   "homepage": "https://github.com/zhangle1987/codex-to-im#readme",