codex-to-im 1.0.59 → 1.0.61

package/dist/daemon.mjs

@@ -321,11 +321,50 @@ var init_sse_utils = __esm({
 // src/codex-provider.ts
 var codex_provider_exports = {};
 __export(codex_provider_exports, {
-  CodexProvider: () => CodexProvider
+  CodexProvider: () => CodexProvider,
+  mapCodexUsage: () => mapCodexUsage
 });
-import fs14 from "node:fs";
+import fs17 from "node:fs";
 import os4 from "node:os";
-import path17 from "node:path";
+import path18 from "node:path";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeTokenCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+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;
+  return {
+    input_tokens: normalizeTokenCount(usage.input_tokens),
+    output_tokens: normalizeTokenCount(usage.output_tokens),
+    cache_read_input_tokens: normalizeTokenCount(cacheRead),
+    reasoning_output_tokens: normalizeTokenCount(usage.reasoning_output_tokens),
+    ...cacheCreation === void 0 ? {} : { cache_creation_input_tokens: normalizeTokenCount(cacheCreation) }
+  };
+}
+function isMissingCodexPackageError(error) {
+  if (!isRecord(error)) return false;
+  const code2 = typeof error.code === "string" ? error.code : "";
+  const message = typeof error.message === "string" ? error.message : "";
+  return (code2 === "ERR_MODULE_NOT_FOUND" || code2 === "MODULE_NOT_FOUND") && /@openai[\\/]codex(?:-sdk)?/.test(message);
+}
+function assertCodexClient(value) {
+  if (!isRecord(value) || typeof value.startThread !== "function" || typeof value.resumeThread !== "function") {
+    throw new Error(
+      "[CodexProvider] Incompatible @openai/codex-sdk: Codex client does not expose startThread() and resumeThread()."
+    );
+  }
+}
+function assertCodexThread(value) {
+  if (!isRecord(value) || typeof value.runStreamed !== "function") {
+    throw new Error(
+      "[CodexProvider] Incompatible @openai/codex-sdk: thread does not expose runStreamed()."
+    );
+  }
+}
 function toApprovalPolicy(permissionMode) {
   switch (permissionMode) {
     case "never":
@@ -441,20 +480,37 @@ var init_codex_provider = __esm({
         if (this.sdk && this.codex) {
           return { sdk: this.sdk, codex: this.codex };
         }
+        let sdk;
         try {
-          this.sdk = await Function('return import("@openai/codex-sdk")')();
-        } catch {
+          sdk = await Function('return import("@openai/codex-sdk")')();
+        } catch (error) {
+          if (isMissingCodexPackageError(error)) {
+            throw new Error(
+              "[CodexProvider] @openai/codex-sdk is missing from this codex-to-im installation. Reinstall codex-to-im or run npm install in the project root.",
+              { cause: error }
+            );
+          }
+          const detail = error instanceof Error ? error.message : String(error);
+          throw new Error(
+            `[CodexProvider] Failed to load @openai/codex-sdk: ${detail}`,
+            { cause: error }
+          );
+        }
+        if (!sdk || typeof sdk.Codex !== "function") {
           throw new Error(
-            "[CodexProvider] @openai/codex-sdk is missing from this codex-to-im installation. Reinstall codex-to-im or run npm install in the project root."
+            "[CodexProvider] Incompatible @openai/codex-sdk: Codex export is unavailable."
           );
         }
+        this.sdk = sdk;
         const apiKey = process.env.CTI_CODEX_API_KEY || process.env.CODEX_API_KEY || process.env.OPENAI_API_KEY || void 0;
         const baseUrl = process.env.CTI_CODEX_BASE_URL || void 0;
-        const CodexClass = this.sdk.Codex;
-        this.codex = new CodexClass({
+        const CodexClass = sdk.Codex;
+        const codex = new CodexClass({
           ...apiKey ? { apiKey } : {},
           ...baseUrl ? { baseUrl } : {}
         });
+        assertCodexClient(codex);
+        this.codex = codex;
         return { sdk: this.sdk, codex: this.codex };
       }
       streamChat(params) {
@@ -487,13 +543,13 @@ var init_codex_provider = __esm({
                     { type: "text", text: params.prompt }
                   ];
                   for (const file of imageFiles) {
-                    if (file.filePath && fs14.existsSync(file.filePath)) {
+                    if (file.filePath && fs17.existsSync(file.filePath)) {
                       parts.push({ type: "local_image", path: file.filePath });
                       continue;
                     }
                     const ext = MIME_EXT[file.type] || ".png";
-                    const tmpPath = path17.join(os4.tmpdir(), `cti-img-${Date.now()}-${Math.random().toString(36).slice(2)}${ext}`);
-                    fs14.writeFileSync(tmpPath, Buffer.from(file.data, "base64"));
+                    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"));
                     tempFiles.push(tmpPath);
                     parts.push({ type: "local_image", path: tmpPath });
                   }
@@ -514,6 +570,7 @@ var init_codex_provider = __esm({
                   } else {
                     thread = codex.startThread(threadOptions);
                   }
+                  assertCodexThread(thread);
                   let sawAnyEvent = false;
                   let sawTerminalEvent = false;
                   let sawCompletedAssistantContent = false;
@@ -581,15 +638,9 @@ var init_codex_provider = __esm({
                           break;
                         }
                         case "turn.completed": {
-                          const usage = event.usage;
                           const threadId = self.threadIds.get(params.sessionId);
                           controller.enqueue(sseEvent("result", {
-                            usage: usage ? {
-                              input_tokens: usage.input_tokens ?? 0,
-                              output_tokens: usage.output_tokens ?? 0,
-                              cache_read_input_tokens: usage.cached_input_tokens ?? 0,
-                              reasoning_output_tokens: usage.reasoning_output_tokens ?? 0
-                            } : void 0,
+                            usage: mapCodexUsage(event.usage),
                             ...threadId ? { session_id: threadId } : {}
                           }));
                           sawTerminalEvent = true;
@@ -610,10 +661,9 @@ var init_codex_provider = __esm({
                           break;
                         }
                         default: {
-                          const exhaustiveEvent = event;
                           console.warn(
                             "[codex-provider] Unhandled thread event:",
-                            stringifyUnknown(exhaustiveEvent)
+                            stringifyUnknown(event)
                           );
                           break;
                         }
@@ -665,7 +715,7 @@ var init_codex_provider = __esm({
               } finally {
                 for (const tmp of tempFiles) {
                   try {
-                    fs14.unlinkSync(tmp);
+                    fs17.unlinkSync(tmp);
                   } catch {
                   }
                 }
@@ -782,10 +832,9 @@ var init_codex_provider = __esm({
             break;
           }
           default: {
-            const exhaustiveItem = item;
             console.warn(
               "[codex-provider] Unhandled thread item:",
-              stringifyUnknown(exhaustiveItem)
+              stringifyUnknown(item)
             );
             break;
           }
@@ -796,9 +845,9 @@ var init_codex_provider = __esm({
 });
 
 // src/main.ts
-import fs15 from "node:fs";
-import path18 from "node:path";
-import crypto7 from "node:crypto";
+import fs18 from "node:fs";
+import path19 from "node:path";
+import crypto11 from "node:crypto";
 
 // src/lib/bridge/context.ts
 var CONTEXT_KEY = "__bridge_context__";
@@ -815,23 +864,175 @@ function getBridgeContext() {
   return ctx;
 }
 
+// src/lib/bridge/channel-adapter.ts
+function buildInboundDedupKey(channelType, messageId) {
+  return `inbound:${channelType}:${messageId}`;
+}
+var BaseChannelAdapter = class {
+  inboundQueue = [];
+  inboundWaiters = [];
+  /** Human-readable instance alias, when applicable. */
+  alias;
+  /**
+   * Answer a callback query or interactive-card action when supported.
+   * Not all platforms support this — default implementation is a no-op.
+   */
+  async answerCallback(_callbackQueryId, _text) {
+  }
+  consumeInboundMessage(isRunning) {
+    const queued = this.inboundQueue.shift();
+    if (queued) return Promise.resolve(queued);
+    if (!isRunning) return Promise.resolve(null);
+    return new Promise((resolve2) => {
+      this.inboundWaiters.push(resolve2);
+    });
+  }
+  enqueueInboundMessage(message) {
+    const waiter = this.inboundWaiters.shift();
+    if (waiter) {
+      waiter(message);
+    } else {
+      this.inboundQueue.push(message);
+    }
+  }
+  clearInboundQueue() {
+    this.inboundQueue = [];
+  }
+  rejectPendingInboundConsumers() {
+    for (const waiter of this.inboundWaiters) {
+      waiter(null);
+    }
+    this.inboundWaiters = [];
+  }
+};
+var adapterFactories = /* @__PURE__ */ new Map();
+function registerAdapterFactory(provider, factory) {
+  adapterFactories.set(provider, factory);
+}
+function createAdapter(instance) {
+  const factory = adapterFactories.get(instance.provider);
+  return factory ? factory(instance) : null;
+}
+
 // src/lib/bridge/bridge-manager.ts
 import { inspect } from "node:util";
 
 // src/lib/bridge/adapters/feishu-adapter.ts
-import crypto from "crypto";
-import fs2 from "node:fs";
+import crypto3 from "crypto";
+import fs3 from "node:fs";
 import path2 from "node:path";
 import * as lark from "@larksuiteoapi/node-sdk";
 
 // src/config.ts
 init_runtime_options();
-import fs from "node:fs";
+import fs2 from "node:fs";
+import crypto2 from "node:crypto";
 import os from "node:os";
 import path from "node:path";
+
+// src/file-lock.ts
+import crypto from "node:crypto";
+import fs from "node:fs";
+var DEFAULT_LOCK_TIMEOUT_MS = 5e3;
+var DEFAULT_STALE_LOCK_MS = 3e4;
+var LOCK_RETRY_INTERVAL_MS = 25;
+var WAIT_ARRAY = new Int32Array(new SharedArrayBuffer(4));
+var ACTIVE_LOCKS = /* @__PURE__ */ new Map();
+function sleepSync(ms) {
+  Atomics.wait(WAIT_ARRAY, 0, 0, Math.max(1, ms));
+}
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function removeStaleLock(lockPath, staleAfterMs) {
+  try {
+    const stat = fs.statSync(lockPath);
+    if (Date.now() - stat.mtimeMs < staleAfterMs) return false;
+    let ownerPid = 0;
+    try {
+      const parsed = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+      ownerPid = typeof parsed.pid === "number" ? parsed.pid : 0;
+    } catch {
+    }
+    if (ownerPid && isProcessAlive(ownerPid)) return false;
+    fs.rmSync(lockPath, { force: true });
+    return true;
+  } catch (error) {
+    return error.code === "ENOENT";
+  }
+}
+function withFileLock(targetPath, operation, options) {
+  const lockPath = `${targetPath}.lock`;
+  const activeDepth = ACTIVE_LOCKS.get(lockPath) || 0;
+  if (activeDepth > 0) {
+    ACTIVE_LOCKS.set(lockPath, activeDepth + 1);
+    try {
+      return operation();
+    } finally {
+      const nextDepth = (ACTIVE_LOCKS.get(lockPath) || 1) - 1;
+      if (nextDepth > 0) ACTIVE_LOCKS.set(lockPath, nextDepth);
+      else ACTIVE_LOCKS.delete(lockPath);
+    }
+  }
+  const timeoutMs = Math.max(0, options?.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS);
+  const staleAfterMs = Math.max(timeoutMs, options?.staleAfterMs ?? DEFAULT_STALE_LOCK_MS);
+  const deadline = Date.now() + timeoutMs;
+  const record = {
+    token: crypto.randomUUID(),
+    pid: process.pid,
+    createdAt: Date.now()
+  };
+  let handle = null;
+  while (handle === null) {
+    try {
+      handle = fs.openSync(lockPath, "wx", 384);
+      fs.writeFileSync(handle, JSON.stringify(record), "utf8");
+    } catch (error) {
+      const code2 = error.code;
+      if (code2 !== "EEXIST") throw error;
+      if (removeStaleLock(lockPath, staleAfterMs)) continue;
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out waiting for file lock: ${lockPath}`);
+      }
+      sleepSync(Math.min(LOCK_RETRY_INTERVAL_MS, Math.max(1, deadline - Date.now())));
+    }
+  }
+  try {
+    ACTIVE_LOCKS.set(lockPath, 1);
+    return operation();
+  } finally {
+    ACTIVE_LOCKS.delete(lockPath);
+    try {
+      fs.closeSync(handle);
+    } catch {
+    }
+    try {
+      const current = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+      if (current.token === record.token) fs.rmSync(lockPath, { force: true });
+    } catch {
+    }
+  }
+}
+function withFileLocks(targetPaths, operation) {
+  const paths = Array.from(new Set(targetPaths)).sort();
+  const acquire = (index) => {
+    if (index >= paths.length) return operation();
+    return withFileLock(paths[index], () => acquire(index + 1));
+  };
+  return acquire(0);
+}
+
+// src/config.ts
 function isSupportedChannelProvider(value) {
   return value === "feishu" || value === "weixin";
 }
+var RAW_CHANNELS = Symbol("rawConfigV2Channels");
 function toFeishuConfig(channel) {
   return channel?.provider === "feishu" ? channel.config : void 0;
 }
@@ -871,7 +1072,7 @@ function parseEnvFile(content) {
 }
 function loadRawConfigEnv() {
   try {
-    return parseEnvFile(fs.readFileSync(CONFIG_PATH, "utf-8"));
+    return parseEnvFile(fs2.readFileSync(CONFIG_PATH, "utf-8"));
   } catch {
     return /* @__PURE__ */ new Map();
   }
@@ -901,26 +1102,66 @@ function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 function ensureConfigDir() {
-  fs.mkdirSync(CTI_HOME, { recursive: true });
+  fs2.mkdirSync(CTI_HOME, { recursive: true });
 }
 function readConfigV2File() {
+  if (!fs2.existsSync(CONFIG_V2_PATH)) return null;
+  let content;
+  try {
+    content = fs2.readFileSync(CONFIG_V2_PATH, "utf-8");
+  } catch (error) {
+    throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u914D\u7F6E\u6587\u4EF6 ${CONFIG_V2_PATH}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(content);
+  } catch (error) {
+    throw new Error(`\u914D\u7F6E\u6587\u4EF6 ${CONFIG_V2_PATH} \u4E0D\u662F\u6709\u6548 JSON\uFF0C\u5DF2\u62D2\u7EDD\u8986\u76D6: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(`\u914D\u7F6E\u6587\u4EF6 ${CONFIG_V2_PATH} \u7684\u6839\u8282\u70B9\u5FC5\u987B\u662F\u5BF9\u8C61\uFF0C\u5DF2\u62D2\u7EDD\u8986\u76D6\u3002`);
+  }
+  if (raw.schemaVersion !== 2) {
+    throw new Error(`\u4E0D\u652F\u6301\u914D\u7F6E schemaVersion=${String(raw.schemaVersion)}\uFF0C\u5DF2\u62D2\u7EDD\u7528\u5F53\u524D\u7248\u672C\u8986\u76D6\u3002`);
+  }
+  if (!raw.runtime || typeof raw.runtime !== "object" || Array.isArray(raw.runtime)) {
+    throw new Error(`\u914D\u7F6E\u6587\u4EF6 ${CONFIG_V2_PATH} \u7F3A\u5C11\u6709\u6548\u7684 runtime \u5BF9\u8C61\uFF0C\u5DF2\u62D2\u7EDD\u8986\u76D6\u3002`);
+  }
+  if (!Array.isArray(raw.channels)) {
+    throw new Error(`\u914D\u7F6E\u6587\u4EF6 ${CONFIG_V2_PATH} \u7F3A\u5C11 channels \u6570\u7EC4\uFF0C\u5DF2\u62D2\u7EDD\u8986\u76D6\u3002`);
+  }
+  const rawChannels = raw.channels;
+  const parsed = {
+    ...raw,
+    schemaVersion: 2,
+    runtime: {
+      ...raw.runtime,
+      provider: normalizeRuntimeProvider(raw.runtime.provider)
+    },
+    channels: normalizeChannelInstances(rawChannels)
+  };
+  Object.defineProperty(parsed, RAW_CHANNELS, { value: rawChannels, enumerable: false });
+  return parsed;
+}
+function atomicWriteFile(filePath, content) {
+  ensureConfigDir();
+  const tmpPath = `${filePath}.${process.pid}.${crypto2.randomUUID()}.tmp`;
   try {
-    const parsed = JSON.parse(fs.readFileSync(CONFIG_V2_PATH, "utf-8"));
-    if (parsed && parsed.schemaVersion === 2 && parsed.runtime && Array.isArray(parsed.channels)) {
-      parsed.runtime.provider = normalizeRuntimeProvider(parsed.runtime.provider);
-      parsed.channels = normalizeChannelInstances(parsed.channels);
-      return parsed;
+    fs2.writeFileSync(tmpPath, content, { mode: 384 });
+    fs2.renameSync(tmpPath, filePath);
+  } finally {
+    try {
+      fs2.rmSync(tmpPath, { force: true });
+    } catch {
     }
-    return null;
-  } catch {
-    return null;
   }
 }
 function writeConfigV2File(config2) {
-  ensureConfigDir();
-  const tmpPath = CONFIG_V2_PATH + ".tmp";
-  fs.writeFileSync(tmpPath, JSON.stringify(config2, null, 2), { mode: 384 });
-  fs.renameSync(tmpPath, CONFIG_V2_PATH);
+  const serialized = {
+    ...config2,
+    channels: config2[RAW_CHANNELS] || config2.channels
+  };
+  atomicWriteFile(CONFIG_V2_PATH, JSON.stringify(serialized, null, 2));
 }
 function defaultAliasForProvider(provider) {
   return provider === "feishu" ? "\u98DE\u4E66" : "\u5FAE\u4FE1";
@@ -941,6 +1182,7 @@ function normalizeChannelInstances(value) {
     const config2 = record.config && typeof record.config === "object" ? record.config : {};
     const timestamp = nowIso();
     return [{
+      ...record,
       id: normalizeChannelId(
         typeof record.id === "string" && record.id.trim() ? record.id : buildDefaultChannelId(provider)
       ),
@@ -1044,29 +1286,33 @@ function expandConfig(v2) {
 function loadConfig() {
   const current = readConfigV2File();
   if (current) return expandConfig(current);
-  const legacyEnv = loadRawConfigEnv();
-  if (legacyEnv.size > 0) {
-    const migrated = migrateLegacyEnvToV2(legacyEnv);
-    writeConfigV2File(migrated);
-    return expandConfig(migrated);
-  }
-  const empty = {
-    schemaVersion: 2,
-    runtime: {
-      provider: "codex",
-      defaultWorkspaceRoot: DEFAULT_WORKSPACE_ROOT,
-      defaultMode: "code",
-      historyMessageLimit: 8,
-      streamStatusIdleStartSeconds: DEFAULT_STREAM_STATUS_IDLE_START_SECONDS,
-      streamStatusCheckIntervalSeconds: DEFAULT_STREAM_STATUS_CHECK_INTERVAL_SECONDS,
-      codexSkipGitRepoCheck: true,
-      codexSandboxMode: "workspace-write",
-      codexReasoningEffort: "medium",
-      uiAllowLan: false
-    },
-    channels: []
-  };
-  return expandConfig(empty);
+  return withFileLock(CONFIG_V2_PATH, () => {
+    const concurrentlyCreated = readConfigV2File();
+    if (concurrentlyCreated) return expandConfig(concurrentlyCreated);
+    const legacyEnv = loadRawConfigEnv();
+    if (legacyEnv.size > 0) {
+      const migrated = migrateLegacyEnvToV2(legacyEnv);
+      writeConfigV2File(migrated);
+      return expandConfig(migrated);
+    }
+    const empty = {
+      schemaVersion: 2,
+      runtime: {
+        provider: "codex",
+        defaultWorkspaceRoot: DEFAULT_WORKSPACE_ROOT,
+        defaultMode: "code",
+        historyMessageLimit: 8,
+        streamStatusIdleStartSeconds: DEFAULT_STREAM_STATUS_IDLE_START_SECONDS,
+        streamStatusCheckIntervalSeconds: DEFAULT_STREAM_STATUS_CHECK_INTERVAL_SECONDS,
+        codexSkipGitRepoCheck: true,
+        codexSandboxMode: "workspace-write",
+        codexReasoningEffort: "medium",
+        uiAllowLan: false
+      },
+      channels: []
+    };
+    return expandConfig(empty);
+  });
 }
 function listChannelInstances(config2) {
   return [...config2?.channels || loadConfig().channels || []];
@@ -1162,53 +1408,6 @@ function configToSettings(config2) {
   return m;
 }
 
-// src/lib/bridge/channel-adapter.ts
-var BaseChannelAdapter = class {
-  inboundQueue = [];
-  inboundWaiters = [];
-  /** Human-readable instance alias, when applicable. */
-  alias;
-  /**
-   * Answer a callback query or interactive-card action when supported.
-   * Not all platforms support this — default implementation is a no-op.
-   */
-  async answerCallback(_callbackQueryId, _text) {
-  }
-  consumeInboundMessage(isRunning) {
-    const queued = this.inboundQueue.shift();
-    if (queued) return Promise.resolve(queued);
-    if (!isRunning) return Promise.resolve(null);
-    return new Promise((resolve2) => {
-      this.inboundWaiters.push(resolve2);
-    });
-  }
-  enqueueInboundMessage(message) {
-    const waiter = this.inboundWaiters.shift();
-    if (waiter) {
-      waiter(message);
-    } else {
-      this.inboundQueue.push(message);
-    }
-  }
-  clearInboundQueue() {
-    this.inboundQueue = [];
-  }
-  rejectPendingInboundConsumers() {
-    for (const waiter of this.inboundWaiters) {
-      waiter(null);
-    }
-    this.inboundWaiters = [];
-  }
-};
-var adapterFactories = /* @__PURE__ */ new Map();
-function registerAdapterFactory(provider, factory) {
-  adapterFactories.set(provider, factory);
-}
-function createAdapter(instance) {
-  const factory = adapterFactories.get(instance.provider);
-  return factory ? factory(instance) : null;
-}
-
 // src/lib/bridge/markdown/feishu.ts
 function hasComplexMarkdown(text2) {
   if (/```[\s\S]*?```/.test(text2)) return true;
@@ -1431,18 +1630,37 @@ function buildPermissionButtonCard(text2, permissionRequestId, chatId) {
 // src/lib/bridge/adapters/feishu-adapter.ts
 var DEDUP_MAX = 1e3;
 var MAX_FILE_SIZE = 20 * 1024 * 1024;
+var ATTACHMENT_REQUEST_TIMEOUT_MS = 6e4;
 var COMPLETED_EMOJI = "DONE";
 var ERROR_EMOJI = "ERROR";
 var CARD_TERMINAL_REACTION_DELAY_MS = 2e3;
 var CARD_THROTTLE_MS = 1e3;
 var CARD_REQUEST_TIMEOUT_MS = 15e3;
 var CARD_FINALIZE_FLUSH_WAIT_EXTRA_MS = 1e3;
+var CARD_FINALIZE_RETRY_DELAYS_MS = [1e3, 5e3, 15e3, 3e4];
+var CARD_STOP_FINALIZE_TIMEOUT_MS = 2e3;
 var CARD_FULL_REFRESH_INTERVAL_MS = 5 * 6e4;
 var FINAL_CARD_FULL_TEXT_MAX_CHARS = 12e3;
 var FINAL_CARD_PREVIEW_CHARS = 4e3;
 var INITIAL_STREAMING_STATUS = "\u5904\u7406\u4E2D";
 var EMPTY_STREAMING_TASKS = "";
 var EMPTY_STREAMING_TOOLS = "";
+function validateFeishuAttachmentPath(filePath, maxSize = MAX_FILE_SIZE) {
+  let stat;
+  try {
+    stat = fs3.statSync(filePath);
+  } catch {
+    return `Attachment not found: ${filePath}`;
+  }
+  if (!stat.isFile()) return `Attachment is not a regular file: ${filePath}`;
+  if (stat.size > maxSize) {
+    return `Attachment is too large: ${stat.size} bytes (max ${maxSize} bytes)`;
+  }
+  return null;
+}
+function normalizeAttachmentFileName(value) {
+  return value.replace(/[\r\n"]/g, "_") || "attachment.bin";
+}
 function shouldDeliverFinalTextSeparately(text2) {
   return text2.trim().length > FINAL_CARD_FULL_TEXT_MAX_CHARS;
 }
@@ -1523,12 +1741,18 @@ var FeishuAdapter = class extends BaseChannelAdapter {
   activeCards = /* @__PURE__ */ new Map();
   /** In-flight card creation promises per stream key — prevents duplicate creation. */
   cardCreatePromises = /* @__PURE__ */ new Map();
+  /** Terminal card updates retained until CardKit confirms finalization. */
+  pendingCardFinalizations = /* @__PURE__ */ new Map();
+  cardFinalizePromises = /* @__PURE__ */ new Map();
   /** Cached tenant token for upload APIs. */
   tenantTokenCache = null;
   cardRequestTimeoutMs = CARD_REQUEST_TIMEOUT_MS;
   cardFinalizeFlushWaitExtraMs = CARD_FINALIZE_FLUSH_WAIT_EXTRA_MS;
   cardFullRefreshIntervalMs = CARD_FULL_REFRESH_INTERVAL_MS;
   cardTerminalReactionDelayMs = CARD_TERMINAL_REACTION_DELAY_MS;
+  cardFinalizeRetryDelaysMs = CARD_FINALIZE_RETRY_DELAYS_MS;
+  cardStopFinalizeTimeoutMs = CARD_STOP_FINALIZE_TIMEOUT_MS;
+  stopping = false;
   constructor(instance) {
     super();
     this.channelType = instance?.id || "feishu";
@@ -1556,6 +1780,7 @@ var FeishuAdapter = class extends BaseChannelAdapter {
   // ── Lifecycle ───────────────────────────────────────────────
   async start() {
     if (this.running) return;
+    this.stopping = false;
     const configError = this.validateConfig();
     if (configError) {
       console.warn("[feishu-adapter] Cannot start:", configError);
@@ -1609,6 +1834,29 @@ var FeishuAdapter = class extends BaseChannelAdapter {
   async stop() {
     if (!this.running) return;
     this.running = false;
+    this.stopping = true;
+    const finalizations = Array.from(this.activeCards.entries()).map(([cardKey, state]) => {
+      const pending = this.pendingCardFinalizations.get(cardKey);
+      return this.finalizeCard(
+        state.chatId,
+        pending?.status || "interrupted",
+        pending?.responseText || "Bridge \u670D\u52A1\u6B63\u5728\u505C\u6B62\uFF0C\u5F53\u524D\u4EFB\u52A1\u5DF2\u4E2D\u65AD\u3002",
+        cardKey
+      );
+    });
+    if (finalizations.length > 0) {
+      let stopTimeout = null;
+      try {
+        await Promise.race([
+          Promise.allSettled(finalizations),
+          new Promise((resolve2) => {
+            stopTimeout = setTimeout(resolve2, Math.max(0, this.cardStopFinalizeTimeoutMs));
+          })
+        ]);
+      } finally {
+        if (stopTimeout) clearTimeout(stopTimeout);
+      }
+    }
     if (this.wsClient) {
       try {
         this.wsClient.close({ force: true });
@@ -1622,8 +1870,13 @@ var FeishuAdapter = class extends BaseChannelAdapter {
     for (const [, state] of this.activeCards) {
       if (state.throttleTimer) clearTimeout(state.throttleTimer);
     }
+    for (const request of this.pendingCardFinalizations.values()) {
+      if (request.retryTimer) clearTimeout(request.retryTimer);
+    }
     this.activeCards.clear();
     this.cardCreatePromises.clear();
+    this.pendingCardFinalizations.clear();
+    this.cardFinalizePromises.clear();
     this.seenMessageIds.clear();
     this.lastIncomingMessageId.clear();
     console.log("[feishu-adapter] Stopped");
@@ -1652,6 +1905,8 @@ var FeishuAdapter = class extends BaseChannelAdapter {
    * Called by bridge-manager via onMessageEnd().
    */
   onMessageEnd(chatId, streamKey) {
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
+    if (this.pendingCardFinalizations.has(cardKey)) return;
     this.cleanupCard(chatId, streamKey);
   }
   // ── Card Action Handler ─────────────────────────────────────
@@ -1955,13 +2210,18 @@ var FeishuAdapter = class extends BaseChannelAdapter {
         const remainingMs = deadline - Date.now();
         if (remainingMs <= 0) return false;
         const timedOut = Symbol("flush-timeout");
+        let flushTimeout = null;
         try {
           const result = await Promise.race([
             inFlight.then(() => null),
-            new Promise((resolve2) => setTimeout(() => resolve2(timedOut), remainingMs))
+            new Promise((resolve2) => {
+              flushTimeout = setTimeout(() => resolve2(timedOut), remainingMs);
+            })
           ]);
           if (result === timedOut) return false;
         } catch {
+        } finally {
+          if (flushTimeout) clearTimeout(flushTimeout);
         }
         continue;
       }
@@ -1986,10 +2246,60 @@ var FeishuAdapter = class extends BaseChannelAdapter {
       } catch {
       }
     }
+    const existingRequest = this.pendingCardFinalizations.get(cardKey);
+    if (existingRequest?.retryTimer) {
+      clearTimeout(existingRequest.retryTimer);
+    }
+    const request = existingRequest || {
+      chatId,
+      status,
+      responseText,
+      streamKey,
+      retryIndex: 0,
+      retryTimer: null
+    };
+    request.chatId = chatId;
+    request.status = status;
+    request.responseText = responseText;
+    request.streamKey = streamKey;
+    request.retryTimer = null;
+    this.pendingCardFinalizations.set(cardKey, request);
+    const result = await this.runCardFinalizationAttempt(cardKey);
+    if (!result.finalized) {
+      if (result.retryable) {
+        this.scheduleCardFinalizationRetry(cardKey);
+      } else {
+        this.clearPendingCardFinalization(cardKey);
+      }
+    }
+    return result.finalized && result.textCovered;
+  }
+  async runCardFinalizationAttempt(cardKey) {
+    const existing = this.cardFinalizePromises.get(cardKey);
+    if (existing) return existing;
+    const attempt = this.performCardFinalizationAttempt(cardKey);
+    this.cardFinalizePromises.set(cardKey, attempt);
+    try {
+      return await attempt;
+    } finally {
+      if (this.cardFinalizePromises.get(cardKey) === attempt) {
+        this.cardFinalizePromises.delete(cardKey);
+      }
+    }
+  }
+  async performCardFinalizationAttempt(cardKey) {
+    const request = this.pendingCardFinalizations.get(cardKey);
     const state = this.activeCards.get(cardKey);
-    if (!state || !this.restClient) return false;
+    if (!request || !state) {
+      return { finalized: false, textCovered: false, retryable: false };
+    }
+    if (!this.restClient) {
+      return { finalized: false, textCovered: false, retryable: !this.stopping };
+    }
     const cardkit = this.restClient.cardkit?.v1;
-    if (!cardkit?.card?.settings || !cardkit?.card?.update) return false;
+    if (!cardkit?.card?.settings || !cardkit?.card?.update) {
+      return { finalized: false, textCovered: false, retryable: false };
+    }
     if (state.throttleTimer) {
       clearTimeout(state.throttleTimer);
       state.throttleTimer = null;
@@ -2016,21 +2326,21 @@ var FeishuAdapter = class extends BaseChannelAdapter {
       };
       const elapsedMs = Date.now() - state.startTime;
       const footer = {
-        status: statusLabels[status] || status,
+        status: statusLabels[request.status] || request.status,
         elapsed: formatElapsed(elapsedMs)
       };
       const existingText = state.pendingText || "";
       const trimmedExisting = existingText.trim();
-      const trimmedResponse = responseText.trim();
+      const trimmedResponse = request.responseText.trim();
       let finalText = trimmedResponse || trimmedExisting;
-      if (status === "interrupted" && trimmedExisting && trimmedResponse && trimmedResponse !== trimmedExisting && !trimmedExisting.includes(trimmedResponse)) {
+      if (request.status === "interrupted" && trimmedExisting && trimmedResponse && trimmedResponse !== trimmedExisting && !trimmedExisting.includes(trimmedResponse)) {
         finalText = `${trimmedExisting}
 
 ${trimmedResponse}`;
       }
       const deliverTextSeparately = shouldDeliverFinalTextSeparately(finalText);
       const cardText = deliverTextSeparately ? buildFinalCardTextPreview(finalText) : finalText;
-      const finalCardJson = buildFinalCardJson(cardText, state.taskItems, state.toolCalls, footer, status);
+      const finalCardJson = buildFinalCardJson(cardText, state.taskItems, state.toolCalls, footer, request.status);
       state.sequence++;
       await this.withFeishuRequestTimeout(cardKey, "card.update", () => cardkit.card.update({
         path: { card_id: state.cardId },
@@ -2040,20 +2350,52 @@ ${trimmedResponse}`;
         }
       }));
       this.activeCards.delete(cardKey);
-      console.log(`[feishu-adapter] Card finalized: streamKey=${cardKey}, cardId=${state.cardId}, status=${status}, elapsed=${formatElapsed(elapsedMs)}`);
-      const terminalReactionEmoji = status === "completed" ? COMPLETED_EMOJI : status === "error" ? ERROR_EMOJI : null;
+      this.clearPendingCardFinalization(cardKey);
+      console.log(`[feishu-adapter] Card finalized: streamKey=${cardKey}, cardId=${state.cardId}, status=${request.status}, elapsed=${formatElapsed(elapsedMs)}`);
+      const terminalReactionEmoji = request.status === "completed" ? COMPLETED_EMOJI : request.status === "error" ? ERROR_EMOJI : null;
       if (terminalReactionEmoji && this.hasTerminalReactionApi()) {
         await this.waitBeforeTerminalReaction();
         await this.addTerminalReaction(cardKey, state.messageId, terminalReactionEmoji);
       }
-      return !deliverTextSeparately;
+      return { finalized: true, textCovered: !deliverTextSeparately, retryable: false };
     } catch (err) {
       console.warn("[feishu-adapter] Card finalize failed:", err instanceof Error ? err.message : err);
-      return false;
-    } finally {
-      this.activeCards.delete(cardKey);
+      return { finalized: false, textCovered: false, retryable: true };
     }
   }
+  scheduleCardFinalizationRetry(cardKey) {
+    const request = this.pendingCardFinalizations.get(cardKey);
+    if (!request || request.retryTimer || this.stopping || !this.restClient) return;
+    if (request.retryIndex >= this.cardFinalizeRetryDelaysMs.length) {
+      console.warn(`[feishu-adapter] Card finalize retries exhausted: streamKey=${cardKey}`);
+      this.cleanupCard(request.chatId, request.streamKey || cardKey);
+      return;
+    }
+    const delayMs = Math.max(0, this.cardFinalizeRetryDelaysMs[request.retryIndex] || 0);
+    request.retryIndex += 1;
+    request.retryTimer = setTimeout(() => {
+      const current = this.pendingCardFinalizations.get(cardKey);
+      if (!current) return;
+      current.retryTimer = null;
+      void this.runCardFinalizationAttempt(cardKey).then((result) => {
+        if (result.finalized) return;
+        if (result.retryable) {
+          this.scheduleCardFinalizationRetry(cardKey);
+        } else {
+          this.cleanupCard(current.chatId, current.streamKey || cardKey);
+        }
+      }).catch((error) => {
+        console.warn("[feishu-adapter] Card finalize retry failed:", error instanceof Error ? error.message : error);
+        this.scheduleCardFinalizationRetry(cardKey);
+      });
+    }, delayMs);
+    request.retryTimer.unref?.();
+  }
+  clearPendingCardFinalization(cardKey) {
+    const request = this.pendingCardFinalizations.get(cardKey);
+    if (request?.retryTimer) clearTimeout(request.retryTimer);
+    this.pendingCardFinalizations.delete(cardKey);
+  }
   hasTerminalReactionApi() {
     const messageReaction = this.restClient?.im?.messageReaction;
     return typeof messageReaction?.create === "function";
@@ -2084,6 +2426,7 @@ ${trimmedResponse}`;
   cleanupCard(chatId, streamKey) {
     const cardKey = this.resolveStreamKey(chatId, streamKey);
     this.cardCreatePromises.delete(cardKey);
+    this.clearPendingCardFinalization(cardKey);
     const state = this.activeCards.get(cardKey);
     if (!state) return;
     if (state.throttleTimer) {
@@ -2322,7 +2665,8 @@ ${trimmedResponse}`;
       body: JSON.stringify({
         app_id: appId,
         app_secret: appSecret
-      })
+      }),
+      signal: AbortSignal.timeout(CARD_REQUEST_TIMEOUT_MS)
     });
     const data = await response.json();
     if (!response.ok || data.code !== 0 || !data.tenant_access_token) {
@@ -2347,9 +2691,8 @@ ${trimmedResponse}`;
     return { ok: true, messageId: lastMessageId };
   }
   async sendAttachment(chatId, attachment, replyToMessageId) {
-    if (!fs2.existsSync(attachment.path)) {
-      return { ok: false, error: `Attachment not found: ${attachment.path}` };
-    }
+    const validationError = validateFeishuAttachmentPath(attachment.path);
+    if (validationError) return { ok: false, error: validationError };
     try {
       if (attachment.kind === "image") {
         const imageKey = await this.uploadImage(attachment);
@@ -2373,14 +2716,17 @@ ${trimmedResponse}`;
   }
   async uploadImage(attachment) {
     const token = await this.getTenantAccessToken();
-    const fileName = attachment.name || path2.basename(attachment.path) || "image.png";
+    const fileName = normalizeAttachmentFileName(
+      attachment.name || path2.basename(attachment.path) || "image.png"
+    );
     const form = new FormData();
     form.set("image_type", "message");
-    form.set("image", new Blob([fs2.readFileSync(attachment.path)]), fileName);
+    form.set("image", new Blob([await fs3.promises.readFile(attachment.path)]), fileName);
     const response = await fetch(`${this.getOpenApiBaseUrl()}/open-apis/im/v1/images`, {
       method: "POST",
       headers: { Authorization: `Bearer ${token}` },
-      body: form
+      body: form,
+      signal: AbortSignal.timeout(ATTACHMENT_REQUEST_TIMEOUT_MS)
     });
     const data = await response.json();
     if (!response.ok || data.code !== 0 || !data.data?.image_key) {
@@ -2390,15 +2736,18 @@ ${trimmedResponse}`;
   }
   async uploadFile(attachment) {
     const token = await this.getTenantAccessToken();
-    const fileName = attachment.name || path2.basename(attachment.path) || "attachment.bin";
+    const fileName = normalizeAttachmentFileName(
+      attachment.name || path2.basename(attachment.path) || "attachment.bin"
+    );
     const form = new FormData();
     form.set("file_type", "stream");
     form.set("file_name", fileName);
-    form.set("file", new Blob([fs2.readFileSync(attachment.path)]), fileName);
+    form.set("file", new Blob([await fs3.promises.readFile(attachment.path)]), fileName);
     const response = await fetch(`${this.getOpenApiBaseUrl()}/open-apis/im/v1/files`, {
       method: "POST",
       headers: { Authorization: `Bearer ${token}` },
-      body: form
+      body: form,
+      signal: AbortSignal.timeout(ATTACHMENT_REQUEST_TIMEOUT_MS)
     });
     const data = await response.json();
     if (!response.ok || data.code !== 0 || !data.data?.file_key) {
@@ -2937,20 +3286,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 fs16 = await import("fs");
+        const fs19 = await import("fs");
         const os5 = await import("os");
-        const path19 = await import("path");
-        const tmpPath = path19.join(os5.tmpdir(), `feishu-dl-${crypto.randomUUID()}`);
+        const path20 = await import("path");
+        const tmpPath = path20.join(os5.tmpdir(), `feishu-dl-${crypto3.randomUUID()}`);
         try {
           await res.writeFile(tmpPath);
-          buffer = fs16.readFileSync(tmpPath);
+          buffer = fs19.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 {
-            fs16.unlinkSync(tmpPath);
+            fs19.unlinkSync(tmpPath);
           } catch {
           }
         }
@@ -2960,7 +3309,7 @@ ${trimmedResponse}`;
         return null;
       }
       const base64 = buffer.toString("base64");
-      const id = crypto.randomUUID();
+      const id = crypto3.randomUUID();
       const mimeType = MIME_BY_TYPE[resourceType] || "application/octet-stream";
       const ext = resourceType === "image" ? "png" : resourceType === "audio" ? "ogg" : resourceType === "video" ? "mp4" : "bin";
       console.log(`[feishu-adapter] Resource downloaded: ${buffer.length} bytes, key=${fileKey}`);
@@ -2996,25 +3345,34 @@ ${trimmedResponse}`;
 registerAdapterFactory("feishu", (instance) => new FeishuAdapter(instance));
 
 // src/weixin-store.ts
-import fs3 from "node:fs";
+import fs4 from "node:fs";
+import crypto4 from "node:crypto";
 import path3 from "node:path";
 var DATA_DIR = path3.join(CTI_HOME, "data");
 var ACCOUNTS_PATH = path3.join(DATA_DIR, "weixin-accounts.json");
 var CONTEXT_TOKENS_PATH = path3.join(DATA_DIR, "weixin-context-tokens.json");
 function ensureDir(dir) {
-  fs3.mkdirSync(dir, { recursive: true });
+  fs4.mkdirSync(dir, { recursive: true });
 }
 function atomicWrite(filePath, data) {
-  const tmpPath = `${filePath}.tmp`;
-  fs3.writeFileSync(tmpPath, data, "utf-8");
-  fs3.renameSync(tmpPath, filePath);
+  const tmpPath = `${filePath}.${process.pid}.${crypto4.randomUUID()}.tmp`;
+  try {
+    fs4.writeFileSync(tmpPath, data, "utf-8");
+    fs4.renameSync(tmpPath, filePath);
+  } finally {
+    try {
+      fs4.rmSync(tmpPath, { force: true });
+    } catch {
+    }
+  }
 }
 function readJson(filePath, fallback) {
   try {
-    const raw = fs3.readFileSync(filePath, "utf-8");
+    const raw = fs4.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
-  } catch {
-    return fallback;
+  } catch (error) {
+    if (error.code === "ENOENT") return fallback;
+    throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u5FAE\u4FE1\u6570\u636E\u6587\u4EF6 ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
 function getAccountRecency(account) {
@@ -3069,13 +3427,15 @@ function getWeixinContextToken(accountId, peerUserId) {
   return tokens[contextKey(accountId, peerUserId)];
 }
 function upsertWeixinContextToken(accountId, peerUserId, contextToken) {
-  const tokens = readContextTokens();
-  tokens[contextKey(accountId, peerUserId)] = contextToken;
-  writeContextTokens(tokens);
+  withFileLock(CONTEXT_TOKENS_PATH, () => {
+    const tokens = readContextTokens();
+    tokens[contextKey(accountId, peerUserId)] = contextToken;
+    writeContextTokens(tokens);
+  });
 }
 
 // src/adapters/weixin/weixin-api.ts
-import crypto2 from "node:crypto";
+import crypto5 from "node:crypto";
 
 // src/adapters/weixin/weixin-types.ts
 var MessageItemType = {
@@ -3099,7 +3459,7 @@ var LONG_POLL_TIMEOUT_MS = 35e3;
 var API_TIMEOUT_MS = 15e3;
 var CONFIG_TIMEOUT_MS = 1e4;
 function generateWechatUin() {
-  return crypto2.randomBytes(4).toString("base64");
+  return crypto5.randomBytes(4).toString("base64");
 }
 function normalizeBaseUrl(baseUrl) {
   return (baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
@@ -3158,7 +3518,7 @@ async function getUpdates(creds, getUpdatesBuf, timeoutMs = LONG_POLL_TIMEOUT_MS
   }
 }
 function generateClientId() {
-  return `cti-weixin-${Date.now()}-${crypto2.randomBytes(4).toString("hex")}`;
+  return `cti-weixin-${Date.now()}-${crypto5.randomBytes(4).toString("hex")}`;
 }
 async function sendMessage(creds, toUserId, items, contextToken) {
   const clientId = generateClientId();
@@ -3235,10 +3595,35 @@ function decodeWeixinChatId(chatId) {
 }
 
 // src/adapters/weixin/weixin-media.ts
-import crypto3 from "node:crypto";
+import crypto6 from "node:crypto";
 var MAX_MEDIA_SIZE = 100 * 1024 * 1024;
+async function readResponseBodyWithLimit(response, maxSize, label) {
+  const contentLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(contentLength) && contentLength > maxSize) {
+    throw new Error(`Media too large: ${contentLength} bytes`);
+  }
+  if (!response.body) return Buffer.alloc(0);
+  const reader = response.body.getReader();
+  const chunks = [];
+  let totalSize = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      totalSize += value.byteLength;
+      if (totalSize > maxSize) {
+        await reader.cancel(`Media too large while downloading ${label}`);
+        throw new Error(`Media too large: more than ${maxSize} bytes`);
+      }
+      chunks.push(Buffer.from(value));
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks, totalSize);
+}
 function decryptMedia(data, key) {
-  const decipher = crypto3.createDecipheriv("aes-128-ecb", key, null);
+  const decipher = crypto6.createDecipheriv("aes-128-ecb", key, null);
   return Buffer.concat([decipher.update(data), decipher.final()]);
 }
 function parseBase64EncodedAesKey(aesKeyBase64) {
@@ -3293,13 +3678,10 @@ async function downloadAndDecryptMedia(cdnUrl, aesKey, label) {
   if (!res.ok) {
     throw new Error(`CDN download failed for ${label}: ${res.status}`);
   }
-  const encrypted = Buffer.from(await res.arrayBuffer());
+  const encrypted = await readResponseBodyWithLimit(res, MAX_MEDIA_SIZE, label);
   if (encrypted.length === 0) {
     throw new Error(`Downloaded ${label} is empty`);
   }
-  if (encrypted.length > MAX_MEDIA_SIZE) {
-    throw new Error(`Media too large: ${encrypted.length} bytes`);
-  }
   return decryptMedia(encrypted, aesKey);
 }
 async function downloadMediaFromItem(item, cdnBaseUrl) {
@@ -3348,7 +3730,7 @@ async function downloadMediaFromItem(item, cdnBaseUrl) {
   }
   const data = await downloadAndDecryptMedia(buildCdnDownloadUrl(encryptParam, cdnBaseUrl), aesKey, filename);
   return {
-    id: crypto3.randomUUID(),
+    id: crypto6.randomUUID(),
     name: filename,
     type: mimeType,
     size: data.length,
@@ -7080,6 +7462,16 @@ function escape2(state, silent) {
     state.pos = pos;
     return true;
   }
+  if (ch1 === 32) {
+    if (!silent) {
+      const token = state.push("text_special", "", 0);
+      token.content = "\\";
+      token.markup = "\\";
+      token.info = "escape";
+    }
+    state.pos = pos;
+    return true;
+  }
   let escapedStr = state.src[pos];
   if (ch1 >= 55296 && ch1 <= 56319 && pos + 1 < max) {
     const ch2 = state.src.charCodeAt(pos + 1);
@@ -7895,34 +8287,34 @@ function re_default(opts) {
   re.src_ZPCc = [re.src_Z, re.src_P, re.src_Cc].join("|");
   re.src_ZCc = [re.src_Z, re.src_Cc].join("|");
   const text_separators = "[><\uFF5C]";
-  re.src_pseudo_letter = "(?:(?!" + text_separators + "|" + re.src_ZPCc + ")" + re.src_Any + ")";
+  re.src_pseudo_letter = `(?:(?!${text_separators}|${re.src_ZPCc})${re.src_Any})`;
   re.src_ip4 = "(?:(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)";
-  re.src_auth = "(?:(?:(?!" + re.src_ZCc + "|[@/\\[\\]()]).)+@)?";
+  re.src_auth = `(?:(?:(?!${re.src_ZCc}|[@/\\[\\]()]).){1,50}@)?`;
   re.src_port = "(?::(?:6(?:[0-4]\\d{3}|5(?:[0-4]\\d{2}|5(?:[0-2]\\d|3[0-5])))|[1-5]?\\d{1,4}))?";
-  re.src_host_terminator = "(?=$|" + text_separators + "|" + re.src_ZPCc + ")(?!" + (opts["---"] ? "-(?!--)|" : "-|") + "_|:\\d|\\.-|\\.(?!$|" + re.src_ZPCc + "))";
-  re.src_path = "(?:[/?#](?:(?!" + re.src_ZCc + "|" + text_separators + `|[()[\\]{}.,"'?!\\-;]).|\\[(?:(?!` + re.src_ZCc + "|\\]).)*\\]|\\((?:(?!" + re.src_ZCc + "|[)]).)*\\)|\\{(?:(?!" + re.src_ZCc + '|[}]).)*\\}|\\"(?:(?!' + re.src_ZCc + `|["]).)+\\"|\\'(?:(?!` + re.src_ZCc + "|[']).)+\\'|\\'(?=" + re.src_pseudo_letter + "|[-])|\\.{2,}[a-zA-Z0-9%/&]|\\.(?!" + re.src_ZCc + "|[.]|$)|" + (opts["---"] ? "\\-(?!--(?:[^-]|$))(?:-*)|" : "\\-+|") + // allow `,,,` in paths
-  ",(?!" + re.src_ZCc + "|$)|;(?!" + re.src_ZCc + "|$)|\\!+(?!" + re.src_ZCc + "|[!]|$)|\\?(?!" + re.src_ZCc + "|[?]|$))+|\\/)?";
-  re.src_email_name = '[\\-;:&=\\+\\$,\\.a-zA-Z0-9_][\\-;:&=\\+\\$,\\"\\.a-zA-Z0-9_]*';
+  re.src_host_terminator = `(?=$|${text_separators}|${re.src_ZPCc})(?!${opts["---"] ? "-(?!--)|" : "-|"}_|:\\d|\\.-|\\.(?!$|${re.src_ZPCc}))`;
+  re.src_path = `(?:[/?#](?:(?!${re.src_ZCc}|${text_separators}|[()[\\]{}.,"'?!\\-;]).|\\[(?:(?!${re.src_ZCc}|\\]).)*\\]|\\((?:(?!${re.src_ZCc}|[)]).)*\\)|\\{(?:(?!${re.src_ZCc}|[}]).)*\\}|\\"(?:(?!${re.src_ZCc}|["]).)+\\"|\\'(?:(?!${re.src_ZCc}|[']).)+\\'|\\'(?=${re.src_pseudo_letter}|[-])|\\.{2,}[a-zA-Z0-9%/&]|\\.(?!${re.src_ZCc}|[.]|$)|` + (opts["---"] ? "\\-(?!--(?:[^-]|$))(?:-*)|" : "\\-+|") + // allow `,,,` in paths
+  `,(?!${re.src_ZCc}|$)|;(?!${re.src_ZCc}|$)|\\!+(?!${re.src_ZCc}|[!]|$)|\\?(?!${re.src_ZCc}|[?]|$))+|\\/)?`;
+  re.src_email_name = '[\\-;:&=\\+\\$,\\.a-zA-Z0-9_][\\-;:&=\\+\\$,\\"\\.a-zA-Z0-9_]{0,63}';
   re.src_xn = "xn--[a-z0-9\\-]{1,59}";
   re.src_domain_root = // Allow letters & digits (http://test1)
-  "(?:" + re.src_xn + "|" + re.src_pseudo_letter + "{1,63})";
-  re.src_domain = "(?:" + re.src_xn + "|(?:" + re.src_pseudo_letter + ")|(?:" + re.src_pseudo_letter + "(?:-|" + re.src_pseudo_letter + "){0,61}" + re.src_pseudo_letter + "))";
-  re.src_host = "(?:(?:(?:(?:" + re.src_domain + ")\\.)*" + re.src_domain + "))";
-  re.tpl_host_fuzzy = "(?:" + re.src_ip4 + "|(?:(?:(?:" + re.src_domain + ")\\.)+(?:%TLDS%)))";
-  re.tpl_host_no_ip_fuzzy = "(?:(?:(?:" + re.src_domain + ")\\.)+(?:%TLDS%))";
+  "(?:" + re.src_xn + `|${re.src_pseudo_letter}{1,63})`;
+  re.src_domain = "(?:" + re.src_xn + `|(?:${re.src_pseudo_letter})|(?:${re.src_pseudo_letter}(?:-|${re.src_pseudo_letter}){0,61}${re.src_pseudo_letter}))`;
+  re.src_host = `(?:(?:(?:(?:${re.src_domain})\\.)*${re.src_domain}))`;
+  re.tpl_host_fuzzy = "(?:" + re.src_ip4 + `|(?:(?:(?:${re.src_domain})\\.)+(?:%TLDS%)))`;
+  re.tpl_host_no_ip_fuzzy = `(?:(?:(?:${re.src_domain})\\.)+(?:%TLDS%))`;
   re.src_host_strict = re.src_host + re.src_host_terminator;
   re.tpl_host_fuzzy_strict = re.tpl_host_fuzzy + re.src_host_terminator;
   re.src_host_port_strict = re.src_host + re.src_port + re.src_host_terminator;
   re.tpl_host_port_fuzzy_strict = re.tpl_host_fuzzy + re.src_port + re.src_host_terminator;
   re.tpl_host_port_no_ip_fuzzy_strict = re.tpl_host_no_ip_fuzzy + re.src_port + re.src_host_terminator;
-  re.tpl_host_fuzzy_test = "localhost|www\\.|\\.\\d{1,3}\\.|(?:\\.(?:%TLDS%)(?:" + re.src_ZPCc + "|>|$))";
-  re.tpl_email_fuzzy = "(^|" + text_separators + '|"|\\(|' + re.src_ZCc + ")(" + re.src_email_name + "@" + re.tpl_host_fuzzy_strict + ")";
+  re.tpl_host_fuzzy_test = `localhost|www\\.|\\.\\d{1,3}\\.|(?:\\.(?:%TLDS%)(?:${re.src_ZPCc}|>|$))`;
+  re.tpl_email_fuzzy = `(^|${text_separators}|"|\\(|${re.src_ZCc})(${re.src_email_name}@${re.tpl_host_fuzzy_strict})`;
   re.tpl_link_fuzzy = // Fuzzy link can't be prepended with .:/\- and non punctuation.
   // but can start with > (markdown blockquote)
-  "(^|(?![.:/\\-_@])(?:[$+<=>^`|\uFF5C]|" + re.src_ZPCc + "))((?![$+<=>^`|\uFF5C])" + re.tpl_host_port_fuzzy_strict + re.src_path + ")";
+  `(^|(?![.:/\\-_@])(?:[$+<=>^\`|\uFF5C]|${re.src_ZPCc}))((?![$+<=>^\`|\uFF5C])${re.tpl_host_port_fuzzy_strict}${re.src_path})`;
   re.tpl_link_no_ip_fuzzy = // Fuzzy link can't be prepended with .:/\- and non punctuation.
   // but can start with > (markdown blockquote)
-  "(^|(?![.:/\\-_@])(?:[$+<=>^`|\uFF5C]|" + re.src_ZPCc + "))((?![$+<=>^`|\uFF5C])" + re.tpl_host_port_no_ip_fuzzy_strict + re.src_path + ")";
+  `(^|(?![.:/\\-_@])(?:[$+<=>^\`|\uFF5C]|${re.src_ZPCc}))((?![$+<=>^\`|\uFF5C])${re.tpl_host_port_no_ip_fuzzy_strict}${re.src_path})`;
   return re;
 }
 
@@ -7973,7 +8365,7 @@ var defaultSchemas = {
       const tail = text2.slice(pos);
       if (!self.re.http) {
         self.re.http = new RegExp(
-          "^\\/\\/" + self.re.src_auth + self.re.src_host_port_strict + self.re.src_path,
+          `^\\/\\/${self.re.src_auth}${self.re.src_host_port_strict}${self.re.src_path}`,
           "i"
         );
       }
@@ -7992,7 +8384,7 @@ var defaultSchemas = {
         self.re.no_http = new RegExp(
           "^" + self.re.src_auth + // Don't allow single-level domains, because of false positives like '//test'
           // with code comments
-          "(?:localhost|(?:(?:" + self.re.src_domain + ")\\.)+" + self.re.src_domain_root + ")" + self.re.src_port + self.re.src_host_terminator + self.re.src_path,
+          `(?:localhost|(?:(?:${self.re.src_domain})\\.)+${self.re.src_domain_root})` + self.re.src_port + self.re.src_host_terminator + self.re.src_path,
           "i"
         );
       }
@@ -8013,7 +8405,7 @@ var defaultSchemas = {
       const tail = text2.slice(pos);
       if (!self.re.mailto) {
         self.re.mailto = new RegExp(
-          "^" + self.re.src_email_name + "@" + self.re.src_host_strict,
+          `^${self.re.src_email_name}@${self.re.src_host_strict}`,
           "i"
         );
       }
@@ -8062,7 +8454,7 @@ function compile(self) {
   const aliases = [];
   self.__compiled__ = {};
   function schemaError(name, val) {
-    throw new Error('(LinkifyIt) Invalid schema "' + name + '": ' + val);
+    throw new Error(`(LinkifyIt) Invalid schema "${name}": ${val}`);
   }
   Object.keys(self.__schemas__).forEach(function(name) {
     const val = self.__schemas__[name];
@@ -8105,11 +8497,11 @@ function compile(self) {
   const slist = Object.keys(self.__compiled__).filter(function(name) {
     return name.length > 0 && self.__compiled__[name];
   }).map(escapeRE2).join("|");
-  self.re.schema_test = RegExp("(^|(?!_)(?:[><\uFF5C]|" + re.src_ZPCc + "))(" + slist + ")", "i");
-  self.re.schema_search = RegExp("(^|(?!_)(?:[><\uFF5C]|" + re.src_ZPCc + "))(" + slist + ")", "ig");
-  self.re.schema_at_start = RegExp("^" + self.re.schema_search.source, "i");
+  self.re.schema_test = RegExp(`(^|(?!_)(?:[><\uFF5C]|${re.src_ZPCc}))(${slist})`, "i");
+  self.re.schema_search = RegExp(`(^|(?!_)(?:[><\uFF5C]|${re.src_ZPCc}))(${slist})`, "ig");
+  self.re.schema_at_start = RegExp(`^${self.re.schema_search.source}`, "i");
   self.re.pretest = RegExp(
-    "(" + self.re.schema_test.source + ")|(" + self.re.host_fuzzy_test.source + ")|@",
+    `(${self.re.schema_test.source})|(${self.re.host_fuzzy_test.source})|@`,
     "i"
   );
 }
@@ -8303,10 +8695,10 @@ LinkifyIt.prototype.tlds = function tlds(list2, keepOld) {
 };
 LinkifyIt.prototype.normalize = function normalize2(match2) {
   if (!match2.schema) {
-    match2.url = "http://" + match2.url;
+    match2.url = `http://${match2.url}`;
   }
   if (match2.schema === "mailto:" && !/^mailto:/i.test(match2.url)) {
-    match2.url = "mailto:" + match2.url;
+    match2.url = `mailto:${match2.url}`;
   }
 };
 LinkifyIt.prototype.onCompile = function onCompile() {
@@ -9352,6 +9744,9 @@ var WeixinAdapter = class extends BaseChannelAdapter {
   consecutiveFailures = /* @__PURE__ */ new Map();
   typingTickets = /* @__PURE__ */ new Map();
   pendingCursors = /* @__PURE__ */ new Map();
+  pollCursors = /* @__PURE__ */ new Map();
+  cursorGenerations = /* @__PURE__ */ new Map();
+  cursorRecoveryGates = /* @__PURE__ */ new Map();
   nextBatchId = 1;
   constructor(instance) {
     super();
@@ -9392,6 +9787,10 @@ var WeixinAdapter = class extends BaseChannelAdapter {
       this.stopAccountWorker(accountId);
     }
     this.pendingCursors.clear();
+    this.pollCursors.clear();
+    this.cursorGenerations.clear();
+    for (const gate of this.cursorRecoveryGates.values()) gate.resolve();
+    this.cursorRecoveryGates.clear();
     this.clearInboundQueue();
     this.rejectPendingInboundConsumers();
     console.log("[weixin-adapter] Stopped");
@@ -9451,11 +9850,11 @@ var WeixinAdapter = class extends BaseChannelAdapter {
   isAuthorized(_userId, _chatId) {
     return true;
   }
-  acknowledgeUpdate(updateId) {
-    const batch = this.pendingCursors.get(updateId);
-    if (!batch) return;
-    batch.remaining = Math.max(0, batch.remaining - 1);
-    this.maybeCommitPendingCursor(updateId);
+  acknowledgeUpdate(updateId, messageId) {
+    this.settlePendingCursorMessage(updateId, messageId, false);
+  }
+  rejectUpdate(updateId, messageId) {
+    this.settlePendingCursorMessage(updateId, messageId, true);
   }
   onMessageStart(chatId) {
     this.sendTypingIndicator(chatId, TypingStatus.TYPING).catch(() => {
@@ -9507,6 +9906,7 @@ var WeixinAdapter = class extends BaseChannelAdapter {
     this.pollAborts.set(accountId, controller);
     this.seenMessageIds.set(accountId, /* @__PURE__ */ new Set());
     this.consecutiveFailures.set(accountId, 0);
+    this.cursorGenerations.set(accountId, 0);
     void this.runPollLoop(accountId, creds, controller.signal);
   }
   stopAccountWorker(accountId) {
@@ -9515,6 +9915,14 @@ var WeixinAdapter = class extends BaseChannelAdapter {
     this.workerSignatures.delete(accountId);
     this.seenMessageIds.delete(accountId);
     this.consecutiveFailures.delete(accountId);
+    this.pollCursors.delete(accountId);
+    this.cursorGenerations.delete(accountId);
+    for (const [batchId, batch] of this.pendingCursors) {
+      if (batch.accountId === accountId) this.pendingCursors.delete(batchId);
+    }
+    const recoveryGate = this.cursorRecoveryGates.get(accountId);
+    recoveryGate?.resolve();
+    this.cursorRecoveryGates.delete(accountId);
     for (const key of Array.from(this.typingTickets.keys())) {
       if (key.startsWith(`${accountId}:`)) {
         this.typingTickets.delete(key);
@@ -9529,11 +9937,20 @@ var WeixinAdapter = class extends BaseChannelAdapter {
         continue;
       }
       try {
+        await this.waitForCursorRecovery(accountId, signal);
+        if (signal.aborted) break;
         const { store } = getBridgeContext();
         const offsetKey = `weixin:${accountId}`;
         const rawOffset = store.getChannelOffset(offsetKey);
-        const cursor = rawOffset === "0" ? "" : rawOffset;
+        const persistedCursor = rawOffset === "0" ? "" : rawOffset;
+        const cursor = this.pollCursors.get(accountId) ?? persistedCursor;
+        this.pollCursors.set(accountId, cursor);
+        const cursorGeneration = this.cursorGenerations.get(accountId) ?? 0;
         const response = await getUpdates(creds, cursor);
+        if (signal.aborted || !this._running) break;
+        if ((this.cursorGenerations.get(accountId) ?? 0) !== cursorGeneration || this.cursorRecoveryGates.has(accountId)) {
+          continue;
+        }
         if (response.errcode === ERRCODE_SESSION_EXPIRED) {
           setPaused(accountId, "Session expired (errcode -14)");
           console.warn(`[weixin-adapter] Account ${accountId} session expired, pausing`);
@@ -9542,34 +9959,33 @@ var WeixinAdapter = class extends BaseChannelAdapter {
         if (response.errcode && response.errcode !== 0) {
           throw new Error(`API error: ${response.errcode} ${response.errmsg || ""}`.trim());
         }
-        let batchId;
-        let batchCompleted = false;
-        if (response.msgs && response.msgs.length > 0 && response.get_updates_buf) {
-          batchId = this.nextBatchId++;
-          this.pendingCursors.set(batchId, {
-            offsetKey,
-            cursor: response.get_updates_buf,
-            remaining: 0,
-            sealed: false
-          });
-          for (const message of response.msgs) {
-            await this.processMessage(accountId, message, batchId);
+        const messages = response.msgs ?? [];
+        const nextCursor = response.get_updates_buf;
+        if (nextCursor) {
+          const batchId = this.createPendingCursorBatch(accountId, offsetKey, nextCursor);
+          try {
+            for (const message of messages) {
+              await this.processMessage(accountId, message, batchId);
+            }
+            const batch = this.pendingCursors.get(batchId);
+            if (batch) batch.sealed = true;
+            this.pollCursors.set(accountId, nextCursor);
+            this.maybeCommitPendingCursors(accountId);
+          } catch (error) {
+            const batch = this.pendingCursors.get(batchId);
+            if (batch) {
+              batch.failed = true;
+              batch.sealed = true;
+              this.ensureCursorRecoveryGate(accountId);
+            }
+            this.maybeCommitPendingCursors(accountId);
+            throw error;
           }
-          batchCompleted = true;
-        } else if (response.msgs && response.msgs.length > 0) {
-          for (const message of response.msgs) {
+        } else {
+          for (const message of messages) {
             await this.processMessage(accountId, message);
           }
         }
-        if (batchId !== void 0 && response.get_updates_buf) {
-          const batch = this.pendingCursors.get(batchId);
-          if (batchCompleted && batch) {
-            batch.sealed = true;
-            this.maybeCommitPendingCursor(batchId);
-          } else if (!batchCompleted) {
-            this.pendingCursors.delete(batchId);
-          }
-        }
         this.consecutiveFailures.set(accountId, 0);
       } catch (err) {
         if (signal.aborted) break;
@@ -9587,12 +10003,20 @@ var WeixinAdapter = class extends BaseChannelAdapter {
   }
   async processMessage(accountId, message, batchId) {
     if (!message.from_user_id) return;
-    const messageKey = message.message_id || `seq_${message.seq}`;
+    const fallbackSequence = message.seq ?? message.create_time ?? "unknown";
+    const inboundMessageId = message.message_id || `weixin_${accountId}_${message.from_user_id}_${fallbackSequence}`;
+    const messageKey = inboundMessageId;
+    if (getBridgeContext().store.checkDedup(buildInboundDedupKey(this.channelType, inboundMessageId))) {
+      return;
+    }
     const seenIds = this.seenMessageIds.get(accountId);
     if (seenIds?.has(messageKey)) {
       return;
     }
     seenIds?.add(messageKey);
+    if (batchId !== void 0) {
+      this.pendingCursors.get(batchId)?.observedMessageIds.add(messageKey);
+    }
     if (seenIds && seenIds.size > DEDUP_MAX2) {
       const overflow = Array.from(seenIds).slice(0, seenIds.size - DEDUP_MAX2);
       for (const staleKey of overflow) {
@@ -9656,7 +10080,7 @@ ${failureNote}` : attachments.length > 0 ? failureNote : text2;
     }
     const chatId = encodeWeixinChatId(accountId, message.from_user_id);
     const inbound = {
-      messageId: message.message_id || `weixin_${accountId}_${message.seq || Date.now()}`,
+      messageId: inboundMessageId,
       address: {
         channelType: this.channelType,
         channelProvider: this.provider,
@@ -9686,7 +10110,10 @@ ${failureNote}` : attachments.length > 0 ? failureNote : text2;
     }
     if (batchId !== void 0) {
       const batch = this.pendingCursors.get(batchId);
-      if (batch) batch.remaining++;
+      if (batch && !batch.messageIds.has(inbound.messageId)) {
+        batch.messageIds.add(inbound.messageId);
+        batch.remaining++;
+      }
     }
     this.enqueueInboundMessage(inbound);
     const summary = attachments.length > 0 ? `[${attachments.length} attachment(s)] ${inbound.text.slice(0, 150)}` : missingVoiceTranscriptCount > 0 && !inbound.text ? "[voice transcription unavailable]" : failedCount > 0 && !inbound.text ? `[${failedCount} attachment(s) failed]` : inbound.text.slice(0, 200);
@@ -9748,13 +10175,103 @@ ${failureNote}` : attachments.length > 0 ? failureNote : text2;
       );
     });
   }
-  maybeCommitPendingCursor(updateId) {
+  createPendingCursorBatch(accountId, offsetKey, cursor) {
+    const batchId = this.nextBatchId++;
+    this.pendingCursors.set(batchId, {
+      accountId,
+      offsetKey,
+      cursor,
+      remaining: 0,
+      sealed: false,
+      failed: false,
+      messageIds: /* @__PURE__ */ new Set(),
+      observedMessageIds: /* @__PURE__ */ new Set(),
+      settledMessageIds: /* @__PURE__ */ new Set()
+    });
+    return batchId;
+  }
+  settlePendingCursorMessage(updateId, messageId, failed) {
     const batch = this.pendingCursors.get(updateId);
-    if (!batch || !batch.sealed || batch.remaining > 0) {
+    if (!batch) return;
+    const targetMessageId = messageId && batch.messageIds.has(messageId) ? messageId : Array.from(batch.messageIds).find((id) => !batch.settledMessageIds.has(id));
+    if (!targetMessageId || batch.settledMessageIds.has(targetMessageId)) return;
+    batch.settledMessageIds.add(targetMessageId);
+    batch.remaining = Math.max(0, batch.remaining - 1);
+    if (failed) {
+      batch.failed = true;
+      this.ensureCursorRecoveryGate(batch.accountId);
+    }
+    this.maybeCommitPendingCursors(batch.accountId);
+  }
+  maybeCommitPendingCursors(accountId) {
+    const accountBatches = () => Array.from(this.pendingCursors.entries()).filter(([, batch]) => batch.accountId === accountId).sort(([left], [right]) => left - right);
+    let batches = accountBatches();
+    while (batches.length > 0) {
+      const [batchId, batch] = batches[0];
+      if (!batch.sealed || batch.remaining > 0 || batch.failed) break;
+      try {
+        getBridgeContext().store.setChannelOffset(batch.offsetKey, batch.cursor);
+      } catch (error) {
+        batch.failed = true;
+        this.ensureCursorRecoveryGate(accountId);
+        console.error(
+          `[weixin-adapter] Failed to commit cursor for ${accountId}:`,
+          error instanceof Error ? error.message : error
+        );
+        break;
+      }
+      this.pendingCursors.delete(batchId);
+      batches = accountBatches();
+    }
+    batches = accountBatches();
+    if (!batches.some(([, batch]) => batch.failed)) return;
+    this.ensureCursorRecoveryGate(accountId);
+    if (!batches.every(([, batch]) => batch.sealed && batch.remaining === 0)) return;
+    const offsetKey = batches[0][1].offsetKey;
+    let persistedCursor;
+    try {
+      const rawOffset = getBridgeContext().store.getChannelOffset(offsetKey);
+      persistedCursor = rawOffset === "0" ? "" : rawOffset;
+    } catch (error) {
+      console.error(
+        `[weixin-adapter] Failed to reload cursor for ${accountId}:`,
+        error instanceof Error ? error.message : error
+      );
       return;
     }
-    getBridgeContext().store.setChannelOffset(batch.offsetKey, batch.cursor);
-    this.pendingCursors.delete(updateId);
+    const seenIds = this.seenMessageIds.get(accountId);
+    for (const [batchId, batch] of batches) {
+      for (const messageKey of batch.observedMessageIds) seenIds?.delete(messageKey);
+      this.pendingCursors.delete(batchId);
+    }
+    this.pollCursors.set(accountId, persistedCursor);
+    this.cursorGenerations.set(accountId, (this.cursorGenerations.get(accountId) ?? 0) + 1);
+    const gate = this.cursorRecoveryGates.get(accountId);
+    this.cursorRecoveryGates.delete(accountId);
+    gate?.resolve();
+  }
+  ensureCursorRecoveryGate(accountId) {
+    const existing = this.cursorRecoveryGates.get(accountId);
+    if (existing) return existing;
+    let resolve2;
+    const promise = new Promise((done) => {
+      resolve2 = done;
+    });
+    const gate = { promise, resolve: resolve2 };
+    this.cursorRecoveryGates.set(accountId, gate);
+    return gate;
+  }
+  waitForCursorRecovery(accountId, signal) {
+    const gate = this.cursorRecoveryGates.get(accountId);
+    if (!gate || signal.aborted) return Promise.resolve();
+    return new Promise((resolve2) => {
+      const finish = () => {
+        signal.removeEventListener("abort", finish);
+        resolve2();
+      };
+      signal.addEventListener("abort", finish, { once: true });
+      gate.promise.then(finish, finish);
+    });
   }
   filterConfiguredAccounts(accounts) {
     if (!this.configuredAccountId) return accounts;
@@ -9810,10 +10327,10 @@ function recordBindingChange(store, input) {
 }
 
 // src/desktop-sessions.ts
-import fs4 from "node:fs";
+import fs5 from "node:fs";
 import os2 from "node:os";
 import path4 from "node:path";
-import crypto4 from "node:crypto";
+import crypto7 from "node:crypto";
 import { DatabaseSync } from "node:sqlite";
 var ACTIVE_WINDOW_MS = 15 * 60 * 1e3;
 var MAX_SESSION_META_BYTES = 4 * 1024 * 1024;
@@ -9838,13 +10355,13 @@ function getDesktopStateDbPath() {
   const codexHome = getCodexHome();
   let entries;
   try {
-    entries = fs4.readdirSync(codexHome, { withFileTypes: true });
+    entries = fs5.readdirSync(codexHome, { withFileTypes: true });
   } catch {
     return null;
   }
   const candidates = entries.filter((entry) => entry.isFile() && /^state_\d+\.sqlite$/i.test(entry.name)).map((entry) => path4.join(codexHome, entry.name)).sort((left, right) => {
     try {
-      return fs4.statSync(right).mtimeMs - fs4.statSync(left).mtimeMs;
+      return fs5.statSync(right).mtimeMs - fs5.statSync(left).mtimeMs;
     } catch {
       return 0;
     }
@@ -9869,10 +10386,10 @@ function isInternalSkillWorkspace(cwd) {
 }
 function loadSavedWorkspaceRoots() {
   const statePath = getCodexGlobalStatePath();
-  if (!fs4.existsSync(statePath)) return null;
+  if (!fs5.existsSync(statePath)) return null;
   let parsed;
   try {
-    parsed = JSON.parse(fs4.readFileSync(statePath, "utf-8"));
+    parsed = JSON.parse(fs5.readFileSync(statePath, "utf-8"));
   } catch {
     return null;
   }
@@ -9887,10 +10404,10 @@ function isWithinSavedWorkspaceRoots(cwd, roots) {
 }
 function loadArchivedThreadIds() {
   const archivedRoot = getArchivedSessionsRoot();
-  if (!fs4.existsSync(archivedRoot)) return /* @__PURE__ */ new Set();
+  if (!fs5.existsSync(archivedRoot)) return /* @__PURE__ */ new Set();
   let entries;
   try {
-    entries = fs4.readdirSync(archivedRoot, { withFileTypes: true });
+    entries = fs5.readdirSync(archivedRoot, { withFileTypes: true });
   } catch {
     return /* @__PURE__ */ new Set();
   }
@@ -9903,13 +10420,13 @@ function loadArchivedThreadIds() {
   return ids;
 }
 function readFirstLine(filePath, maxBytes = MAX_SESSION_META_BYTES) {
-  const fd = fs4.openSync(filePath, "r");
+  const fd = fs5.openSync(filePath, "r");
   try {
     const chunks = [];
     let bytesReadTotal = 0;
     const buffer = Buffer.alloc(4096);
     while (bytesReadTotal < maxBytes) {
-      const bytesRead = fs4.readSync(fd, buffer, 0, buffer.length, bytesReadTotal);
+      const bytesRead = fs5.readSync(fd, buffer, 0, buffer.length, bytesReadTotal);
       if (bytesRead <= 0) break;
       const slice = Buffer.from(buffer.subarray(0, bytesRead));
       chunks.push(slice);
@@ -9922,31 +10439,31 @@ function readFirstLine(filePath, maxBytes = MAX_SESSION_META_BYTES) {
     }
     return Buffer.concat(chunks).toString("utf-8").split(/\r?\n/, 1)[0] || "";
   } finally {
-    fs4.closeSync(fd);
+    fs5.closeSync(fd);
   }
 }
 function readFilePrefix(filePath, maxBytes = MAX_SESSION_TITLE_SCAN_BYTES) {
-  const fd = fs4.openSync(filePath, "r");
+  const fd = fs5.openSync(filePath, "r");
   try {
     const buffer = Buffer.alloc(Math.min(maxBytes, 64 * 1024));
     const chunks = [];
     let offset = 0;
     while (offset < maxBytes) {
       const bytesToRead = Math.min(buffer.length, maxBytes - offset);
-      const bytesRead = fs4.readSync(fd, buffer, 0, bytesToRead, offset);
+      const bytesRead = fs5.readSync(fd, buffer, 0, bytesToRead, offset);
       if (bytesRead <= 0) break;
       chunks.push(Buffer.from(buffer.subarray(0, bytesRead)));
       offset += bytesRead;
     }
     return Buffer.concat(chunks).toString("utf-8");
   } finally {
-    fs4.closeSync(fd);
+    fs5.closeSync(fd);
   }
 }
 function walkSessionFiles(dirPath, target) {
   let entries;
   try {
-    entries = fs4.readdirSync(dirPath, { withFileTypes: true });
+    entries = fs5.readdirSync(dirPath, { withFileTypes: true });
   } catch {
     return;
   }
@@ -9969,10 +10486,10 @@ function isDesktopLike(meta) {
 }
 function loadThreadIndexEntries(archivedThreadIds) {
   const indexPath = getSessionIndexPath();
-  if (!fs4.existsSync(indexPath)) return /* @__PURE__ */ new Map();
+  if (!fs5.existsSync(indexPath)) return /* @__PURE__ */ new Map();
   let content = "";
   try {
-    content = fs4.readFileSync(indexPath, "utf-8");
+    content = fs5.readFileSync(indexPath, "utf-8");
   } catch {
     return /* @__PURE__ */ new Map();
   }
@@ -10012,7 +10529,7 @@ function parseUpdatedAtValue(value) {
 }
 function loadVisibleDesktopThreads(limit) {
   const dbPath = getDesktopStateDbPath();
-  if (!dbPath || !fs4.existsSync(dbPath)) return null;
+  if (!dbPath || !fs5.existsSync(dbPath)) return null;
   let db = null;
   try {
     db = new DatabaseSync(dbPath, { readOnly: true });
@@ -10079,7 +10596,7 @@ function parseDesktopSession(filePath, threadIndexEntries, archivedThreadIds) {
   }
   let stat;
   try {
-    stat = fs4.statSync(filePath);
+    stat = fs5.statSync(filePath);
   } catch {
     return null;
   }
@@ -10268,25 +10785,34 @@ function formatDesktopToolName(namespaceValue, nameValue) {
   return namespace.endsWith("__") || namespace.endsWith("/") || namespace.endsWith(".") ? `${namespace}${name}` : `${namespace}__${name}`;
 }
 function createDesktopEventSignature(rawLine) {
-  return crypto4.createHash("sha1").update(rawLine).digest("hex");
+  return crypto7.createHash("sha1").update(rawLine).digest("hex");
 }
-function readFileUtf8Range(filePath, startOffset, endOffset) {
+function readCompleteUtf8LineRange(filePath, startOffset, endOffset) {
   const safeStart = Math.max(0, startOffset);
   const safeEnd = Math.max(safeStart, endOffset);
   const bytesToRead = safeEnd - safeStart;
-  if (bytesToRead <= 0) return "";
-  const fd = fs4.openSync(filePath, "r");
+  if (bytesToRead <= 0) return { content: "", nextOffset: safeStart };
+  const fd = fs5.openSync(filePath, "r");
   try {
     const buffer = Buffer.alloc(bytesToRead);
     let totalRead = 0;
     while (totalRead < bytesToRead) {
-      const bytesRead = fs4.readSync(fd, buffer, totalRead, bytesToRead - totalRead, safeStart + totalRead);
+      const bytesRead = fs5.readSync(fd, buffer, totalRead, bytesToRead - totalRead, safeStart + totalRead);
       if (bytesRead <= 0) break;
       totalRead += bytesRead;
     }
-    return buffer.subarray(0, totalRead).toString("utf-8");
+    const readBuffer = buffer.subarray(0, totalRead);
+    const lastNewlineIndex = readBuffer.lastIndexOf(10);
+    if (lastNewlineIndex < 0) {
+      return { content: "", nextOffset: safeStart };
+    }
+    const consumedBytes = lastNewlineIndex + 1;
+    return {
+      content: readBuffer.subarray(0, consumedBytes).toString("utf-8"),
+      nextOffset: safeStart + consumedBytes
+    };
   } finally {
-    fs4.closeSync(fd);
+    fs5.closeSync(fd);
   }
 }
 function isSessionEventLine(line) {
@@ -10301,6 +10827,7 @@ function isTurnContextLine(line) {
 var IGNORED_EVENT_MSG_TYPES = /* @__PURE__ */ new Set([
   "context_compacted",
   "thread_settings_applied",
+  "thread_goal_updated",
   "thread_name_updated",
   "thread_rolled_back",
   "token_count"
@@ -10309,6 +10836,12 @@ var IGNORED_RESPONSE_ITEM_TYPES = /* @__PURE__ */ new Set([
   "image_generation_call",
   "web_search_call"
 ]);
+var IGNORED_TOP_LEVEL_TYPES = /* @__PURE__ */ new Set([
+  "compacted",
+  "session_meta",
+  "turn_context",
+  "world_state"
+]);
 var TERMINAL_COMPLETION_EVENT_TYPES = /* @__PURE__ */ new Set([
   "task_complete",
   "turn.completed",
@@ -10334,6 +10867,10 @@ function extractTerminalCompletionText(payload) {
   }
   return "";
 }
+function isSyntheticDesktopUserContext(text2) {
+  const normalized = text2.trim();
+  return normalized.startsWith("<environment_context>") && normalized.endsWith("</environment_context>");
+}
 function isIgnoredMirrorLineKind(line) {
   if (isSessionEventLine(line)) {
     const payloadType = typeof line.payload?.type === "string" ? line.payload.type.trim() : "";
@@ -10343,7 +10880,8 @@ function isIgnoredMirrorLineKind(line) {
     const payloadType = typeof line.payload?.type === "string" ? line.payload.type.trim() : "";
     return IGNORED_RESPONSE_ITEM_TYPES.has(payloadType);
   }
-  return false;
+  const topLevelType = typeof line.type === "string" ? line.type.trim() : "";
+  return IGNORED_TOP_LEVEL_TYPES.has(topLevelType);
 }
 function describeUnhandledMirrorLineKind(line) {
   if (isIgnoredMirrorLineKind(line)) return null;
@@ -10355,11 +10893,12 @@ function describeUnhandledMirrorLineKind(line) {
     const payloadType = typeof line.payload?.type === "string" ? line.payload.type.trim() : "";
     return `response_item:${payloadType || "<unknown>"}`;
   }
-  return null;
+  const topLevelType = typeof line.type === "string" ? line.type.trim() : "";
+  return `top_level:${topLevelType || "<unknown>"}`;
 }
 function listDesktopSessions(limit) {
   const root = getCodexSessionsRoot();
-  if (!fs4.existsSync(root)) return [];
+  if (!fs5.existsSync(root)) return [];
   const archivedThreadIds = loadArchivedThreadIds();
   const threadIndexEntries = loadThreadIndexEntries(archivedThreadIds);
   const savedWorkspaceRoots = loadSavedWorkspaceRoots();
@@ -10397,9 +10936,17 @@ function listDesktopSessions(limit) {
   }
   return sessions.sort((a, b) => b.lastEventAt.localeCompare(a.lastEventAt)).slice(0, typeof limit === "number" && Number.isFinite(limit) && limit > 0 ? Math.max(1, Math.floor(limit)) : void 0);
 }
+var DESKTOP_SESSION_LOOKUP_CACHE_TTL_MS = 1e3;
+var desktopSessionLookupCache = null;
 function getDesktopSessionByThreadId(threadId) {
-  const sessions = listDesktopSessions(200);
-  return sessions.find((session) => session.threadId === threadId) || null;
+  const timestamp = Date.now();
+  if (!desktopSessionLookupCache || desktopSessionLookupCache.expiresAt <= timestamp) {
+    desktopSessionLookupCache = {
+      expiresAt: timestamp + DESKTOP_SESSION_LOOKUP_CACHE_TTL_MS,
+      sessions: new Map(listDesktopSessions().map((session) => [session.threadId, session]))
+    };
+  }
+  return desktopSessionLookupCache.sessions.get(threadId) || null;
 }
 function extractDesktopMessageText(line) {
   const parts = line.payload?.content?.map((item) => item && typeof item.text === "string" ? item.text : "").filter(Boolean) || [];
@@ -10636,7 +11183,7 @@ function pushDesktopMirrorEventRecord(records, parsed, rawLine, activeTurnId) {
   }
   if (parsed.payload?.type === "user_message") {
     const text2 = extractNormalizedStructuredText(parsed.payload.message);
-    if (!text2) return true;
+    if (!text2 || isSyntheticDesktopUserContext(text2)) return true;
     records.push({
       signature,
       type: "message",
@@ -10691,6 +11238,26 @@ function pushDesktopMirrorResponseRecord(records, parsed, rawLine, activeTurnId,
     });
     return true;
   }
+  if (parsed.payload?.type === "message" && parsed.payload.role === "user") {
+    const text2 = extractDesktopMessageText(parsed);
+    if (!text2 || isSyntheticDesktopUserContext(text2)) return true;
+    const previous = records.at(-1);
+    if (previous?.type === "message" && previous.role === "user" && previous.content === text2 && previous.turnId === (activeTurnId || void 0)) {
+      return true;
+    }
+    records.push({
+      signature,
+      type: "message",
+      role: "user",
+      content: text2,
+      timestamp,
+      ...activeTurnId ? { turnId: activeTurnId } : {}
+    });
+    return true;
+  }
+  if (parsed.payload?.type === "message") {
+    return true;
+  }
   if (parsed.payload?.type === "tool_search_call") {
     const toolId = extractNormalizedFreeText(parsed.payload.call_id) || signature;
     records.push({
@@ -10920,16 +11487,16 @@ ${event.content}` : event.content
 function readDesktopSessionEventStreamByFilePath(filePath) {
   let content = "";
   try {
-    content = fs4.readFileSync(filePath, "utf-8");
+    content = fs5.readFileSync(filePath, "utf-8");
   } catch {
     return [];
   }
   return parseDesktopSessionEventText(content, "", true).events;
 }
 function readDesktopSessionMirrorRecordDeltaByFilePath(filePath, startOffset, endOffset, trailingText = "", currentTurnId = null, currentSpecialCallIds = []) {
-  let content = "";
+  let range;
   try {
-    content = readFileUtf8Range(filePath, startOffset, endOffset);
+    range = readCompleteUtf8LineRange(filePath, startOffset, endOffset);
   } catch {
     return {
       records: [],
@@ -10940,10 +11507,16 @@ function readDesktopSessionMirrorRecordDeltaByFilePath(filePath, startOffset, en
       unknownKinds: []
     };
   }
-  const parsed = parseDesktopMirrorRecordText(content, trailingText, false, currentTurnId, currentSpecialCallIds);
+  const parsed = parseDesktopMirrorRecordText(
+    range.content,
+    trailingText,
+    false,
+    currentTurnId,
+    currentSpecialCallIds
+  );
   return {
     records: parsed.records,
-    nextOffset: Math.max(startOffset, endOffset),
+    nextOffset: range.nextOffset,
     trailingText: parsed.trailingText,
     nextTurnId: parsed.nextTurnId,
     nextSpecialCallIds: parsed.nextSpecialCallIds,
@@ -11103,14 +11676,14 @@ function bindStoreToSdkSession(store, channelType, chatId, sdkSessionId, opts) {
 }
 
 // src/internal-sessions.ts
-import fs5 from "node:fs";
+import fs6 from "node:fs";
 import path6 from "node:path";
 var DRAFT_TTL_MS = 24 * 60 * 60 * 1e3;
 var MAX_HIDDEN_DRAFT_SESSIONS = 64;
 var INTERNAL_SESSION_ROOT = path6.join(CTI_HOME, "runtime", "internal-sessions");
 var DRAFT_SESSION_PREFIX = "Draft";
 function ensureDirectory(dirPath) {
-  fs5.mkdirSync(dirPath, { recursive: true });
+  fs6.mkdirSync(dirPath, { recursive: true });
 }
 function sanitizePathSlug(raw) {
   return raw.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "scratch";
@@ -12601,6 +13174,10 @@ function filterSuppressedMirrorRecords(store, sessionId, records, config2, nowMs
           break;
         }
         if (record.type === "message" && record.role === "user") {
+          if (isSyntheticDesktopUserContext(record.content || "")) {
+            handled = true;
+            break;
+          }
           if (suppression.promptText && normalizedContent === suppression.promptText) {
             suppression.awaitingPromptMatch = false;
             suppression.droppingTurn = true;
@@ -12874,15 +13451,32 @@ function createAdapterRuntime(getState2, deps) {
           const msg = await adapter.consumeOne();
           if (!msg) continue;
           if (msg.callbackData || msg.text.trim().startsWith("/") || deps.isNumericPermissionShortcut(adapter.provider, msg.text.trim(), msg.address.chatId)) {
-            await deps.handleMessage(adapter, msg);
+            try {
+              await deps.handleMessage(adapter, msg);
+            } catch (error) {
+              if (msg.updateId != null) {
+                adapter.rejectUpdate?.(msg.updateId, msg.messageId);
+              }
+              throw error;
+            }
           } else {
-            const sessionId = deps.resolveSessionIdForMessage(msg);
-            deps.processWithSessionLock(
-              sessionId,
-              () => deps.handleMessage(adapter, msg)
-            ).catch((err) => {
-              console.error(`[bridge-manager] Session ${sessionId.slice(0, 8)} error:`, err);
-            });
+            try {
+              const sessionId = deps.resolveSessionIdForMessage(msg);
+              deps.processWithSessionLock(
+                sessionId,
+                () => deps.handleMessage(adapter, msg)
+              ).catch((err) => {
+                if (msg.updateId != null) {
+                  adapter.rejectUpdate?.(msg.updateId, msg.messageId);
+                }
+                console.error(`[bridge-manager] Session ${sessionId.slice(0, 8)} error:`, err);
+              });
+            } catch (error) {
+              if (msg.updateId != null) {
+                adapter.rejectUpdate?.(msg.updateId, msg.messageId);
+              }
+              throw error;
+            }
           }
         } catch (err) {
           if (abort.signal.aborted) break;
@@ -12925,11 +13519,11 @@ function createAdapterRuntime(getState2, deps) {
 }
 
 // src/lib/bridge/bridge-session-support.ts
-import fs7 from "node:fs";
+import fs8 from "node:fs";
 import path10 from "node:path";
 
 // src/codex-models.ts
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 import os3 from "node:os";
 import path9 from "node:path";
 var DEFAULT_CODEX_CONFIG_PATH = path9.join(os3.homedir(), ".codex", "config.toml");
@@ -12982,7 +13576,7 @@ var KNOWN_CODEX_MODEL_FALLBACKS = [
 ];
 function readConfiguredCodexModel(configPath = DEFAULT_CODEX_CONFIG_PATH) {
   try {
-    const raw = fs6.readFileSync(configPath, "utf-8");
+    const raw = fs7.readFileSync(configPath, "utf-8");
     let inSection = false;
     for (const line of raw.split(/\r?\n/)) {
       const trimmed = line.trim();
@@ -13026,7 +13620,7 @@ function parseSupportedReasoningLevels(value) {
 }
 function listCachedCodexModels(cachePath = DEFAULT_CODEX_MODELS_CACHE_PATH) {
   try {
-    const raw = fs6.readFileSync(cachePath, "utf-8");
+    const raw = fs7.readFileSync(cachePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.models)) return [];
     const seen = /* @__PURE__ */ new Set();
@@ -13212,7 +13806,7 @@ function resolveNewSessionWorkingDirectory(rawArgs, binding, session) {
   return { ok: true, workDir: validated };
 }
 function ensureWorkingDirectoryExists(workDir) {
-  fs7.mkdirSync(workDir, { recursive: true });
+  fs8.mkdirSync(workDir, { recursive: true });
 }
 function resetDraftSession2(address) {
   const { store } = getBridgeContext();
@@ -13382,14 +13976,20 @@ async function deliverResponse(adapter, address, responseText, sessionId, replyT
       replyToMessageId
     }, { sessionId });
     if (!attachmentResult.ok) {
-      return deliverTextResponse(
+      const attachmentError = attachmentResult.error || "\u672A\u77E5\u9519\u8BEF";
+      const noticeResult = await deliverTextResponse(
         adapter,
         address,
         `\u9644\u4EF6\u53D1\u9001\u5931\u8D25\uFF1A${attachment.path}
-${attachmentResult.error || "\u672A\u77E5\u9519\u8BEF"}`,
+${attachmentError}`,
         sessionId,
         replyToMessageId
       );
+      return {
+        ok: false,
+        messageId: noticeResult.messageId,
+        error: noticeResult.ok ? `\u9644\u4EF6\u53D1\u9001\u5931\u8D25\uFF1A${attachment.path}: ${attachmentError}` : `\u9644\u4EF6\u53D1\u9001\u5931\u8D25\uFF1A${attachment.path}: ${attachmentError}; \u9519\u8BEF\u63D0\u793A\u4E5F\u53D1\u9001\u5931\u8D25\uFF1A${noticeResult.error || "\u672A\u77E5\u9519\u8BEF"}`
+      };
     }
     lastResult = attachmentResult;
   }
@@ -14115,9 +14715,9 @@ ${truncateHistoryContent(formatStoredMessageContent(message.content))}`;
 import path13 from "node:path";
 
 // src/lib/bridge/conversation-engine.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import path12 from "path";
-import crypto5 from "crypto";
+import crypto8 from "crypto";
 
 // src/lib/bridge/turns/final-response-artifacts.ts
 function attachmentKey(attachment) {
@@ -14195,6 +14795,74 @@ async function consumeSseEvents(stream, onEvent) {
 }
 
 // src/lib/bridge/conversation-engine.ts
+var MAX_INBOUND_ATTACHMENT_BYTES = 100 * 1024 * 1024;
+var MAX_INBOUND_ATTACHMENTS_TOTAL_BYTES = 120 * 1024 * 1024;
+function validateInboundAttachmentSizes(files, maxFileBytes = MAX_INBOUND_ATTACHMENT_BYTES, maxTotalBytes = MAX_INBOUND_ATTACHMENTS_TOTAL_BYTES) {
+  if (!files || files.length === 0) return null;
+  let totalBytes = 0;
+  for (const file of files) {
+    const encodedSize = typeof file.data === "string" ? Buffer.byteLength(file.data, "base64") : 0;
+    const fileSize = Math.max(0, Number(file.size) || 0, encodedSize);
+    if (fileSize > maxFileBytes) {
+      return `Attachment "${file.name}" is too large (${fileSize} bytes; max ${maxFileBytes} bytes).`;
+    }
+    totalBytes += fileSize;
+    if (totalBytes > maxTotalBytes) {
+      return `Attachments are too large in total (${totalBytes} bytes; max ${maxTotalBytes} bytes).`;
+    }
+  }
+  return null;
+}
+var DEFAULT_DESKTOP_BUSY_RETRY_DELAYS_MS = [
+  5e3,
+  1e4,
+  15e3,
+  3e4,
+  3e4
+];
+function isSessionBusyErrorMessage(message) {
+  return (message || "").toLowerCase().includes("session is busy processing another request");
+}
+function isDesktopBackedSessionForBusyRetry(session) {
+  if (session?.thread_origin !== "desktop") return false;
+  return Boolean(session.desktop_thread_id || session.sdk_session_id || session.codex_thread_id);
+}
+function getDesktopBusyRetryDelaysMs() {
+  const configured = process.env.CTI_DESKTOP_BUSY_RETRY_DELAYS_MS;
+  if (!configured?.trim()) return DEFAULT_DESKTOP_BUSY_RETRY_DELAYS_MS;
+  const delays = configured.split(",").map((part) => parseInt(part.trim(), 10)).filter((value) => Number.isFinite(value) && value >= 0);
+  return delays.length > 0 ? delays : DEFAULT_DESKTOP_BUSY_RETRY_DELAYS_MS;
+}
+function isRetryableDesktopBusyResult(result) {
+  return result.hasError && (result.errorCode === "session_busy" || isSessionBusyErrorMessage(result.errorMessage)) && !result.responseText.trim() && result.outboundAttachments.length === 0 && result.permissionRequests.length === 0;
+}
+function formatDesktopBusyRetryNote(attempt, maxAttempts, delayMs) {
+  const delaySeconds = Math.ceil(delayMs / 1e3);
+  const delayText = delaySeconds > 0 ? `${delaySeconds} \u79D2\u540E` : "\u9A6C\u4E0A";
+  return `Codex Desktop thread \u4ECD\u5728\u5904\u7406\u4E0A\u4E00\u8F6E\u8BF7\u6C42\uFF0C${delayText}\u91CD\u8BD5\uFF08${attempt}/${maxAttempts}\uFF09\u3002`;
+}
+function buildDesktopBusyExhaustedMessage(originalMessage) {
+  const detail = originalMessage?.trim();
+  return detail ? `Codex Desktop thread \u4ECD\u5728\u5904\u7406\u4E0A\u4E00\u8F6E\u8BF7\u6C42\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002\u539F\u59CB\u9519\u8BEF\uFF1A${detail}` : "Codex Desktop thread \u4ECD\u5728\u5904\u7406\u4E0A\u4E00\u8F6E\u8BF7\u6C42\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
+}
+function waitForRetryDelay(delayMs, signal) {
+  if (signal.aborted) return Promise.resolve(false);
+  if (delayMs <= 0) return Promise.resolve(true);
+  return new Promise((resolve2) => {
+    let timer = null;
+    const finish = (completed) => {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      signal.removeEventListener("abort", onAbort);
+      resolve2(completed);
+    };
+    const onAbort = () => finish(false);
+    timer = setTimeout(() => finish(true), delayMs);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
 function resolveReasoningEffort(store, session) {
   return normalizeReasoningEffort(
     session?.reasoning_effort || store.getSetting("bridge_codex_reasoning_effort")
@@ -14237,7 +14905,19 @@ ${attachmentSupplement}` : attachmentSupplement;
 async function processMessage(binding, text2, onPermissionRequest, abortSignal, files, onPartialText, onToolEvent, onTaskEvent, onStatusNote, onPromptPrepared) {
   const { store, llm } = getBridgeContext();
   const sessionId = binding.codepilotSessionId;
-  const lockId = crypto5.randomBytes(8).toString("hex");
+  const attachmentValidationError = validateInboundAttachmentSizes(files);
+  if (attachmentValidationError) {
+    return {
+      responseText: "",
+      outboundAttachments: [],
+      tokenUsage: null,
+      hasError: true,
+      errorMessage: attachmentValidationError,
+      permissionRequests: [],
+      sdkSessionId: null
+    };
+  }
+  const lockId = crypto8.randomBytes(8).toString("hex");
   const lockAcquired = store.acquireSessionLock(sessionId, lockId, `bridge-${binding.channelType}`, 600);
   if (!lockAcquired) {
     return {
@@ -14246,6 +14926,7 @@ async function processMessage(binding, text2, onPermissionRequest, abortSignal,
       tokenUsage: null,
       hasError: true,
       errorMessage: "Session is busy processing another request",
+      errorCode: "session_busy",
       permissionRequests: [],
       sdkSessionId: null
     };
@@ -14267,16 +14948,21 @@ async function processMessage(binding, text2, onPermissionRequest, abortSignal,
     let persistedFileMeta = [];
     if (files && files.length > 0) {
       if (workDir) {
+        const createdFilePaths = [];
         try {
           const uploadDir = path12.join(workDir, ".codepilot-uploads");
-          if (!fs8.existsSync(uploadDir)) {
-            fs8.mkdirSync(uploadDir, { recursive: true });
+          if (!fs9.existsSync(uploadDir)) {
+            fs9.mkdirSync(uploadDir, { recursive: true });
           }
           const fileMeta = files.map((f) => {
             const safeName = path12.basename(f.name).replace(/[^a-zA-Z0-9._-]/g, "_");
-            const filePath = path12.join(uploadDir, `${Date.now()}-${safeName}`);
+            const filePath = path12.join(uploadDir, `${crypto8.randomUUID()}-${safeName || "attachment.bin"}`);
             const buffer = Buffer.from(f.data, "base64");
-            fs8.writeFileSync(filePath, buffer);
+            if (buffer.length > MAX_INBOUND_ATTACHMENT_BYTES) {
+              throw new Error(`Attachment "${f.name}" exceeds the maximum size after decoding`);
+            }
+            fs9.writeFileSync(filePath, buffer);
+            createdFilePaths.push(filePath);
             return { id: f.id, name: f.name, type: f.type, size: buffer.length, filePath };
           });
           persistedFileMeta = fileMeta;
@@ -14286,6 +14972,12 @@ async function processMessage(binding, text2, onPermissionRequest, abortSignal,
           });
           savedContent = `<!--files:${JSON.stringify(fileMeta)}-->${text2}`;
         } catch (err) {
+          for (const filePath of createdFilePaths) {
+            try {
+              fs9.rmSync(filePath, { force: true });
+            } catch {
+            }
+          }
           console.warn("[conversation-engine] Failed to persist file attachments:", err instanceof Error ? err.message : err);
           savedContent = `[${files.length} attachment(s) attached] ${text2}`;
         }
@@ -14331,37 +15023,65 @@ async function processMessage(binding, text2, onPermissionRequest, abortSignal,
         abortSignal.addEventListener("abort", () => abortController.abort(), { once: true });
       }
     }
-    const stream = llm.streamChat({
-      prompt: promptText,
-      sessionId,
-      sdkSessionId: binding.sdkSessionId || void 0,
-      model: effectiveModel,
-      forceModel: !binding.sdkSessionId && Boolean(effectiveModel),
-      sandboxMode,
-      modelReasoningEffort,
-      systemPrompt: session?.system_prompt || void 0,
-      workingDirectory: workDir || void 0,
-      abortController,
-      permissionMode,
-      provider: resolvedProvider,
-      conversationHistory: historyMsgs,
-      files: llmFiles,
-      onRuntimeStatusChange: (status) => {
-        try {
-          store.setSessionRuntimeStatus(sessionId, status);
-        } catch {
+    const desktopBusyRetryDelaysMs = isDesktopBackedSessionForBusyRetry(session) ? getDesktopBusyRetryDelaysMs() : [];
+    let desktopBusyRetryCount = 0;
+    while (true) {
+      const stream = llm.streamChat({
+        prompt: promptText,
+        sessionId,
+        sdkSessionId: binding.sdkSessionId || void 0,
+        model: effectiveModel,
+        forceModel: !binding.sdkSessionId && Boolean(effectiveModel),
+        sandboxMode,
+        modelReasoningEffort,
+        systemPrompt: session?.system_prompt || void 0,
+        workingDirectory: workDir || void 0,
+        abortController,
+        permissionMode,
+        provider: resolvedProvider,
+        conversationHistory: historyMsgs,
+        files: llmFiles,
+        onRuntimeStatusChange: (status) => {
+          try {
+            store.setSessionRuntimeStatus(sessionId, status);
+          } catch {
+          }
         }
+      });
+      const result = await consumeStream(
+        stream,
+        sessionId,
+        onPermissionRequest,
+        onPartialText,
+        onToolEvent,
+        onTaskEvent,
+        onStatusNote
+      );
+      if (!isRetryableDesktopBusyResult(result) || desktopBusyRetryDelaysMs.length === 0) {
+        return result;
       }
-    });
-    return await consumeStream(
-      stream,
-      sessionId,
-      onPermissionRequest,
-      onPartialText,
-      onToolEvent,
-      onTaskEvent,
-      onStatusNote
-    );
+      if (desktopBusyRetryCount >= desktopBusyRetryDelaysMs.length) {
+        return {
+          ...result,
+          errorMessage: buildDesktopBusyExhaustedMessage(result.errorMessage)
+        };
+      }
+      const delayMs = desktopBusyRetryDelaysMs[desktopBusyRetryCount];
+      desktopBusyRetryCount += 1;
+      onStatusNote?.(formatDesktopBusyRetryNote(
+        desktopBusyRetryCount,
+        desktopBusyRetryDelaysMs.length,
+        delayMs
+      ));
+      const shouldRetry2 = await waitForRetryDelay(delayMs, abortController.signal);
+      if (!shouldRetry2) {
+        return {
+          ...result,
+          errorMessage: "Task stopped by user",
+          errorCode: void 0
+        };
+      }
+    }
   } finally {
     clearInterval(renewalInterval);
     store.releaseSessionLock(sessionId, lockId);
@@ -14376,10 +15096,36 @@ async function consumeStream(stream, sessionId, onPermissionRequest, onPartialTe
   let tokenUsage = null;
   let hasError = false;
   let errorMessage = "";
+  let errorCode;
   const seenToolResultIds = /* @__PURE__ */ new Set();
   const permissionRequests = [];
   let capturedSdkSessionId = null;
-  const outboundAttachments = [];
+  const finalizeConsumedContent = () => {
+    if (currentText.trim()) {
+      contentBlocks.push({ type: "text", text: currentText });
+      currentText = "";
+    }
+    const outboundAttachments = [];
+    for (const block2 of contentBlocks) {
+      if (block2.type !== "text") continue;
+      const parsed = collectFinalResponseArtifacts(block2.text);
+      block2.text = parsed.text;
+      outboundAttachments.push(...parsed.attachments);
+    }
+    if (contentBlocks.length > 0) {
+      const hasToolBlocks = contentBlocks.some(
+        (block2) => block2.type === "tool_use" || block2.type === "tool_result"
+      );
+      const content = hasToolBlocks ? JSON.stringify(contentBlocks) : contentBlocks.filter((block2) => block2.type === "text").map((block2) => block2.text).join("\n\n").trim();
+      if (content) {
+        store.addMessage(sessionId, "assistant", content, tokenUsage ? JSON.stringify(tokenUsage) : null);
+      }
+    }
+    return {
+      responseText: contentBlocks.filter((block2) => block2.type === "text").map((block2) => block2.text).join("").trim(),
+      outboundAttachments: dedupeOutboundAttachments(outboundAttachments)
+    };
+  };
   try {
     await consumeSseEvents(stream, async (event) => {
       switch (event.type) {
@@ -14507,6 +15253,9 @@ async function consumeStream(stream, sessionId, onPermissionRequest, onPartialTe
         case "error":
           hasError = true;
           errorMessage = event.data || "Unknown error";
+          if (isSessionBusyErrorMessage(errorMessage)) {
+            errorCode = "session_busy";
+          }
           break;
         case "result": {
           try {
@@ -14523,54 +15272,28 @@ async function consumeStream(stream, sessionId, onPermissionRequest, onPartialTe
         }
       }
     });
-    if (currentText.trim()) {
-      contentBlocks.push({ type: "text", text: currentText });
-    }
-    if (contentBlocks.length > 0) {
-      for (const block2 of contentBlocks) {
-        if (block2.type !== "text") continue;
-        const parsed = collectFinalResponseArtifacts(block2.text);
-        block2.text = parsed.text;
-        outboundAttachments.push(...parsed.attachments);
-      }
-      const hasToolBlocks = contentBlocks.some(
-        (b) => b.type === "tool_use" || b.type === "tool_result"
-      );
-      const content = hasToolBlocks ? JSON.stringify(contentBlocks) : contentBlocks.filter((b) => b.type === "text").map((b) => b.text).join("\n\n").trim();
-      if (content) {
-        store.addMessage(sessionId, "assistant", content, tokenUsage ? JSON.stringify(tokenUsage) : null);
-      }
-    }
-    const responseText = contentBlocks.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
+    const finalizedContent = finalizeConsumedContent();
     return {
-      responseText,
-      outboundAttachments: dedupeOutboundAttachments(outboundAttachments),
-      tokenUsage,
-      hasError,
-      errorMessage,
-      permissionRequests,
-      sdkSessionId: capturedSdkSessionId
-    };
-  } catch (e) {
-    if (currentText.trim()) {
-      contentBlocks.push({ type: "text", text: currentText });
-    }
-    if (contentBlocks.length > 0) {
-      const hasToolBlocks = contentBlocks.some(
-        (b) => b.type === "tool_use" || b.type === "tool_result"
-      );
-      const content = hasToolBlocks ? JSON.stringify(contentBlocks) : contentBlocks.filter((b) => b.type === "text").map((b) => b.text).join("\n\n").trim();
-      if (content) {
-        store.addMessage(sessionId, "assistant", content);
-      }
-    }
+      responseText: finalizedContent.responseText,
+      outboundAttachments: finalizedContent.outboundAttachments,
+      tokenUsage,
+      hasError,
+      errorMessage,
+      errorCode,
+      permissionRequests,
+      sdkSessionId: capturedSdkSessionId
+    };
+  } catch (e) {
+    const finalizedContent = finalizeConsumedContent();
     const isAbort = e instanceof DOMException && e.name === "AbortError" || e instanceof Error && e.name === "AbortError";
+    const fallbackErrorMessage = isAbort ? "Task stopped by user" : e instanceof Error ? e.message : "Stream consumption error";
     return {
-      responseText: "",
-      outboundAttachments: [],
+      responseText: finalizedContent.responseText,
+      outboundAttachments: finalizedContent.outboundAttachments,
       tokenUsage,
       hasError: true,
-      errorMessage: isAbort ? "Task stopped by user" : e instanceof Error ? e.message : "Stream consumption error",
+      errorMessage: fallbackErrorMessage,
+      errorCode: isSessionBusyErrorMessage(fallbackErrorMessage) ? "session_busy" : void 0,
       permissionRequests,
       sdkSessionId: capturedSdkSessionId
     };
@@ -15206,8 +15929,28 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
   }
   let finalOutcome = "failed";
   let finalOutcomeDetail;
+  let finalDeliveryError;
   let shouldRecordHealthEnd = true;
   let forceStopStarted = false;
+  const deliverFinalPayload = async (response, options) => {
+    try {
+      const result = await deliverFinalResponse({
+        adapter,
+        address: msg.address,
+        sessionId: binding.codepilotSessionId,
+        replyToMessageId: msg.messageId,
+        deliverResponse: deps.deliverResponse
+      }, response, options);
+      if (result.ok) return true;
+      finalDeliveryError = `\u6700\u7EC8\u56DE\u590D\u6295\u9012\u5931\u8D25\uFF1A${result.error || "\u672A\u77E5\u9519\u8BEF"}`;
+    } catch (error) {
+      finalDeliveryError = `\u6700\u7EC8\u56DE\u590D\u6295\u9012\u5F02\u5E38\uFF1A${error instanceof Error ? error.message : String(error)}`;
+    }
+    console.error(`[interactive-message-runner] ${finalDeliveryError}`);
+    finalOutcome = "failed";
+    finalOutcomeDetail = finalDeliveryError;
+    return false;
+  };
   taskState.forceStop = async (detail = "\u4EFB\u52A1\u5DF2\u6536\u5230\u505C\u6B62\u8BF7\u6C42\u3002") => {
     if (forceStopStarted) return true;
     forceStopStarted = true;
@@ -15295,13 +16038,7 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
       });
       const cardFinalized2 = await finalizeStreamUiOnce(streamEndStatus, terminalResponse2.text);
       if (hasFinalResponsePayload(terminalResponse2)) {
-        await deliverFinalResponse({
-          adapter,
-          address: msg.address,
-          sessionId: binding.codepilotSessionId,
-          replyToMessageId: msg.messageId,
-          deliverResponse: deps.deliverResponse
-        }, terminalResponse2, { skipText: cardFinalized2 });
+        await deliverFinalPayload(terminalResponse2, { skipText: cardFinalized2 });
       }
       return;
     }
@@ -15334,30 +16071,11 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
       );
     }
     if (staleResponse) {
-      await deliverFinalResponse({
-        adapter,
-        address: msg.address,
-        sessionId: binding.codepilotSessionId,
-        replyToMessageId: msg.messageId,
-        deliverResponse: deps.deliverResponse
-      }, staleResponse, { skipText: cardFinalized });
+      await deliverFinalPayload(staleResponse, { skipText: cardFinalized });
     } else if (hasFinalResponsePayload(effectiveResponse)) {
-      await deliverFinalResponse({
-        adapter,
-        address: msg.address,
-        sessionId: binding.codepilotSessionId,
-        replyToMessageId: msg.messageId,
-        deliverResponse: deps.deliverResponse
-      }, effectiveResponse, { skipText: cardFinalized });
+      await deliverFinalPayload(effectiveResponse, { skipText: cardFinalized });
     } else if (result.hasError && !taskAbort.signal.aborted) {
-      await deliverFinalResponse(
-        {
-          adapter,
-          address: msg.address,
-          sessionId: binding.codepilotSessionId,
-          replyToMessageId: msg.messageId,
-          deliverResponse: deps.deliverResponse
-        },
+      await deliverFinalPayload(
         assembleSdkFinalResponse({
           text: `**Error:** ${result.errorMessage}`,
           hasError: true,
@@ -15369,8 +16087,10 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
       deps.persistSdkSessionUpdate(binding.codepilotSessionId, result.sdkSessionId, result.hasError);
     } catch {
     }
-    finalOutcome = terminalAfterProcess?.outcome || (result.hasError ? "failed" : "completed");
-    finalOutcomeDetail = terminalAfterProcess?.detail || (result.hasError ? result.errorMessage?.trim() || void 0 : void 0);
+    if (!finalDeliveryError) {
+      finalOutcome = terminalAfterProcess?.outcome || (result.hasError ? "failed" : "completed");
+      finalOutcomeDetail = terminalAfterProcess?.detail || (result.hasError ? result.errorMessage?.trim() || void 0 : void 0);
+    }
   } finally {
     await finalizeStreamUiOnce(
       taskAbort.signal.aborted ? "interrupted" : finalOutcome === "completed" ? "completed" : "error",
@@ -15567,7 +16287,7 @@ function createInteractiveRuntime(getState2, deps) {
 }
 
 // src/lib/bridge/mirror-runtime.ts
-import fs10 from "node:fs";
+import fs11 from "node:fs";
 
 // src/lib/bridge/mirror-subscription-state.ts
 function resetMirrorReadState(subscription) {
@@ -15588,7 +16308,7 @@ function createMirrorSubscription(input) {
     chatId: input.chatId,
     threadId: input.threadId,
     filePath: input.filePath,
-    cursor: { initialized: false, lastEventCount: 0 },
+    cursor: input.lastDeliveredAt ? { initialized: true, lastEventTimestamp: input.lastDeliveredAt, lastEventCount: 0 } : { initialized: false, lastEventCount: 0 },
     dirty: true,
     status: input.filePath ? "watching" : "stale",
     watcher: null,
@@ -15612,7 +16332,7 @@ function createMirrorSubscription(input) {
   };
 }
 function resetMirrorSubscriptionForThreadChange(subscription, lastDeliveredAt) {
-  subscription.cursor = { initialized: false, lastEventCount: 0 };
+  subscription.cursor = lastDeliveredAt ? { initialized: true, lastEventTimestamp: lastDeliveredAt, lastEventCount: 0 } : { initialized: false, lastEventCount: 0 };
   subscription.lastDeliveredAt = lastDeliveredAt;
   subscription.dirty = true;
   subscription.pendingTurn = null;
@@ -15669,7 +16389,7 @@ function recordMirrorSubscriptionFailure(subscription, suspendThreshold, suspend
 }
 
 // src/lib/bridge/mirror-reconcile-core.ts
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 
 // src/desktop-session-mirror.ts
 function makeCursor(records) {
@@ -15760,7 +16480,7 @@ function reconcileDesktopMirrorCursor(cursor, records) {
   if (cursor.lastEventCount === 0) {
     return {
       nextCursor,
-      deliverableRecords: records,
+      deliverableRecords: cursor.lastEventTimestamp ? collectEventsAfterTimestamp(records, cursor.lastEventTimestamp) : records,
       reset: false
     };
   }
@@ -15782,7 +16502,7 @@ function reconcileDesktopMirrorCursor(cursor, records) {
 // src/lib/bridge/mirror-reconcile-core.ts
 function statMirrorFile(filePath) {
   try {
-    const stat = fs9.statSync(filePath);
+    const stat = fs10.statSync(filePath);
     if (!stat.isFile()) return null;
     return {
       size: stat.size,
@@ -15810,12 +16530,43 @@ function markMirrorSnapshotMissing(subscription) {
   resetMirrorReadState(subscription);
 }
 function isMirrorSnapshotUnchanged(subscription, snapshot) {
-  return !subscription.dirty && subscription.fileIdentity === snapshot.identity && subscription.fileSize === snapshot.size && subscription.fileMtimeMs === snapshot.mtimeMs;
+  return !subscription.dirty && subscription.fileIdentity === snapshot.identity && subscription.fileOffset === snapshot.size && !subscription.trailingText && subscription.fileSize === snapshot.size && subscription.fileMtimeMs === snapshot.mtimeMs;
+}
+function findLastCompleteLineOffset(filePath, fileSize) {
+  if (fileSize <= 0) return 0;
+  const fd = fs10.openSync(filePath, "r");
+  try {
+    const chunkSize = 64 * 1024;
+    let end = fileSize;
+    while (end > 0) {
+      const start2 = Math.max(0, end - chunkSize);
+      const buffer = Buffer.alloc(end - start2);
+      const bytesRead = fs10.readSync(fd, buffer, 0, buffer.length, start2);
+      const newlineIndex = buffer.subarray(0, bytesRead).lastIndexOf(10);
+      if (newlineIndex >= 0) return start2 + newlineIndex + 1;
+      end = start2;
+    }
+    return 0;
+  } finally {
+    fs10.closeSync(fd);
+  }
 }
 function readMirrorDeliverableRecords(subscription, snapshot) {
   let deliverableRecords = [];
   let unknownKinds = [];
   const requiresFullRecover = !subscription.cursor.initialized || subscription.fileOffset === 0 || subscription.fileIdentity !== null && subscription.fileIdentity !== snapshot.identity || subscription.fileSize !== null && snapshot.size < subscription.fileOffset || subscription.fileSize !== null && snapshot.size === subscription.fileOffset && subscription.fileMtimeMs !== null && snapshot.mtimeMs !== subscription.fileMtimeMs;
+  if (requiresFullRecover && !subscription.cursor.initialized && !subscription.lastDeliveredAt) {
+    subscription.cursor = { initialized: true, lastEventCount: 0 };
+    subscription.trailingText = "";
+    subscription.fileOffset = findLastCompleteLineOffset(subscription.filePath, snapshot.size);
+    subscription.activeMirrorTurnId = null;
+    subscription.activeSpecialCallIds.clear();
+    subscription.fileSize = snapshot.size;
+    subscription.fileMtimeMs = snapshot.mtimeMs;
+    subscription.fileIdentity = snapshot.identity;
+    subscription.dirty = false;
+    return { records: [], unknownKinds: [] };
+  }
   if (requiresFullRecover) {
     const previousCursor = subscription.cursor;
     const fullDelta = readDesktopSessionMirrorRecordDeltaByFilePath(
@@ -15829,8 +16580,8 @@ function readMirrorDeliverableRecords(subscription, snapshot) {
     const delta = reconcileDesktopMirrorCursor(subscription.cursor, fullDelta.records);
     subscription.cursor = delta.nextCursor;
     deliverableRecords = filterDuplicateAssistantEvents(previousCursor, delta.deliverableRecords);
-    subscription.trailingText = "";
-    subscription.fileOffset = snapshot.size;
+    subscription.trailingText = fullDelta.trailingText;
+    subscription.fileOffset = fullDelta.nextOffset;
     subscription.activeMirrorTurnId = fullDelta.nextTurnId;
     subscription.activeSpecialCallIds = new Set(fullDelta.nextSpecialCallIds);
     unknownKinds = fullDelta.unknownKinds;
@@ -15939,6 +16690,44 @@ async function runMirrorReconcileBatch(deps) {
 
 // src/lib/bridge/mirror-runtime.ts
 function createMirrorRuntime(getState2, options, deps) {
+  function isAtOrBefore(timestamp, boundary) {
+    if (!timestamp) return true;
+    const timestampMs = Date.parse(timestamp);
+    const boundaryMs = Date.parse(boundary);
+    if (Number.isFinite(timestampMs) && Number.isFinite(boundaryMs)) {
+      return timestampMs <= boundaryMs;
+    }
+    return timestamp <= boundary;
+  }
+  function discardClaimedMirrorTurn(subscription, routeResult) {
+    if (!routeResult.terminalClaimed) return;
+    const claimedTurnId = routeResult.claimedTurnId;
+    if (claimedTurnId) {
+      const claimedStreamKey = buildMirrorStreamKey(subscription.sessionId, claimedTurnId, "");
+      subscription.bufferedRecords = subscription.bufferedRecords.filter(
+        (record) => record.turnId !== claimedTurnId
+      );
+      subscription.pendingDeliveries = subscription.pendingDeliveries.filter(
+        (turn) => turn.streamKey !== claimedStreamKey
+      );
+      if (subscription.pendingTurn?.turnId === claimedTurnId) {
+        deps.stopMirrorStreaming(subscription, "interrupted");
+        subscription.pendingTurn = null;
+      }
+    }
+    const claimedAt = routeResult.claimedAt;
+    if (!claimedAt) return;
+    const retainedAtOrBeforeClaim = [
+      ...subscription.bufferedRecords.map((record) => record.timestamp),
+      ...subscription.pendingDeliveries.map((turn) => turn.timestamp),
+      ...routeResult.unclaimed.map((record) => record.timestamp),
+      ...subscription.pendingTurn ? [subscription.pendingTurn.lastActivityAt] : []
+    ].some((timestamp) => isAtOrBefore(timestamp, claimedAt));
+    if (retainedAtOrBeforeClaim) return;
+    if (!subscription.lastDeliveredAt || !isAtOrBefore(claimedAt, subscription.lastDeliveredAt)) {
+      subscription.lastDeliveredAt = claimedAt;
+    }
+  }
   function closeMirrorWatcher(subscription) {
     if (subscription.watcher) {
       try {
@@ -15970,7 +16759,7 @@ function createMirrorRuntime(getState2, options, deps) {
     }
     closeMirrorWatcher(subscription);
     try {
-      subscription.watcher = fs10.watch(filePath, () => {
+      subscription.watcher = fs11.watch(filePath, () => {
         subscription.dirty = true;
         scheduleMirrorWake();
       });
@@ -16126,7 +16915,14 @@ function createMirrorRuntime(getState2, options, deps) {
         `[bridge-manager] Unhandled desktop mirror event for thread ${subscription.threadId}: ${kind}`
       );
     }
-    const routeResult = deliverableRecords.length > 0 && deps.routeDesktopRecords ? await deps.routeDesktopRecords(subscription.sessionId, subscription.threadId, deliverableRecords) : { claimed: [], unclaimed: deliverableRecords, terminalClaimed: false };
+    const routeResult = deliverableRecords.length > 0 && deps.routeDesktopRecords ? await deps.routeDesktopRecords(subscription.sessionId, subscription.threadId, deliverableRecords) : {
+      claimed: [],
+      unclaimed: deliverableRecords,
+      terminalClaimed: false,
+      claimedTurnId: null,
+      claimedAt: null
+    };
+    discardClaimedMirrorTurn(subscription, routeResult);
     const mirrorRecords = routeResult.unclaimed;
     if (mirrorRecords.length > 0) {
       deps.observeSessionHealthRecords(subscription.sessionId, subscription.threadId, mirrorRecords);
@@ -16371,7 +17167,9 @@ function createMirrorFeedbackController(deps) {
   }
   async function deliverMirrorTurn(subscription, turn) {
     const adapter = deps.getAdapter(subscription.channelType);
-    if (!adapter || !adapter.isRunning()) return;
+    if (!adapter || !adapter.isRunning()) {
+      throw new Error(`mirror adapter unavailable: ${subscription.channelType}`);
+    }
     const title = deps.getThreadTitle(subscription.threadId)?.trim() || "\u684C\u9762\u7EBF\u7A0B";
     const responseParseMode = getFeedbackParseMode(subscription.channelType);
     const markdown = responseParseMode === "Markdown";
@@ -17190,7 +17988,9 @@ async function routeDesktopRecords(sessionId, desktopThreadId, records, coordina
     return {
       claimed: [],
       unclaimed: records,
-      terminalClaimed: false
+      terminalClaimed: false,
+      claimedTurnId: null,
+      claimedAt: null
     };
   }
   const claim = await coordinator.claimDesktopTerminal(
@@ -17200,7 +18000,9 @@ async function routeDesktopRecords(sessionId, desktopThreadId, records, coordina
     return {
       claimed: [],
       unclaimed: records,
-      terminalClaimed: false
+      terminalClaimed: false,
+      claimedTurnId: null,
+      claimedAt: null
     };
   }
   const claimedTurnId = terminalRecord.turnId;
@@ -17209,7 +18011,9 @@ async function routeDesktopRecords(sessionId, desktopThreadId, records, coordina
   return {
     claimed,
     unclaimed: records.filter((record) => !claimedSet.has(record.signature)),
-    terminalClaimed: true
+    terminalClaimed: true,
+    claimedTurnId: claimedTurnId || null,
+    claimedAt: terminalRecord.timestamp || null
   };
 }
 
@@ -17660,10 +18464,26 @@ async function handleMessage(adapter, msg) {
   const meta = adapterState.adapterMeta.get(adapter.channelType) || { lastMessageAt: null, lastError: null, configFingerprint: "" };
   meta.lastMessageAt = (/* @__PURE__ */ new Date()).toISOString();
   adapterState.adapterMeta.set(adapter.channelType, meta);
+  let updateSettled = false;
+  const reject = () => {
+    if (updateSettled) return;
+    updateSettled = true;
+    if (msg.updateId != null) {
+      adapter.rejectUpdate?.(msg.updateId, msg.messageId);
+    }
+  };
   const ack = () => {
-    if (msg.updateId != null && adapter.acknowledgeUpdate) {
-      adapter.acknowledgeUpdate(msg.updateId);
+    if (updateSettled) return;
+    if (msg.updateId != null) {
+      try {
+        store.insertDedup(buildInboundDedupKey(adapter.channelType, msg.messageId));
+      } catch (error) {
+        reject();
+        throw error;
+      }
+      adapter.acknowledgeUpdate?.(msg.updateId, msg.messageId);
     }
+    updateSettled = true;
   };
   if (msg.callbackData) {
     const handled = handlePermissionCallback(msg.callbackData, msg.address.chatId, msg.callbackMessageId);
@@ -17761,34 +18581,31 @@ async function handleMessage(adapter, msg) {
     ack();
     return;
   }
-  try {
-    await runInteractiveMessage(adapter, msg, text2, hasAttachments ? msg.attachments : void 0, {
-      registerInteractiveTask: (task) => INTERACTIVE_RUNTIME.registerInteractiveTask(task),
-      registerBridgeTurn: (turn) => TURN_COORDINATOR.registerInteractiveTurn(turn),
-      resetMirrorSessionForInteractiveRun,
-      isCurrentInteractiveTask: (sessionId, taskId) => INTERACTIVE_RUNTIME.isCurrentInteractiveTask(sessionId, taskId),
-      touchInteractiveTask: (sessionId, taskId) => INTERACTIVE_RUNTIME.touchInteractiveTask(sessionId, taskId),
-      recordInteractiveHealthStart: (sessionId, detail) => SESSION_HEALTH_RUNTIME.recordInteractiveStart(sessionId, detail),
-      recordInteractiveHealthProgress: (sessionId, type, detail) => SESSION_HEALTH_RUNTIME.recordInteractiveProgress(sessionId, type, detail),
-      recordInteractiveHealthTool: (sessionId, toolId, toolName, status) => {
-        SESSION_HEALTH_RUNTIME.recordToolState(sessionId, toolId, toolName, status);
-      },
-      recordInteractiveStreamUiSnapshot: (sessionId, snapshot) => {
-        SESSION_HEALTH_RUNTIME.recordStructuredStreamUi(sessionId, snapshot);
-      },
-      recordInteractiveHealthEnd: (sessionId, outcome, detail) => SESSION_HEALTH_RUNTIME.recordInteractiveEnd(sessionId, outcome, detail),
-      beginMirrorSuppression: beginMirrorSuppression2,
-      abortMirrorSuppression: abortMirrorSuppression2,
-      settleMirrorSuppression: settleMirrorSuppression2,
-      releaseInteractiveTask: (sessionId, taskId) => INTERACTIVE_RUNTIME.releaseInteractiveTask(sessionId, taskId),
-      releaseBridgeTurn: (sessionId, taskId) => TURN_COORDINATOR.releaseSessionTurn(sessionId, taskId),
-      deliverResponse,
-      persistSdkSessionUpdate,
-      desktopTerminalFinalizationTimeoutMs: DESKTOP_TERMINAL_FINALIZATION_TIMEOUT_MS
-    });
-  } finally {
-    ack();
-  }
+  await runInteractiveMessage(adapter, msg, text2, hasAttachments ? msg.attachments : void 0, {
+    registerInteractiveTask: (task) => INTERACTIVE_RUNTIME.registerInteractiveTask(task),
+    registerBridgeTurn: (turn) => TURN_COORDINATOR.registerInteractiveTurn(turn),
+    resetMirrorSessionForInteractiveRun,
+    isCurrentInteractiveTask: (sessionId, taskId) => INTERACTIVE_RUNTIME.isCurrentInteractiveTask(sessionId, taskId),
+    touchInteractiveTask: (sessionId, taskId) => INTERACTIVE_RUNTIME.touchInteractiveTask(sessionId, taskId),
+    recordInteractiveHealthStart: (sessionId, detail) => SESSION_HEALTH_RUNTIME.recordInteractiveStart(sessionId, detail),
+    recordInteractiveHealthProgress: (sessionId, type, detail) => SESSION_HEALTH_RUNTIME.recordInteractiveProgress(sessionId, type, detail),
+    recordInteractiveHealthTool: (sessionId, toolId, toolName, status) => {
+      SESSION_HEALTH_RUNTIME.recordToolState(sessionId, toolId, toolName, status);
+    },
+    recordInteractiveStreamUiSnapshot: (sessionId, snapshot) => {
+      SESSION_HEALTH_RUNTIME.recordStructuredStreamUi(sessionId, snapshot);
+    },
+    recordInteractiveHealthEnd: (sessionId, outcome, detail) => SESSION_HEALTH_RUNTIME.recordInteractiveEnd(sessionId, outcome, detail),
+    beginMirrorSuppression: beginMirrorSuppression2,
+    abortMirrorSuppression: abortMirrorSuppression2,
+    settleMirrorSuppression: settleMirrorSuppression2,
+    releaseInteractiveTask: (sessionId, taskId) => INTERACTIVE_RUNTIME.releaseInteractiveTask(sessionId, taskId),
+    releaseBridgeTurn: (sessionId, taskId) => TURN_COORDINATOR.releaseSessionTurn(sessionId, taskId),
+    deliverResponse,
+    persistSdkSessionUpdate,
+    desktopTerminalFinalizationTimeoutMs: DESKTOP_TERMINAL_FINALIZATION_TIMEOUT_MS
+  });
+  ack();
 }
 async function handleCommand(adapter, msg, text2) {
   await handleBridgeCommand(adapter, msg, text2, {
@@ -17826,32 +18643,87 @@ function persistSdkSessionUpdate(sessionId, sdkSessionId, hasError) {
 }
 
 // src/store.ts
-import fs11 from "node:fs";
+import fs13 from "node:fs";
+import path15 from "node:path";
+import crypto10 from "node:crypto";
+
+// src/atomic-file.ts
+import crypto9 from "node:crypto";
+import fs12 from "node:fs";
 import path14 from "node:path";
-import crypto6 from "node:crypto";
-var DATA_DIR2 = path14.join(CTI_HOME, "data");
-var MESSAGES_DIR = path14.join(DATA_DIR2, "messages");
+var RETRYABLE_RENAME_CODES = /* @__PURE__ */ new Set(["EACCES", "EBUSY", "EPERM"]);
+var WAIT_ARRAY2 = new Int32Array(new SharedArrayBuffer(4));
+function defaultSleepSync(delayMs) {
+  Atomics.wait(WAIT_ARRAY2, 0, 0, Math.max(1, delayMs));
+}
+function isRetryableRenameError(error) {
+  return RETRYABLE_RENAME_CODES.has(error?.code || "");
+}
+function renameFileWithRetrySync(source, destination, options = {}) {
+  const maxAttempts = Math.max(1, options.maxAttempts ?? 8);
+  const baseDelayMs = Math.max(1, options.baseDelayMs ?? 15);
+  const renameSync = options.renameSync ?? fs12.renameSync;
+  const sleepSync2 = options.sleepSync ?? defaultSleepSync;
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    try {
+      renameSync(source, destination);
+      return;
+    } catch (error) {
+      if (!isRetryableRenameError(error) || attempt === maxAttempts - 1) {
+        throw error;
+      }
+      sleepSync2(Math.min(250, baseDelayMs * 2 ** attempt));
+    }
+  }
+}
+function atomicWriteFileSync(filePath, data) {
+  fs12.mkdirSync(path14.dirname(filePath), { recursive: true });
+  const tmpPath = `${filePath}.${process.pid}.${crypto9.randomUUID()}.tmp`;
+  try {
+    fs12.writeFileSync(tmpPath, data, "utf-8");
+    renameFileWithRetrySync(tmpPath, filePath);
+  } finally {
+    try {
+      fs12.rmSync(tmpPath, { force: true });
+    } catch {
+    }
+  }
+}
+
+// src/store.ts
+var DATA_DIR2 = path15.join(CTI_HOME, "data");
+var MESSAGES_DIR = path15.join(DATA_DIR2, "messages");
+var SESSIONS_PATH = path15.join(DATA_DIR2, "sessions.json");
+var BINDINGS_PATH = path15.join(DATA_DIR2, "bindings.json");
+var PERMISSIONS_PATH = path15.join(DATA_DIR2, "permissions.json");
+var OFFSETS_PATH = path15.join(DATA_DIR2, "offsets.json");
+var DEDUP_PATH = path15.join(DATA_DIR2, "dedup.json");
+var AUDIT_PATH = path15.join(DATA_DIR2, "audit.json");
+var DEFAULT_DEDUP_TTL_MS = 5 * 60 * 1e3;
+var INBOUND_DEDUP_TTL_MS = 24 * 60 * 60 * 1e3;
 function ensureDir2(dir) {
-  fs11.mkdirSync(dir, { recursive: true });
+  fs13.mkdirSync(dir, { recursive: true });
 }
 function atomicWrite2(filePath, data) {
-  const tmp = filePath + ".tmp";
-  fs11.writeFileSync(tmp, data, "utf-8");
-  fs11.renameSync(tmp, filePath);
+  atomicWriteFileSync(filePath, data);
+}
+function dedupTtlMs(key) {
+  return key.startsWith("inbound:") ? INBOUND_DEDUP_TTL_MS : DEFAULT_DEDUP_TTL_MS;
 }
 function readJson2(filePath, fallback) {
   try {
-    const raw = fs11.readFileSync(filePath, "utf-8");
+    const raw = fs13.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
-  } catch {
-    return fallback;
+  } catch (error) {
+    if (error.code === "ENOENT") return fallback;
+    throw new Error(`\u65E0\u6CD5\u8BFB\u53D6 JSON \u6570\u636E\u6587\u4EF6 ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
 function writeJson(filePath, data) {
   atomicWrite2(filePath, JSON.stringify(data, null, 2));
 }
 function uuid() {
-  return crypto6.randomUUID();
+  return crypto10.randomUUID();
 }
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -17910,38 +18782,38 @@ var JsonFileStore = class {
     this.reloadSessions();
     this.reloadBindings();
     const perms = readJson2(
-      path14.join(DATA_DIR2, "permissions.json"),
+      PERMISSIONS_PATH,
       {}
     );
     for (const [id, p] of Object.entries(perms)) {
       this.permissionLinks.set(id, p);
     }
     const offsets = readJson2(
-      path14.join(DATA_DIR2, "offsets.json"),
+      OFFSETS_PATH,
       {}
     );
     for (const [k, v] of Object.entries(offsets)) {
       this.offsets.set(k, v);
     }
     const dedup = readJson2(
-      path14.join(DATA_DIR2, "dedup.json"),
+      DEDUP_PATH,
       {}
     );
     for (const [k, v] of Object.entries(dedup)) {
       this.dedupKeys.set(k, v);
     }
-    this.auditLog = readJson2(path14.join(DATA_DIR2, "audit.json"), []);
+    this.auditLog = readJson2(AUDIT_PATH, []);
   }
   reloadSessions() {
     const sessions = readJson2(
-      path14.join(DATA_DIR2, "sessions.json"),
+      SESSIONS_PATH,
       {}
     );
     this.sessions = new Map(Object.entries(sessions));
   }
   reloadBindings() {
     const bindings = readJson2(
-      path14.join(DATA_DIR2, "bindings.json"),
+      BINDINGS_PATH,
       {}
     );
     const normalized = /* @__PURE__ */ new Map();
@@ -17955,57 +18827,104 @@ var JsonFileStore = class {
     }
     this.bindings = normalized;
     if (changed) {
-      this.persistBindings();
+      withFileLock(BINDINGS_PATH, () => {
+        const latest = readJson2(BINDINGS_PATH, {});
+        this.bindings = new Map(Object.values(latest).map((binding) => {
+          const upgraded = upgradeLegacyBinding(binding);
+          return [`${upgraded.channelType}:${upgraded.chatId}`, upgraded];
+        }));
+        this.persistBindings();
+      });
     }
   }
+  reloadPermissions() {
+    this.permissionLinks = new Map(Object.entries(
+      readJson2(PERMISSIONS_PATH, {})
+    ));
+  }
+  reloadOffsets() {
+    this.offsets = new Map(Object.entries(readJson2(OFFSETS_PATH, {})));
+  }
+  reloadDedup() {
+    this.dedupKeys = new Map(Object.entries(readJson2(DEDUP_PATH, {})));
+  }
+  reloadAudit() {
+    this.auditLog = readJson2(AUDIT_PATH, []);
+  }
   persistSessions() {
     writeJson(
-      path14.join(DATA_DIR2, "sessions.json"),
+      SESSIONS_PATH,
       Object.fromEntries(this.sessions)
     );
   }
   persistBindings() {
     writeJson(
-      path14.join(DATA_DIR2, "bindings.json"),
+      BINDINGS_PATH,
       Object.fromEntries(this.bindings)
     );
   }
   persistPermissions() {
     writeJson(
-      path14.join(DATA_DIR2, "permissions.json"),
+      PERMISSIONS_PATH,
       Object.fromEntries(this.permissionLinks)
     );
   }
   persistOffsets() {
     writeJson(
-      path14.join(DATA_DIR2, "offsets.json"),
+      OFFSETS_PATH,
       Object.fromEntries(this.offsets)
     );
   }
   persistDedup() {
     writeJson(
-      path14.join(DATA_DIR2, "dedup.json"),
+      DEDUP_PATH,
       Object.fromEntries(this.dedupKeys)
     );
   }
   persistAudit() {
-    writeJson(path14.join(DATA_DIR2, "audit.json"), this.auditLog);
+    writeJson(AUDIT_PATH, this.auditLog);
   }
   persistMessages(sessionId) {
     const msgs = this.messages.get(sessionId) || [];
-    writeJson(path14.join(MESSAGES_DIR, `${sessionId}.json`), msgs);
+    writeJson(path15.join(MESSAGES_DIR, `${sessionId}.json`), msgs);
   }
   loadMessages(sessionId) {
     if (this.messages.has(sessionId)) {
       return this.messages.get(sessionId);
     }
     const msgs = readJson2(
-      path14.join(MESSAGES_DIR, `${sessionId}.json`),
+      path15.join(MESSAGES_DIR, `${sessionId}.json`),
       []
     );
     this.messages.set(sessionId, msgs);
     return msgs;
   }
+  mutateBindings(mutation) {
+    return withFileLock(BINDINGS_PATH, () => {
+      this.reloadBindings();
+      const result = mutation();
+      this.persistBindings();
+      return result;
+    });
+  }
+  mutateSessions(mutation) {
+    return withFileLock(SESSIONS_PATH, () => {
+      this.reloadSessions();
+      const result = mutation();
+      this.persistSessions();
+      return result;
+    });
+  }
+  mutateMessages(sessionId, mutation) {
+    const messagePath = path15.join(MESSAGES_DIR, `${sessionId}.json`);
+    return withFileLock(messagePath, () => {
+      const messages = readJson2(messagePath, []);
+      this.messages.set(sessionId, messages);
+      const result = mutation(messages);
+      this.persistMessages(sessionId);
+      return result;
+    });
+  }
   // ── Settings ──
   refreshSettings() {
     if (!this.dynamicSettings) return;
@@ -18028,66 +18947,65 @@ var JsonFileStore = class {
     return this.bindings.get(`${channelType}:${chatId}`) ?? null;
   }
   upsertChannelBinding(data) {
-    this.reloadBindings();
-    const key = `${data.channelType}:${data.chatId}`;
-    const existing = this.bindings.get(key);
-    if (existing) {
-      const updated = {
-        ...existing,
+    return this.mutateBindings(() => {
+      const key = `${data.channelType}:${data.chatId}`;
+      const existing = this.bindings.get(key);
+      if (existing) {
+        const updated = {
+          ...existing,
+          codepilotSessionId: data.codepilotSessionId,
+          sdkSessionId: data.sdkSessionId ?? existing.sdkSessionId,
+          channelProvider: data.channelProvider ?? existing.channelProvider,
+          channelAlias: data.channelAlias ?? existing.channelAlias,
+          chatUserId: data.chatUserId ?? existing.chatUserId,
+          chatDisplayName: data.chatDisplayName ?? existing.chatDisplayName,
+          workingDirectory: data.workingDirectory,
+          model: data.model,
+          mode: data.mode ?? existing.mode,
+          updatedAt: now()
+        };
+        this.bindings.set(key, updated);
+        return updated;
+      }
+      const binding = {
+        id: uuid(),
+        channelType: data.channelType,
+        channelProvider: data.channelProvider,
+        channelAlias: data.channelAlias,
+        chatId: data.chatId,
+        chatUserId: data.chatUserId,
+        chatDisplayName: data.chatDisplayName,
         codepilotSessionId: data.codepilotSessionId,
-        sdkSessionId: data.sdkSessionId ?? existing.sdkSessionId,
-        channelProvider: data.channelProvider ?? existing.channelProvider,
-        channelAlias: data.channelAlias ?? existing.channelAlias,
-        chatUserId: data.chatUserId ?? existing.chatUserId,
-        chatDisplayName: data.chatDisplayName ?? existing.chatDisplayName,
+        sdkSessionId: data.sdkSessionId ?? "",
         workingDirectory: data.workingDirectory,
         model: data.model,
-        mode: data.mode ?? existing.mode,
+        mode: data.mode || this.getSetting("bridge_default_mode") || "code",
+        active: true,
+        createdAt: now(),
         updatedAt: now()
       };
-      this.bindings.set(key, updated);
-      this.persistBindings();
-      return updated;
-    }
-    const binding = {
-      id: uuid(),
-      channelType: data.channelType,
-      channelProvider: data.channelProvider,
-      channelAlias: data.channelAlias,
-      chatId: data.chatId,
-      chatUserId: data.chatUserId,
-      chatDisplayName: data.chatDisplayName,
-      codepilotSessionId: data.codepilotSessionId,
-      sdkSessionId: data.sdkSessionId ?? "",
-      workingDirectory: data.workingDirectory,
-      model: data.model,
-      mode: data.mode || this.getSetting("bridge_default_mode") || "code",
-      active: true,
-      createdAt: now(),
-      updatedAt: now()
-    };
-    this.bindings.set(key, binding);
-    this.persistBindings();
-    return binding;
+      this.bindings.set(key, binding);
+      return binding;
+    });
   }
   deleteChannelBinding(id) {
-    this.reloadBindings();
-    for (const [key, binding] of this.bindings) {
-      if (binding.id !== id) continue;
-      this.bindings.delete(key);
-      this.persistBindings();
-      return;
-    }
+    this.mutateBindings(() => {
+      for (const [key, binding] of this.bindings) {
+        if (binding.id !== id) continue;
+        this.bindings.delete(key);
+        return;
+      }
+    });
   }
   updateChannelBinding(id, updates) {
-    this.reloadBindings();
-    for (const [key, b] of this.bindings) {
-      if (b.id === id) {
-        this.bindings.set(key, { ...b, ...updates, updatedAt: now() });
-        this.persistBindings();
-        break;
+    this.mutateBindings(() => {
+      for (const [key, b] of this.bindings) {
+        if (b.id === id) {
+          this.bindings.set(key, { ...b, ...updates, updatedAt: now() });
+          break;
+        }
       }
-    }
+    });
   }
   listChannelBindings(channelType) {
     this.reloadBindings();
@@ -18114,74 +19032,78 @@ var JsonFileStore = class {
     return null;
   }
   createSession(name, model, systemPrompt, cwd, mode, options) {
-    this.reloadSessions();
-    const timestamp = now();
-    const session = {
-      id: uuid(),
-      name,
-      working_directory: cwd || process.cwd(),
-      model,
-      preferred_mode: mode,
-      system_prompt: systemPrompt,
-      reasoning_effort: options?.reasoningEffort,
-      session_type: options?.sessionType || "normal",
-      hidden: options?.hidden === true,
-      parent_session_id: options?.parentSessionId,
-      expires_at: options?.expiresAt,
-      created_at: timestamp,
-      updated_at: timestamp
-    };
-    this.sessions.set(session.id, session);
-    this.persistSessions();
-    return session;
+    return this.mutateSessions(() => {
+      const timestamp = now();
+      const session = {
+        id: uuid(),
+        name,
+        working_directory: cwd || process.cwd(),
+        model,
+        preferred_mode: mode,
+        system_prompt: systemPrompt,
+        reasoning_effort: options?.reasoningEffort,
+        session_type: options?.sessionType || "normal",
+        hidden: options?.hidden === true,
+        parent_session_id: options?.parentSessionId,
+        expires_at: options?.expiresAt,
+        created_at: timestamp,
+        updated_at: timestamp
+      };
+      this.sessions.set(session.id, session);
+      return session;
+    });
   }
   updateSessionProviderId(sessionId, providerId) {
-    this.reloadSessions();
-    const s = this.sessions.get(sessionId);
-    if (s) {
+    this.mutateSessions(() => {
+      const s = this.sessions.get(sessionId);
+      if (!s) return;
       s.provider_id = providerId;
       s.updated_at = now();
-      this.persistSessions();
-    }
+    });
   }
   updateSession(sessionId, updates, options) {
-    this.reloadSessions();
-    const session = this.sessions.get(sessionId);
-    if (!session) return;
-    const next = {
-      ...session,
-      ...updates,
-      id: session.id,
-      updated_at: options?.touch === false ? session.updated_at : now()
-    };
-    this.sessions.set(sessionId, next);
-    this.persistSessions();
+    this.mutateSessions(() => {
+      const session = this.sessions.get(sessionId);
+      if (!session) return;
+      const next = {
+        ...session,
+        ...updates,
+        id: session.id,
+        updated_at: options?.touch === false ? session.updated_at : now()
+      };
+      this.sessions.set(sessionId, next);
+    });
   }
   deleteSession(sessionId) {
-    this.reloadSessions();
-    this.reloadBindings();
-    this.sessions.delete(sessionId);
-    for (const [key, binding] of this.bindings) {
-      if (binding.codepilotSessionId === sessionId) {
-        this.bindings.delete(key);
+    const messagePath = path15.join(MESSAGES_DIR, `${sessionId}.json`);
+    withFileLocks([SESSIONS_PATH, BINDINGS_PATH, messagePath], () => {
+      this.reloadSessions();
+      this.reloadBindings();
+      this.sessions.delete(sessionId);
+      for (const [key, binding] of this.bindings) {
+        if (binding.codepilotSessionId === sessionId) {
+          this.bindings.delete(key);
+        }
       }
-    }
-    this.messages.delete(sessionId);
-    try {
-      fs11.rmSync(path14.join(MESSAGES_DIR, `${sessionId}.json`), { force: true });
-    } catch {
-    }
-    this.persistSessions();
-    this.persistBindings();
+      this.messages.delete(sessionId);
+      try {
+        fs13.rmSync(messagePath, { force: true });
+      } catch {
+      }
+      this.persistSessions();
+      this.persistBindings();
+    });
   }
   // ── Messages ──
   addMessage(sessionId, role, content, _usage) {
-    const msgs = this.loadMessages(sessionId);
-    msgs.push({ role, content });
-    this.persistMessages(sessionId);
+    this.mutateMessages(sessionId, (messages) => {
+      messages.push({ role, content });
+    });
   }
   getMessages(sessionId, opts) {
-    const msgs = this.loadMessages(sessionId);
+    const messagePath = path15.join(MESSAGES_DIR, `${sessionId}.json`);
+    const msgs = readJson2(messagePath, []);
+    this.messages.set(sessionId, msgs);
     if (opts?.limit && opts.limit > 0) {
       return { messages: msgs.slice(-opts.limit) };
     }
@@ -18213,61 +19135,62 @@ var JsonFileStore = class {
     }
   }
   setSessionRuntimeStatus(_sessionId, _status) {
-    this.reloadSessions();
-    const session = this.sessions.get(_sessionId);
-    if (!session) return;
-    const queuedCount = session.queued_count && session.queued_count > 0 ? session.queued_count : 0;
-    let runtimeStatus;
-    if (_status === "running") {
-      runtimeStatus = queuedCount > 0 ? "queued" : "running";
-    } else if (_status === "idle") {
-      runtimeStatus = queuedCount > 0 ? "queued" : "idle";
-    } else {
-      runtimeStatus = session.runtime_status;
-    }
-    const next = {
-      ...session,
-      runtime_status: runtimeStatus,
-      last_runtime_update_at: now(),
-      updated_at: now()
-    };
-    this.sessions.set(_sessionId, next);
-    this.persistSessions();
+    this.mutateSessions(() => {
+      const session = this.sessions.get(_sessionId);
+      if (!session) return;
+      const queuedCount = session.queued_count && session.queued_count > 0 ? session.queued_count : 0;
+      let runtimeStatus;
+      if (_status === "running") {
+        runtimeStatus = queuedCount > 0 ? "queued" : "running";
+      } else if (_status === "idle") {
+        runtimeStatus = queuedCount > 0 ? "queued" : "idle";
+      } else {
+        runtimeStatus = session.runtime_status;
+      }
+      const next = {
+        ...session,
+        runtime_status: runtimeStatus,
+        last_runtime_update_at: now(),
+        updated_at: now()
+      };
+      this.sessions.set(_sessionId, next);
+    });
   }
   // ── SDK Session ──
   updateSdkSessionId(sessionId, sdkSessionId) {
-    this.reloadSessions();
-    this.reloadBindings();
-    const s = this.sessions.get(sessionId);
-    if (s) {
-      s.sdk_session_id = sdkSessionId;
-      if (sdkSessionId) {
-        s.codex_thread_id = sdkSessionId;
-        s.thread_origin = s.thread_origin || "bridge";
-      } else {
-        delete s.codex_thread_id;
-        if (s.thread_origin !== "desktop") {
-          delete s.thread_origin;
+    withFileLocks([SESSIONS_PATH, BINDINGS_PATH], () => {
+      this.reloadSessions();
+      this.reloadBindings();
+      const s = this.sessions.get(sessionId);
+      if (s) {
+        s.sdk_session_id = sdkSessionId;
+        if (sdkSessionId) {
+          s.codex_thread_id = sdkSessionId;
+          s.thread_origin = s.thread_origin || "bridge";
+        } else {
+          delete s.codex_thread_id;
+          if (s.thread_origin !== "desktop") {
+            delete s.thread_origin;
+          }
         }
+        s.updated_at = now();
       }
-      s.updated_at = now();
-      this.persistSessions();
-    }
-    for (const [key, b] of this.bindings) {
-      if (b.codepilotSessionId === sessionId) {
-        this.bindings.set(key, { ...b, sdkSessionId, updatedAt: now() });
+      for (const [key, b] of this.bindings) {
+        if (b.codepilotSessionId === sessionId) {
+          this.bindings.set(key, { ...b, sdkSessionId, updatedAt: now() });
+        }
       }
-    }
-    this.persistBindings();
+      this.persistSessions();
+      this.persistBindings();
+    });
   }
   updateSessionModel(sessionId, model) {
-    this.reloadSessions();
-    const s = this.sessions.get(sessionId);
-    if (s) {
+    this.mutateSessions(() => {
+      const s = this.sessions.get(sessionId);
+      if (!s) return;
       s.model = model;
       s.updated_at = now();
-      this.persistSessions();
-    }
+    });
   }
   syncSdkTasks(_sessionId, _todos) {
   }
@@ -18280,66 +19203,84 @@ var JsonFileStore = class {
   }
   // ── Audit & Dedup ──
   insertAuditLog(entry) {
-    this.auditLog.push({
-      ...entry,
-      id: uuid(),
-      createdAt: now()
+    withFileLock(AUDIT_PATH, () => {
+      this.reloadAudit();
+      this.auditLog.push({
+        ...entry,
+        id: uuid(),
+        createdAt: now()
+      });
+      if (this.auditLog.length > 1e3) {
+        this.auditLog = this.auditLog.slice(-1e3);
+      }
+      this.persistAudit();
     });
-    if (this.auditLog.length > 1e3) {
-      this.auditLog = this.auditLog.slice(-1e3);
-    }
-    this.persistAudit();
   }
   checkDedup(key) {
+    this.reloadDedup();
     const ts = this.dedupKeys.get(key);
     if (ts === void 0) return false;
-    if (Date.now() - ts > 5 * 60 * 1e3) {
+    if (Date.now() - ts > dedupTtlMs(key)) {
       this.dedupKeys.delete(key);
       return false;
     }
     return true;
   }
   insertDedup(key) {
-    this.dedupKeys.set(key, Date.now());
-    this.persistDedup();
+    withFileLock(DEDUP_PATH, () => {
+      this.reloadDedup();
+      this.dedupKeys.set(key, Date.now());
+      this.persistDedup();
+    });
   }
   cleanupExpiredDedup() {
-    const cutoff = Date.now() - 5 * 60 * 1e3;
-    let changed = false;
-    for (const [key, ts] of this.dedupKeys) {
-      if (ts < cutoff) {
-        this.dedupKeys.delete(key);
-        changed = true;
+    withFileLock(DEDUP_PATH, () => {
+      this.reloadDedup();
+      const timestamp = Date.now();
+      let changed = false;
+      for (const [key, ts] of this.dedupKeys) {
+        if (timestamp - ts > dedupTtlMs(key)) {
+          this.dedupKeys.delete(key);
+          changed = true;
+        }
       }
-    }
-    if (changed) this.persistDedup();
+      if (changed) this.persistDedup();
+    });
   }
   insertOutboundRef(_ref) {
   }
   // ── Permission Links ──
   insertPermissionLink(link2) {
-    const record = {
-      permissionRequestId: link2.permissionRequestId,
-      chatId: link2.chatId,
-      messageId: link2.messageId,
-      sessionId: link2.sessionId,
-      resolved: false,
-      suggestions: link2.suggestions
-    };
-    this.permissionLinks.set(link2.permissionRequestId, record);
-    this.persistPermissions();
+    withFileLock(PERMISSIONS_PATH, () => {
+      this.reloadPermissions();
+      const record = {
+        permissionRequestId: link2.permissionRequestId,
+        chatId: link2.chatId,
+        messageId: link2.messageId,
+        sessionId: link2.sessionId,
+        resolved: false,
+        suggestions: link2.suggestions
+      };
+      this.permissionLinks.set(link2.permissionRequestId, record);
+      this.persistPermissions();
+    });
   }
   getPermissionLink(permissionRequestId) {
+    this.reloadPermissions();
     return this.permissionLinks.get(permissionRequestId) ?? null;
   }
   markPermissionLinkResolved(permissionRequestId) {
-    const link2 = this.permissionLinks.get(permissionRequestId);
-    if (!link2 || link2.resolved) return false;
-    link2.resolved = true;
-    this.persistPermissions();
-    return true;
+    return withFileLock(PERMISSIONS_PATH, () => {
+      this.reloadPermissions();
+      const link2 = this.permissionLinks.get(permissionRequestId);
+      if (!link2 || link2.resolved) return false;
+      link2.resolved = true;
+      this.persistPermissions();
+      return true;
+    });
   }
   listPendingPermissionLinksByChat(chatId) {
+    this.reloadPermissions();
     const result = [];
     for (const link2 of this.permissionLinks.values()) {
       if (link2.chatId === chatId && !link2.resolved) {
@@ -18350,11 +19291,15 @@ var JsonFileStore = class {
   }
   // ── Channel Offsets ──
   getChannelOffset(key) {
+    this.reloadOffsets();
     return this.offsets.get(key) ?? "0";
   }
   setChannelOffset(key, offset) {
-    this.offsets.set(key, offset);
-    this.persistOffsets();
+    withFileLock(OFFSETS_PATH, () => {
+      this.reloadOffsets();
+      this.offsets.set(key, offset);
+      this.persistOffsets();
+    });
   }
 };
 
@@ -18397,8 +19342,8 @@ var PendingPermissions = class {
 };
 
 // src/logger.ts
-import fs12 from "node:fs";
-import path15 from "node:path";
+import fs14 from "node:fs";
+import path16 from "node:path";
 import { inspect as inspect2 } from "node:util";
 var MASK_PATTERNS = [
   /(?:token|secret|password|api_key)["']?\s*[:=]\s*["']?([^\s"',]+)/gi,
@@ -18416,8 +19361,8 @@ function maskSecrets(text2) {
   }
   return result;
 }
-var LOG_DIR = path15.join(CTI_HOME, "logs");
-var LOG_PATH = path15.join(LOG_DIR, "bridge.log");
+var LOG_DIR = path16.join(CTI_HOME, "logs");
+var LOG_PATH = path16.join(LOG_DIR, "bridge.log");
 var MAX_LOG_SIZE = 10 * 1024 * 1024;
 var MAX_ROTATED = 3;
 var logStream = null;
@@ -18438,11 +19383,11 @@ function formatLogArg(value) {
   return String(value);
 }
 function openLogStream() {
-  return fs12.createWriteStream(LOG_PATH, { flags: "a" });
+  return fs14.createWriteStream(LOG_PATH, { flags: "a" });
 }
 function rotateIfNeeded() {
   try {
-    const stat = fs12.statSync(LOG_PATH);
+    const stat = fs14.statSync(LOG_PATH);
     if (stat.size < MAX_LOG_SIZE) return;
   } catch {
     return;
@@ -18452,17 +19397,17 @@ function rotateIfNeeded() {
     logStream = null;
   }
   const path32 = `${LOG_PATH}.${MAX_ROTATED}`;
-  if (fs12.existsSync(path32)) fs12.unlinkSync(path32);
+  if (fs14.existsSync(path32)) fs14.unlinkSync(path32);
   for (let i = MAX_ROTATED - 1; i >= 1; i--) {
     const src = `${LOG_PATH}.${i}`;
     const dst = `${LOG_PATH}.${i + 1}`;
-    if (fs12.existsSync(src)) fs12.renameSync(src, dst);
+    if (fs14.existsSync(src)) fs14.renameSync(src, dst);
   }
-  fs12.renameSync(LOG_PATH, `${LOG_PATH}.1`);
+  fs14.renameSync(LOG_PATH, `${LOG_PATH}.1`);
   logStream = openLogStream();
 }
 function setupLogger() {
-  fs12.mkdirSync(LOG_DIR, { recursive: true });
+  fs14.mkdirSync(LOG_DIR, { recursive: true });
   logStream = openLogStream();
   const write = (level, args) => {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -18478,18 +19423,18 @@ function setupLogger() {
 }
 
 // src/bridge-instance-lock.ts
-import fs13 from "node:fs";
-import path16 from "node:path";
-var runtimeDir = path16.join(CTI_HOME, "runtime");
-var bridgeInstanceLockFile = path16.join(runtimeDir, "bridge.instance.lock");
+import fs15 from "node:fs";
+import path17 from "node:path";
+var runtimeDir = path17.join(CTI_HOME, "runtime");
+var bridgeInstanceLockFile = path17.join(runtimeDir, "bridge.instance.lock");
 function readJsonFile(filePath, fallback) {
   try {
-    return JSON.parse(fs13.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs15.readFileSync(filePath, "utf-8"));
   } catch {
     return fallback;
   }
 }
-function isProcessAlive(pid) {
+function isProcessAlive2(pid) {
   if (!pid) return false;
   try {
     process.kill(pid, 0);
@@ -18509,15 +19454,15 @@ function tryAcquireBridgeInstanceLock(options = {}) {
   const filePath = options.filePath ?? bridgeInstanceLockFile;
   const ownerPid = options.ownerPid ?? process.pid;
   const nowMs = options.nowMs ?? Date.now();
-  const isAlive = options.isAlive ?? isProcessAlive;
+  const isAlive = options.isAlive ?? isProcessAlive2;
   const payload = {
     pid: ownerPid,
     createdAt: new Date(nowMs).toISOString()
   };
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      fs13.mkdirSync(path16.dirname(filePath), { recursive: true });
-      fs13.writeFileSync(filePath, JSON.stringify(payload, null, 2), { encoding: "utf-8", flag: "wx" });
+      fs15.mkdirSync(path17.dirname(filePath), { recursive: true });
+      fs15.writeFileSync(filePath, JSON.stringify(payload, null, 2), { encoding: "utf-8", flag: "wx" });
       return { acquired: true };
     } catch (error) {
       const code2 = error.code;
@@ -18527,7 +19472,7 @@ function tryAcquireBridgeInstanceLock(options = {}) {
         return { acquired: false, holderPid: existing2.pid };
       }
       try {
-        fs13.unlinkSync(filePath);
+        fs15.unlinkSync(filePath);
       } catch {
       }
     }
@@ -18542,37 +19487,46 @@ function releaseBridgeInstanceLock(filePath = bridgeInstanceLockFile, ownerPid =
   const existing = readBridgeInstanceLock(filePath);
   if (!existing) {
     try {
-      fs13.unlinkSync(filePath);
+      fs15.unlinkSync(filePath);
     } catch {
     }
     return;
   }
   if (existing.pid !== ownerPid) return;
   try {
-    fs13.unlinkSync(filePath);
+    fs15.unlinkSync(filePath);
   } catch {
   }
 }
 
-// src/main.ts
-var RUNTIME_DIR = path18.join(CTI_HOME, "runtime");
-var STATUS_FILE = path18.join(RUNTIME_DIR, "status.json");
-var PID_FILE = path18.join(RUNTIME_DIR, "bridge.pid");
-async function resolveProvider() {
-  const { CodexProvider: CodexProvider2 } = await Promise.resolve().then(() => (init_codex_provider(), codex_provider_exports));
-  return new CodexProvider2();
-}
-function writeStatus(info) {
-  fs15.mkdirSync(RUNTIME_DIR, { recursive: true });
+// src/runtime-status.ts
+import fs16 from "node:fs";
+function writeRuntimeStatus(filePath, info, options = {}) {
   let existing = {};
   try {
-    existing = JSON.parse(fs15.readFileSync(STATUS_FILE, "utf-8"));
+    existing = JSON.parse(fs16.readFileSync(filePath, "utf-8"));
   } catch {
   }
+  const existingRunId = typeof existing.runId === "string" ? existing.runId : "";
+  if (options.expectedRunId && existingRunId && existingRunId !== options.expectedRunId && options.allowRunIdTakeover !== true) {
+    return false;
+  }
   const merged = { ...existing, ...info };
-  const tmp = STATUS_FILE + ".tmp";
-  fs15.writeFileSync(tmp, JSON.stringify(merged, null, 2), "utf-8");
-  fs15.renameSync(tmp, STATUS_FILE);
+  atomicWriteFileSync(filePath, JSON.stringify(merged, null, 2));
+  return true;
+}
+
+// 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() {
+  const { CodexProvider: CodexProvider2 } = await Promise.resolve().then(() => (init_codex_provider(), codex_provider_exports));
+  return new CodexProvider2();
+}
+function writeStatus(info, options = {}) {
+  return writeRuntimeStatus(STATUS_FILE, info, options);
 }
 function getRunningChannels() {
   return getStatus().adapters.map((adapter) => adapter.channelType).sort();
@@ -18584,10 +19538,6 @@ async function main() {
   const lockState = tryAcquireBridgeInstanceLock();
   if (!lockState.acquired) {
     const holderPid = lockState.holderPid;
-    writeStatus({
-      running: true,
-      ...Number.isFinite(holderPid) && holderPid ? { pid: holderPid } : {}
-    });
     console.log(
       `[codex-to-im] Another bridge daemon is already running${holderPid ? ` (PID: ${holderPid})` : ""}. Exiting duplicate launcher.`
     );
@@ -18599,9 +19549,15 @@ async function main() {
     releaseBridgeInstanceLock(void 0, process.pid);
     instanceLockHeld = false;
   };
+  writeStatus({
+    running: false,
+    pid: process.pid,
+    runId,
+    channels: [],
+    adapters: []
+  }, { expectedRunId: runId, allowRunIdTakeover: true });
   const config2 = loadConfig();
   setupLogger();
-  const runId = crypto7.randomUUID();
   console.log(`[codex-to-im] Starting bridge (run_id: ${runId})`);
   const settings = configToSettings(config2);
   const store = new JsonFileStore(settings, { dynamicSettings: true });
@@ -18617,8 +19573,8 @@ async function main() {
     permissions: gateway,
     lifecycle: {
       onBridgeStart: () => {
-        fs15.mkdirSync(RUNTIME_DIR, { recursive: true });
-        fs15.writeFileSync(PID_FILE, String(process.pid), "utf-8");
+        fs18.mkdirSync(RUNTIME_DIR, { recursive: true });
+        fs18.writeFileSync(PID_FILE, String(process.pid), "utf-8");
         const channels = getRunningChannels();
         writeStatus({
           running: true,
@@ -18627,7 +19583,7 @@ async function main() {
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
           channels,
           adapters: getAdapterStatuses()
-        });
+        }, { expectedRunId: runId });
         console.log(`[codex-to-im] Bridge started (PID: ${process.pid}, channels: ${channels.join(", ")})`);
       },
       onBridgeAdaptersChanged: (channels) => {
@@ -18637,41 +19593,60 @@ async function main() {
           runId,
           channels,
           adapters: getAdapterStatuses()
-        });
+        }, { expectedRunId: runId });
         console.log(`[codex-to-im] Active channels updated: ${channels.join(", ") || "none"}`);
       },
       onBridgeStop: () => {
         releaseInstanceLock();
-        writeStatus({ running: false, channels: [], adapters: [] });
+        writeStatus({ running: false, channels: [], adapters: [] }, { expectedRunId: runId });
         console.log("[codex-to-im] Bridge stopped");
       }
     }
   });
   await start();
   let shuttingDown = false;
-  const shutdown = async (signal) => {
+  const shutdown = async (reason, exitCode = 0) => {
     if (shuttingDown) return;
     shuttingDown = true;
-    const reason = signal ? `signal: ${signal}` : "shutdown requested";
     console.log(`[codex-to-im] Shutting down (${reason})...`);
     pendingPerms.denyAll();
-    await stop();
-    releaseInstanceLock();
-    writeStatus({ running: false, lastExitReason: reason });
-    process.exit(0);
+    try {
+      await stop();
+    } catch (error) {
+      console.error("[codex-to-im] Graceful bridge stop failed:", error instanceof Error ? error.stack || error.message : error);
+    } finally {
+      releaseInstanceLock();
+      try {
+        writeStatus({ running: false, lastExitReason: reason }, { expectedRunId: runId });
+      } catch (error) {
+        console.error("[codex-to-im] Failed to write final runtime status:", error instanceof Error ? error.message : error);
+      }
+      process.exit(exitCode);
+    }
   };
-  process.on("SIGTERM", () => shutdown("SIGTERM"));
-  process.on("SIGINT", () => shutdown("SIGINT"));
-  process.on("SIGHUP", () => shutdown("SIGHUP"));
+  process.on("SIGTERM", () => {
+    void shutdown("signal: SIGTERM");
+  });
+  process.on("SIGINT", () => {
+    void shutdown("signal: SIGINT");
+  });
+  process.on("SIGHUP", () => {
+    void shutdown("signal: SIGHUP");
+  });
   process.on("unhandledRejection", (reason) => {
     console.error("[codex-to-im] unhandledRejection:", reason instanceof Error ? reason.stack || reason.message : reason);
-    writeStatus({ running: false, lastExitReason: `unhandledRejection: ${reason instanceof Error ? reason.message : String(reason)}` });
+    writeStatus({
+      running: true,
+      pid: process.pid,
+      runId,
+      channels: getRunningChannels(),
+      adapters: getAdapterStatuses(),
+      lastExitReason: `unhandledRejection: ${reason instanceof Error ? reason.message : String(reason)}`
+    }, { expectedRunId: runId });
   });
   process.on("uncaughtException", (err) => {
     console.error("[codex-to-im] uncaughtException:", err.stack || err.message);
-    releaseInstanceLock();
-    writeStatus({ running: false, lastExitReason: `uncaughtException: ${err.message}` });
-    process.exit(1);
+    void shutdown(`uncaughtException: ${err.message}`, 1);
   });
   process.on("beforeExit", (code2) => {
     console.log(`[codex-to-im] beforeExit (code: ${code2})`);
@@ -18687,7 +19662,10 @@ main().catch((err) => {
   console.error("[codex-to-im] Fatal error:", err instanceof Error ? err.stack || err.message : err);
   releaseBridgeInstanceLock(void 0, process.pid);
   try {
-    writeStatus({ running: false, lastExitReason: `fatal: ${err instanceof Error ? err.message : String(err)}` });
+    writeStatus(
+      { running: false, lastExitReason: `fatal: ${err instanceof Error ? err.message : String(err)}` },
+      { expectedRunId: runId }
+    );
   } catch {
   }
   process.exit(1);