codex-to-im 1.0.61 → 1.0.63

package/dist/daemon.mjs

@@ -318,15 +318,900 @@ var init_sse_utils = __esm({
   }
 });
 
+// src/codex-app-server-client.ts
+import crypto11 from "node:crypto";
+import fs17 from "node:fs";
+import path18 from "node:path";
+import { createRequire as createRequire2 } from "node:module";
+import { spawn } from "node:child_process";
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asString(value) {
+  return typeof value === "string" ? value : "";
+}
+function abortError() {
+  const error = new Error("Task stopped by user");
+  error.name = "AbortError";
+  return error;
+}
+function mapApprovalPolicy(permissionMode) {
+  return permissionMode === "never" ? "never" : "on-request";
+}
+function mapSandboxMode(value) {
+  if (value === "read-only" || value === "danger-full-access") return value;
+  return "workspace-write";
+}
+function getThreadId(params) {
+  return asString(params.threadId ?? params.thread_id);
+}
+function getTurnId(params) {
+  return asString(params.turnId ?? params.turn_id ?? asRecord(params.turn).id);
+}
+function getItemId(params) {
+  return asString(params.itemId ?? params.item_id);
+}
+function getThreadStatus(value) {
+  const type = asString(asRecord(value).type);
+  if (type === "idle" || type === "active" || type === "notLoaded") {
+    return type === "notLoaded" ? "not_loaded" : type;
+  }
+  if (type === "systemError") return "system_error";
+  return "unknown";
+}
+function resolveBundledCodexExecutable() {
+  const target = PLATFORM_TARGETS[`${process.platform}:${process.arch}`];
+  if (!target) {
+    throw new Error(`Unsupported Codex platform: ${process.platform} (${process.arch})`);
+  }
+  let codexPackageJson = "";
+  try {
+    codexPackageJson = localRequire2.resolve("@openai/codex/package.json");
+  } catch {
+    const sdkEntry = localRequire2.resolve("@openai/codex-sdk");
+    codexPackageJson = createRequire2(sdkEntry).resolve("@openai/codex/package.json");
+  }
+  const codexRequire = createRequire2(codexPackageJson);
+  let vendorRoot = path18.join(path18.dirname(codexPackageJson), "vendor");
+  try {
+    const platformPackageJson = codexRequire.resolve(`${target.packageName}/package.json`);
+    vendorRoot = path18.join(path18.dirname(platformPackageJson), "vendor");
+  } catch {
+  }
+  const executablePath = path18.join(
+    vendorRoot,
+    target.triple,
+    "bin",
+    process.platform === "win32" ? "codex.exe" : "codex"
+  );
+  if (!fs17.existsSync(executablePath)) {
+    throw new Error(`Bundled Codex executable is missing: ${executablePath}`);
+  }
+  return executablePath;
+}
+var DEFAULT_REQUEST_TIMEOUT_MS, DEFAULT_INTERRUPT_GRACE_MS, DEFAULT_THREAD_IDLE_RELEASE_MS, STDERR_TAIL_LIMIT, localRequire2, PLATFORM_TARGETS, AsyncEventQueue, AppServerPreTurnError, AppServerTurnStartUncertainError, CodexAppServerClient;
+var init_codex_app_server_client = __esm({
+  "src/codex-app-server-client.ts"() {
+    "use strict";
+    DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+    DEFAULT_INTERRUPT_GRACE_MS = 15e3;
+    DEFAULT_THREAD_IDLE_RELEASE_MS = 10 * 6e4;
+    STDERR_TAIL_LIMIT = 16384;
+    localRequire2 = createRequire2(import.meta.url);
+    PLATFORM_TARGETS = {
+      "linux:x64": { packageName: "@openai/codex-linux-x64", triple: "x86_64-unknown-linux-musl" },
+      "linux:arm64": { packageName: "@openai/codex-linux-arm64", triple: "aarch64-unknown-linux-musl" },
+      "darwin:x64": { packageName: "@openai/codex-darwin-x64", triple: "x86_64-apple-darwin" },
+      "darwin:arm64": { packageName: "@openai/codex-darwin-arm64", triple: "aarch64-apple-darwin" },
+      "win32:x64": { packageName: "@openai/codex-win32-x64", triple: "x86_64-pc-windows-msvc" },
+      "win32:arm64": { packageName: "@openai/codex-win32-arm64", triple: "aarch64-pc-windows-msvc" }
+    };
+    AsyncEventQueue = class {
+      values = [];
+      waiters = [];
+      closed = false;
+      failure = null;
+      push(value) {
+        if (this.closed) return;
+        const waiter = this.waiters.shift();
+        if (waiter) waiter.resolve({ value, done: false });
+        else this.values.push(value);
+      }
+      close() {
+        if (this.closed) return;
+        this.closed = true;
+        for (const waiter of this.waiters.splice(0)) waiter.resolve({ value: void 0, done: true });
+      }
+      fail(error) {
+        if (this.closed) return;
+        this.failure = error;
+        this.closed = true;
+        for (const waiter of this.waiters.splice(0)) waiter.reject(error);
+      }
+      [Symbol.asyncIterator]() {
+        return {
+          next: () => {
+            const value = this.values.shift();
+            if (value !== void 0) return Promise.resolve({ value, done: false });
+            if (this.failure) return Promise.reject(this.failure);
+            if (this.closed) return Promise.resolve({ value: void 0, done: true });
+            return new Promise((resolve2, reject) => {
+              this.waiters.push({ resolve: resolve2, reject });
+            });
+          }
+        };
+      }
+    };
+    AppServerPreTurnError = class extends Error {
+      constructor(message, options) {
+        super(message, options);
+        this.name = "AppServerPreTurnError";
+      }
+    };
+    AppServerTurnStartUncertainError = class extends Error {
+      constructor(message, options) {
+        super(message, options);
+        this.name = "AppServerTurnStartUncertainError";
+      }
+    };
+    CodexAppServerClient = class {
+      constructor(pendingPermissions, options = {}) {
+        this.pendingPermissions = pendingPermissions;
+        this.options = options;
+      }
+      child = null;
+      startupPromise = null;
+      nextRequestId = 1;
+      generation = 0;
+      stdoutBuffer = "";
+      stderrTail = "";
+      pendingRequests = /* @__PURE__ */ new Map();
+      activeTurns = /* @__PURE__ */ new Map();
+      startingTurns = /* @__PURE__ */ new Map();
+      approvalPermissionIds = /* @__PURE__ */ new Map();
+      unknownMethods = /* @__PURE__ */ new Set();
+      subscribedThreadIds = /* @__PURE__ */ new Set();
+      threadStatuses = /* @__PURE__ */ new Map();
+      threadReleaseTimers = /* @__PURE__ */ new Map();
+      recyclePromise = null;
+      getOwnedProcessIds() {
+        const pid = this.child?.pid;
+        return typeof pid === "number" && pid > 0 ? [pid] : [];
+      }
+      getThreadRuntimeStatus(threadId) {
+        if (!this.subscribedThreadIds.has(threadId) && !this.threadStatuses.has(threadId)) return null;
+        return {
+          status: this.threadStatuses.get(threadId) || "unknown",
+          ...this.child?.pid ? { processId: this.child.pid } : {}
+        };
+      }
+      async startTurn(params) {
+        if (params.abortSignal?.aborted) throw abortError();
+        let turnStartDispatched = false;
+        let threadResolutionStarted = false;
+        try {
+          await this.ensureStarted();
+          threadResolutionStarted = true;
+          const threadId = await this.resolveThread(params);
+          if (params.abortSignal?.aborted) {
+            this.scheduleThreadRelease(threadId);
+            throw abortError();
+          }
+          this.clearThreadReleaseTimer(threadId);
+          const starting = {
+            threadId,
+            messages: [],
+            queue: new AsyncEventQueue(),
+            permissionRequestIds: /* @__PURE__ */ new Set()
+          };
+          this.startingTurns.set(threadId, starting);
+          let response;
+          try {
+            response = asRecord(await this.sendRequest("turn/start", {
+              threadId,
+              clientUserMessageId: crypto11.randomUUID(),
+              input: [
+                { type: "text", text: params.prompt, text_elements: [] },
+                ...(params.imagePaths || []).map((imagePath) => ({ type: "localImage", path: imagePath }))
+              ],
+              ...params.workingDirectory ? { cwd: params.workingDirectory } : {},
+              ...params.forceModel && params.model ? { model: params.model } : {},
+              ...params.modelReasoningEffort ? { effort: params.modelReasoningEffort } : {},
+              approvalPolicy: mapApprovalPolicy(params.permissionMode)
+            }, () => {
+              turnStartDispatched = true;
+            }));
+          } catch (error) {
+            this.startingTurns.delete(threadId);
+            this.cancelPermissions(starting, "Turn failed before startup completed");
+            starting.queue.fail(error instanceof Error ? error : new Error(String(error)));
+            throw error;
+          }
+          const turn = asRecord(response.turn);
+          const turnId = asString(turn.id);
+          if (!turnId) {
+            this.startingTurns.delete(threadId);
+            const error = new Error("turn/start returned no turn id");
+            this.cancelPermissions(starting, error.message);
+            starting.queue.fail(error);
+            throw error;
+          }
+          const active = {
+            threadId,
+            turnId,
+            queue: starting.queue,
+            abortSignal: params.abortSignal,
+            permissionRequestIds: starting.permissionRequestIds
+          };
+          this.activeTurns.set(turnId, active);
+          this.threadStatuses.set(threadId, "active");
+          this.startingTurns.delete(threadId);
+          for (const message of starting.messages) this.routeTurnMessage(active, message);
+          if (params.abortSignal && this.activeTurns.has(turnId)) {
+            active.abortListener = () => {
+              void this.interruptTurn(threadId, turnId);
+            };
+            if (params.abortSignal.aborted) {
+              void this.interruptTurn(threadId, turnId);
+            } else {
+              params.abortSignal.addEventListener("abort", active.abortListener, { once: true });
+            }
+          }
+          return {
+            threadId,
+            turnId,
+            events: active.queue,
+            interrupt: () => this.interruptTurn(threadId, turnId)
+          };
+        } catch (error) {
+          if (error instanceof AppServerPreTurnError || error instanceof AppServerTurnStartUncertainError || error instanceof Error && error.name === "AbortError") {
+            throw error;
+          }
+          const detail = error instanceof Error ? error.message : String(error);
+          if (turnStartDispatched) {
+            await this.recycleChild(`turn/start result is unknown for thread ${params.savedThreadId || "new"}`);
+            throw new AppServerTurnStartUncertainError(
+              `Codex app-server turn/start was dispatched but its result is unknown: ${detail}`,
+              { cause: error }
+            );
+          }
+          if (threadResolutionStarted) {
+            await this.recycleChild(`thread preparation failed before turn/start: ${detail}`);
+          }
+          throw new AppServerPreTurnError(`Codex app-server could not start the turn: ${detail}`, { cause: error });
+        }
+      }
+      async close() {
+        const child = this.child;
+        if (!child) return;
+        const error = new Error("Codex app-server client closed");
+        for (const pending of this.pendingRequests.values()) {
+          clearTimeout(pending.timer);
+          pending.reject(error);
+        }
+        this.pendingRequests.clear();
+        for (const active of this.activeTurns.values()) {
+          if (active.interruptTimer) clearTimeout(active.interruptTimer);
+          this.cancelPermissions(active, error.message);
+          active.queue.fail(error);
+        }
+        this.activeTurns.clear();
+        for (const starting of this.startingTurns.values()) {
+          this.cancelPermissions(starting, error.message);
+          starting.queue.fail(error);
+        }
+        this.startingTurns.clear();
+        this.approvalPermissionIds.clear();
+        this.clearAllThreadReleaseTimers();
+        this.subscribedThreadIds.clear();
+        this.threadStatuses.clear();
+        this.startupPromise = null;
+        if (child.exitCode !== null) {
+          if (this.child === child) this.child = null;
+          return;
+        }
+        await new Promise((resolve2) => {
+          let settled = false;
+          const finish = () => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            child.off("exit", finish);
+            resolve2();
+          };
+          const timer = setTimeout(finish, 2e3);
+          child.once("exit", finish);
+          try {
+            child.stdin.end();
+          } catch {
+          }
+          try {
+            child.kill();
+          } catch {
+            finish();
+          }
+        });
+        if (this.child === child) this.child = null;
+      }
+      async resolveThread(params) {
+        const common = {
+          ...params.forceModel && params.model ? { model: params.model } : {},
+          ...params.workingDirectory ? { cwd: params.workingDirectory } : {},
+          approvalPolicy: mapApprovalPolicy(params.permissionMode),
+          sandbox: mapSandboxMode(params.sandboxMode),
+          ...params.systemPrompt ? { developerInstructions: params.systemPrompt } : {},
+          ...params.skipGitRepoCheck ? { config: { skip_git_repo_check: true } } : {}
+        };
+        if (params.savedThreadId) {
+          if (this.subscribedThreadIds.has(params.savedThreadId)) {
+            if (this.threadStatuses.get(params.savedThreadId) !== "system_error") {
+              return params.savedThreadId;
+            }
+            this.forgetThread(params.savedThreadId);
+          }
+          const resumed = asRecord(await this.sendRequest("thread/resume", {
+            threadId: params.savedThreadId,
+            excludeTurns: true,
+            ...common
+          }));
+          const resumedThread = asRecord(resumed.thread);
+          const resumedThreadId = asString(resumedThread.id);
+          if (!resumedThreadId) throw new Error("thread/resume returned no thread id");
+          this.markThreadSubscribed(resumedThreadId, getThreadStatus(resumedThread.status));
+          return resumedThreadId;
+        }
+        const started = asRecord(await this.sendRequest("thread/start", {
+          ...common,
+          threadSource: "codex-to-im"
+        }));
+        const startedThread = asRecord(started.thread);
+        const threadId = asString(startedThread.id);
+        if (!threadId) throw new Error("thread/start returned no thread id");
+        this.markThreadSubscribed(threadId, getThreadStatus(startedThread.status));
+        return threadId;
+      }
+      async ensureStarted() {
+        if (this.recyclePromise) await this.recyclePromise;
+        if (this.child && this.child.exitCode === null && this.startupPromise) {
+          return this.startupPromise;
+        }
+        if (this.startupPromise) return this.startupPromise;
+        this.startupPromise = (async () => {
+          let executablePath;
+          try {
+            executablePath = this.options.executablePath || resolveBundledCodexExecutable();
+          } catch (error) {
+            throw new AppServerPreTurnError(
+              error instanceof Error ? error.message : String(error),
+              { cause: error }
+            );
+          }
+          const env = { ...process.env };
+          const apiKey = process.env.CTI_CODEX_API_KEY || process.env.CODEX_API_KEY;
+          if (apiKey) env.OPENAI_API_KEY = apiKey;
+          if (process.env.CTI_CODEX_BASE_URL) env.OPENAI_BASE_URL = process.env.CTI_CODEX_BASE_URL;
+          const spawnProcess = this.options.spawnProcess || spawn;
+          const child = spawnProcess(executablePath, this.options.executableArgs || ["app-server"], {
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+            env
+          });
+          this.child = child;
+          this.generation += 1;
+          this.stdoutBuffer = "";
+          this.stderrTail = "";
+          child.stdout.setEncoding("utf8");
+          child.stdout.on("data", (chunk) => this.handleStdout(chunk));
+          child.stderr.setEncoding("utf8");
+          child.stderr.on("data", (chunk) => {
+            this.stderrTail = `${this.stderrTail}${chunk}`.slice(-STDERR_TAIL_LIMIT);
+          });
+          child.on("exit", (code2, signal) => this.handleExit(child, code2, signal));
+          await new Promise((resolve2, reject) => {
+            const onSpawn = () => {
+              cleanup();
+              resolve2();
+            };
+            const onError = (error) => {
+              cleanup();
+              reject(error);
+            };
+            const cleanup = () => {
+              child.off("spawn", onSpawn);
+              child.off("error", onError);
+            };
+            child.once("spawn", onSpawn);
+            child.once("error", onError);
+          });
+          child.on("error", (error) => {
+            if (this.child !== child) return;
+            console.warn("[codex-app-server] Child process error:", error.message);
+            try {
+              child.kill();
+            } catch {
+            }
+          });
+          child.stdin.on("error", (error) => {
+            if (this.child !== child) return;
+            console.warn("[codex-app-server] stdin error:", error.message);
+            try {
+              child.kill();
+            } catch {
+            }
+          });
+          await this.sendRequest("initialize", {
+            clientInfo: { name: "codex-to-im", title: "Codex to IM", version: "1" },
+            capabilities: {
+              experimentalApi: true,
+              requestAttestation: false
+            }
+          });
+          this.sendNotification("initialized", {});
+        })().catch((error) => {
+          const detail = error instanceof Error ? error.message : String(error);
+          this.startupPromise = null;
+          try {
+            this.child?.kill();
+          } catch {
+          }
+          this.child = null;
+          throw error instanceof AppServerPreTurnError ? error : new AppServerPreTurnError(`Codex app-server initialization failed: ${detail}`, { cause: error });
+        });
+        return this.startupPromise;
+      }
+      sendRequest(method, params, onDispatched) {
+        const child = this.child;
+        if (!child || child.exitCode !== null || !child.stdin.writable) {
+          return Promise.reject(new Error("Codex app-server is not running"));
+        }
+        const id = this.nextRequestId++;
+        const timeoutMs = Math.max(10, this.options.requestTimeoutMs || DEFAULT_REQUEST_TIMEOUT_MS);
+        return new Promise((resolve2, reject) => {
+          const timer = setTimeout(() => {
+            this.pendingRequests.delete(id);
+            reject(new Error(`${method} timed out after ${timeoutMs}ms`));
+          }, timeoutMs);
+          this.pendingRequests.set(id, { method, resolve: resolve2, reject, timer });
+          try {
+            this.writeMessage({ id, method, params });
+            onDispatched?.();
+          } catch (error) {
+            clearTimeout(timer);
+            this.pendingRequests.delete(id);
+            reject(error instanceof Error ? error : new Error(String(error)));
+          }
+        });
+      }
+      sendNotification(method, params) {
+        this.writeMessage({ method, params });
+      }
+      writeMessage(message) {
+        const child = this.child;
+        if (!child || child.exitCode !== null || !child.stdin.writable) {
+          throw new Error("Codex app-server stdin is unavailable");
+        }
+        child.stdin.write(`${JSON.stringify(message)}
+`);
+      }
+      handleStdout(chunk) {
+        this.stdoutBuffer += chunk;
+        while (true) {
+          const newlineIndex = this.stdoutBuffer.indexOf("\n");
+          if (newlineIndex < 0) break;
+          const line = this.stdoutBuffer.slice(0, newlineIndex).trim();
+          this.stdoutBuffer = this.stdoutBuffer.slice(newlineIndex + 1);
+          if (!line) continue;
+          try {
+            this.handleMessage(JSON.parse(line));
+          } catch (error) {
+            console.warn("[codex-app-server] Ignored invalid protocol line:", error instanceof Error ? error.message : error);
+          }
+        }
+      }
+      handleMessage(message) {
+        if (message.id !== void 0 && !message.method) {
+          const pending = this.pendingRequests.get(message.id);
+          if (!pending) return;
+          this.pendingRequests.delete(message.id);
+          clearTimeout(pending.timer);
+          if (message.error) {
+            const detail = message.error.message || `JSON-RPC error ${message.error.code ?? ""}`.trim();
+            pending.reject(new Error(`${pending.method} failed: ${detail}`));
+          } else {
+            pending.resolve(message.result);
+          }
+          return;
+        }
+        if (!message.method) return;
+        if (message.id !== void 0) {
+          void this.handleServerRequest(message);
+          return;
+        }
+        const params = asRecord(message.params);
+        if (message.method === "thread/started") {
+          const thread = asRecord(params.thread);
+          const threadId2 = asString(thread.id);
+          if (threadId2) this.markThreadSubscribed(threadId2, getThreadStatus(thread.status));
+          return;
+        }
+        if (message.method === "thread/status/changed") {
+          const threadId2 = getThreadId(params);
+          const status = getThreadStatus(params.status);
+          if (threadId2 && (status === "system_error" || status === "not_loaded")) {
+            const active2 = this.findActiveTurnByThreadId(threadId2);
+            if (active2) {
+              active2.queue.push({
+                type: "turn.completed",
+                status: "failed",
+                errorMessage: status === "system_error" ? "Codex app-server reported a system error for this thread." : "Codex app-server unloaded this thread before the turn completed."
+              });
+              this.finishTurn(active2, {
+                threadStatus: status,
+                releaseThread: status === "system_error"
+              });
+            }
+            if (status === "not_loaded") this.forgetThread(threadId2);
+            else this.threadStatuses.set(threadId2, status);
+          } else if (threadId2) {
+            this.threadStatuses.set(threadId2, status);
+          }
+          return;
+        }
+        if (message.method === "thread/closed") {
+          const threadId2 = getThreadId(params);
+          if (threadId2) {
+            const active2 = this.findActiveTurnByThreadId(threadId2);
+            if (active2) {
+              active2.queue.push({
+                type: "turn.completed",
+                status: "failed",
+                errorMessage: "Codex app-server closed the thread before the turn completed."
+              });
+              this.finishTurn(active2, { threadStatus: "not_loaded", releaseThread: false });
+            }
+            this.forgetThread(threadId2);
+          }
+          return;
+        }
+        if (message.method === "serverRequest/resolved") {
+          const protocolRequestId = String(params.requestId ?? "");
+          const permissionRequestId = this.approvalPermissionIds.get(protocolRequestId);
+          if (permissionRequestId) {
+            this.approvalPermissionIds.delete(protocolRequestId);
+            this.pendingPermissions?.resolve(permissionRequestId, {
+              behavior: "deny",
+              message: "Permission request was resolved by Codex"
+            });
+          }
+          return;
+        }
+        const turnId = getTurnId(params);
+        const threadId = getThreadId(params);
+        const active = turnId ? this.activeTurns.get(turnId) : threadId ? this.findActiveTurnByThreadId(threadId) : void 0;
+        if (active) {
+          this.routeTurnMessage(active, message);
+          return;
+        }
+        const starting = threadId ? this.startingTurns.get(threadId) : void 0;
+        if (starting) starting.messages.push(message);
+      }
+      routeTurnMessage(active, message) {
+        const method = message.method || "";
+        const params = asRecord(message.params);
+        const messageTurnId = getTurnId(params);
+        if (messageTurnId && messageTurnId !== active.turnId) return;
+        switch (method) {
+          case "item/started":
+          case "item/completed":
+            active.queue.push({
+              type: method === "item/started" ? "item.started" : "item.completed",
+              item: asRecord(params.item)
+            });
+            return;
+          case "item/agentMessage/delta":
+            active.queue.push({ type: "agent_message.delta", itemId: getItemId(params), delta: asString(params.delta) });
+            return;
+          case "item/reasoning/summaryTextDelta":
+          case "item/reasoning/textDelta":
+            active.queue.push({ type: "reasoning.delta", itemId: getItemId(params), delta: asString(params.delta) });
+            return;
+          case "turn/plan/updated": {
+            const plan = Array.isArray(params.plan) ? params.plan.map((entry) => {
+              const record = asRecord(entry);
+              return { step: asString(record.step), status: asString(record.status) };
+            }).filter((entry) => entry.step) : [];
+            active.queue.push({ type: "plan.updated", plan });
+            return;
+          }
+          case "thread/tokenUsage/updated": {
+            const tokenUsage = asRecord(params.tokenUsage);
+            active.queue.push({ type: "usage.updated", usage: asRecord(tokenUsage.last) });
+            return;
+          }
+          case "model/rerouted": {
+            const model = asString(params.toModel ?? params.model);
+            if (model) active.queue.push({ type: "model.updated", model });
+            return;
+          }
+          case "error": {
+            const error = asRecord(params.error);
+            const messageText = asString(error.message);
+            if (messageText && params.willRetry === true) {
+              active.queue.push({ type: "warning", message: messageText });
+            }
+            return;
+          }
+          case "turn/completed": {
+            const turn = asRecord(params.turn);
+            const error = asRecord(turn.error);
+            active.queue.push({
+              type: "turn.completed",
+              status: asString(turn.status) || "completed",
+              ...asString(error.message) ? { errorMessage: asString(error.message) } : {}
+            });
+            this.finishTurn(active);
+            return;
+          }
+          case "warning": {
+            const messageText = asString(params.message);
+            if (messageText) active.queue.push({ type: "warning", message: messageText });
+            return;
+          }
+          default:
+            if (method && getTurnId(params) && !this.unknownMethods.has(method)) {
+              this.unknownMethods.add(method);
+              console.warn(`[codex-app-server] Unhandled turn notification: ${method}`);
+            }
+        }
+      }
+      async handleServerRequest(message) {
+        const id = message.id;
+        const method = message.method || "";
+        const params = asRecord(message.params);
+        try {
+          if (method === "item/commandExecution/requestApproval" || method === "item/fileChange/requestApproval" || method === "item/permissions/requestApproval" || method === "execCommandApproval" || method === "applyPatchApproval") {
+            const result = await this.requestApproval(id, method, params);
+            this.writeMessage({ id, result });
+            return;
+          }
+          if (method === "item/tool/requestUserInput") {
+            const owner = this.getRequestOwner(params);
+            owner?.queue.push({
+              type: "warning",
+              message: "Codex requested interactive input, but this IM bridge cannot answer structured questions yet."
+            });
+            this.writeMessage({ id, result: { answers: {} } });
+            return;
+          }
+          if (method === "mcpServer/elicitation/request") {
+            const owner = this.getRequestOwner(params);
+            owner?.queue.push({
+              type: "warning",
+              message: "An MCP server requested interactive input; the request was declined by the IM bridge."
+            });
+            this.writeMessage({ id, result: { action: "decline", content: null, _meta: null } });
+            return;
+          }
+          this.writeMessage({ id, error: { code: -32601, message: `Unsupported server request: ${method}` } });
+        } catch (error) {
+          try {
+            this.writeMessage({
+              id,
+              error: { code: -32603, message: error instanceof Error ? error.message : String(error) }
+            });
+          } catch {
+          }
+        }
+      }
+      async requestApproval(id, method, params) {
+        const requestId = `app-server:${this.generation}:${String(id)}`;
+        const turnId = getTurnId(params);
+        const active = turnId ? this.activeTurns.get(turnId) : void 0;
+        const starting = this.startingTurns.get(getThreadId(params));
+        const owner = active || starting;
+        const toolName = method.includes("fileChange") || method === "applyPatchApproval" ? "apply_patch" : method.includes("permissions") ? "request_permissions" : "Bash";
+        const suggestions = [params.reason, params.proposedExecpolicyAmendment, params.proposedNetworkPolicyAmendments].filter((value) => value != null);
+        const resolutionPromise = this.pendingPermissions ? this.pendingPermissions.waitFor(requestId) : Promise.resolve({ behavior: "deny", message: "Permission gateway unavailable" });
+        this.approvalPermissionIds.set(String(id), requestId);
+        owner?.permissionRequestIds.add(requestId);
+        owner?.queue.push({
+          type: "permission.request",
+          requestId,
+          toolName,
+          toolInput: params,
+          ...suggestions.length > 0 ? { suggestions } : {}
+        });
+        const resolution = await resolutionPromise;
+        this.approvalPermissionIds.delete(String(id));
+        owner?.permissionRequestIds.delete(requestId);
+        const allowed = resolution.behavior === "allow";
+        if (method === "item/permissions/requestApproval") {
+          const requested = asRecord(params.permissions);
+          const granted = {};
+          if (allowed && requested.network) granted.network = requested.network;
+          if (allowed && requested.fileSystem) granted.fileSystem = requested.fileSystem;
+          return { permissions: granted, scope: "turn" };
+        }
+        if (method === "execCommandApproval" || method === "applyPatchApproval") {
+          return { decision: allowed ? "approved" : "denied" };
+        }
+        return { decision: allowed ? "accept" : "decline" };
+      }
+      async interruptTurn(threadId, turnId) {
+        const active = this.activeTurns.get(turnId);
+        if (active && !active.interruptTimer) {
+          const graceMs = Math.max(10, this.options.interruptGraceMs || DEFAULT_INTERRUPT_GRACE_MS);
+          active.interruptTimer = setTimeout(() => {
+            active.interruptTimer = void 0;
+            if (this.activeTurns.get(turnId) !== active) return;
+            active.queue.push({
+              type: "turn.completed",
+              status: "interrupted",
+              errorMessage: "Codex app-server did not confirm interruption before the timeout."
+            });
+            this.finishTurn(active);
+            void this.recycleChild(`interrupt timeout for turn ${turnId}`);
+          }, graceMs);
+          active.interruptTimer.unref?.();
+        }
+        try {
+          await this.sendRequest("turn/interrupt", { threadId, turnId });
+        } catch (error) {
+          console.warn("[codex-app-server] Failed to interrupt turn:", error instanceof Error ? error.message : error);
+        }
+      }
+      finishTurn(active, options = {}) {
+        this.activeTurns.delete(active.turnId);
+        this.threadStatuses.set(active.threadId, options.threadStatus || "idle");
+        if (active.interruptTimer) {
+          clearTimeout(active.interruptTimer);
+          active.interruptTimer = void 0;
+        }
+        this.cancelPermissions(active, "Turn completed before the permission request was resolved");
+        if (active.abortSignal && active.abortListener) {
+          active.abortSignal.removeEventListener("abort", active.abortListener);
+        }
+        active.queue.close();
+        if (options.releaseThread === false) this.clearThreadReleaseTimer(active.threadId);
+        else this.scheduleThreadRelease(active.threadId);
+      }
+      findActiveTurnByThreadId(threadId) {
+        for (const active of this.activeTurns.values()) {
+          if (active.threadId === threadId) return active;
+        }
+        return void 0;
+      }
+      getRequestOwner(params) {
+        const turnId = getTurnId(params);
+        if (turnId) return this.activeTurns.get(turnId);
+        const threadId = getThreadId(params);
+        if (!threadId) return void 0;
+        return this.findActiveTurnByThreadId(threadId) || this.startingTurns.get(threadId);
+      }
+      markThreadSubscribed(threadId, status) {
+        this.subscribedThreadIds.add(threadId);
+        this.threadStatuses.set(threadId, status === "unknown" ? "idle" : status);
+        this.clearThreadReleaseTimer(threadId);
+      }
+      forgetThread(threadId) {
+        this.clearThreadReleaseTimer(threadId);
+        this.subscribedThreadIds.delete(threadId);
+        this.threadStatuses.delete(threadId);
+      }
+      scheduleThreadRelease(threadId) {
+        this.clearThreadReleaseTimer(threadId);
+        const idleMs = this.options.threadIdleReleaseMs ?? DEFAULT_THREAD_IDLE_RELEASE_MS;
+        if (!Number.isFinite(idleMs) || idleMs < 0) return;
+        const timer = setTimeout(() => {
+          this.threadReleaseTimers.delete(threadId);
+          void this.unsubscribeThread(threadId);
+        }, Math.max(1, idleMs));
+        timer.unref?.();
+        this.threadReleaseTimers.set(threadId, timer);
+      }
+      clearThreadReleaseTimer(threadId) {
+        const timer = this.threadReleaseTimers.get(threadId);
+        if (!timer) return;
+        clearTimeout(timer);
+        this.threadReleaseTimers.delete(threadId);
+      }
+      clearAllThreadReleaseTimers() {
+        for (const timer of this.threadReleaseTimers.values()) clearTimeout(timer);
+        this.threadReleaseTimers.clear();
+      }
+      async unsubscribeThread(threadId) {
+        if (!this.subscribedThreadIds.has(threadId) || this.findActiveTurnByThreadId(threadId)) return;
+        try {
+          await this.sendRequest("thread/unsubscribe", { threadId });
+          this.forgetThread(threadId);
+        } catch (error) {
+          console.warn(
+            `[codex-app-server] Failed to release idle thread ${threadId}:`,
+            error instanceof Error ? error.message : error
+          );
+          if (this.child) this.scheduleThreadRelease(threadId);
+        }
+      }
+      cancelPermissions(owner, message) {
+        for (const requestId of owner.permissionRequestIds) {
+          this.pendingPermissions?.resolve(requestId, { behavior: "deny", message });
+        }
+        owner.permissionRequestIds.clear();
+      }
+      recycleChild(reason) {
+        const child = this.child;
+        if (this.recyclePromise) return this.recyclePromise;
+        if (!child || child.exitCode !== null) return Promise.resolve();
+        console.warn(`[codex-app-server] Recycling app-server: ${reason}`);
+        this.recyclePromise = new Promise((resolve2) => {
+          let settled = false;
+          const finish = () => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            child.off("exit", finish);
+            this.recyclePromise = null;
+            resolve2();
+          };
+          const timer = setTimeout(() => {
+            if (this.child === child) this.handleExit(child, null, "SIGKILL");
+            try {
+              child.kill("SIGKILL");
+            } catch {
+            }
+            finish();
+          }, 2e3);
+          child.once("exit", finish);
+          try {
+            child.kill();
+          } catch {
+            finish();
+          }
+        });
+        return this.recyclePromise;
+      }
+      handleExit(child, code2, signal) {
+        if (this.child !== child) return;
+        this.child = null;
+        this.startupPromise = null;
+        this.clearAllThreadReleaseTimers();
+        this.subscribedThreadIds.clear();
+        this.threadStatuses.clear();
+        const detail = this.stderrTail.trim();
+        const error = new Error(
+          `Codex app-server exited (${signal || (code2 ?? "unknown")})${detail ? `: ${detail}` : ""}`
+        );
+        for (const pending of this.pendingRequests.values()) {
+          clearTimeout(pending.timer);
+          pending.reject(error);
+        }
+        this.pendingRequests.clear();
+        for (const active of this.activeTurns.values()) {
+          if (active.interruptTimer) clearTimeout(active.interruptTimer);
+          this.cancelPermissions(active, "Codex app-server exited");
+          active.queue.fail(error);
+        }
+        this.activeTurns.clear();
+        for (const starting of this.startingTurns.values()) {
+          this.cancelPermissions(starting, "Codex app-server exited");
+          starting.queue.fail(error);
+        }
+        this.startingTurns.clear();
+        this.approvalPermissionIds.clear();
+      }
+    };
+  }
+});
+
 // src/codex-provider.ts
 var codex_provider_exports = {};
 __export(codex_provider_exports, {
   CodexProvider: () => CodexProvider,
   mapCodexUsage: () => mapCodexUsage
 });
-import fs17 from "node:fs";
+import fs18 from "node:fs";
 import os4 from "node:os";
-import path18 from "node:path";
+import path19 from "node:path";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -335,13 +1220,13 @@ function normalizeTokenCount(value) {
 }
 function mapCodexUsage(usage) {
   if (!isRecord(usage)) return void 0;
-  const cacheRead = usage.cached_input_tokens ?? usage.cache_read_input_tokens;
-  const cacheCreation = usage.cache_write_input_tokens ?? usage.cache_creation_input_tokens;
+  const cacheRead = usage.cached_input_tokens ?? usage.cache_read_input_tokens ?? usage.cachedInputTokens;
+  const cacheCreation = usage.cache_write_input_tokens ?? usage.cache_creation_input_tokens ?? usage.cacheWriteInputTokens;
   return {
-    input_tokens: normalizeTokenCount(usage.input_tokens),
-    output_tokens: normalizeTokenCount(usage.output_tokens),
+    input_tokens: normalizeTokenCount(usage.input_tokens ?? usage.inputTokens),
+    output_tokens: normalizeTokenCount(usage.output_tokens ?? usage.outputTokens),
     cache_read_input_tokens: normalizeTokenCount(cacheRead),
-    reasoning_output_tokens: normalizeTokenCount(usage.reasoning_output_tokens),
+    reasoning_output_tokens: normalizeTokenCount(usage.reasoning_output_tokens ?? usage.reasoningOutputTokens),
     ...cacheCreation === void 0 ? {} : { cache_creation_input_tokens: normalizeTokenCount(cacheCreation) }
   };
 }
@@ -449,11 +1334,88 @@ function stringifyUnknown(value) {
     return String(value);
   }
 }
+function normalizeTransport(value) {
+  return value === "app-server" || value === "auto" ? value : "sdk";
+}
+function normalizeAppServerItem(item) {
+  const type = typeof item.type === "string" ? item.type : "";
+  const id = typeof item.id === "string" ? item.id : `item-${Date.now()}`;
+  switch (type) {
+    case "agentMessage":
+      return { type: "agent_message", id, text: typeof item.text === "string" ? item.text : "" };
+    case "reasoning": {
+      const summary = Array.isArray(item.summary) ? item.summary.filter((part) => typeof part === "string") : [];
+      const content = Array.isArray(item.content) ? item.content.filter((part) => typeof part === "string") : [];
+      return { type: "reasoning", id, text: [...summary, ...content].join("\n\n") };
+    }
+    case "commandExecution":
+      return {
+        type: "command_execution",
+        id,
+        command: typeof item.command === "string" ? item.command : "",
+        aggregated_output: typeof item.aggregatedOutput === "string" ? item.aggregatedOutput : "",
+        exit_code: typeof item.exitCode === "number" ? item.exitCode : void 0,
+        status: item.status
+      };
+    case "fileChange":
+      return {
+        type: "file_change",
+        id,
+        changes: Array.isArray(item.changes) ? item.changes : [],
+        status: item.status
+      };
+    case "mcpToolCall":
+      return {
+        type: "mcp_tool_call",
+        id,
+        server: typeof item.server === "string" ? item.server : "",
+        tool: typeof item.tool === "string" ? item.tool : "",
+        arguments: item.arguments,
+        status: item.status,
+        result: item.result,
+        error: item.error
+      };
+    case "dynamicToolCall":
+      return {
+        type: "mcp_tool_call",
+        id,
+        server: typeof item.namespace === "string" ? item.namespace : "dynamic",
+        tool: typeof item.tool === "string" ? item.tool : "tool",
+        arguments: item.arguments,
+        status: item.status,
+        result: { content: item.contentItems },
+        error: item.success === false ? { message: "Dynamic tool call failed" } : void 0
+      };
+    case "webSearch":
+      return {
+        type: "web_search",
+        id,
+        query: typeof item.query === "string" ? item.query : ""
+      };
+    case "imageGeneration": {
+      const savedPath = typeof item.savedPath === "string" ? item.savedPath : "";
+      const resultText = savedPath || (typeof item.result === "string" ? item.result : "Image generation completed");
+      return {
+        type: "mcp_tool_call",
+        id,
+        server: "codex",
+        tool: "image_generation",
+        arguments: { prompt: item.revisedPrompt },
+        status: item.status,
+        result: { content: [{ type: "text", text: resultText }] },
+        error: item.status === "failed" ? { message: resultText } : void 0
+      };
+    }
+    default:
+      return null;
+  }
+}
 var MIME_EXT, DEFAULT_TERMINAL_DRAIN_TIMEOUT_MS, CodexProvider;
 var init_codex_provider = __esm({
   "src/codex-provider.ts"() {
     "use strict";
     init_sse_utils();
+    init_codex_app_server_client();
     init_runtime_options();
     MIME_EXT = {
       "image/png": ".png",
@@ -466,9 +1428,26 @@ var init_codex_provider = __esm({
     CodexProvider = class {
       sdk = null;
       codex = null;
+      pendingPermissions;
+      transport;
+      appServerClient;
+      warnedDesktopAppServerOverride = false;
       /** Maps session IDs to Codex thread IDs for resume. */
       threadIds = /* @__PURE__ */ new Map();
-      constructor(_pendingPerms) {
+      constructor(pendingPerms, options = {}) {
+        this.pendingPermissions = pendingPerms;
+        this.transport = normalizeTransport(options.transport ?? process.env.CTI_CODEX_TRANSPORT);
+        this.appServerClient = options.appServerClient || null;
+      }
+      async dispose() {
+        await this.appServerClient?.close();
+      }
+      getOwnedProcessIds() {
+        return this.appServerClient?.getOwnedProcessIds() || [];
+      }
+      getThreadRuntimeStatus(threadId) {
+        const runtime = this.appServerClient?.getThreadRuntimeStatus(threadId);
+        return runtime ? { transport: "app-server", ...runtime } : null;
       }
       clearCachedThreadId(sessionId) {
         this.threadIds.delete(sessionId);
@@ -514,6 +1493,20 @@ var init_codex_provider = __esm({
         return { sdk: this.sdk, codex: this.codex };
       }
       streamChat(params) {
+        const desktopBacked = params.sessionOrigin === "desktop" || Boolean(params.desktopThreadId);
+        if (desktopBacked && this.transport === "app-server" && !this.warnedDesktopAppServerOverride) {
+          this.warnedDesktopAppServerOverride = true;
+          console.warn(
+            "[codex-provider] Ignoring CTI_CODEX_TRANSPORT=app-server for Desktop-backed sessions; a separate app-server cannot safely attach to the Desktop host process."
+          );
+        }
+        const useAppServer = !desktopBacked && (this.transport === "app-server" || this.transport === "auto");
+        if (useAppServer) {
+          return this.streamChatViaAppServer(params, this.transport === "auto");
+        }
+        return this.streamChatViaSdk(params);
+      }
+      streamChatViaSdk(params) {
         const self = this;
         return new ReadableStream({
           start(controller) {
@@ -543,13 +1536,13 @@ var init_codex_provider = __esm({
                     { type: "text", text: params.prompt }
                   ];
                   for (const file of imageFiles) {
-                    if (file.filePath && fs17.existsSync(file.filePath)) {
+                    if (file.filePath && fs18.existsSync(file.filePath)) {
                       parts.push({ type: "local_image", path: file.filePath });
                       continue;
                     }
                     const ext = MIME_EXT[file.type] || ".png";
-                    const tmpPath = path18.join(os4.tmpdir(), `cti-img-${Date.now()}-${Math.random().toString(36).slice(2)}${ext}`);
-                    fs17.writeFileSync(tmpPath, Buffer.from(file.data, "base64"));
+                    const tmpPath = path19.join(os4.tmpdir(), `cti-img-${Date.now()}-${Math.random().toString(36).slice(2)}${ext}`);
+                    fs18.writeFileSync(tmpPath, Buffer.from(file.data, "base64"));
                     tempFiles.push(tmpPath);
                     parts.push({ type: "local_image", path: tmpPath });
                   }
@@ -715,7 +1708,212 @@ var init_codex_provider = __esm({
               } finally {
                 for (const tmp of tempFiles) {
                   try {
-                    fs17.unlinkSync(tmp);
+                    fs18.unlinkSync(tmp);
+                  } catch {
+                  }
+                }
+              }
+            })();
+          }
+        });
+      }
+      streamChatViaAppServer(params, allowSdkFallback) {
+        const self = this;
+        return new ReadableStream({
+          start(controller) {
+            (async () => {
+              const tempFiles = [];
+              try {
+                const imageFiles = params.files?.filter((file) => file.type.startsWith("image/")) || [];
+                const imagePaths = [];
+                for (const file of imageFiles) {
+                  if (file.filePath && fs18.existsSync(file.filePath)) {
+                    imagePaths.push(file.filePath);
+                    continue;
+                  }
+                  const ext = MIME_EXT[file.type] || ".png";
+                  const tmpPath = path19.join(
+                    os4.tmpdir(),
+                    `cti-img-${Date.now()}-${Math.random().toString(36).slice(2)}${ext}`
+                  );
+                  fs18.writeFileSync(tmpPath, Buffer.from(file.data, "base64"));
+                  tempFiles.push(tmpPath);
+                  imagePaths.push(tmpPath);
+                }
+                self.appServerClient ||= new CodexAppServerClient(self.pendingPermissions);
+                let turn;
+                try {
+                  turn = await self.appServerClient.startTurn({
+                    savedThreadId: self.threadIds.get(params.sessionId) || params.sdkSessionId || void 0,
+                    prompt: params.prompt,
+                    imagePaths,
+                    model: params.model,
+                    forceModel: params.forceModel,
+                    modelReasoningEffort: parseReasoningEffort(params.modelReasoningEffort),
+                    workingDirectory: params.workingDirectory,
+                    sandboxMode: normalizeSandboxMode(params.sandboxMode),
+                    permissionMode: params.permissionMode,
+                    systemPrompt: params.systemPrompt,
+                    skipGitRepoCheck: shouldSkipGitRepoCheck(),
+                    abortSignal: params.abortController?.signal
+                  });
+                } catch (error) {
+                  if (allowSdkFallback && error instanceof AppServerPreTurnError) {
+                    console.warn("[codex-provider] app-server unavailable before turn/start; falling back to SDK:", error.message);
+                    const fallback = self.streamChatViaSdk(params).getReader();
+                    try {
+                      while (true) {
+                        const { done, value } = await fallback.read();
+                        if (done) break;
+                        controller.enqueue(value);
+                      }
+                      controller.close();
+                    } finally {
+                      fallback.releaseLock();
+                    }
+                    return;
+                  }
+                  throw error;
+                }
+                self.threadIds.set(params.sessionId, turn.threadId);
+                controller.enqueue(sseEvent("status", {
+                  session_id: turn.threadId,
+                  turn_id: turn.turnId,
+                  transport: "app-server"
+                }));
+                const emittedToolStarts = /* @__PURE__ */ new Set();
+                const streamedAgentItems = /* @__PURE__ */ new Set();
+                const agentItemPhases = /* @__PURE__ */ new Map();
+                const reasoningText = /* @__PURE__ */ new Map();
+                let usage;
+                let terminalSeen = false;
+                for await (const event of turn.events) {
+                  if (params.abortController?.signal.aborted && event.type !== "turn.completed") {
+                    continue;
+                  }
+                  switch (event.type) {
+                    case "agent_message.delta":
+                      if (event.delta) {
+                        if (agentItemPhases.get(event.itemId) === "commentary") {
+                          const accumulated = `${reasoningText.get(event.itemId) || ""}${event.delta}`;
+                          reasoningText.set(event.itemId, accumulated);
+                          controller.enqueue(sseEvent("status", { reasoning: accumulated }));
+                          break;
+                        }
+                        streamedAgentItems.add(event.itemId);
+                        controller.enqueue(sseEvent("text", event.delta));
+                      }
+                      break;
+                    case "reasoning.delta": {
+                      const accumulated = `${reasoningText.get(event.itemId) || ""}${event.delta}`;
+                      reasoningText.set(event.itemId, accumulated);
+                      if (accumulated.trim()) {
+                        controller.enqueue(sseEvent("status", { reasoning: accumulated }));
+                      }
+                      break;
+                    }
+                    case "item.started":
+                    case "item.completed": {
+                      const itemId = typeof event.item.id === "string" ? event.item.id : "";
+                      if (event.item.type === "agentMessage" && itemId) {
+                        const phase = typeof event.item.phase === "string" ? event.item.phase : "";
+                        if (phase) agentItemPhases.set(itemId, phase);
+                        if (phase === "commentary") {
+                          if (event.type === "item.completed" && !reasoningText.has(itemId)) {
+                            const text2 = typeof event.item.text === "string" ? event.item.text : "";
+                            if (text2.trim()) controller.enqueue(sseEvent("status", { reasoning: text2 }));
+                          }
+                          break;
+                        }
+                      }
+                      const normalized = normalizeAppServerItem(event.item);
+                      if (!normalized) break;
+                      if (event.type === "item.completed" && normalized.type === "agent_message" && streamedAgentItems.has(normalized.id)) {
+                        break;
+                      }
+                      self.handleItemEvent(
+                        controller,
+                        normalized,
+                        event.type === "item.started" ? "started" : "completed",
+                        params.sessionId,
+                        emittedToolStarts
+                      );
+                      break;
+                    }
+                    case "plan.updated": {
+                      const tasks = event.plan.map((step) => ({
+                        text: step.step,
+                        status: step.status === "completed" ? "completed" : step.status === "inProgress" || step.status === "in_progress" ? "in_progress" : "pending"
+                      }));
+                      controller.enqueue(sseEvent("task_update", {
+                        session_id: turn.threadId,
+                        sdk_session_id: turn.threadId,
+                        tasks,
+                        todos: tasks
+                      }));
+                      break;
+                    }
+                    case "usage.updated":
+                      usage = mapCodexUsage(event.usage);
+                      break;
+                    case "model.updated":
+                      controller.enqueue(sseEvent("status", { model: event.model }));
+                      break;
+                    case "permission.request":
+                      controller.enqueue(sseEvent("permission_request", {
+                        permissionRequestId: event.requestId,
+                        toolName: event.toolName,
+                        toolInput: event.toolInput,
+                        suggestions: event.suggestions
+                      }));
+                      break;
+                    case "warning":
+                      controller.enqueue(sseEvent("status", { reasoning: event.message }));
+                      break;
+                    case "turn.completed":
+                      terminalSeen = true;
+                      if (event.status === "completed") {
+                        controller.enqueue(sseEvent("result", {
+                          usage,
+                          session_id: turn.threadId,
+                          turn_id: turn.turnId
+                        }));
+                      } else if (event.status === "failed") {
+                        self.clearCachedThreadId(params.sessionId);
+                        controller.enqueue(sseEvent(
+                          "error",
+                          normalizeCodexErrorMessage(event.errorMessage || "Turn failed")
+                        ));
+                      } else if (!params.abortController?.signal.aborted) {
+                        controller.enqueue(sseEvent("error", event.errorMessage || "Task interrupted"));
+                      }
+                      break;
+                  }
+                }
+                if (!terminalSeen && !params.abortController?.signal.aborted) {
+                  throw new Error("Codex app-server stream ended without turn/completed");
+                }
+                controller.close();
+              } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error("[codex-provider] app-server error:", error instanceof Error ? error.stack || error.message : error);
+                self.clearCachedThreadId(params.sessionId);
+                if (params.abortController?.signal.aborted) {
+                  try {
+                    controller.close();
+                  } catch {
+                  }
+                  return;
+                }
+                try {
+                  controller.enqueue(sseEvent("error", normalizeCodexErrorMessage(message)));
+                  controller.close();
+                } catch {
+                }
+              } finally {
+                for (const tempFile of tempFiles) {
+                  try {
+                    fs18.unlinkSync(tempFile);
                   } catch {
                   }
                 }
@@ -845,9 +2043,9 @@ var init_codex_provider = __esm({
 });
 
 // src/main.ts
-import fs18 from "node:fs";
-import path19 from "node:path";
-import crypto11 from "node:crypto";
+import fs19 from "node:fs";
+import path20 from "node:path";
+import crypto12 from "node:crypto";
 
 // src/lib/bridge/context.ts
 var CONTEXT_KEY = "__bridge_context__";
@@ -3286,20 +4484,20 @@ ${trimmedResponse}`;
         buffer = Buffer.concat(chunks);
       } catch (streamErr) {
         console.warn("[feishu-adapter] Stream read failed, falling back to writeFile:", streamErr instanceof Error ? streamErr.message : streamErr);
-        const fs19 = await import("fs");
+        const fs20 = await import("fs");
         const os5 = await import("os");
-        const path20 = await import("path");
-        const tmpPath = path20.join(os5.tmpdir(), `feishu-dl-${crypto3.randomUUID()}`);
+        const path21 = await import("path");
+        const tmpPath = path21.join(os5.tmpdir(), `feishu-dl-${crypto3.randomUUID()}`);
         try {
           await res.writeFile(tmpPath);
-          buffer = fs19.readFileSync(tmpPath);
+          buffer = fs20.readFileSync(tmpPath);
           if (buffer.length > MAX_FILE_SIZE) {
             console.warn(`[feishu-adapter] Resource too large (>${MAX_FILE_SIZE} bytes), key: ${fileKey}`);
             return null;
           }
         } finally {
           try {
-            fs19.unlinkSync(tmpPath);
+            fs20.unlinkSync(tmpPath);
           } catch {
           }
         }
@@ -10331,11 +11529,25 @@ import fs5 from "node:fs";
 import os2 from "node:os";
 import path4 from "node:path";
 import crypto7 from "node:crypto";
-import { DatabaseSync } from "node:sqlite";
+import { createRequire } from "node:module";
 var ACTIVE_WINDOW_MS = 15 * 60 * 1e3;
 var MAX_SESSION_META_BYTES = 4 * 1024 * 1024;
 var MAX_SESSION_TITLE_SCAN_BYTES = 512 * 1024;
+var INITIAL_HISTORY_TAIL_BYTES = 256 * 1024;
+var MAX_HISTORY_TAIL_BYTES = 64 * 1024 * 1024;
 var TITLE_MAX_CHARS = 72;
+var localRequire = createRequire(import.meta.url);
+var databaseSyncConstructor;
+function getDatabaseSyncConstructor() {
+  if (databaseSyncConstructor !== void 0) return databaseSyncConstructor;
+  try {
+    const sqlite = localRequire("node:sqlite");
+    databaseSyncConstructor = typeof sqlite.DatabaseSync === "function" ? sqlite.DatabaseSync : null;
+  } catch {
+    databaseSyncConstructor = null;
+  }
+  return databaseSyncConstructor;
+}
 function getCodexHome() {
   return process.env.CODEX_HOME || path4.join(os2.homedir(), ".codex");
 }
@@ -10478,10 +11690,37 @@ function walkSessionFiles(dirPath, target) {
     }
   }
 }
+function normalizeSourceKind(value) {
+  if (typeof value === "string") {
+    const normalized = value.trim();
+    if (!normalized) return "";
+    if (normalized.startsWith("{")) {
+      try {
+        return normalizeSourceKind(JSON.parse(normalized));
+      } catch {
+        return normalized.toLowerCase();
+      }
+    }
+    return normalized.toLowerCase();
+  }
+  if (!value || typeof value !== "object") return "";
+  const record = value;
+  if ("subagent" in record || "sub_agent" in record) return "subagent";
+  for (const key of ["type", "kind", "source", "name"]) {
+    const nested = normalizeSourceKind(record[key]);
+    if (nested) return nested;
+  }
+  return "";
+}
+function isSubagentThread(source, threadSource, parentThreadId) {
+  if (typeof parentThreadId === "string" && parentThreadId.trim()) return true;
+  return normalizeSourceKind(threadSource) === "subagent" || normalizeSourceKind(source) === "subagent";
+}
 function isDesktopLike(meta) {
   const originator = typeof meta?.originator === "string" ? meta.originator.toLowerCase() : "";
-  const source = typeof meta?.source === "string" ? meta.source.toLowerCase() : "";
+  const source = normalizeSourceKind(meta?.source);
   if (source === "exec") return false;
+  if (isSubagentThread(meta?.source, meta?.thread_source, meta?.parent_thread_id)) return false;
   return originator.includes("desktop") || source === "vscode" || source === "desktop";
 }
 function loadThreadIndexEntries(archivedThreadIds) {
@@ -10530,25 +11769,46 @@ function parseUpdatedAtValue(value) {
 function loadVisibleDesktopThreads(limit) {
   const dbPath = getDesktopStateDbPath();
   if (!dbPath || !fs5.existsSync(dbPath)) return null;
+  const DatabaseSync = getDatabaseSyncConstructor();
+  if (!DatabaseSync) return null;
   let db = null;
   try {
     db = new DatabaseSync(dbPath, { readOnly: true });
+    const columns = new Set(
+      db.prepare("PRAGMA table_info(threads)").all().map((row) => row && typeof row === "object" ? row.name : null).filter((name) => typeof name === "string")
+    );
+    if (!columns.has("id") || !columns.has("updated_at")) return null;
     const hasLimit = typeof limit === "number" && Number.isFinite(limit) && limit > 0;
+    const selectedColumns = [
+      "id",
+      "updated_at",
+      ...["updated_at_ms", "rollout_path", "title", "cwd", "source", "thread_source"].filter((column) => columns.has(column))
+    ];
+    const whereClauses = columns.has("archived") ? ["archived = 0"] : ["1 = 1"];
+    if (columns.has("source")) whereClauses.push("COALESCE(source, '') != 'exec'");
+    if (columns.has("thread_source")) whereClauses.push("COALESCE(thread_source, '') != 'subagent'");
     const sql = `
-      SELECT id, updated_at
+      SELECT ${selectedColumns.join(", ")}
       FROM threads
-      WHERE archived = 0
-        AND source != 'exec'
-      ORDER BY updated_at DESC
+      WHERE ${whereClauses.join("\n        AND ")}
+      ORDER BY ${columns.has("updated_at_ms") ? "updated_at_ms" : "updated_at"} DESC
       ${hasLimit ? "LIMIT ?" : ""}
     `;
     const rows = hasLimit ? db.prepare(sql).all(Math.max(1, Math.floor(limit))) : db.prepare(sql).all();
     const ids = rows.map((row) => {
-      const id = typeof row.id === "string" ? row.id.trim() : "";
+      if (!row || typeof row !== "object") return null;
+      const record = row;
+      const id = typeof record.id === "string" ? record.id.trim() : "";
       if (!id) return null;
+      if (isSubagentThread(record.source, record.thread_source)) return null;
       return {
         id,
-        updatedAtMs: parseUpdatedAtValue(row.updated_at)
+        updatedAtMs: parseUpdatedAtValue(record.updated_at_ms ?? record.updated_at),
+        ...typeof record.rollout_path === "string" && record.rollout_path.trim() ? { rolloutPath: record.rollout_path.trim() } : {},
+        ...typeof record.title === "string" && trimTitle(record.title) ? { title: trimTitle(record.title) } : {},
+        ...typeof record.cwd === "string" ? { cwd: record.cwd } : {},
+        ...typeof record.source === "string" ? { source: record.source } : {},
+        ...typeof record.thread_source === "string" ? { threadSource: record.thread_source } : {}
       };
     }).filter((row) => Boolean(row));
     return ids.length > 0 ? ids : null;
@@ -10579,7 +11839,7 @@ function buildFallbackTitle(threadId, filePath, cwd) {
   if (dirName) return dirName;
   return `Session ${threadId.slice(0, 8)}`;
 }
-function parseDesktopSession(filePath, threadIndexEntries, archivedThreadIds) {
+function parseDesktopSession(filePath, threadIndexEntries, archivedThreadIds, visibleThread) {
   const firstLine = readFirstLine(filePath);
   if (!firstLine) return null;
   let parsed;
@@ -10591,7 +11851,8 @@ function parseDesktopSession(filePath, threadIndexEntries, archivedThreadIds) {
   if (parsed.type !== "session_meta" || !parsed.payload?.id || !isDesktopLike(parsed.payload)) {
     return null;
   }
-  if (archivedThreadIds.has(parsed.payload.id)) {
+  const threadId = visibleThread?.id || parsed.payload.id;
+  if (archivedThreadIds.has(threadId)) {
     return null;
   }
   let stat;
@@ -10600,20 +11861,19 @@ function parseDesktopSession(filePath, threadIndexEntries, archivedThreadIds) {
   } catch {
     return null;
   }
-  const cwd = parsed.payload.cwd || "";
+  const cwd = visibleThread?.cwd || parsed.payload.cwd || "";
   if (isInternalSkillWorkspace(cwd)) {
     return null;
   }
-  const lastEventAt = stat.mtime.toISOString();
+  const lastEventAt = visibleThread?.updatedAtMs ? new Date(visibleThread.updatedAtMs).toISOString() : stat.mtime.toISOString();
   const firstSeenAt = parsed.payload.timestamp || parsed.timestamp || stat.birthtime.toISOString();
-  const threadId = parsed.payload.id;
-  const title = threadIndexEntries.get(threadId)?.title || buildFallbackTitle(threadId, filePath, cwd);
+  const title = visibleThread?.title || threadIndexEntries.get(threadId)?.title || buildFallbackTitle(threadId, filePath, cwd);
   return {
     threadId,
     filePath,
     cwd,
     originator: typeof parsed.payload.originator === "string" ? parsed.payload.originator : "Codex Desktop",
-    source: typeof parsed.payload.source === "string" ? parsed.payload.source : void 0,
+    source: visibleThread?.source || (typeof parsed.payload.source === "string" ? parsed.payload.source : void 0),
     cliVersion: typeof parsed.payload.cli_version === "string" ? parsed.payload.cli_version : void 0,
     firstSeenAt,
     lastEventAt,
@@ -10826,6 +12086,7 @@ function isTurnContextLine(line) {
 }
 var IGNORED_EVENT_MSG_TYPES = /* @__PURE__ */ new Set([
   "context_compacted",
+  "sub_agent_activity",
   "thread_settings_applied",
   "thread_goal_updated",
   "thread_name_updated",
@@ -10833,11 +12094,13 @@ var IGNORED_EVENT_MSG_TYPES = /* @__PURE__ */ new Set([
   "token_count"
 ]);
 var IGNORED_RESPONSE_ITEM_TYPES = /* @__PURE__ */ new Set([
+  "agent_message",
   "image_generation_call",
   "web_search_call"
 ]);
 var IGNORED_TOP_LEVEL_TYPES = /* @__PURE__ */ new Set([
   "compacted",
+  "inter_agent_communication_metadata",
   "session_meta",
   "turn_context",
   "world_state"
@@ -10853,6 +12116,13 @@ function isTerminalCompletionEventType(value) {
 function getEventTurnId(payload) {
   return payload?.turn_id || payload?.turnId || "";
 }
+function getResponseItemTurnId(payload) {
+  const metadata = payload?.internal_chat_message_metadata_passthrough;
+  return extractNormalizedFreeText(metadata?.turn_id ?? metadata?.turnId);
+}
+function getResponseItemClientId(payload) {
+  return extractNormalizedFreeText(payload?.client_id);
+}
 function extractTerminalCompletionText(payload) {
   if (!payload) return "";
   for (const value of [
@@ -10906,12 +12176,31 @@ function listDesktopSessions(limit) {
   const visibleThreadIds = visibleThreads?.map((thread) => thread.id) || null;
   const visibleThreadSet = visibleThreadIds ? new Set(visibleThreadIds) : null;
   const visibleThreadUpdatedAt = new Map(visibleThreads?.map((thread) => [thread.id, thread.updatedAtMs]) || []);
+  const visibleThreadRows = new Map(visibleThreads?.map((thread) => [thread.id, thread]) || []);
   const oldestVisibleUpdatedAtMs = visibleThreads && visibleThreads.length > 0 ? Math.min(...visibleThreads.map((thread) => thread.updatedAtMs || Number.MAX_SAFE_INTEGER)) : 0;
   const files = [];
   walkSessionFiles(root, files);
   const allSessions = /* @__PURE__ */ new Map();
+  for (const thread of visibleThreads || []) {
+    if (!thread.rolloutPath || !fs5.existsSync(thread.rolloutPath)) continue;
+    const session = parseDesktopSession(
+      thread.rolloutPath,
+      threadIndexEntries,
+      archivedThreadIds,
+      thread
+    );
+    if (!session || !isWithinSavedWorkspaceRoots(session.cwd, savedWorkspaceRoots)) continue;
+    allSessions.set(session.threadId, session);
+  }
   for (const filePath of files) {
-    const session = parseDesktopSession(filePath, threadIndexEntries, archivedThreadIds);
+    const threadId = extractThreadIdFromRolloutName(path4.basename(filePath));
+    if (threadId && allSessions.has(threadId)) continue;
+    const session = parseDesktopSession(
+      filePath,
+      threadIndexEntries,
+      archivedThreadIds,
+      threadId ? visibleThreadRows.get(threadId) : void 0
+    );
     if (!session) continue;
     if (!isWithinSavedWorkspaceRoots(session.cwd, savedWorkspaceRoots)) continue;
     allSessions.set(session.threadId, session);
@@ -11210,6 +12499,8 @@ function pushDesktopMirrorEventRecord(records, parsed, rawLine, activeTurnId) {
 function pushDesktopMirrorResponseRecord(records, parsed, rawLine, activeTurnId, activeSpecialCallIds) {
   const signature = createDesktopEventSignature(rawLine);
   const timestamp = parsed.timestamp || "";
+  activeTurnId = getResponseItemTurnId(parsed.payload) || activeTurnId;
+  const clientId = getResponseItemClientId(parsed.payload);
   if (isIgnoredMirrorLineKind(parsed)) {
     return true;
   }
@@ -11221,7 +12512,8 @@ function pushDesktopMirrorResponseRecord(records, parsed, rawLine, activeTurnId,
       type: "reasoning",
       content: text2,
       timestamp,
-      ...activeTurnId ? { turnId: activeTurnId } : {}
+      ...activeTurnId ? { turnId: activeTurnId } : {},
+      ...clientId ? { clientId } : {}
     });
     return true;
   }
@@ -11234,7 +12526,8 @@ function pushDesktopMirrorResponseRecord(records, parsed, rawLine, activeTurnId,
       role: parsed.payload.phase === "commentary" ? "commentary" : "assistant",
       content: parsed.payload.phase === "commentary" ? text2.replace(/^\[commentary\]\n/, "") : text2,
       timestamp,
-      ...activeTurnId ? { turnId: activeTurnId } : {}
+      ...activeTurnId ? { turnId: activeTurnId } : {},
+      ...clientId ? { clientId } : {}
     });
     return true;
   }
@@ -11251,7 +12544,8 @@ function pushDesktopMirrorResponseRecord(records, parsed, rawLine, activeTurnId,
       role: "user",
       content: text2,
       timestamp,
-      ...activeTurnId ? { turnId: activeTurnId } : {}
+      ...activeTurnId ? { turnId: activeTurnId } : {},
+      ...clientId ? { clientId } : {}
     });
     return true;
   }
@@ -11475,23 +12769,67 @@ function parseDesktopMirrorRecordText(content, leadingText = "", flushTrailingTe
     unknownKinds: Array.from(unknownKinds)
   };
 }
-function readDesktopSessionMessages(threadId, limit = 8) {
-  const messages = readDesktopSessionEventStream(threadId).map((event) => ({
+function mapDesktopEventsToMessages(events) {
+  return events.map((event) => ({
     role: event.role === "commentary" ? "assistant" : event.role,
     content: event.role === "commentary" ? `[commentary]
 ${event.content}` : event.content
   }));
-  const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 8;
-  return messages.slice(-safeLimit);
 }
-function readDesktopSessionEventStreamByFilePath(filePath) {
-  let content = "";
+function readUtf8FileTail(filePath, maxBytes) {
+  const stat = fs5.statSync(filePath);
+  const bytesToRead = Math.min(stat.size, Math.max(1, maxBytes));
+  const startOffset = Math.max(0, stat.size - bytesToRead);
+  const buffer = Buffer.alloc(bytesToRead);
+  const fd = fs5.openSync(filePath, "r");
   try {
-    content = fs5.readFileSync(filePath, "utf-8");
+    let totalRead = 0;
+    while (totalRead < bytesToRead) {
+      const bytesRead = fs5.readSync(
+        fd,
+        buffer,
+        totalRead,
+        bytesToRead - totalRead,
+        startOffset + totalRead
+      );
+      if (bytesRead <= 0) break;
+      totalRead += bytesRead;
+    }
+    let contentBuffer = buffer.subarray(0, totalRead);
+    if (startOffset > 0) {
+      const firstNewline = contentBuffer.indexOf(10);
+      contentBuffer = firstNewline >= 0 ? contentBuffer.subarray(firstNewline + 1) : Buffer.alloc(0);
+    }
+    return {
+      content: contentBuffer.toString("utf-8"),
+      reachedStart: startOffset === 0
+    };
+  } finally {
+    fs5.closeSync(fd);
+  }
+}
+function readDesktopSessionMessagesByFilePath(filePath, limit = 8) {
+  const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 8;
+  const targetEventCount = safeLimit + 4;
+  let bytesToRead = INITIAL_HISTORY_TAIL_BYTES;
+  let events = [];
+  try {
+    while (bytesToRead <= MAX_HISTORY_TAIL_BYTES) {
+      const tail = readUtf8FileTail(filePath, bytesToRead);
+      events = parseDesktopSessionEventText(tail.content, "", true).events;
+      if (tail.reachedStart || events.length >= targetEventCount) break;
+      if (bytesToRead === MAX_HISTORY_TAIL_BYTES) break;
+      bytesToRead = Math.min(MAX_HISTORY_TAIL_BYTES, bytesToRead * 2);
+    }
   } catch {
     return [];
   }
-  return parseDesktopSessionEventText(content, "", true).events;
+  return mapDesktopEventsToMessages(events).slice(-safeLimit);
+}
+function readDesktopSessionMessages(threadId, limit = 8) {
+  const session = getDesktopSessionByThreadId(threadId);
+  if (!session) return [];
+  return readDesktopSessionMessagesByFilePath(session.filePath, limit);
 }
 function readDesktopSessionMirrorRecordDeltaByFilePath(filePath, startOffset, endOffset, trailingText = "", currentTurnId = null, currentSpecialCallIds = []) {
   let range;
@@ -11523,11 +12861,6 @@ function readDesktopSessionMirrorRecordDeltaByFilePath(filePath, startOffset, en
     unknownKinds: parsed.unknownKinds
   };
 }
-function readDesktopSessionEventStream(threadId) {
-  const session = getDesktopSessionByThreadId(threadId);
-  if (!session) return [];
-  return readDesktopSessionEventStreamByFilePath(session.filePath);
-}
 
 // src/lib/bridge/turns/turn-classifier.ts
 function normalizeThreadId(value) {
@@ -13145,7 +14478,7 @@ function abortMirrorSuppression(store, sessionId, config2, suppressionId, nowMs
   }
   target.until = nowMs + config2.suppressionWindowMs;
 }
-function filterSuppressedMirrorRecords(store, sessionId, records, config2, nowMs = Date.now()) {
+function filterSuppressedMirrorRecords(store, sessionId, records, config2, nowMs = Date.now(), onTurnAssociated) {
   const suppressions = getMirrorSuppressionStates(store, sessionId, nowMs);
   const ignoredTurnIds = cleanupIgnoredMirrorTurns(store, sessionId, nowMs);
   if (suppressions.length === 0 && ignoredTurnIds.size === 0 || records.length === 0) return records;
@@ -13182,6 +14515,9 @@ function filterSuppressedMirrorRecords(store, sessionId, records, config2, nowMs
             suppression.awaitingPromptMatch = false;
             suppression.droppingTurn = true;
             suppression.activeTurnId = record.turnId || suppression.candidateTurnId || null;
+            if (suppression.activeTurnId) {
+              onTurnAssociated?.(sessionId, suppression.activeTurnId);
+            }
             handled = true;
             break;
           }
@@ -13241,6 +14577,29 @@ function filterSuppressedMirrorRecords(store, sessionId, records, config2, nowMs
   }
   return filtered;
 }
+function associateMirrorSuppressionTurns(store, sessionId, records, nowMs = Date.now(), onTurnAssociated) {
+  const suppressions = getMirrorSuppressionStates(store, sessionId, nowMs);
+  if (suppressions.length === 0 || records.length === 0) return;
+  const suppression = suppressions[0];
+  if (!suppression.awaitingPromptMatch) return;
+  for (const record of records) {
+    if (record.type === "task_started" && record.turnId) {
+      suppression.candidateTurnId = record.turnId;
+      continue;
+    }
+    if (record.type !== "message" || record.role !== "user") continue;
+    if (isSyntheticDesktopUserContext(record.content || "")) continue;
+    const normalizedContent = normalizeMirrorPromptText(record.content || "");
+    if (!suppression.promptText || normalizedContent !== suppression.promptText) break;
+    const turnId = record.turnId || suppression.candidateTurnId;
+    if (!turnId) break;
+    suppression.awaitingPromptMatch = false;
+    suppression.droppingTurn = true;
+    suppression.activeTurnId = turnId;
+    onTurnAssociated?.(sessionId, turnId);
+    break;
+  }
+}
 
 // src/lib/bridge/adapter-sync-plan.ts
 function stableFingerprintValue(value) {
@@ -15030,6 +16389,8 @@ async function processMessage(binding, text2, onPermissionRequest, abortSignal,
         prompt: promptText,
         sessionId,
         sdkSessionId: binding.sdkSessionId || void 0,
+        sessionOrigin: session?.thread_origin === "desktop" ? "desktop" : "bridge",
+        desktopThreadId: session?.desktop_thread_id || void 0,
         model: effectiveModel,
         forceModel: !binding.sdkSessionId && Boolean(effectiveModel),
         sandboxMode,
@@ -16689,7 +18050,9 @@ async function runMirrorReconcileBatch(deps) {
 }
 
 // src/lib/bridge/mirror-runtime.ts
+var MIRROR_ORPHAN_PROCESS_PROBE_INTERVAL_MS = 6e4;
 function createMirrorRuntime(getState2, options, deps) {
+  const orphanProbeAt = /* @__PURE__ */ new Map();
   function isAtOrBefore(timestamp, boundary) {
     if (!timestamp) return true;
     const timestampMs = Date.parse(timestamp);
@@ -16776,8 +18139,35 @@ function createMirrorRuntime(getState2, options, deps) {
     deps.stopMirrorStreaming(existing);
     closeMirrorWatcher(existing);
     state.mirrorSubscriptions.delete(bindingId);
+    orphanProbeAt.delete(bindingId);
     deps.syncMirrorSessionStateSafe(existing.sessionId, "mirror subscription removal");
   }
+  async function finalizeOrphanedMirrorStream(subscription, snapshot, blocked, runtimeBusy, nowMs) {
+    const pendingTurn = subscription.pendingTurn;
+    if (!pendingTurn?.streamStarted || blocked || runtimeBusy) return null;
+    const timeoutMs = options.streamOrphanTimeoutMs;
+    const lastActivityMs = Date.parse(pendingTurn.lastActivityAt);
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || !Number.isFinite(lastActivityMs)) {
+      return null;
+    }
+    const sourceActivityMs = Math.max(lastActivityMs, snapshot.mtimeMs);
+    if (nowMs - sourceActivityMs < timeoutMs) return null;
+    const lastProbeAt = orphanProbeAt.get(subscription.bindingId);
+    if (typeof lastProbeAt === "number" && nowMs - lastProbeAt < MIRROR_ORPHAN_PROCESS_PROBE_INTERVAL_MS) {
+      return null;
+    }
+    orphanProbeAt.set(subscription.bindingId, nowMs);
+    if (!await deps.isThreadProcessDefinitelyGone(subscription.threadId)) return null;
+    const finalized = flushTimedOutMirrorTurn(subscription, timeoutMs, nowMs);
+    if (!finalized) return null;
+    orphanProbeAt.delete(subscription.bindingId);
+    const detail = "\u684C\u9762\u7EBF\u7A0B\u957F\u65F6\u95F4\u6CA1\u6709\u65B0\u8BB0\u5F55\uFF0C\u4E14\u672C\u673A\u672A\u627E\u5230\u5BF9\u5E94\u8FDB\u7A0B\uFF1B\u5DF2\u7ED3\u675F\u5B64\u7ACB\u7684\u6D41\u5F0F\u540C\u6B65\u3002";
+    deps.recordOrphanedMirrorTurn(subscription.sessionId, detail);
+    console.warn(
+      `[bridge-manager] Finalized orphaned mirror turn ${pendingTurn.turnId || pendingTurn.streamKey} for thread ${subscription.threadId}`
+    );
+    return finalized;
+  }
   function clearDanglingMirrorThread(subscription, reason) {
     const { store } = getBridgeContext();
     const session = store.getSession(subscription.sessionId);
@@ -16835,6 +18225,7 @@ function createMirrorRuntime(getState2, options, deps) {
     });
     if (threadChanged || filePathChanged) {
       deps.stopMirrorStreaming(existing);
+      orphanProbeAt.delete(existing.bindingId);
     }
     watchMirrorFile(existing, filePath);
     if (previousSessionId !== binding.codepilotSessionId) {
@@ -16934,6 +18325,20 @@ function createMirrorRuntime(getState2, options, deps) {
       flushTimedOutTurn: (currentSubscription) => deps.flushTimedOutMirrorTurn(currentSubscription),
       consumeBufferedTurns: (currentSubscription) => deps.consumeBufferedMirrorTurns(currentSubscription)
     });
+    const runtimeBusy = session.runtime_status === "running" || session.runtime_status === "queued";
+    const orphanedTurn = await finalizeOrphanedMirrorStream(
+      subscription,
+      snapshot,
+      blocked,
+      runtimeBusy,
+      Date.now()
+    );
+    if (orphanedTurn) {
+      deliveryPlan.finalizedTurns.push(orphanedTurn);
+      deliveryPlan.syncReason = "mirror reconcile delivered turns";
+    } else if (!subscription.pendingTurn?.streamStarted) {
+      orphanProbeAt.delete(subscription.bindingId);
+    }
     if (deliveryPlan.finalizedTurns.length > 0) {
       enqueuePendingMirrorDeliveries(subscription, deliveryPlan.finalizedTurns);
     }
@@ -17297,7 +18702,7 @@ function normalizeProbeRecord(threadId, checkedAt, raw) {
 function escapePowerShellSingleQuoted(value) {
   return value.replace(/'/g, "''");
 }
-async function probeCodexThreadProcess(threadId) {
+async function probeCodexThreadProcess(threadId, options = {}) {
   const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
   const trimmedThreadId = threadId.trim();
   if (!trimmedThreadId) {
@@ -17318,11 +18723,14 @@ async function probeCodexThreadProcess(threadId) {
     };
   }
   const psThreadId = escapePowerShellSingleQuoted(trimmedThreadId);
+  const excludePids = Array.from(options.excludePids || []).filter((pid) => Number.isInteger(pid) && pid > 0);
+  const excludedLiteral = excludePids.length > 0 ? excludePids.join(",") : "";
   const script = [
     `$threadId = '${psThreadId}'`,
     "$escaped = [regex]::Escape($threadId)",
+    `$excludedPids = @(${excludedLiteral})`,
     "$proc = Get-CimInstance Win32_Process | Where-Object {",
-    "  $_.Name -ieq 'codex.exe' -and $_.CommandLine -match $escaped",
+    "  $_.Name -ieq 'codex.exe' -and $_.CommandLine -match $escaped -and $excludedPids -notcontains [int]$_.ProcessId",
     "} | Select-Object -First 1 ProcessId, CreationDate, CommandLine",
     "if ($null -eq $proc) { '' } else { $proc | ConvertTo-Json -Compress }"
   ].join("; ");
@@ -17356,6 +18764,12 @@ async function probeCodexThreadProcess(threadId) {
     };
   }
 }
+async function isCodexThreadProcessDefinitelyGone(threadId, probe = probeCodexThreadProcess) {
+  const threadProbe = await probe(threadId);
+  if (threadProbe.status !== "not_found") return false;
+  const hostProbe = await probe("app-server");
+  return hostProbe.status === "not_found";
+}
 
 // src/lib/bridge/session-health-reducer.ts
 var HEALTH_RECENT_PROGRESS_MS = 10 * 60 * 1e3;
@@ -17495,7 +18909,9 @@ 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)) {
+  const terminalHealth = previousStatus === "completed" || previousStatus === "failed" || previousStatus === "aborted";
+  const activeDesktopMirror = session.thread_origin === "desktop" && session.mirror_status === "watching" && isRunningHealthStatus(previousStatus);
+  if (!isRunningRuntimeStatus(runtimeStatus) && !terminalHealth && !activeDesktopMirror) {
     return {
       sessionId: session.id,
       checkedAt: null,
@@ -17583,6 +18999,12 @@ function applyProcessProbeDiagnosis(diagnosis, processProbe) {
       processProbe: null
     };
   }
+  if (!isRunningHealthStatus(diagnosis.healthStatus)) {
+    return {
+      ...diagnosis,
+      processProbe
+    };
+  }
   if (processProbe.status === "alive") {
     const healthStatus = diagnosis.activeToolName ? "waiting_tool" : "slow_observed";
     const healthReason = diagnosis.activeToolName ? "\u68C0\u6D4B\u5230\u672C\u673A\u7EBF\u7A0B\u8FDB\u7A0B\u4ECD\u5728\u8FD0\u884C\uFF0C\u5F53\u524D\u66F4\u50CF\u662F\u957F\u65F6\u5DE5\u5177\u6267\u884C\u3002" : "\u68C0\u6D4B\u5230\u672C\u673A\u7EBF\u7A0B\u8FDB\u7A0B\u4ECD\u5728\u8FD0\u884C\uFF0C\u5F53\u524D\u66F4\u50CF\u662F\u957F\u65F6\u4EFB\u52A1\u3002";
@@ -18026,6 +19448,14 @@ function createTurnCoordinator(deps = {}) {
   function getActiveTurn(sessionId) {
     return activeTurnsBySession.get(sessionId);
   }
+  function associateDesktopTurn(sessionId, turnId) {
+    const turn = activeTurnsBySession.get(sessionId);
+    const normalizedTurnId = turnId.trim();
+    if (!turn || turn.kind !== "im_desktop_reuse" || !normalizedTurnId) return false;
+    if (turn.codexTurnId && turn.codexTurnId !== normalizedTurnId) return false;
+    turn.codexTurnId = normalizedTurnId;
+    return true;
+  }
   async function claimDesktopTerminal(terminal) {
     const turn = activeTurnsBySession.get(terminal.sessionId);
     if (!turn || turn.kind !== "im_desktop_reuse") {
@@ -18034,6 +19464,9 @@ function createTurnCoordinator(deps = {}) {
     if (turn.desktopThreadId && turn.desktopThreadId !== terminal.desktopThreadId) {
       return { claimed: false };
     }
+    if (!turn.codexTurnId || terminal.turnId !== turn.codexTurnId) {
+      return { claimed: false, turn };
+    }
     const finalized = await deps.finalizeTerminalTurn?.(turn, terminal);
     return finalized ? { claimed: true, turn } : { claimed: false, turn };
   }
@@ -18056,6 +19489,7 @@ function createTurnCoordinator(deps = {}) {
   return {
     registerInteractiveTurn,
     getActiveTurn,
+    associateDesktopTurn,
     claimDesktopTerminal,
     releaseTurn,
     releaseSessionTurn,
@@ -18076,6 +19510,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_STREAM_ORPHAN_TIMEOUT_MS = 30 * 6e4;
 var MIRROR_TURN_BUFFER_TIMEOUT_MS = 10 * 6e4;
 function describeUnknownError(error) {
   if (error instanceof Error) {
@@ -18178,10 +19613,49 @@ var TURN_COORDINATOR = createTurnCoordinator({
     terminal.text
   )
 });
+function getBridgeOwnedCodexProcessIds() {
+  try {
+    return getBridgeContext().llm.getOwnedProcessIds?.() || [];
+  } catch {
+    return [];
+  }
+}
+async function probeManagedThreadProcess(threadId) {
+  const checkedAt = nowIso3();
+  try {
+    const runtime = getBridgeContext().llm.getThreadRuntimeStatus?.(threadId);
+    if (runtime) {
+      if (runtime.status === "system_error") {
+        return {
+          threadId,
+          status: "error",
+          supported: true,
+          checkedAt,
+          ...runtime.processId ? { pid: runtime.processId } : {},
+          error: "Codex app-server reported a system error for this thread"
+        };
+      }
+      if (runtime.status !== "not_loaded") {
+        return {
+          threadId,
+          status: "alive",
+          supported: true,
+          checkedAt,
+          ...runtime.processId ? { pid: runtime.processId } : {},
+          commandLine: `codex app-server (${runtime.status})`
+        };
+      }
+    }
+  } catch {
+  }
+  return probeCodexThreadProcess(threadId, {
+    excludePids: getBridgeOwnedCodexProcessIds()
+  });
+}
 var SESSION_HEALTH_RUNTIME = createSessionHealthRuntime({
   getStore: () => getBridgeContext().store,
   nowIso: nowIso3,
-  probeThreadProcess: (threadId) => probeCodexThreadProcess(threadId)
+  probeThreadProcess: probeManagedThreadProcess
 });
 var MIRROR_SUPPRESSION_CONFIG = {
   suppressionWindowMs: MIRROR_SUPPRESSION_WINDOW_MS,
@@ -18219,7 +19693,22 @@ function filterSuppressedMirrorRecords2(sessionId, records) {
     getMirrorSuppressionStore(),
     sessionId,
     records,
-    MIRROR_SUPPRESSION_CONFIG
+    MIRROR_SUPPRESSION_CONFIG,
+    Date.now(),
+    (associatedSessionId, turnId) => {
+      TURN_COORDINATOR.associateDesktopTurn(associatedSessionId, turnId);
+    }
+  );
+}
+function associateSuppressedDesktopTurn(sessionId, records) {
+  associateMirrorSuppressionTurns(
+    getMirrorSuppressionStore(),
+    sessionId,
+    records,
+    Date.now(),
+    (associatedSessionId, turnId) => {
+      TURN_COORDINATOR.associateDesktopTurn(associatedSessionId, turnId);
+    }
   );
 }
 function syncMirrorSessionState(sessionId) {
@@ -18305,7 +19794,8 @@ var MIRROR_RUNTIME = createMirrorRuntime(getState, {
   watchDebounceMs: MIRROR_WATCH_DEBOUNCE_MS,
   danglingThreadRetryLimit: DANGLING_MIRROR_THREAD_RETRY_LIMIT,
   failureSuspendThreshold: MIRROR_FAILURE_SUSPEND_THRESHOLD,
-  failureSuspendMs: MIRROR_FAILURE_SUSPEND_MS
+  failureSuspendMs: MIRROR_FAILURE_SUSPEND_MS,
+  streamOrphanTimeoutMs: MIRROR_STREAM_ORPHAN_TIMEOUT_MS
 }, {
   nowIso: nowIso3,
   describeUnknownError,
@@ -18315,12 +19805,19 @@ var MIRROR_RUNTIME = createMirrorRuntime(getState, {
   observeSessionHealthRecords: (sessionId, threadId, records) => {
     SESSION_HEALTH_RUNTIME.observeDesktopMirrorRecords(sessionId, threadId, records);
   },
-  routeDesktopRecords: (sessionId, threadId, records) => routeDesktopRecords(
-    sessionId,
+  recordOrphanedMirrorTurn: (sessionId, detail) => {
+    SESSION_HEALTH_RUNTIME.recordInteractiveEnd(sessionId, "aborted", detail);
+  },
+  isThreadProcessDefinitelyGone: (threadId) => isCodexThreadProcessDefinitelyGone(
     threadId,
-    records,
-    TURN_COORDINATOR
+    (probeValue) => probeCodexThreadProcess(probeValue, {
+      excludePids: getBridgeOwnedCodexProcessIds()
+    })
   ),
+  routeDesktopRecords: (sessionId, threadId, records) => {
+    associateSuppressedDesktopTurn(sessionId, records);
+    return routeDesktopRecords(sessionId, threadId, records, TURN_COORDINATOR);
+  },
   consumeMirrorRecords: consumeMirrorRecords2,
   flushTimedOutMirrorTurn: (subscription) => flushTimedOutMirrorTurn2(subscription),
   hasPendingMirrorWork: hasPendingMirrorWork2,
@@ -19517,13 +21014,15 @@ function writeRuntimeStatus(filePath, info, options = {}) {
 }
 
 // src/main.ts
-var RUNTIME_DIR = path19.join(CTI_HOME, "runtime");
-var STATUS_FILE = path19.join(RUNTIME_DIR, "status.json");
-var PID_FILE = path19.join(RUNTIME_DIR, "bridge.pid");
-var runId = crypto11.randomUUID();
-async function resolveProvider() {
+var RUNTIME_DIR = path20.join(CTI_HOME, "runtime");
+var STATUS_FILE = path20.join(RUNTIME_DIR, "status.json");
+var PID_FILE = path20.join(RUNTIME_DIR, "bridge.pid");
+var runId = crypto12.randomUUID();
+async function resolveProvider(pendingPerms) {
   const { CodexProvider: CodexProvider2 } = await Promise.resolve().then(() => (init_codex_provider(), codex_provider_exports));
-  return new CodexProvider2();
+  return new CodexProvider2(pendingPerms, {
+    transport: process.env.CTI_CODEX_TRANSPORT || "auto"
+  });
 }
 function writeStatus(info, options = {}) {
   return writeRuntimeStatus(STATUS_FILE, info, options);
@@ -19562,7 +21061,7 @@ async function main() {
   const settings = configToSettings(config2);
   const store = new JsonFileStore(settings, { dynamicSettings: true });
   const pendingPerms = new PendingPermissions();
-  const llm = await resolveProvider();
+  const llm = await resolveProvider(pendingPerms);
   console.log(`[codex-to-im] Runtime: ${config2.runtime}`);
   const gateway = {
     resolvePendingPermission: (id, resolution) => pendingPerms.resolve(id, resolution)
@@ -19573,8 +21072,8 @@ async function main() {
     permissions: gateway,
     lifecycle: {
       onBridgeStart: () => {
-        fs18.mkdirSync(RUNTIME_DIR, { recursive: true });
-        fs18.writeFileSync(PID_FILE, String(process.pid), "utf-8");
+        fs19.mkdirSync(RUNTIME_DIR, { recursive: true });
+        fs19.writeFileSync(PID_FILE, String(process.pid), "utf-8");
         const channels = getRunningChannels();
         writeStatus({
           running: true,
@@ -19615,6 +21114,11 @@ async function main() {
     } catch (error) {
       console.error("[codex-to-im] Graceful bridge stop failed:", error instanceof Error ? error.stack || error.message : error);
     } finally {
+      try {
+        await llm.dispose?.();
+      } catch (error) {
+        console.error("[codex-to-im] Failed to stop Codex provider:", error instanceof Error ? error.stack || error.message : error);
+      }
       releaseInstanceLock();
       try {
         writeStatus({ running: false, lastExitReason: reason }, { expectedRunId: runId });