codex-to-im 1.0.64 → 1.0.66

package/dist/daemon.mjs

@@ -1280,6 +1280,16 @@ function normalizeCodexErrorMessage(message) {
   }
   return trimmed;
 }
+function isCodexProcessRecoveryErrorMessage(message) {
+  const lower = (message || "").trim().toLowerCase();
+  return lower.includes("timeout waiting for child process to exit") || lower.includes("reconnecting...");
+}
+function enqueueCodexError(controller, message) {
+  if (isCodexProcessRecoveryErrorMessage(message)) {
+    controller.enqueue(sseEvent("status", { error_code: "desktop_transport_lost" }));
+  }
+  controller.enqueue(sseEvent("error", normalizeCodexErrorMessage(message)));
+}
 function getTerminalDrainTimeoutMs() {
   const configured = parseInt(process.env.CTI_CODEX_TERMINAL_DRAIN_TIMEOUT_MS || "", 10);
   if (Number.isFinite(configured) && configured >= 10) {
@@ -1452,6 +1462,10 @@ var init_codex_provider = __esm({
       clearCachedThreadId(sessionId) {
         this.threadIds.delete(sessionId);
       }
+      recycleSdkClient(sessionId) {
+        this.clearCachedThreadId(sessionId);
+        this.codex = null;
+      }
       /**
        * Lazily load the Codex SDK. Throws a clear error if the installation is incomplete.
        */
@@ -1641,15 +1655,25 @@ var init_codex_provider = __esm({
                         }
                         case "turn.failed": {
                           const error = event.error?.message;
-                          self.clearCachedThreadId(params.sessionId);
-                          controller.enqueue(sseEvent("error", normalizeCodexErrorMessage(error || "Turn failed")));
+                          const message = error || "Turn failed";
+                          if (isCodexProcessRecoveryErrorMessage(message)) {
+                            self.recycleSdkClient(params.sessionId);
+                          } else {
+                            self.clearCachedThreadId(params.sessionId);
+                          }
+                          enqueueCodexError(controller, message);
                           sawTerminalEvent = true;
                           break;
                         }
                         case "error": {
                           const error = event.message;
-                          self.clearCachedThreadId(params.sessionId);
-                          controller.enqueue(sseEvent("error", normalizeCodexErrorMessage(error || "Thread error")));
+                          const message = error || "Thread error";
+                          if (isCodexProcessRecoveryErrorMessage(message)) {
+                            self.recycleSdkClient(params.sessionId);
+                          } else {
+                            self.clearCachedThreadId(params.sessionId);
+                          }
+                          enqueueCodexError(controller, message);
                           sawTerminalEvent = true;
                           break;
                         }
@@ -1681,6 +1705,12 @@ var init_codex_provider = __esm({
                       console.warn("[codex-provider] Suppressed Codex SDK Windows process cleanup parse noise:", message);
                       break;
                     }
+                    if (isCodexProcessRecoveryErrorMessage(message)) {
+                      if (!runAbortController.signal.aborted) {
+                        runAbortController.abort();
+                      }
+                      self.recycleSdkClient(params.sessionId);
+                    }
                     if (savedThreadId && !retryFresh && !sawAnyEvent && shouldRetryFreshThread(message)) {
                       console.warn("[codex-provider] Resume failed, retrying with a fresh thread:", message);
                       self.clearCachedThreadId(params.sessionId);
@@ -1699,9 +1729,13 @@ var init_codex_provider = __esm({
               } catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
                 console.error("[codex-provider] Error:", err instanceof Error ? err.stack || err.message : err);
-                self.clearCachedThreadId(params.sessionId);
+                if (isCodexProcessRecoveryErrorMessage(message)) {
+                  self.recycleSdkClient(params.sessionId);
+                } else {
+                  self.clearCachedThreadId(params.sessionId);
+                }
                 try {
-                  controller.enqueue(sseEvent("error", normalizeCodexErrorMessage(message)));
+                  enqueueCodexError(controller, message);
                   controller.close();
                 } catch {
                 }
@@ -11867,7 +11901,7 @@ function parseDesktopSession(filePath, threadIndexEntries, archivedThreadIds, vi
   }
   const lastEventAt = visibleThread?.updatedAtMs ? new Date(visibleThread.updatedAtMs).toISOString() : stat.mtime.toISOString();
   const firstSeenAt = parsed.payload.timestamp || parsed.timestamp || stat.birthtime.toISOString();
-  const title = visibleThread?.title || threadIndexEntries.get(threadId)?.title || buildFallbackTitle(threadId, filePath, cwd);
+  const title = threadIndexEntries.get(threadId)?.title || visibleThread?.title || buildFallbackTitle(threadId, filePath, cwd);
   return {
     threadId,
     filePath,
@@ -12047,30 +12081,53 @@ function formatDesktopToolName(namespaceValue, nameValue) {
 function createDesktopEventSignature(rawLine) {
   return crypto7.createHash("sha1").update(rawLine).digest("hex");
 }
-function readCompleteUtf8LineRange(filePath, startOffset, endOffset) {
+function readCompleteUtf8LineRange(filePath, startOffset, endOffset, maxBytes) {
   const safeStart = Math.max(0, startOffset);
   const safeEnd = Math.max(safeStart, endOffset);
-  const bytesToRead = safeEnd - safeStart;
-  if (bytesToRead <= 0) return { content: "", nextOffset: safeStart };
+  const availableBytes = safeEnd - safeStart;
+  if (availableBytes <= 0) return { content: "", nextOffset: safeStart };
+  const boundedBytes = typeof maxBytes === "number" && Number.isFinite(maxBytes) ? Math.max(1, Math.min(availableBytes, Math.floor(maxBytes))) : availableBytes;
   const fd = fs5.openSync(filePath, "r");
   try {
-    const buffer = Buffer.alloc(bytesToRead);
-    let totalRead = 0;
-    while (totalRead < bytesToRead) {
-      const bytesRead = fs5.readSync(fd, buffer, totalRead, bytesToRead - totalRead, safeStart + totalRead);
-      if (bytesRead <= 0) break;
-      totalRead += bytesRead;
-    }
-    const readBuffer = buffer.subarray(0, totalRead);
-    const lastNewlineIndex = readBuffer.lastIndexOf(10);
-    if (lastNewlineIndex < 0) {
-      return { content: "", nextOffset: safeStart };
+    const chunks = [];
+    let totalBytes = 0;
+    let position = safeStart;
+    let firstChunk = true;
+    while (position < safeEnd) {
+      const requestedBytes = Math.min(boundedBytes, safeEnd - position);
+      const buffer = Buffer.allocUnsafe(requestedBytes);
+      let totalRead = 0;
+      while (totalRead < requestedBytes) {
+        const bytesRead = fs5.readSync(
+          fd,
+          buffer,
+          totalRead,
+          requestedBytes - totalRead,
+          position + totalRead
+        );
+        if (bytesRead <= 0) break;
+        totalRead += bytesRead;
+      }
+      if (totalRead <= 0) break;
+      const readBuffer = buffer.subarray(0, totalRead);
+      const newlineIndex = firstChunk ? readBuffer.lastIndexOf(10) : readBuffer.indexOf(10);
+      if (newlineIndex >= 0) {
+        const completeChunk = readBuffer.subarray(0, newlineIndex + 1);
+        chunks.push(completeChunk);
+        totalBytes += completeChunk.length;
+        const completeBuffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, totalBytes);
+        return {
+          content: completeBuffer.toString("utf-8"),
+          nextOffset: safeStart + totalBytes
+        };
+      }
+      chunks.push(readBuffer);
+      totalBytes += totalRead;
+      position += totalRead;
+      firstChunk = false;
+      if (totalRead < requestedBytes) break;
     }
-    const consumedBytes = lastNewlineIndex + 1;
-    return {
-      content: readBuffer.subarray(0, consumedBytes).toString("utf-8"),
-      nextOffset: safeStart + consumedBytes
-    };
+    return { content: "", nextOffset: safeStart };
   } finally {
     fs5.closeSync(fd);
   }
@@ -12831,10 +12888,10 @@ function readDesktopSessionMessages(threadId, limit = 8) {
   if (!session) return [];
   return readDesktopSessionMessagesByFilePath(session.filePath, limit);
 }
-function readDesktopSessionMirrorRecordDeltaByFilePath(filePath, startOffset, endOffset, trailingText = "", currentTurnId = null, currentSpecialCallIds = []) {
+function readDesktopSessionMirrorRecordDeltaByFilePath(filePath, startOffset, endOffset, trailingText = "", currentTurnId = null, currentSpecialCallIds = [], options = {}) {
   let range;
   try {
-    range = readCompleteUtf8LineRange(filePath, startOffset, endOffset);
+    range = readCompleteUtf8LineRange(filePath, startOffset, endOffset, options.maxBytes);
   } catch {
     return {
       records: [],
@@ -14478,6 +14535,18 @@ function abortMirrorSuppression(store, sessionId, config2, suppressionId, nowMs
   }
   target.until = nowMs + config2.suppressionWindowMs;
 }
+function handoffMirrorSuppression(store, sessionId, suppressionId) {
+  clearMirrorSuppression(store, sessionId, suppressionId);
+}
+function ignoreMirrorTurn(store, sessionId, config2, turnId, nowMs = Date.now()) {
+  markIgnoredMirrorTurn(
+    store,
+    sessionId,
+    turnId,
+    config2.promptMatchGraceMs,
+    nowMs
+  );
+}
 function filterSuppressedMirrorRecords(store, sessionId, records, config2, nowMs = Date.now(), onTurnAssociated) {
   const suppressions = getMirrorSuppressionStates(store, sessionId, nowMs);
   const ignoredTurnIds = cleanupIgnoredMirrorTurns(store, sessionId, nowMs);
@@ -14489,7 +14558,7 @@ function filterSuppressedMirrorRecords(store, sessionId, records, config2, nowMs
     while (true) {
       const ignoredTurnIds2 = cleanupIgnoredMirrorTurns(store, sessionId, nowMs);
       if (record.turnId && ignoredTurnIds2.has(record.turnId)) {
-        if (record.type === "task_complete") {
+        if (record.type === "task_complete" || record.type === "task_aborted") {
           clearIgnoredMirrorTurn(store, sessionId, record.turnId, nowMs);
         }
         handled = true;
@@ -15951,16 +16020,35 @@ ${truncateHistoryContent(formatStoredMessageContent(message.content))}`;
         "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) {
+      const taskName = getSessionDisplayName(session, binding.workingDirectory);
+      const stopDetail = "\u7528\u6237\u6267\u884C /stop\uFF0C\u8BF7\u6C42\u505C\u6B62\u5F53\u524D\u4EFB\u52A1\u3002";
+      if (deps.forceStopSession) {
+        const result = await deps.forceStopSession(binding.codepilotSessionId, stopDetail);
+        if (result.status === "stopped") {
+          deps.recordInteractiveHealthEnd?.(binding.codepilotSessionId, "aborted", stopDetail);
+          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 if (result.status === "stop_requested") {
+          deps.recordInteractiveHealthEnd?.(binding.codepilotSessionId, "aborted", stopDetail);
+          response = `\u5DF2\u5411\u65E7\u4F1A\u8BDD\u300C${taskName}\u300D\u53D1\u9001\u505C\u6B62\u8BF7\u6C42\u3002\u53EF\u53D1\u9001 \`//\` \u786E\u8BA4\u6700\u7EC8\u72B6\u6001\u3002`;
+        } else if (result.status === "not_running") {
+          response = result.detail || "\u5F53\u524D\u6CA1\u6709\u6B63\u5728\u8FD0\u884C\u7684\u4EFB\u52A1\u3002";
+        } else if (result.status === "unavailable") {
+          response = `\u65E0\u6CD5\u4ECE IM \u5B89\u5168\u505C\u6B62\u65E7\u4F1A\u8BDD\u300C${taskName}\u300D\uFF1A${result.detail}
+
+\u672A\u7EC8\u6B62 Codex Desktop App \u6216\u5176\u4ED6\u65E0\u6CD5\u786E\u8BA4\u5F52\u5C5E\u7684\u8FDB\u7A0B\u3002`;
+        } else {
+          response = `\u505C\u6B62\u65E7\u4F1A\u8BDD\u300C${taskName}\u300D\u5931\u8D25\uFF1A${result.detail}
+
+\u53EF\u7A0D\u540E\u91CD\u8BD5 \`/stop\`\uFF0C\u6216\u53D1\u9001 \`//\` \u67E5\u770B\u4EFB\u52A1\u662F\u5426\u4ECD\u5728\u8FD0\u884C\u3002`;
+        }
+      } else if (task || looksRunning) {
+        if (task) {
           task.abortController.abort();
+          deps.recordInteractiveHealthEnd?.(binding.codepilotSessionId, "aborted", stopDetail);
+          response = `\u5DF2\u5411\u65E7\u4F1A\u8BDD\u300C${taskName}\u300D\u53D1\u9001\u505C\u6B62\u8BF7\u6C42\u3002\u53EF\u53D1\u9001 \`//\` \u786E\u8BA4\u6700\u7EC8\u72B6\u6001\u3002`;
+        } else {
+          response = "\u5F53\u524D\u4EFB\u52A1\u770B\u8D77\u6765\u4ECD\u5728\u8FD0\u884C\uFF0C\u4F46\u5F53\u524D\u8FD0\u884C\u65F6\u4E0D\u652F\u6301\u4ECE IM \u5B89\u5168\u505C\u6B62\u3002";
         }
-        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";
       }
@@ -16458,6 +16546,7 @@ async function consumeStream(stream, sessionId, onPermissionRequest, onPartialTe
   let hasError = false;
   let errorMessage = "";
   let errorCode;
+  let providerErrorCode;
   const seenToolResultIds = /* @__PURE__ */ new Set();
   const permissionRequests = [];
   let capturedSdkSessionId = null;
@@ -16590,6 +16679,9 @@ async function consumeStream(stream, sessionId, onPermissionRequest, onPartialTe
               } catch {
               }
             }
+            if (statusData.error_code === "desktop_transport_lost") {
+              providerErrorCode = "desktop_transport_lost";
+            }
           } catch {
           }
           break;
@@ -16616,6 +16708,8 @@ async function consumeStream(stream, sessionId, onPermissionRequest, onPartialTe
           errorMessage = event.data || "Unknown error";
           if (isSessionBusyErrorMessage(errorMessage)) {
             errorCode = "session_busy";
+          } else if (providerErrorCode) {
+            errorCode = providerErrorCode;
           }
           break;
         case "result": {
@@ -16640,7 +16734,7 @@ async function consumeStream(stream, sessionId, onPermissionRequest, onPartialTe
       tokenUsage,
       hasError,
       errorMessage,
-      errorCode,
+      errorCode: errorCode || providerErrorCode,
       permissionRequests,
       sdkSessionId: capturedSdkSessionId
     };
@@ -16654,7 +16748,7 @@ async function consumeStream(stream, sessionId, onPermissionRequest, onPartialTe
       tokenUsage,
       hasError: true,
       errorMessage: fallbackErrorMessage,
-      errorCode: isSessionBusyErrorMessage(fallbackErrorMessage) ? "session_busy" : void 0,
+      errorCode: isSessionBusyErrorMessage(fallbackErrorMessage) ? "session_busy" : providerErrorCode,
       permissionRequests,
       sdkSessionId: capturedSdkSessionId
     };
@@ -16977,6 +17071,12 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
   const streamState = createStreamState(taskStartedAt);
   let externalTerminalRequest = null;
   let desktopTerminalFinalExpected = false;
+  let desktopTurnAccepted = false;
+  let desktopTurnId = null;
+  let desktopHandoffPreparation = null;
+  let desktopHandoffStopReady = false;
+  let desktopHandoffTaskActivated = false;
+  let retainDesktopHandoffTask = false;
   let resolveExternalTerminal = null;
   const externalTerminalPromise = new Promise((resolve2) => {
     resolveExternalTerminal = resolve2;
@@ -17032,7 +17132,25 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     desktopThreadId,
     requestMessageId: msg.messageId,
     streamKey,
-    startedAt: taskStartedAt
+    startedAt: taskStartedAt,
+    onDesktopTurnAssociated: (turnId) => {
+      desktopTurnAccepted = true;
+      desktopTurnId = turnId;
+      if (desktopThreadId && deps.prepareDesktopHandoffTask && !desktopHandoffPreparation) {
+        desktopHandoffPreparation = deps.prepareDesktopHandoffTask({
+          sessionId: binding.codepilotSessionId,
+          taskId,
+          threadId: desktopThreadId,
+          turnId
+        }).catch((error) => {
+          console.warn(
+            `[interactive-message-runner] Failed to prepare Desktop handoff stop control for ${desktopThreadId}:`,
+            error instanceof Error ? error.message : error
+          );
+          return false;
+        });
+      }
+    }
   });
   deps.recordInteractiveHealthStart(binding.codepilotSessionId);
   let previewState = null;
@@ -17409,7 +17527,30 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
       shouldRecordHealthEnd = false;
       return;
     }
+    const desktopTransportLost = Boolean(
+      desktopThreadId && desktopTurnAccepted && result.hasError && result.errorCode === "desktop_transport_lost"
+    );
+    if (desktopTransportLost && desktopHandoffPreparation && deps.activateDesktopHandoffTask) {
+      desktopHandoffStopReady = await desktopHandoffPreparation;
+      if (deps.isCurrentInteractiveTask(binding.codepilotSessionId, taskId)) {
+        desktopHandoffTaskActivated = deps.activateDesktopHandoffTask(
+          binding.codepilotSessionId,
+          taskId
+        );
+      }
+    }
+    if (!deps.isCurrentInteractiveTask(binding.codepilotSessionId, taskId)) {
+      shouldRecordHealthEnd = false;
+      return;
+    }
     const terminalAfterProcess = await waitForDesktopTerminalFinalization();
+    if (!deps.isCurrentInteractiveTask(binding.codepilotSessionId, taskId)) {
+      shouldRecordHealthEnd = false;
+      return;
+    }
+    if (taskAbort.signal.aborted && !externalTerminalRequest) {
+      return;
+    }
     const terminalResponse = terminalAfterProcess?.outcome === "completed" ? assembleDesktopFinalResponse({ text: terminalAfterProcess.finalText || "" }) : null;
     const sdkResponse = assembleSdkFinalResponse({
       text: result.responseText,
@@ -17417,6 +17558,33 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
       hasError: result.hasError,
       errorMessage: result.errorMessage
     });
+    const shouldHandoffToMirror = Boolean(
+      desktopThreadId && desktopTurnAccepted && !terminalAfterProcess && result.hasError && result.errorCode === "desktop_transport_lost" && deps.handoffMirrorSuppression
+    );
+    if (shouldHandoffToMirror) {
+      const canStopFromIm = desktopHandoffTaskActivated && desktopHandoffStopReady;
+      retainDesktopHandoffTask = Boolean(desktopHandoffTaskActivated && desktopTurnId);
+      const handoffText = [
+        "Codex Desktop \u5DF2\u63A5\u6536\u672C\u6B21\u8BF7\u6C42\uFF0C\u4F46 SDK \u8FDE\u63A5\u5728\u6267\u884C\u4E2D\u65AD\u5F00\u3002",
+        "\u5DF2\u81EA\u52A8\u5207\u6362\u4E3A\u684C\u9762\u955C\u50CF\u63A5\u7BA1\uFF1B\u540E\u7EED\u56DE\u590D\u548C\u9644\u4EF6\u4F1A\u7EE7\u7EED\u56DE\u4F20\uFF0C\u8BF7\u4E0D\u8981\u91CD\u590D\u53D1\u9001\u540C\u4E00\u8BF7\u6C42\u3002",
+        canStopFromIm ? "\u53EF\u53D1\u9001 `//` \u67E5\u770B\u5F53\u524D\u72B6\u6001\uFF1B\u82E5\u8981\u653E\u5F03\u672C\u6B21\u684C\u9762\u4EFB\u52A1\uFF0C\u8BF7\u53D1\u9001 `/stop`\u3002`/t 0` \u53EA\u5207\u6362\u4F1A\u8BDD\uFF0C\u4E0D\u4F1A\u505C\u6B62\u539F\u4EFB\u52A1\u3002" : "\u53EF\u53D1\u9001 `//` \u67E5\u770B\u5F53\u524D\u72B6\u6001\uFF1B\u4E5F\u53EF\u53D1\u9001 `/stop` \u5C1D\u8BD5\u5B89\u5168\u505C\u6B62\u3002\u82E5\u65E0\u6CD5\u9A8C\u8BC1 bridge \u81EA\u6709\u8FDB\u7A0B\uFF0C\u7CFB\u7EDF\u4E0D\u4F1A\u8BEF\u505C Desktop App\u3002"
+      ].join("\n\n");
+      if (taskState.mirrorSuppressionId && deps.handoffMirrorSuppression) {
+        deps.handoffMirrorSuppression(
+          binding.codepilotSessionId,
+          taskState.mirrorSuppressionId
+        );
+        taskState.mirrorSuppressionId = null;
+      }
+      const handoffResponse = assembleSdkFinalResponse({
+        text: handoffText,
+        attachments: result.outboundAttachments
+      });
+      const cardFinalized2 = await finalizeStreamUiOnce("interrupted", handoffResponse.text);
+      await deliverFinalPayload(handoffResponse, { skipText: cardFinalized2 });
+      shouldRecordHealthEnd = false;
+      return;
+    }
     const terminalHasFinalPayload = Boolean(
       terminalResponse && hasFinalResponsePayload(terminalResponse)
     );
@@ -17472,6 +17640,9 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
       }
       deps.recordInteractiveHealthEnd(binding.codepilotSessionId, finalOutcome, finalOutcomeDetail);
     }
+    if (!retainDesktopHandoffTask) {
+      deps.releaseDesktopHandoffTask?.(binding.codepilotSessionId, taskId);
+    }
     deps.releaseInteractiveTask(binding.codepilotSessionId, taskId);
     deps.releaseBridgeTurn?.(binding.codepilotSessionId, taskId);
     endMessageUiOnce();
@@ -17545,7 +17716,7 @@ function createInteractiveRuntime(getState2, deps) {
   async function forceStopSession(sessionId, detail) {
     const state = getState2();
     const task = state.activeTasks.get(sessionId);
-    let handled = false;
+    let handled = getQueuedCount(sessionId) > 0;
     if (task?.forceStop) {
       handled = await task.forceStop(detail);
     } else if (task) {
@@ -17659,6 +17830,7 @@ function resetMirrorReadState(subscription) {
   subscription.trailingText = "";
   subscription.activeMirrorTurnId = null;
   subscription.activeSpecialCallIds.clear();
+  subscription.recoveryState = null;
   subscription.bufferedRecords = [];
 }
 function createMirrorSubscription(input) {
@@ -17683,6 +17855,7 @@ function createMirrorSubscription(input) {
     trailingText: "",
     activeMirrorTurnId: null,
     activeSpecialCallIds: /* @__PURE__ */ new Set(),
+    recoveryState: null,
     bufferedRecords: [],
     pendingTurn: null,
     pendingDeliveries: [],
@@ -17794,73 +17967,9 @@ function filterDuplicateAssistantEvents(cursor, records) {
   }
   return startIndex === 0 ? records : records.slice(startIndex);
 }
-function findLastEventIndex(records, signature) {
-  for (let index = records.length - 1; index >= 0; index -= 1) {
-    if (records[index]?.signature === signature) {
-      return index;
-    }
-  }
-  return -1;
-}
-function collectEventsAfterTimestamp(records, timestamp) {
-  if (!timestamp) return [];
-  return records.filter((event) => Boolean(event.timestamp) && event.timestamp > timestamp);
-}
-function reconcileDesktopMirrorCursor(cursor, records) {
-  const nextCursor = makeCursor(records);
-  if (!cursor?.initialized) {
-    return {
-      nextCursor,
-      deliverableRecords: [],
-      reset: false
-    };
-  }
-  if (records.length === 0) {
-    return {
-      nextCursor,
-      deliverableRecords: [],
-      reset: cursor.lastEventCount > 0
-    };
-  }
-  if (cursor.lastEventSignature) {
-    const lastSeenIndex = findLastEventIndex(records, cursor.lastEventSignature);
-    if (lastSeenIndex === -1) {
-      const recoveredEvents = collectEventsAfterTimestamp(records, cursor.lastEventTimestamp);
-      return {
-        nextCursor,
-        deliverableRecords: recoveredEvents,
-        reset: true
-      };
-    }
-    return {
-      nextCursor,
-      deliverableRecords: records.slice(lastSeenIndex + 1),
-      reset: false
-    };
-  }
-  if (cursor.lastEventCount === 0) {
-    return {
-      nextCursor,
-      deliverableRecords: cursor.lastEventTimestamp ? collectEventsAfterTimestamp(records, cursor.lastEventTimestamp) : records,
-      reset: false
-    };
-  }
-  if (records.length < cursor.lastEventCount) {
-    const recoveredEvents = collectEventsAfterTimestamp(records, cursor.lastEventTimestamp);
-    return {
-      nextCursor,
-      deliverableRecords: recoveredEvents,
-      reset: true
-    };
-  }
-  return {
-    nextCursor,
-    deliverableRecords: records.slice(cursor.lastEventCount),
-    reset: false
-  };
-}
 
 // src/lib/bridge/mirror-reconcile-core.ts
+var DEFAULT_MAX_MIRROR_READ_BYTES = 64 * 1024 * 1024;
 function statMirrorFile(filePath) {
   try {
     const stat = fs10.statSync(filePath);
@@ -17912,12 +18021,70 @@ function findLastCompleteLineOffset(filePath, fileSize) {
     fs10.closeSync(fd);
   }
 }
-function readMirrorDeliverableRecords(subscription, snapshot) {
+function beginMirrorRecovery(subscription) {
+  subscription.recoveryState = {
+    baselineCursor: { ...subscription.cursor },
+    scannedCursor: { initialized: true, lastEventCount: 0 },
+    boundaryFound: false,
+    dedupePending: true,
+    scannedRecordCount: 0
+  };
+  subscription.trailingText = "";
+  subscription.fileOffset = 0;
+  subscription.activeMirrorTurnId = null;
+  subscription.activeSpecialCallIds.clear();
+}
+function findCursorTimestampBoundary(cursor, records) {
+  if (!cursor.lastEventTimestamp) return -1;
+  return records.findIndex((record) => Boolean(record.timestamp) && record.timestamp > cursor.lastEventTimestamp);
+}
+function selectRecoveredRecords(subscription, records) {
+  const recovery = subscription.recoveryState;
+  if (!recovery || records.length === 0) return [];
+  if (recovery.boundaryFound) return records;
+  const baseline = recovery.baselineCursor;
+  if (baseline.lastEventSignature) {
+    for (let index = records.length - 1; index >= 0; index -= 1) {
+      if (records[index]?.signature !== baseline.lastEventSignature) continue;
+      recovery.boundaryFound = true;
+      return records.slice(index + 1);
+    }
+  }
+  const timestampBoundary = findCursorTimestampBoundary(baseline, records);
+  if (timestampBoundary >= 0) {
+    recovery.boundaryFound = true;
+    return records.slice(timestampBoundary);
+  }
+  if (baseline.lastEventSignature || baseline.lastEventTimestamp) return [];
+  if (baseline.lastEventCount > recovery.scannedRecordCount) {
+    const boundary = baseline.lastEventCount - recovery.scannedRecordCount;
+    if (boundary >= records.length) return [];
+    recovery.boundaryFound = true;
+    return records.slice(boundary);
+  }
+  recovery.boundaryFound = true;
+  return records;
+}
+function filterFirstRecoveredAssistantDuplicates(subscription, records) {
+  const recovery = subscription.recoveryState;
+  if (!recovery?.dedupePending || records.length === 0) return records;
+  const filtered = filterDuplicateAssistantEvents(recovery.baselineCursor, records);
+  if (filtered.length > 0) {
+    recovery.dedupePending = false;
+  }
+  return filtered;
+}
+function readMirrorDeliverableRecords(subscription, snapshot, options = {}) {
   let deliverableRecords = [];
   let unknownKinds = [];
-  const requiresFullRecover = !subscription.cursor.initialized || subscription.fileOffset === 0 || subscription.fileIdentity !== null && subscription.fileIdentity !== snapshot.identity || subscription.fileSize !== null && snapshot.size < subscription.fileOffset || subscription.fileSize !== null && snapshot.size === subscription.fileOffset && subscription.fileMtimeMs !== null && snapshot.mtimeMs !== subscription.fileMtimeMs;
+  const previousOffset = subscription.fileOffset;
+  const configuredMaxReadBytes = options.maxReadBytes ?? DEFAULT_MAX_MIRROR_READ_BYTES;
+  const maxReadBytes = Number.isFinite(configuredMaxReadBytes) && configuredMaxReadBytes > 0 ? Math.max(1, Math.floor(configuredMaxReadBytes)) : DEFAULT_MAX_MIRROR_READ_BYTES;
+  const sourceChanged = subscription.fileIdentity !== null && subscription.fileIdentity !== snapshot.identity || subscription.fileSize !== null && snapshot.size < subscription.fileOffset || subscription.fileSize !== null && snapshot.size === subscription.fileOffset && subscription.fileMtimeMs !== null && snapshot.mtimeMs !== subscription.fileMtimeMs;
+  const requiresFullRecover = Boolean(subscription.recoveryState) || !subscription.cursor.initialized || subscription.fileOffset === 0 || sourceChanged;
   if (requiresFullRecover && !subscription.cursor.initialized && !subscription.lastDeliveredAt) {
     subscription.cursor = { initialized: true, lastEventCount: 0 };
+    subscription.recoveryState = null;
     subscription.trailingText = "";
     subscription.fileOffset = findLastCompleteLineOffset(subscription.filePath, snapshot.size);
     subscription.activeMirrorTurnId = null;
@@ -17926,26 +18093,37 @@ function readMirrorDeliverableRecords(subscription, snapshot) {
     subscription.fileMtimeMs = snapshot.mtimeMs;
     subscription.fileIdentity = snapshot.identity;
     subscription.dirty = false;
-    return { records: [], unknownKinds: [] };
+    return { records: [], unknownKinds: [], hasMoreData: false };
   }
   if (requiresFullRecover) {
-    const previousCursor = subscription.cursor;
-    const fullDelta = readDesktopSessionMirrorRecordDeltaByFilePath(
+    if (!subscription.recoveryState || sourceChanged) {
+      beginMirrorRecovery(subscription);
+    }
+    const recovery = subscription.recoveryState;
+    const delta = readDesktopSessionMirrorRecordDeltaByFilePath(
       subscription.filePath,
-      0,
+      subscription.fileOffset,
       snapshot.size,
-      "",
-      null,
-      []
+      subscription.trailingText,
+      subscription.activeMirrorTurnId,
+      subscription.activeSpecialCallIds,
+      { maxBytes: maxReadBytes }
+    );
+    deliverableRecords = filterFirstRecoveredAssistantDuplicates(
+      subscription,
+      selectRecoveredRecords(subscription, delta.records)
     );
-    const delta = reconcileDesktopMirrorCursor(subscription.cursor, fullDelta.records);
-    subscription.cursor = delta.nextCursor;
-    deliverableRecords = filterDuplicateAssistantEvents(previousCursor, delta.deliverableRecords);
-    subscription.trailingText = fullDelta.trailingText;
-    subscription.fileOffset = fullDelta.nextOffset;
-    subscription.activeMirrorTurnId = fullDelta.nextTurnId;
-    subscription.activeSpecialCallIds = new Set(fullDelta.nextSpecialCallIds);
-    unknownKinds = fullDelta.unknownKinds;
+    recovery.scannedCursor = advanceDesktopMirrorCursor(recovery.scannedCursor, delta.records);
+    recovery.scannedRecordCount += delta.records.length;
+    subscription.trailingText = delta.trailingText;
+    subscription.fileOffset = delta.nextOffset;
+    subscription.activeMirrorTurnId = delta.nextTurnId;
+    subscription.activeSpecialCallIds = new Set(delta.nextSpecialCallIds);
+    unknownKinds = delta.unknownKinds;
+    if (subscription.fileOffset >= snapshot.size && !subscription.trailingText) {
+      subscription.cursor = recovery.scannedCursor;
+      subscription.recoveryState = null;
+    }
   } else if (snapshot.size > subscription.fileOffset || subscription.trailingText) {
     const previousCursor = subscription.cursor;
     const delta = readDesktopSessionMirrorRecordDeltaByFilePath(
@@ -17954,7 +18132,8 @@ function readMirrorDeliverableRecords(subscription, snapshot) {
       snapshot.size,
       subscription.trailingText,
       subscription.activeMirrorTurnId,
-      subscription.activeSpecialCallIds
+      subscription.activeSpecialCallIds,
+      { maxBytes: maxReadBytes }
     );
     deliverableRecords = filterDuplicateAssistantEvents(previousCursor, delta.records);
     subscription.cursor = advanceDesktopMirrorCursor(subscription.cursor, delta.records);
@@ -17970,7 +18149,8 @@ function readMirrorDeliverableRecords(subscription, snapshot) {
   subscription.dirty = false;
   return {
     records: deliverableRecords,
-    unknownKinds
+    unknownKinds,
+    hasMoreData: subscription.fileOffset > previousOffset && subscription.fileOffset < snapshot.size
   };
 }
 
@@ -18298,6 +18478,9 @@ function createMirrorRuntime(getState2, options, deps) {
       return "processed";
     }
     const readResult = readMirrorDeliverableRecords(subscription, snapshot);
+    if (readResult.hasMoreData) {
+      scheduleMirrorWake();
+    }
     const deliverableRecords = readResult.records;
     for (const kind of readResult.unknownKinds) {
       if (subscription.unknownMirrorKindsSeen.has(kind)) continue;
@@ -18423,8 +18606,41 @@ function createMirrorRuntime(getState2, options, deps) {
       }
     }
   }
+  function interruptMirrorTurn(sessionId, threadId, turnId) {
+    const normalizedTurnId = turnId.trim();
+    if (!normalizedTurnId) return false;
+    const streamKey = buildMirrorStreamKey(sessionId, normalizedTurnId, "");
+    let interrupted = false;
+    for (const subscription of getState2().mirrorSubscriptions.values()) {
+      if (subscription.sessionId !== sessionId || subscription.threadId !== threadId) continue;
+      let subscriptionInterrupted = false;
+      const bufferedCount = subscription.bufferedRecords.length;
+      const deliveryCount = subscription.pendingDeliveries.length;
+      subscription.bufferedRecords = subscription.bufferedRecords.filter(
+        (record) => record.turnId !== normalizedTurnId
+      );
+      subscription.pendingDeliveries = subscription.pendingDeliveries.filter(
+        (turn) => turn.streamKey !== streamKey
+      );
+      if (subscription.pendingTurn?.turnId === normalizedTurnId) {
+        deps.stopMirrorStreaming(subscription, "interrupted");
+        subscription.pendingTurn = null;
+        subscriptionInterrupted = true;
+      }
+      if (subscription.bufferedRecords.length !== bufferedCount || subscription.pendingDeliveries.length !== deliveryCount) {
+        subscriptionInterrupted = true;
+      }
+      if (subscriptionInterrupted) {
+        interrupted = true;
+        orphanProbeAt.delete(subscription.bindingId);
+        deps.syncMirrorSessionStateSafe(sessionId, "mirror turn interrupted from IM");
+      }
+    }
+    return interrupted;
+  }
   return {
     resetMirrorSessionForInteractiveRun: resetMirrorSessionForInteractiveRun2,
+    interruptMirrorTurn,
     reconcileMirrorSubscriptions: reconcileMirrorSubscriptions2,
     clearMirrorSubscriptions: clearMirrorSubscriptions2
   };
@@ -19453,7 +19669,11 @@ function createTurnCoordinator(deps = {}) {
     const normalizedTurnId = turnId.trim();
     if (!turn || turn.kind !== "im_desktop_reuse" || !normalizedTurnId) return false;
     if (turn.codexTurnId && turn.codexTurnId !== normalizedTurnId) return false;
+    const changed = turn.codexTurnId !== normalizedTurnId;
     turn.codexTurnId = normalizedTurnId;
+    if (changed) {
+      turn.onDesktopTurnAssociated?.(normalizedTurnId);
+    }
     return true;
   }
   async function claimDesktopTerminal(terminal) {
@@ -19497,6 +19717,354 @@ function createTurnCoordinator(deps = {}) {
   };
 }
 
+// src/lib/bridge/managed-codex-process.ts
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync2 = promisify2(execFile2);
+var PROCESS_QUERY_TIMEOUT_MS = 5e3;
+var PROCESS_STOP_TIMEOUT_MS = 1e4;
+var PROCESS_EXIT_WAIT_MS = 5e3;
+function escapePowerShellSingleQuoted2(value) {
+  return value.replace(/'/g, "''");
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizeSnapshot(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const record = raw;
+  const pid = Number(record.ProcessId);
+  const parentPid = Number(record.ParentProcessId);
+  const createdAt = typeof record.CreationDate === "string" ? record.CreationDate.trim() : "";
+  const name = typeof record.Name === "string" ? record.Name.trim() : "";
+  const commandLine = typeof record.CommandLine === "string" ? record.CommandLine.trim() : "";
+  if (!Number.isInteger(pid) || pid <= 0 || !Number.isInteger(parentPid) || parentPid <= 0) {
+    return null;
+  }
+  if (!createdAt || !name || !commandLine) return null;
+  return { pid, parentPid, createdAt, name, commandLine };
+}
+function parseSnapshots(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) return [];
+  const parsed = JSON.parse(trimmed);
+  const records = Array.isArray(parsed) ? parsed : [parsed];
+  return records.map((record) => normalizeSnapshot(record)).filter((record) => Boolean(record));
+}
+function isManagedCodexExecProcess(processSnapshot, expected) {
+  if (processSnapshot.name.toLowerCase() !== "codex.exe") return false;
+  if (processSnapshot.parentPid !== expected.parentPid) return false;
+  const commandLine = processSnapshot.commandLine;
+  if (!/(?:^|\s)exec(?=\s|$)/i.test(commandLine)) return false;
+  const threadId = escapeRegex(expected.threadId.trim());
+  if (!threadId) return false;
+  const resumePattern = new RegExp(
+    `(?:^|\\s)resume\\s+(?:"${threadId}"|${threadId})(?=\\s|$)`,
+    "i"
+  );
+  return resumePattern.test(commandLine);
+}
+async function captureManagedCodexExecProcess(threadId, ownerPid = process.pid) {
+  const normalizedThreadId = threadId.trim();
+  if (process.platform !== "win32" || !normalizedThreadId || !Number.isInteger(ownerPid) || ownerPid <= 0) {
+    return null;
+  }
+  const escapedThreadId = escapePowerShellSingleQuoted2(normalizedThreadId);
+  const script = [
+    `$threadId = '${escapedThreadId}'`,
+    "$escaped = [regex]::Escape($threadId)",
+    `$ownerPid = ${ownerPid}`,
+    "$procs = Get-CimInstance Win32_Process | Where-Object {",
+    "  $_.Name -ieq 'codex.exe' -and [int]$_.ParentProcessId -eq $ownerPid -and $_.CommandLine -match $escaped",
+    "} | Select-Object ProcessId, ParentProcessId, CreationDate, Name, CommandLine",
+    "if ($null -eq $procs) { '' } else { $procs | ConvertTo-Json -Compress }"
+  ].join("; ");
+  try {
+    const { stdout } = await execFileAsync2(
+      "powershell.exe",
+      ["-NoProfile", "-NonInteractive", "-Command", script],
+      {
+        windowsHide: true,
+        timeout: PROCESS_QUERY_TIMEOUT_MS,
+        maxBuffer: 512 * 1024,
+        encoding: "utf8"
+      }
+    );
+    const snapshot = parseSnapshots(stdout).find((candidate) => isManagedCodexExecProcess(candidate, {
+      threadId: normalizedThreadId,
+      parentPid: ownerPid
+    }));
+    return snapshot ? {
+      threadId: normalizedThreadId,
+      pid: snapshot.pid,
+      parentPid: snapshot.parentPid,
+      createdAt: snapshot.createdAt
+    } : null;
+  } catch {
+    return null;
+  }
+}
+async function inspectManagedCodexProcess(pid) {
+  if (process.platform !== "win32") {
+    return { status: "unsupported", error: "Managed Desktop task stopping is currently supported only on Windows." };
+  }
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return { status: "error", error: "Invalid Codex process id." };
+  }
+  const script = [
+    `$proc = Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}" | Select-Object -First 1 ProcessId, ParentProcessId, CreationDate, Name, CommandLine`,
+    "if ($null -eq $proc) { '' } else { $proc | ConvertTo-Json -Compress }"
+  ].join("; ");
+  try {
+    const { stdout } = await execFileAsync2(
+      "powershell.exe",
+      ["-NoProfile", "-NonInteractive", "-Command", script],
+      {
+        windowsHide: true,
+        timeout: PROCESS_QUERY_TIMEOUT_MS,
+        maxBuffer: 512 * 1024,
+        encoding: "utf8"
+      }
+    );
+    const snapshot = parseSnapshots(stdout)[0];
+    return snapshot ? { status: "found", process: snapshot } : { status: "not_found" };
+  } catch (error) {
+    return { status: "error", error: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function terminateWindowsProcessTree(pid) {
+  await execFileAsync2(
+    "taskkill.exe",
+    ["/PID", String(pid), "/T", "/F"],
+    {
+      windowsHide: true,
+      timeout: PROCESS_STOP_TIMEOUT_MS,
+      maxBuffer: 512 * 1024
+    }
+  );
+}
+function sleep(delayMs) {
+  return new Promise((resolve2) => setTimeout(resolve2, delayMs));
+}
+async function stopManagedCodexExecProcess(identity, deps = {}) {
+  const inspectProcess = deps.inspectProcess ?? inspectManagedCodexProcess;
+  const terminateProcessTree = deps.terminateProcessTree ?? terminateWindowsProcessTree;
+  const sleepFn = deps.sleep ?? sleep;
+  const nowMs = deps.nowMs ?? (() => Date.now());
+  const initial = await inspectProcess(identity.pid);
+  if (initial.status === "not_found") return { status: "not_running" };
+  if (initial.status === "unsupported") return initial;
+  if (initial.status === "error") return { status: "failed", error: initial.error };
+  if (initial.process.createdAt !== identity.createdAt || !isManagedCodexExecProcess(initial.process, identity)) {
+    return {
+      status: "unsafe",
+      error: "The recorded process identity no longer matches the bridge-owned Codex exec process."
+    };
+  }
+  try {
+    await terminateProcessTree(identity.pid);
+  } catch (error) {
+    const afterFailure = await inspectProcess(identity.pid);
+    if (afterFailure.status === "not_found") return { status: "stopped" };
+    return { status: "failed", error: error instanceof Error ? error.message : String(error) };
+  }
+  const deadline = nowMs() + PROCESS_EXIT_WAIT_MS;
+  while (nowMs() < deadline) {
+    const inspection = await inspectProcess(identity.pid);
+    if (inspection.status === "not_found") return { status: "stopped" };
+    if (inspection.status === "found") {
+      if (inspection.process.createdAt !== identity.createdAt || !isManagedCodexExecProcess(inspection.process, identity)) {
+        return { status: "stopped" };
+      }
+    } else if (inspection.status === "unsupported") {
+      return inspection;
+    } else {
+      return { status: "failed", error: inspection.error };
+    }
+    await sleepFn(100);
+  }
+  return { status: "failed", error: "Codex process did not exit before the stop timeout." };
+}
+
+// src/lib/bridge/desktop-handoff-control.ts
+function clearHandoffFields() {
+  return {
+    desktop_handoff_task_id: void 0,
+    desktop_handoff_thread_id: void 0,
+    desktop_handoff_turn_id: void 0,
+    desktop_handoff_owner_pid: void 0,
+    desktop_handoff_process_pid: void 0,
+    desktop_handoff_process_parent_pid: void 0,
+    desktop_handoff_process_created_at: void 0,
+    desktop_handoff_registered_at: void 0,
+    desktop_handoff_active: void 0
+  };
+}
+function readTask(session) {
+  const sessionId = session?.id || "";
+  const taskId = session?.desktop_handoff_task_id?.trim() || "";
+  const threadId = session?.desktop_handoff_thread_id?.trim() || "";
+  const turnId = session?.desktop_handoff_turn_id?.trim() || "";
+  const registeredAt = session?.desktop_handoff_registered_at?.trim() || "";
+  const ownerPid = Number(session?.desktop_handoff_owner_pid);
+  if (!sessionId || !taskId || !threadId || !turnId || !registeredAt) return null;
+  if (!Number.isInteger(ownerPid) || ownerPid <= 0) return null;
+  const pid = Number(session?.desktop_handoff_process_pid);
+  const parentPid = Number(session?.desktop_handoff_process_parent_pid);
+  const createdAt = session?.desktop_handoff_process_created_at?.trim() || "";
+  const hasProcessIdentity = Number.isInteger(pid) && pid > 0 && Number.isInteger(parentPid) && parentPid > 0 && Boolean(createdAt);
+  return {
+    sessionId,
+    taskId,
+    threadId,
+    turnId,
+    ownerPid,
+    registeredAt,
+    active: session?.desktop_handoff_active === true,
+    processIdentity: hasProcessIdentity ? {
+      threadId,
+      pid,
+      parentPid,
+      createdAt
+    } : null
+  };
+}
+function isTerminalRecord2(record) {
+  return record.type === "task_complete" || record.type === "task_aborted";
+}
+function createDesktopHandoffControl(deps) {
+  const captureProcess = deps.captureProcess ?? captureManagedCodexExecProcess;
+  const stopProcess = deps.stopProcess ?? stopManagedCodexExecProcess;
+  const nowIso4 = deps.nowIso ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const ownerPid = deps.ownerPid ?? process.pid;
+  function releaseTask(sessionId, taskId) {
+    const store = deps.getStore();
+    const current = readTask(store.getSession(sessionId));
+    if (!current) return;
+    if (taskId && current.taskId !== taskId) return;
+    store.updateSession(sessionId, clearHandoffFields(), { touch: false });
+  }
+  async function prepareTask(task) {
+    const store = deps.getStore();
+    const session = store.getSession(task.sessionId);
+    if (!session) return false;
+    const registeredAt = nowIso4();
+    store.updateSession(task.sessionId, {
+      ...clearHandoffFields(),
+      desktop_handoff_task_id: task.taskId,
+      desktop_handoff_thread_id: task.threadId,
+      desktop_handoff_turn_id: task.turnId,
+      desktop_handoff_owner_pid: ownerPid,
+      desktop_handoff_registered_at: registeredAt,
+      desktop_handoff_active: false
+    }, { touch: false });
+    let identity = null;
+    try {
+      identity = await captureProcess(task.threadId, ownerPid);
+    } catch (error) {
+      console.warn(
+        `[desktop-handoff] Failed to capture Codex exec process for ${task.threadId}:`,
+        error instanceof Error ? error.message : error
+      );
+    }
+    if (!identity) return false;
+    const current = readTask(store.getSession(task.sessionId));
+    if (!current || current.taskId !== task.taskId || current.turnId !== task.turnId) return false;
+    store.updateSession(task.sessionId, {
+      desktop_handoff_process_pid: identity.pid,
+      desktop_handoff_process_parent_pid: identity.parentPid,
+      desktop_handoff_process_created_at: identity.createdAt
+    }, { touch: false });
+    return true;
+  }
+  function hasTask(sessionId) {
+    return readTask(deps.getStore().getSession(sessionId))?.active === true;
+  }
+  function activateTask(sessionId, taskId) {
+    const store = deps.getStore();
+    const current = readTask(store.getSession(sessionId));
+    if (!current || current.taskId !== taskId) return false;
+    store.updateSession(sessionId, { desktop_handoff_active: true }, { touch: false });
+    return true;
+  }
+  async function stopTask(sessionId) {
+    const store = deps.getStore();
+    let task = readTask(store.getSession(sessionId));
+    if (!task || !task.active) return { status: "not_running" };
+    if (!task.processIdentity) {
+      let identity = null;
+      try {
+        identity = await captureProcess(task.threadId, task.ownerPid);
+      } catch (error) {
+        return {
+          status: "failed",
+          task,
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+      if (!identity) {
+        return {
+          status: "unavailable",
+          task,
+          error: "\u672A\u627E\u5230\u53EF\u9A8C\u8BC1\u4E3A bridge \u81EA\u6709\u7684 Codex exec \u8FDB\u7A0B\u3002"
+        };
+      }
+      store.updateSession(sessionId, {
+        desktop_handoff_process_pid: identity.pid,
+        desktop_handoff_process_parent_pid: identity.parentPid,
+        desktop_handoff_process_created_at: identity.createdAt
+      }, { touch: false });
+      task = { ...task, processIdentity: identity };
+    }
+    const processIdentity = task.processIdentity;
+    if (!processIdentity) {
+      return { status: "unavailable", task, error: "\u672A\u80FD\u4FDD\u5B58\u53EF\u9A8C\u8BC1\u7684 Codex exec \u8FDB\u7A0B\u8EAB\u4EFD\u3002" };
+    }
+    let stopped;
+    try {
+      stopped = await stopProcess(processIdentity);
+    } catch (error) {
+      return {
+        status: "failed",
+        task,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+    if (stopped.status === "stopped") {
+      releaseTask(sessionId, task.taskId);
+      return { status: "stopped", task };
+    }
+    if (stopped.status === "not_running") {
+      releaseTask(sessionId, task.taskId);
+      return { status: "not_running", task };
+    }
+    if (stopped.status === "unsafe") {
+      releaseTask(sessionId, task.taskId);
+      return { status: "unavailable", task, error: stopped.error };
+    }
+    if (stopped.status === "unsupported") {
+      return { status: "unavailable", task, error: stopped.error };
+    }
+    return { status: "failed", task, error: stopped.error };
+  }
+  function observeRecords(sessionId, threadId, records) {
+    if (records.length === 0) return;
+    const task = readTask(deps.getStore().getSession(sessionId));
+    if (!task || task.threadId !== threadId) return;
+    if (records.some((record) => record.turnId === task.turnId && isTerminalRecord2(record))) {
+      releaseTask(sessionId, task.taskId);
+    }
+  }
+  return {
+    prepareTask,
+    activateTask,
+    releaseTask,
+    hasTask,
+    stopTask,
+    observeRecords
+  };
+}
+
 // src/lib/bridge/bridge-manager.ts
 var GLOBAL_KEY = "__bridge_manager__";
 var DANGLING_MIRROR_THREAD_RETRY_LIMIT = 3;
@@ -19596,6 +20164,10 @@ var INTERACTIVE_RUNTIME = createInteractiveRuntime(getState, {
   getStore: () => getBridgeContext().store,
   nowIso: nowIso3
 });
+var DESKTOP_HANDOFF_CONTROL = createDesktopHandoffControl({
+  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";
@@ -19679,6 +20251,17 @@ function abortMirrorSuppression2(sessionId, suppressionId) {
     suppressionId
   );
 }
+function handoffMirrorSuppression2(sessionId, suppressionId) {
+  handoffMirrorSuppression(getMirrorSuppressionStore(), sessionId, suppressionId);
+}
+function ignoreMirrorTurn2(sessionId, turnId) {
+  ignoreMirrorTurn(
+    getMirrorSuppressionStore(),
+    sessionId,
+    MIRROR_SUPPRESSION_CONFIG,
+    turnId
+  );
+}
 function settleMirrorSuppression2(sessionId, suppressionId, durationMs = MIRROR_SUPPRESSION_WINDOW_MS) {
   settleMirrorSuppression(
     getMirrorSuppressionStore(),
@@ -19803,6 +20386,7 @@ var MIRROR_RUNTIME = createMirrorRuntime(getState, {
   syncMirrorSessionStateSafe,
   filterSuppressedMirrorRecords: filterSuppressedMirrorRecords2,
   observeSessionHealthRecords: (sessionId, threadId, records) => {
+    DESKTOP_HANDOFF_CONTROL.observeRecords(sessionId, threadId, records);
     SESSION_HEALTH_RUNTIME.observeDesktopMirrorRecords(sessionId, threadId, records);
   },
   recordOrphanedMirrorTurn: (sessionId, detail) => {
@@ -19835,6 +20419,51 @@ async function reconcileMirrorSubscriptions() {
 function clearMirrorSubscriptions() {
   MIRROR_RUNTIME.clearMirrorSubscriptions();
 }
+async function forceStopBridgeSession(sessionId, detail) {
+  const activeTask = INTERACTIVE_RUNTIME.getActiveTask(sessionId);
+  const hadQueuedWork = INTERACTIVE_RUNTIME.getQueuedCount(sessionId) > 0;
+  const handoffResult = DESKTOP_HANDOFF_CONTROL.hasTask(sessionId) ? await DESKTOP_HANDOFF_CONTROL.stopTask(sessionId) : null;
+  let interactiveHandled = false;
+  if (activeTask || hadQueuedWork) {
+    interactiveHandled = await INTERACTIVE_RUNTIME.forceStopSession(sessionId, detail);
+    if (activeTask && !handoffResult) {
+      DESKTOP_HANDOFF_CONTROL.releaseTask(sessionId, activeTask.id);
+    }
+  }
+  if (handoffResult) {
+    if (handoffResult.status === "stopped") {
+      ignoreMirrorTurn2(sessionId, handoffResult.task.turnId);
+      MIRROR_RUNTIME.interruptMirrorTurn(
+        sessionId,
+        handoffResult.task.threadId,
+        handoffResult.task.turnId
+      );
+      return { status: "stopped" };
+    }
+    if (handoffResult.status === "unavailable") {
+      return {
+        status: "unavailable",
+        detail: `${interactiveHandled ? "\u5F53\u524D IM \u8BF7\u6C42\u5DF2\u505C\u6B62\uFF0C\u4F46\u6B64\u524D\u7684 Desktop \u4EFB\u52A1\u4ECD\u65E0\u6CD5\u786E\u8BA4\u3002 " : ""}${handoffResult.error}`
+      };
+    }
+    if (handoffResult.status === "failed") {
+      return {
+        status: "failed",
+        detail: `${interactiveHandled ? "\u5F53\u524D IM \u8BF7\u6C42\u5DF2\u505C\u6B62\uFF1B\u6B64\u524D\u7684 Desktop \u4EFB\u52A1\u505C\u6B62\u5931\u8D25\u3002 " : ""}${handoffResult.error}`
+      };
+    }
+    if (!interactiveHandled) {
+      return {
+        status: "not_running",
+        detail: "\u8BB0\u5F55\u4E2D\u7684 Desktop \u4EFB\u52A1\u8FDB\u7A0B\u5DF2\u7ECF\u7ED3\u675F\uFF1B\u5982\u6709\u5C1A\u672A\u6295\u9012\u7684\u7ED3\u679C\uFF0Cmirror \u4F1A\u7EE7\u7EED\u5B8C\u6210\u6536\u5C3E\u3002"
+      };
+    }
+  }
+  if (interactiveHandled) {
+    return activeTask ? { status: "stop_requested" } : { status: "stopped" };
+  }
+  return { status: "not_running" };
+}
 var ADAPTER_RUNTIME = createAdapterRuntime(getState, {
   notifyAdapterSetChanged: (channelTypes) => {
     const { lifecycle } = getBridgeContext();
@@ -20095,7 +20724,11 @@ async function handleMessage(adapter, msg) {
     recordInteractiveHealthEnd: (sessionId, outcome, detail) => SESSION_HEALTH_RUNTIME.recordInteractiveEnd(sessionId, outcome, detail),
     beginMirrorSuppression: beginMirrorSuppression2,
     abortMirrorSuppression: abortMirrorSuppression2,
+    handoffMirrorSuppression: handoffMirrorSuppression2,
     settleMirrorSuppression: settleMirrorSuppression2,
+    prepareDesktopHandoffTask: (task) => DESKTOP_HANDOFF_CONTROL.prepareTask(task),
+    activateDesktopHandoffTask: (sessionId, taskId) => DESKTOP_HANDOFF_CONTROL.activateTask(sessionId, taskId),
+    releaseDesktopHandoffTask: (sessionId, taskId) => DESKTOP_HANDOFF_CONTROL.releaseTask(sessionId, taskId),
     releaseInteractiveTask: (sessionId, taskId) => INTERACTIVE_RUNTIME.releaseInteractiveTask(sessionId, taskId),
     releaseBridgeTurn: (sessionId, taskId) => TURN_COORDINATOR.releaseSessionTurn(sessionId, taskId),
     deliverResponse,
@@ -20107,7 +20740,7 @@ 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),
+    forceStopSession: forceStopBridgeSession,
     recordInteractiveHealthEnd: (sessionId, outcome, detail) => SESSION_HEALTH_RUNTIME.recordInteractiveEnd(sessionId, outcome, detail),
     diagnoseSessionHealth: (sessionId) => SESSION_HEALTH_RUNTIME.diagnoseSessionHealth(sessionId),
     diagnoseAllActiveSessions: () => SESSION_HEALTH_RUNTIME.diagnoseAllActiveSessions()

package/dist/ui-server.mjs

@@ -5548,7 +5548,7 @@ function parseDesktopSession(filePath, threadIndexEntries, archivedThreadIds, vi
   }
   const lastEventAt = visibleThread?.updatedAtMs ? new Date(visibleThread.updatedAtMs).toISOString() : stat.mtime.toISOString();
   const firstSeenAt = parsed.payload.timestamp || parsed.timestamp || stat.birthtime.toISOString();
-  const title = visibleThread?.title || threadIndexEntries.get(threadId)?.title || buildFallbackTitle(threadId, filePath, cwd);
+  const title = threadIndexEntries.get(threadId)?.title || visibleThread?.title || buildFallbackTitle(threadId, filePath, cwd);
   return {
     threadId,
     filePath,

package/package.json

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