@ycodium-ai/plugin-im 0.2.3192 → 0.2.3202

package/dist/index.js

@@ -23360,7 +23360,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash: createHash5 } = __require("crypto");
+    var { randomBytes, createHash: createHash6 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -24028,7 +24028,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash5("sha1").update(key + GUID).digest("base64");
+        const digest = createHash6("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -24397,7 +24397,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash5 } = __require("crypto");
+    var { createHash: createHash6 } = __require("crypto");
     var extension = require_extension();
     var PerMessageDeflate = require_permessage_deflate();
     var subprotocol = require_subprotocol();
@@ -24704,7 +24704,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash5("sha1").update(key + GUID).digest("base64");
+        const digest = createHash6("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -126185,22 +126185,26 @@ var makeAcknowledgements = (core) => {
       host.log.warn("chat could not acknowledge the message", { error: describeError(error) });
     }
   };
-  const clearWorking = async (binding, threadId, outcome) => {
+  const takeWorking = (binding, threadId, outcome) => {
     const adapter = adapterFor(binding.platform);
+    const clear = adapter?.clearAcknowledge?.bind(adapter);
     const pending = acknowledgements.get(threadId);
-    if (pending === void 0 || adapter?.clearAcknowledge === void 0) return;
+    if (pending === void 0 || clear === void 0) return async () => void 0;
     acknowledgements.delete(threadId);
-    for (const entry of pending) {
-      try {
-        await adapter.clearAcknowledge(binding, entry.messageId, entry.ackId, outcome);
-      } catch (error) {
-        host.log.warn("chat could not clear the acknowledgement", {
-          error: describeError(error)
-        });
+    return async () => {
+      for (const entry of pending) {
+        try {
+          await clear(binding, entry.messageId, entry.ackId, outcome);
+        } catch (error) {
+          host.log.warn("chat could not clear the acknowledgement", {
+            error: describeError(error)
+          });
+        }
       }
-    }
+    };
   };
-  return { markWorking, clearWorking };
+  const clearWorking = (binding, threadId, outcome) => takeWorking(binding, threadId, outcome)();
+  return { markWorking, takeWorking, clearWorking };
 };
 
 // src/botConfig.ts
@@ -126401,7 +126405,7 @@ var makeConclusionLedger = (core) => {
         return false;
       inFlight.add(key);
       try {
-        const sent = await send();
+        const sent = await send(() => conclusionDebtsOf(core.state)[key] !== void 0);
         if (sent) settle(debt);
         return sent;
       } finally {
@@ -126837,6 +126841,7 @@ var readString = (row, key) => {
 
 // src/settingsContract.ts
 var SETTINGS_VIEW_COMMAND = "settings.view";
+var SETTINGS_CONNECTIONS_COMMAND = "settings.connections";
 var SETTINGS_SAVE_BOT_COMMAND = "settings.saveBot";
 var SETTINGS_REMOVE_BOT_COMMAND = "settings.removeBot";
 var SETTINGS_SAVE_GENERAL_COMMAND = "settings.saveGeneral";
@@ -126877,6 +126882,7 @@ var foldFlowItem = (snapshot, item) => {
     }
   }
 };
+var connectionHintKey = (hint) => hint === "notAvailable" ? "settingsSection.connection.reason.not-available" : `rowAction.checkConnection.hint.${hint}`;
 
 // src/targetKind.ts
 var TARGET_KIND_OPTIONS = [
@@ -127943,13 +127949,58 @@ var makeCommands = (core, deps) => {
 };
 
 // src/keyedQueue.ts
-var makeKeyedQueue = (onError) => {
-  const tails = /* @__PURE__ */ new Map();
-  return (key, work) => {
-    const run = (tails.get(key) ?? Promise.resolve()).then(work).catch(onError).then(() => {
-      if (tails.get(key) === run) tails.delete(key);
+var makeKeyedQueue = (onError, options = {}) => {
+  const queues = /* @__PURE__ */ new Map();
+  const run = (key, work, kind = {}) => {
+    const queue = queues.get(key) ?? { tail: Promise.resolve(), size: 0, droppable: 0 };
+    const droppable = kind.droppable === true;
+    if (droppable && options.limit !== void 0 && queue.droppable >= options.limit) {
+      options.onFull?.(key, options.limit);
+      return false;
+    }
+    queue.size += 1;
+    if (droppable) queue.droppable += 1;
+    queue.tail = queue.tail.then(work).catch(onError).then(() => {
+      queue.size -= 1;
+      if (droppable) queue.droppable -= 1;
+      if (queue.size === 0 && queues.get(key) === queue) queues.delete(key);
     });
-    tails.set(key, run);
+    queues.set(key, queue);
+    return true;
+  };
+  return Object.assign(run, { activeKeys: () => queues.size });
+};
+
+// src/redact.ts
+var DETAIL_MAX_CHARS = 200;
+var MASK = "***";
+var TOKEN_LIKE = /[A-Za-z0-9_=-]{24,}/g;
+var MIN_SECRET_LENGTH = 6;
+var botRedactor = (columns, values) => {
+  const redactor = makeRedactor();
+  for (const column of columns) {
+    if (column.kind !== "password") continue;
+    const value2 = values[column.key];
+    redactor.register(value2);
+    if (value2 !== void 0) redactor.register(encodeURIComponent(value2));
+  }
+  return redactor;
+};
+var makeRedactor = () => {
+  const secrets = /* @__PURE__ */ new Set();
+  const redact = (text4) => {
+    let out = text4;
+    for (const secret of [...secrets].sort((a, b) => b.length - a.length)) {
+      out = out.split(secret).join(MASK);
+    }
+    return out.replace(TOKEN_LIKE, MASK);
+  };
+  return {
+    register: (secret) => {
+      if (typeof secret === "string" && secret.length >= MIN_SECRET_LENGTH) secrets.add(secret);
+    },
+    redact,
+    detail: (text4) => redact(text4).slice(0, DETAIL_MAX_CHARS)
   };
 };
 
@@ -127967,26 +128018,61 @@ var connectionKey = (adapter, bot) => JSON.stringify([
 var startConnections = (core, inboundHandlersFor) => {
   const { host, adapterFor, ready } = core;
   const live = /* @__PURE__ */ new Map();
+  const statuses = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    const snapshot = Object.fromEntries(statuses);
+    for (const listener of [...listeners]) listener(snapshot);
+  };
+  const record3 = (rowId, status) => {
+    const previous = statuses.get(rowId);
+    if (previous?.state === status.state && previous.error === status.error && previous.reason === status.reason && previous.duplicateOf === status.duplicateOf && previous.hint === status.hint)
+      return;
+    statuses.set(rowId, status);
+    notify();
+  };
+  const remove = (rowId) => {
+    if (statuses.delete(rowId)) notify();
+  };
   const enqueueForRow = makeKeyedQueue((error) => {
     host.log.warn("chat could not start an inbound connection", { error: describeError(error) });
   });
   let disposed = false;
   const open = (bot, key) => {
     const adapter = adapterFor(bot.platform);
+    const redactor = botRedactor(adapter?.columns ?? [], bot.values);
     let closed = false;
     let closeConnection;
+    record3(bot.rowId, { state: "connecting" });
     enqueueForRow(bot.rowId, async () => {
       try {
         await ready;
         if (closed || adapter === void 0) return;
-        const connection = await adapter.connect(bot, inboundHandlersFor(bot));
+        const connection = await adapter.connect(bot, {
+          ...inboundHandlersFor(bot),
+          onConnectionState: (status) => {
+            if (closed) return;
+            if (status.state === "connected") {
+              record3(bot.rowId, status);
+              return;
+            }
+            record3(bot.rowId, {
+              state: "failed",
+              ...status.reason === void 0 ? {} : { reason: status.reason },
+              ...status.error === void 0 ? {} : { error: redactor.redact(describeError(status.error)) },
+              ...status.hint === void 0 ? {} : { hint: status.hint }
+            });
+          }
+        });
         if (closed) connection.close();
         else closeConnection = () => connection.close();
       } catch (error) {
+        const detail = redactor.redact(describeError(error));
+        if (!closed) record3(bot.rowId, { state: "failed", error: detail });
         host.log.warn("chat could not start an inbound connection", {
           bot: bot.displayName,
           platform: bot.platform,
-          error: describeError(error)
+          error: detail
         });
       }
     });
@@ -128001,19 +128087,25 @@ var startConnections = (core, inboundHandlersFor) => {
   const reconcile = () => {
     const bots = disposed ? [] : core.bots();
     const wanted = /* @__PURE__ */ new Map();
-    const credentials3 = /* @__PURE__ */ new Set();
+    const credentials3 = /* @__PURE__ */ new Map();
+    const duplicates = /* @__PURE__ */ new Map();
     for (const bot of bots) {
       const adapter = adapterFor(bot.platform);
       if (adapter === void 0) continue;
       const fingerprint = `${bot.platform}:${adapter.columns.map((column) => bot.values[column.key] ?? "").join(" ")}`;
-      if (credentials3.has(fingerprint)) {
+      const duplicateOf = credentials3.get(fingerprint);
+      if (duplicateOf !== void 0) {
+        duplicates.set(bot.rowId, duplicateOf);
+        if (statuses.get(bot.rowId)?.duplicateOf !== duplicateOf) {
+          record3(bot.rowId, { state: "duplicate", duplicateOf });
+        }
         host.log.warn("chat did not connect a bot that repeats another bot's credentials", {
           bot: bot.displayName,
           platform: bot.platform
         });
         continue;
       }
-      credentials3.add(fingerprint);
+      credentials3.set(fingerprint, bot.rowId);
       wanted.set(bot.rowId, { bot, key: connectionKey(adapter, bot) });
     }
     for (const [rowId, connection] of live) {
@@ -128021,6 +128113,9 @@ var startConnections = (core, inboundHandlersFor) => {
       connection.close();
       live.delete(rowId);
     }
+    for (const rowId of statuses.keys()) {
+      if (!wanted.has(rowId) && !duplicates.has(rowId)) remove(rowId);
+    }
     for (const [rowId, { bot, key }] of wanted) {
       if (!live.has(rowId)) live.set(rowId, open(bot, key));
     }
@@ -128029,8 +128124,18 @@ var startConnections = (core, inboundHandlersFor) => {
   host.onDispose(() => {
     disposed = true;
     reconcile();
+    listeners.clear();
   });
-  return { reconcile };
+  return {
+    reconcile,
+    subscribe: (listener) => {
+      if (!disposed) listeners.add(listener);
+      listener(Object.fromEntries(statuses));
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
 };
 
 // src/deliveryHttp.ts
@@ -128279,6 +128384,7 @@ ${token}` : void 0;
 };
 
 // src/core.ts
+var OUTBOUND_QUEUE_LIMIT = 100;
 var makeImCore = (input) => {
   const { host, t, adapters } = input;
   const adapterFor = (platform) => adapters.find((adapter) => adapter.platform === platform);
@@ -128313,10 +128419,21 @@ var makeImCore = (input) => {
   const bindChat = (chatKey, threadId) => {
     commit("chat-updated", { chatKey, threadId });
   };
-  const outbound = makeKeyedQueue((error) => {
-    host.log.warn("chat could not deliver a card", { error: describeError(error) });
-  });
-  const postImages = async (binding, attachments) => {
+  const outbound = makeKeyedQueue(
+    (error) => {
+      host.log.warn("chat could not deliver queued work", { error: describeError(error) });
+    },
+    {
+      limit: OUTBOUND_QUEUE_LIMIT,
+      onFull: (chatKey, limit) => {
+        host.log.warn("chat queue is full; refused a conclusion until restart", {
+          chatKey,
+          limit
+        });
+      }
+    }
+  );
+  const postImages = async (binding, attachments, onFailure) => {
     const adapter = adapterFor(binding.platform);
     if (adapter?.sendImage === void 0) return;
     for (const attachment of attachments) {
@@ -128333,19 +128450,22 @@ var makeImCore = (input) => {
           name: attachment.name,
           error: describeError(error)
         });
+        await onFailure?.(error);
       }
     }
   };
-  const deliver = async (binding, text4, attachments = []) => {
-    await postImages(binding, attachments);
+  const deliver = async (binding, text4, attachments = [], options = {}) => {
+    const { retry, onFailure } = options;
+    await postImages(binding, attachments, onFailure);
     if (text4.trim() === "") return true;
     const adapter = adapterFor(binding.platform);
     if (adapter === void 0) return false;
     try {
-      await adapter.sendText(binding, text4);
+      await adapter.sendText(binding, text4, { retry });
       return true;
     } catch (error) {
       host.log.warn("chat could not deliver", { error: describeError(error) });
+      await onFailure?.(error);
       return false;
     }
   };
@@ -128377,6 +128497,92 @@ var makeImCore = (input) => {
 // src/conclusionDelivery.ts
 import { threadOrNull as threadOrNull3 } from "@ycodium-ai/plugin-api";
 
+// src/abortableSleep.ts
+var abortableSleep = (ms, signal) => new Promise((resolve, reject) => {
+  if (signal?.aborted === true) {
+    reject(new Error("aborted"));
+    return;
+  }
+  const onAbort = () => {
+    clearTimeout(timer);
+    reject(new Error("aborted"));
+  };
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve();
+  }, ms);
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+
+// src/deliveryFailure.ts
+import * as NodeCrypto2 from "node:crypto";
+
+// src/diagnostics.ts
+var PREFIX = {
+  conn: "IM-CONN",
+  msg: "IM-MSG",
+  setup: "IM-SETUP"
+};
+var shortSalt = () => {
+  const bytes = new Uint8Array(2);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).toUpperCase().padStart(2, "0")).join("");
+};
+var stableDiagnosticRef = (kind, digest) => `${PREFIX[kind]}-${digest.slice(0, 16).toUpperCase()}`;
+var diagnosticRef = (kind, nowMs = Date.now()) => {
+  const stamp = nowMs.toString(36).toUpperCase();
+  return `${PREFIX[kind]}-${stamp}-${shortSalt()}`;
+};
+var formatDiagnosticCopy = (report) => [
+  `ok=${report.ok ? "yes" : "no"}`,
+  `platform=${report.platform}`,
+  `bot=${report.botName}`,
+  `row=${report.rowId}`,
+  `stage=${report.stage}`,
+  `at=${report.at}`,
+  `detail=${report.detail}`
+].join("\n");
+
+// src/deliveryFailure.ts
+var deliveryFailure = (core, binding, threadId, turnId) => async (error) => {
+  const rejection = core.adapterFor(binding.platform)?.describeDeliveryRejection?.(error, binding);
+  if (rejection === void 0) return;
+  const { recipients } = rejection;
+  const digest = NodeCrypto2.createHash("sha256").update(JSON.stringify([threadId, turnId, binding.platform, binding.rowId, recipients])).digest("hex");
+  const id = `im.delivery-failed:${digest}`;
+  const reference2 = stableDiagnosticRef("msg", digest);
+  const payload = {
+    platform: binding.platform,
+    recipients,
+    hint: rejection.hint,
+    providerCode: rejection.providerCode,
+    reference: reference2,
+    sourceTurnId: turnId
+  };
+  core.host.log.warn("chat recipient rejected delivery", { threadId, ...payload });
+  if (core.state.opened[threadId] === void 0) return;
+  try {
+    await core.host.threads.externalMessages.append({
+      requestId: id,
+      threadId,
+      messages: [],
+      activities: [
+        {
+          id,
+          tone: "error",
+          kind: "im.delivery-failed",
+          summary: rejection.summary,
+          payload,
+          turnId: null,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      ]
+    });
+  } catch {
+    core.host.log.warn("chat could not append delivery failure notice", { threadId, reference: reference2 });
+  }
+};
+
 // src/threadMessages.ts
 import {
   isThreadNotFound,
@@ -128428,20 +128634,30 @@ async function messagesAfterLastUser(threads, threadId) {
 }
 
 // src/conclusionDelivery.ts
+var ALWAYS_OWED = () => true;
 var makeConclusionDelivery = (core, anchors) => {
   let disposed = false;
+  const stopped = new AbortController();
   core.host.onDispose(() => {
     disposed = true;
+    stopped.abort();
   });
   const marked = (text4, recovered) => recovered ? `${core.t("reply.conclusionRecovered")}
 ${text4}` : text4;
+  const sleep3 = (ms) => abortableSleep(ms, stopped.signal).catch(() => void 0);
+  const retryFor = (threadId, owed = ALWAYS_OWED) => ({
+    sleep: sleep3,
+    shouldContinue: async () => !disposed && owed() && await threadOrNull3(core.host.threads, threadId) !== null
+  });
   return {
+    retryFor,
     prepareConclusion: async (threadId, turnId = null) => {
       const thread = await threadOrNull3(core.host.threads, threadId);
       const final = thread === null ? void 0 : await latestMessage(
         core.host.threads,
         threadId,
-        (message) => message.role === "assistant" && message.text.trim() !== ""
+        // 给了轮次就只取这一轮的正文：排队等着的结论不能拿到下一轮的话。没记轮次的老消息照旧认。
+        (message) => message.role === "assistant" && message.text.trim() !== "" && (turnId === null || message.turnId === null || message.turnId === turnId)
       );
       const attachments = final === void 0 ? [] : await attachmentsOf(core.host.threads, threadId, final);
       return async (binding, options) => {
@@ -128451,12 +128667,22 @@ ${text4}` : text4;
 
 ${final.text}`, options.recovered);
         const anchored = await anchors.anchored(binding, threadId, turnId ?? final.turnId);
-        return !disposed && core.deliver(anchored, text4, attachments);
+        return !disposed && core.deliver(anchored, text4, attachments, {
+          retry: retryFor(threadId, options.owed),
+          onFailure: deliveryFailure(core, binding, threadId, turnId ?? final.turnId)
+        });
       };
     },
-    failure: async (binding, threadId, notice, recovered, turnId = null) => {
+    /**
+     * 发一段已经写好的结论文字（失败通知、卡片定稿失败时的文字兜底）：锚点、停用检查、重发与
+     * 拒收提醒都在这里，调用方只管写文字。
+     */
+    sendText: async (binding, threadId, notice, recovered, turnId = null, owed = ALWAYS_OWED) => {
       const anchored = await anchors.anchored(binding, threadId, turnId);
-      return !disposed && core.deliver(anchored, marked(notice, recovered));
+      return !disposed && core.deliver(anchored, marked(notice, recovered), [], {
+        retry: retryFor(threadId, owed),
+        onFailure: deliveryFailure(core, binding, threadId, turnId)
+      });
     }
   };
 };
@@ -130583,29 +130809,6 @@ var sleep = async (deps) => {
   }
 };
 
-// src/redact.ts
-var DETAIL_MAX_CHARS = 200;
-var MASK = "***";
-var TOKEN_LIKE = /[A-Za-z0-9_=-]{24,}/g;
-var MIN_SECRET_LENGTH = 6;
-var makeRedactor = () => {
-  const secrets = /* @__PURE__ */ new Set();
-  const redact = (text4) => {
-    let out = text4;
-    for (const secret of [...secrets].sort((a, b) => b.length - a.length)) {
-      out = out.split(secret).join(MASK);
-    }
-    return out.replace(TOKEN_LIKE, MASK);
-  };
-  return {
-    register: (secret) => {
-      if (typeof secret === "string" && secret.length >= MIN_SECRET_LENGTH) secrets.add(secret);
-    },
-    redact,
-    detail: (text4) => redact(text4).slice(0, DETAIL_MAX_CHARS)
-  };
-};
-
 // src/lark/setup/cookieJar.ts
 var MAX_REDIRECT_HOPS = 10;
 var parseSetCookie = (responseUrl, header) => {
@@ -131323,21 +131526,7 @@ var buildChecklist = () => ({
 });
 var makeRealClock = () => ({
   now: () => Date.now(),
-  sleep: (ms, signal) => new Promise((resolve, reject) => {
-    if (signal?.aborted === true) {
-      reject(new Error("aborted"));
-      return;
-    }
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(new Error("aborted"));
-    };
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    signal?.addEventListener("abort", onAbort, { once: true });
-  })
+  sleep: abortableSleep
 });
 var saveAndConclude = async (ctx, updateSettings, result) => {
   try {
@@ -131429,6 +131618,9 @@ var registerLarkSetup = (ctx, options = {}) => {
   return runner;
 };
 
+// src/larkApi.ts
+import { parseRetryAfterMs } from "@ycodium-ai/plugin-api";
+
 // src/larkPost.ts
 var styledText = (text4, style) => {
   let out = text4;
@@ -131608,6 +131800,33 @@ var parseLarkReply = (message) => {
   }
 };
 
+// src/sendRetry.ts
+var NO_RETRY = { retry: false };
+var SEND_RETRY_DELAYS_MS = [1e3, 4e3, 15e3];
+var MAX_WAIT_MS = 6e4;
+var SendStoppedError = class extends Error {
+  constructor(cause) {
+    super("send stopped before retrying", { cause });
+    this.name = "SendStoppedError";
+  }
+};
+var sendWithRetry = async (request, verdictOf, retry) => {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      return await request();
+    } catch (error) {
+      const delayMs = SEND_RETRY_DELAYS_MS[attempt];
+      if (retry === void 0 || delayMs === void 0) throw error;
+      const verdict = verdictOf(error);
+      if (!verdict.retry) throw error;
+      const waitMs = verdict.afterMs ?? delayMs;
+      if (waitMs > MAX_WAIT_MS) throw error;
+      await retry.sleep(waitMs);
+      if (!await retry.shouldContinue()) throw new SendStoppedError(error);
+    }
+  }
+};
+
 // src/splitMessage.ts
 var splitMessage = (text4, limit) => {
   if (text4.length <= limit) return [text4];
@@ -131640,19 +131859,39 @@ var LARK_TEXT_MAX_CHARS = 3500;
 var LarkApiError = class extends Error {
   operation;
   code;
-  constructor(operation, code2, message) {
+  status;
+  retryAfterMs;
+  constructor(operation, code2, message, http = {}) {
     super(`lark ${operation} failed (code ${String(code2 ?? "?")}): ${message}`);
     this.name = "LarkApiError";
     this.operation = operation;
     this.code = code2;
+    this.status = http.status;
+    this.retryAfterMs = http.retryAfterMs;
   }
 };
-var isLarkPermissionError = (error) => error instanceof LarkApiError && (error.code === 99991672 || error.code === 99991679 || "status" in error && (error.status === 401 || error.status === 403));
+var isLarkPermissionError = (error) => error instanceof LarkApiError && (error.code === 99991672 || error.code === 99991679 || error.status === 401 || error.status === 403);
+var LARK_RATE_LIMITED = 99991400;
+var isReplyRejected = (error) => error instanceof LarkApiError && error.status === void 0 && error.code !== LARK_RATE_LIMITED;
+var larkSendVerdict = (error) => {
+  if (!(error instanceof LarkApiError)) return NO_RETRY;
+  if (error.status === 429 || error.code === LARK_RATE_LIMITED) {
+    return { retry: true, afterMs: error.retryAfterMs };
+  }
+  if (error.status !== void 0 && error.status >= 500) {
+    return { retry: true, afterMs: error.retryAfterMs };
+  }
+  return NO_RETRY;
+};
 var readEnvelope = async (operation, response) => {
   if (!response.ok) {
     await response.body?.cancel().catch(() => void 0);
-    throw Object.assign(new LarkApiError(operation, void 0, `HTTP ${String(response.status)}`), {
-      status: response.status
+    throw new LarkApiError(operation, void 0, `HTTP ${String(response.status)}`, {
+      status: response.status,
+      retryAfterMs: parseRetryAfterMs(
+        response.headers.get("retry-after") ?? response.headers.get("x-ogw-ratelimit-reset"),
+        Date.now()
+      ) ?? void 0
     });
   }
   const body = await response.json();
@@ -131679,35 +131918,37 @@ var postMessage = async (input) => {
     authorization: `Bearer ${input.token}`,
     "content-type": "application/json; charset=utf-8"
   };
-  const message = { msg_type: input.msgType, content: JSON.stringify(input.content) };
-  const sentOf = async (response2) => (await readEnvelope(input.operation, response2)).data;
+  const message = {
+    msg_type: input.msgType,
+    content: JSON.stringify(input.content),
+    ...input.retry === void 0 ? {} : { uuid: crypto.randomUUID() }
+  };
+  const post = (url, body) => sendWithRetry(
+    async () => (await readEnvelope(
+      input.operation,
+      await input.http(url, { method: "POST", headers, body: JSON.stringify(body) })
+    )).data,
+    larkSendVerdict,
+    input.retry
+  );
   if (input.reply !== void 0) {
     try {
-      const response2 = await input.http(
+      const sent2 = await post(
         `${LARK_BASE}/im/v1/messages/${encodeURIComponent(input.reply.messageId)}/reply`,
-        {
-          method: "POST",
-          headers,
-          body: JSON.stringify({
-            ...message,
-            ...input.reply.inThread ? { reply_in_thread: true } : {}
-          })
-        }
+        { ...message, ...input.reply.inThread ? { reply_in_thread: true } : {} }
       );
-      const sent = await sentOf(response2);
-      if (input.reply.inThread) input.onThreadReply?.(sent?.thread_id || void 0);
-      return sent?.message_id ?? null;
+      if (input.reply.inThread) input.onThreadReply?.(sent2?.thread_id || void 0);
+      return sent2?.message_id ?? null;
     } catch (error) {
-      if (!(error instanceof LarkApiError)) throw error;
+      if (!isReplyRejected(error)) throw error;
     }
   }
   const idType = input.receiveIdType ?? "chat_id";
-  const response = await input.http(`${LARK_BASE}/im/v1/messages?receive_id_type=${idType}`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify({ receive_id: input.chatId, ...message })
+  const sent = await post(`${LARK_BASE}/im/v1/messages?receive_id_type=${idType}`, {
+    receive_id: input.chatId,
+    ...message
   });
-  return (await sentOf(response))?.message_id ?? null;
+  return sent?.message_id ?? null;
 };
 var readMessage = async (input) => {
   const response = await input.http(
@@ -137310,7 +137551,7 @@ var UNSUPPORTED_MESSAGE_TYPES = /* @__PURE__ */ new Set([
   "share_chat",
   "share_user",
   "system",
-  "merge",
+  "merge_forward",
   "interactive"
 ]);
 var botIdsOf = (mentions, appId) => {
@@ -137482,6 +137723,7 @@ var cardActionOperator = (event) => {
   }
   return null;
 };
+var isLarkAppId = (appId) => /^cli_[0-9a-fA-F]{16}$/u.test(appId);
 var startLarkInbound = (input) => {
   const dispatcher = new import_node_sdk.EventDispatcher({}).register({
     "im.message.receive_v1": (event) => {
@@ -137523,20 +137765,42 @@ var startLarkInbound = (input) => {
       return notice === null ? {} : { toast: { type: "info", content: notice } };
     }
   });
+  if (!isLarkAppId(input.appId)) {
+    input.onConnectionState?.({ state: "failed", reason: "invalid-app-id" });
+    return { close: () => void 0 };
+  }
+  let closed = false;
+  const connected = () => {
+    if (!closed) input.onConnectionState?.({ state: "connected" });
+  };
+  const failed = (error) => {
+    if (!closed) {
+      input.onConnectionState?.({ state: "failed", reason: "disconnected", error });
+    }
+  };
   const client = new import_node_sdk.WSClient({
     appId: input.appId,
     appSecret: input.appSecret,
     ...input.domain === void 0 ? {} : { domain: input.domain },
     autoReconnect: true,
-    onError: (cause) => input.onError(cause.message)
+    onReady: connected,
+    onReconnected: connected,
+    onReconnecting: () => failed(),
+    onError: (cause) => {
+      if (closed) return;
+      failed(cause);
+      input.onError(cause.message);
+    }
   });
-  void client.start({ eventDispatcher: dispatcher });
-  return { close: () => client.close({ force: true }) };
+  void client.start({ eventDispatcher: dispatcher }).catch(failed);
+  return {
+    close: () => {
+      closed = true;
+      client.close({ force: true });
+    }
+  };
 };
 
-// src/replyReference.ts
-import * as NodeCrypto2 from "node:crypto";
-
 // src/deadline.ts
 var withDeadline2 = async (timeoutMs, load) => {
   const signal = AbortSignal.timeout(timeoutMs);
@@ -137554,6 +137818,7 @@ var withDeadline2 = async (timeoutMs, load) => {
 };
 
 // src/replyReference.ts
+import * as NodeCrypto3 from "node:crypto";
 var CONTENT_MAX = 8e3;
 var ATTACHMENTS_MAX = 20;
 var AUTHOR_MAX = 256;
@@ -137626,15 +137891,16 @@ var formatReplyReference = (reference2) => {
     ...lines.map((line) => `> ${line}`)
   ].join("\n");
 };
-var textWithInboundContext = (message, rowId, t) => {
-  const reply = formatReplyReference(message.replyTo);
-  const text4 = reply === null ? message.text : `${reply}
-
-${message.text}`;
+var textWithInboundContext = (message, rowId, t, topicRoot) => {
+  const text4 = [
+    formatReplyReference(topicRoot),
+    formatReplyReference(message.replyTo),
+    message.text
+  ].filter((part) => part !== null).join("\n\n");
   if (message.chatKind !== "group" || message.senderId === null) return text4;
   let name = cleanString(message.senderName, AUTHOR_MAX).value;
   if (!name) {
-    const code2 = NodeCrypto2.createHash("sha256").update(JSON.stringify([rowId, message.senderId])).digest("hex").slice(0, 4);
+    const code2 = NodeCrypto3.createHash("sha256").update(JSON.stringify([rowId, message.senderId])).digest("hex").slice(0, 4);
     name = t("source.member", { code: code2 });
   }
   const chat = cleanString(message.chatTitle, AUTHOR_MAX).value;
@@ -137687,6 +137953,26 @@ var makeLookup = (rowId, load) => {
 };
 var makeLarkMessageContext = (deps) => {
   let contactDenied = false;
+  const deliveredRoots = makeBoundedSeen(CACHE_LIMIT);
+  const loadReference = (messageId) => loadReplyReference(async (signal) => {
+    const token = await deps.tenantToken();
+    signal.throwIfAborted();
+    return fetchMessageReference({ http: deps.http, token, messageId, signal });
+  });
+  const topicRootForSession = (message) => {
+    const topic = message.topic;
+    if (topic === void 0 || topic.rootGiven === false) return void 0;
+    return async (recipientId) => {
+      const key = JSON.stringify([message.chatId, topic.rootMessageId, recipientId]);
+      if (deliveredRoots.has(key)) return void 0;
+      return {
+        reference: topic.rootMessageId === message.messageId ? void 0 : await loadReference(topic.rootMessageId),
+        confirmConsumed: () => {
+          deliveredRoots.claim(key);
+        }
+      };
+    };
+  };
   const userName = makeLookup(deps.rowId, async (openId, signal) => {
     try {
       const token = await deps.tenantToken();
@@ -137713,7 +137999,7 @@ var makeLarkMessageContext = (deps) => {
     });
     return name instanceof Promise || chat instanceof Promise ? Promise.all([name, chat]).then(([senderName, info]) => fields(senderName, info)) : fields(name, chat);
   };
-  return { chatInfo, forMessage };
+  return { chatInfo, forMessage, loadReference, topicRootForSession };
 };
 
 // src/larkAdapter.ts
@@ -137755,6 +138041,7 @@ var larkConfigIssues = (binding) => {
   const { appId, appSecret } = credentials(binding);
   const issues = [];
   if (appId === "") issues.push({ column: "larkAppId", code: "required" });
+  else if (!isLarkAppId(appId)) issues.push({ column: "larkAppId", code: "format" });
   if (appSecret === "") issues.push({ column: "larkAppSecret", code: "required" });
   return issues;
 };
@@ -137842,7 +138129,7 @@ var makeLarkAdapter = (deps) => {
       return rootMessageId === void 0 ? void 0 : groupId;
     },
     validate: larkConfigIssues,
-    isConfigured: (binding) => larkConfigIssues(binding).length === 0,
+    isConfigured: (binding) => larkConfigIssues(binding).every((issue) => issue.code !== "required"),
     connect: (binding, handlers) => {
       const { appId, appSecret } = credentials(binding);
       const port = {
@@ -137871,6 +138158,7 @@ var makeLarkAdapter = (deps) => {
         topicOnMention: topicOnMentionOf(binding),
         isSoloGroup: soloGroupFor(context),
         onError: handlers.onError,
+        ...handlers.onConnectionState === void 0 ? {} : { onConnectionState: handlers.onConnectionState },
         onCardAction: handlers.onButton,
         onPanelClick: (click, operatorOpenId) => handlers.onPanelClick?.({
           chatId: click.chatId,
@@ -137883,14 +138171,7 @@ var makeLarkAdapter = (deps) => {
           const { topic } = message;
           const source = context.forMessage(message);
           const parentMessageId = message.parentMessageId;
-          const reference2 = parentMessageId === void 0 ? null : loadReplyReference(
-            async (signal) => fetchMessageReference({
-              http: deps.http,
-              token: await tenantToken(binding),
-              messageId: parentMessageId,
-              signal
-            })
-          );
+          const reference2 = parentMessageId === void 0 ? null : context.loadReference(parentMessageId);
           const deliver = (names, replyTo) => handlers.onMessage({
             messageId: message.messageId,
             // 已经开出来的话题就是它自己那个聊天；将要开出来的（主窗口里 @ 机器人）先算群的，
@@ -137906,6 +138187,7 @@ var makeLarkAdapter = (deps) => {
             senderId: message.senderOpenId,
             ...names,
             text: message.text,
+            topicRootForSession: context.topicRootForSession(message),
             ...replyTo === void 0 ? {} : { replyTo },
             chatKind: message.chatType === "p2p" ? "private" : "group",
             replyInThread: message.inThread,
@@ -137960,7 +138242,8 @@ var makeLarkAdapter = (deps) => {
         const messageId = await sendChatText({
           ...target2,
           receiveIdType,
-          text: chunk
+          text: chunk,
+          retry: options?.retry
         });
         deps.log.info("lark delivered a message", { messageId, bot: binding.displayName });
       }
@@ -137974,6 +138257,9 @@ var makeLarkAdapter = (deps) => {
           detail: "missing app id or secret in saved config"
         };
       }
+      if (!isLarkAppId(appId)) {
+        return { stage: "credentials", ok: false, detail: "malformed app id in saved config" };
+      }
       try {
         const { expiresInSeconds } = await fetchTenantToken({ http: deps.http, appId, appSecret });
         return {
@@ -138295,7 +138581,7 @@ var en_default = {
     },
     wecomAppListenPort: {
       label: "Local callback port (optional)",
-      description: "Defaults to 30987. Self-built apps listening on the same address share one port.",
+      description: "Defaults to 30987. Self-built apps listening on the same address share one port; rows with different listen addresses (say 0.0.0.0 and 127.0.0.1) need different ports, or the second one fails to listen.",
       placeholder: "30987"
     },
     wecomAppListenHost: {
@@ -138313,6 +138599,7 @@ var en_default = {
     }
   },
   reply: {
+    wecomDeliveryFailed: "This reply didn't reach {{recipient}} in WeCom: they are outside this app's visible range. Add them to the app's visible range in the WeCom admin console, then ask the agent to send it again.",
     conclusionRecovered: "(Finished while restarting; delivered now)",
     notAllowed: "You are not on this bot's allow list, so this tap had no effect.",
     noDefaultModel: 'Project "{{title}}" has no agent selected yet, so a thread cannot be started. Send /model to pick one, or set a default in the project settings, then message again.',
@@ -138668,13 +138955,16 @@ var en_default = {
       description: "Verify platform credentials still work; does not open a session or call a model.",
       running: "Checking {{rowId}}\u2026",
       done: "Connection OK",
-      failed: "Connection failed (ref {{ref}})",
+      failed: "Connection failed",
       notSaved: "Save this row first (credentials are read from saved config only).",
       hint: {
-        badToken: "This does not look like a bot token. Copy it again from BotFather: digits, a colon, then the key (ref {{ref}})",
-        unauthorized: "Telegram does not accept this token. It may have been revoked; get the current one from BotFather (ref {{ref}})",
-        notBot: "This token does not belong to a bot. Use the token BotFather gave you (ref {{ref}})",
-        webhookActive: "This bot has a webhook set by another service, so it cannot receive messages here. Remove the webhook there, then check again (ref {{ref}})"
+        badToken: "This does not look like a bot token. Copy it again from BotFather: digits, a colon, then the key.",
+        unauthorized: "Telegram does not accept this token. It may have been revoked; get the current one from BotFather.",
+        notBot: "This token does not belong to a bot. Use the token BotFather gave you.",
+        webhookActive: "This bot has a webhook set by another service, so it cannot receive messages here. Remove the webhook there, then check again.",
+        wecomTrustedIp: "Add this machine's outbound public IP to the app's trusted IP list in the WeCom admin console.",
+        wecomInvalidUser: "Check that the recipient, department or tag exists and is in this app's visible range.",
+        wecomInvalidAgent: "Check the AgentId against this self-built application in the WeCom admin console."
       }
     },
     copyDiagnostics: {
@@ -138682,24 +138972,24 @@ var en_default = {
       description: "Run a connection probe and produce copy-paste diagnostics (no secrets).",
       running: "Building diagnostics for {{rowId}}\u2026",
       done: "Diagnostics ready \u2014 see details below",
-      failed: "Diagnostics failed (ref {{ref}})",
+      failed: "Diagnostics failed",
       notSaved: "Save this row first before copying diagnostics."
     },
     diagnostic: {
-      ref: "Ref {{ref}}\n{{detail}}"
+      ref: "Reference: {{ref}}\n{{detail}}"
     },
     larkRepair: {
       label: "Repair scopes",
-      description: "Verify the Lark app can still mint a token and list scope / publish steps.",
+      description: "Check whether the saved credentials can mint a token; scopes, event subscriptions and publishing are not checked automatically.",
       step: {
-        scopes: "Confirm message / resource / panel scopes",
-        events: "Confirm long connection and event subscriptions",
-        publish: "Publish if scopes were added",
+        scopes: "Scopes \u2014 not checked",
+        events: "Event subscriptions \u2014 not checked",
+        publish: "Publishing \u2014 not checked",
         verify: "Verify the app can still mint a tenant token"
       },
-      done: "Credentials work; add any missing scopes in the Feishu console and publish",
-      hint: "Ref {{ref}}\n{{detail}}\nIf scopes are missing, request them on the Feishu open platform and publish; a chat /repair command will follow.",
-      failed: "Could not verify the Lark app (ref {{ref}})",
+      done: "Only token issuance was verified. Scopes, event subscriptions and publishing were not checked automatically; review them on the Feishu open platform.",
+      hint: "Reference: {{ref}}\n{{detail}}\nReview scopes, event subscriptions and publishing on the Feishu open platform; none were checked automatically.",
+      failed: "Could not mint a token with the saved credentials. Scopes, event subscriptions and publishing were not checked automatically; review them on the Feishu open platform.",
       notLark: "This row is not a saved Lark bot."
     }
   },
@@ -138738,7 +139028,23 @@ var en_default = {
     removeFailed: "Couldn't delete this bot.",
     status: {
       ready: "Ready",
-      incomplete: "Incomplete"
+      incomplete: "Incomplete",
+      connecting: "Connecting",
+      connected: "Connected",
+      notConnected: "Not connected"
+    },
+    connection: {
+      failed: "The last connection attempt failed.",
+      details: "Details: {{error}}",
+      reason: {
+        "not-available": "This platform can't be connected yet.",
+        "invalid-app-id": "The App ID isn't in the right format.",
+        disconnected: "The connection to the platform is down.",
+        "subscription-failed": "The platform didn't confirm the subscription.",
+        "token-unavailable": "Couldn't get an access token.",
+        "credentials-rejected": "The platform rejected the credentials."
+      },
+      duplicate: "Uses the same credentials as \u201C{{name}}\u201D. Only that row connects."
     },
     secret: {
       saved: "Saved. Leave blank to keep it.",
@@ -138977,7 +139283,7 @@ var zh_CN_default = {
     },
     wecomAppListenPort: {
       label: "\u672C\u673A\u56DE\u8C03\u7AEF\u53E3\uFF08\u53EF\u9009\uFF09",
-      description: "\u9ED8\u8BA4 30987\u3002\u76D1\u542C\u5730\u5740\u76F8\u540C\u7684\u81EA\u5EFA\u5E94\u7528\u5171\u7528\u4E00\u4E2A\u7AEF\u53E3\u3002",
+      description: "\u9ED8\u8BA4 30987\u3002\u76D1\u542C\u5730\u5740\u76F8\u540C\u7684\u81EA\u5EFA\u5E94\u7528\u5171\u7528\u4E00\u4E2A\u7AEF\u53E3\uFF1B\u76D1\u542C\u5730\u5740\u4E0D\u540C\u7684\u4E24\u884C\uFF08\u6BD4\u5982 0.0.0.0 \u548C 127.0.0.1\uFF09\u8981\u7528\u4E0D\u540C\u7AEF\u53E3\uFF0C\u5426\u5219\u540E\u4E00\u4E2A\u76D1\u542C\u4E0D\u8D77\u6765\u3002",
       placeholder: "30987"
     },
     wecomAppListenHost: {
@@ -138995,6 +139301,7 @@ var zh_CN_default = {
     }
   },
   reply: {
+    wecomDeliveryFailed: "\u8FD9\u6761\u56DE\u590D\u6CA1\u9001\u5230\u4F01\u4E1A\u5FAE\u4FE1\u91CC\u7684 {{recipient}}\uFF1A\u5BF9\u65B9\u4E0D\u5728\u8FD9\u4E2A\u5E94\u7528\u7684\u53EF\u89C1\u8303\u56F4\u3002\u5230\u4F01\u4E1A\u5FAE\u4FE1\u7BA1\u7406\u540E\u53F0\u628A\u4ED6\u4EEC\u52A0\u8FDB\u5E94\u7528\u7684\u53EF\u89C1\u8303\u56F4\uFF0C\u518D\u8BA9 agent \u91CD\u53D1\u4E00\u6B21\u3002",
     conclusionRecovered: "\uFF08\u91CD\u542F\u671F\u95F4\u5B8C\u6210\uFF0C\u73B0\u5728\u8865\u53D1\uFF09",
     notAllowed: "\u4F60\u4E0D\u5728\u8FD9\u4E2A\u673A\u5668\u4EBA\u7684\u5141\u8BB8\u540D\u5355\u91CC\uFF0C\u8FD9\u6B21\u70B9\u51FB\u6CA1\u6709\u751F\u6548\u3002",
     noDefaultModel: "\u9879\u76EE\u300C{{title}}\u300D\u8FD8\u6CA1\u9009 agent\uFF0C\u5F00\u4E0D\u4E86\u4F1A\u8BDD\u3002\u53D1 /model \u9009\u4E00\u4E2A\uFF0C\u6216\u8005\u5230\u9879\u76EE\u8BBE\u7F6E\u91CC\u8BBE\u4E2A\u9ED8\u8BA4\uFF0C\u518D\u53D1\u4E00\u6B21\u6D88\u606F\u3002",
@@ -139350,13 +139657,16 @@ var zh_CN_default = {
       description: "\u9A8C\u8BC1\u5E73\u53F0\u51ED\u636E\u662F\u5426\u4ECD\u53EF\u7528\uFF1B\u4E0D\u4F1A\u5F00\u4F1A\u8BDD\uFF0C\u4E5F\u4E0D\u4F1A\u8C03\u6A21\u578B\u3002",
       running: "\u6B63\u5728\u68C0\u67E5 {{rowId}} \u2026",
       done: "\u8FDE\u63A5\u6B63\u5E38",
-      failed: "\u8FDE\u63A5\u5931\u8D25\uFF08\u53C2\u8003\u53F7 {{ref}}\uFF09",
+      failed: "\u8FDE\u63A5\u5931\u8D25",
       notSaved: "\u8BF7\u5148\u4FDD\u5B58\u8FD9\u4E00\u884C\u518D\u68C0\u67E5\u8FDE\u63A5\uFF08\u51ED\u636E\u53EA\u4ECE\u5DF2\u4FDD\u5B58\u914D\u7F6E\u8BFB\u53D6\uFF09\u3002",
       hint: {
-        badToken: "\u8FD9\u4E0D\u50CF\u673A\u5668\u4EBA\u7684 token\u3002\u5230 BotFather \u91CD\u65B0\u590D\u5236\u4E00\u4EFD\uFF1A\u6570\u5B57\u3001\u5192\u53F7\uFF0C\u540E\u9762\u662F\u5BC6\u94A5\uFF08\u53C2\u8003\u53F7 {{ref}}\uFF09",
-        unauthorized: "Telegram \u4E0D\u8BA4\u8FD9\u4E2A token\uFF0C\u53EF\u80FD\u5DF2\u7ECF\u4F5C\u5E9F\u3002\u5230 BotFather \u53D6\u73B0\u5728\u7684\u90A3\u4E00\u4EFD\uFF08\u53C2\u8003\u53F7 {{ref}}\uFF09",
-        notBot: "\u8FD9\u4E2A token \u4E0D\u662F\u673A\u5668\u4EBA\u7684\u3002\u8BF7\u7528 BotFather \u7ED9\u7684\u90A3\u4E00\u4EFD\uFF08\u53C2\u8003\u53F7 {{ref}}\uFF09",
-        webhookActive: "\u8FD9\u4E2A\u673A\u5668\u4EBA\u88AB\u522B\u7684\u670D\u52A1\u8BBE\u4E86 webhook\uFF0C\u5728\u8FD9\u91CC\u6536\u4E0D\u5230\u6D88\u606F\u3002\u5148\u5230\u90A3\u8FB9\u64A4\u6389 webhook\uFF0C\u518D\u68C0\u67E5\u4E00\u6B21\uFF08\u53C2\u8003\u53F7 {{ref}}\uFF09"
+        badToken: "\u8FD9\u4E0D\u50CF\u673A\u5668\u4EBA\u7684 token\u3002\u5230 BotFather \u91CD\u65B0\u590D\u5236\u4E00\u4EFD\uFF1A\u6570\u5B57\u3001\u5192\u53F7\uFF0C\u540E\u9762\u662F\u5BC6\u94A5\u3002",
+        unauthorized: "Telegram \u4E0D\u8BA4\u8FD9\u4E2A token\uFF0C\u53EF\u80FD\u5DF2\u7ECF\u4F5C\u5E9F\u3002\u5230 BotFather \u53D6\u73B0\u5728\u7684\u90A3\u4E00\u4EFD\u3002",
+        notBot: "\u8FD9\u4E2A token \u4E0D\u662F\u673A\u5668\u4EBA\u7684\u3002\u8BF7\u7528 BotFather \u7ED9\u7684\u90A3\u4E00\u4EFD\u3002",
+        webhookActive: "\u8FD9\u4E2A\u673A\u5668\u4EBA\u88AB\u522B\u7684\u670D\u52A1\u8BBE\u4E86 webhook\uFF0C\u5728\u8FD9\u91CC\u6536\u4E0D\u5230\u6D88\u606F\u3002\u5148\u5230\u90A3\u8FB9\u64A4\u6389 webhook\uFF0C\u518D\u68C0\u67E5\u4E00\u6B21\u3002",
+        wecomTrustedIp: "\u628A\u8FD9\u53F0\u673A\u5668\u7684\u51FA\u7AD9\u516C\u7F51 IP \u52A0\u8FDB\u4F01\u4E1A\u5FAE\u4FE1\u540E\u53F0\u8FD9\u4E2A\u5E94\u7528\u7684\u4F01\u4E1A\u53EF\u4FE1 IP\u3002",
+        wecomInvalidUser: "\u786E\u8BA4\u6536\u4EF6\u4EBA\u3001\u90E8\u95E8\u6216\u6807\u7B7E\u5B58\u5728\uFF0C\u5E76\u5728\u8FD9\u4E2A\u81EA\u5EFA\u5E94\u7528\u7684\u53EF\u89C1\u8303\u56F4\u5185\u3002",
+        wecomInvalidAgent: "\u6838\u5BF9\u4F01\u4E1A\u5FAE\u4FE1\u540E\u53F0\u8FD9\u4E2A\u81EA\u5EFA\u5E94\u7528\u7684 AgentId\u3002"
       }
     },
     copyDiagnostics: {
@@ -139364,24 +139674,24 @@ var zh_CN_default = {
       description: "\u8DD1\u4E00\u6B21\u8FDE\u63A5\u63A2\u6D4B\uFF0C\u751F\u6210\u53EF\u590D\u5236\u7684\u8BCA\u65AD\u6587\u672C\uFF08\u4E0D\u542B\u5BC6\u94A5\uFF09\u3002",
       running: "\u6B63\u5728\u751F\u6210\u8BCA\u65AD {{rowId}} \u2026",
       done: "\u8BCA\u65AD\u5DF2\u751F\u6210\uFF0C\u89C1\u4E0B\u65B9\u8BE6\u60C5",
-      failed: "\u8BCA\u65AD\u5931\u8D25\uFF08\u53C2\u8003\u53F7 {{ref}}\uFF09",
+      failed: "\u8BCA\u65AD\u5931\u8D25",
       notSaved: "\u8BF7\u5148\u4FDD\u5B58\u8FD9\u4E00\u884C\u518D\u590D\u5236\u8BCA\u65AD\u3002"
     },
     diagnostic: {
-      ref: "\u53C2\u8003\u53F7 {{ref}}\n{{detail}}"
+      ref: "\u53C2\u8003\u53F7\uFF1A{{ref}}\n{{detail}}"
     },
     larkRepair: {
       label: "\u8865\u5168\u6743\u9650",
-      description: "\u6838\u5BF9\u98DE\u4E66\u5E94\u7528\u4ECD\u80FD\u6362 token\uFF0C\u5E76\u63D0\u793A\u9700\u8981\u8865\u7684\u6743\u9650\u4E0E\u53D1\u5E03\u6B65\u9AA4\u3002",
+      description: "\u68C0\u67E5\u5DF2\u4FDD\u5B58\u7684\u51ED\u636E\u80FD\u5426\u6362\u53D6 token\uFF1B\u6743\u9650\u3001\u4E8B\u4EF6\u8BA2\u9605\u548C\u53D1\u5E03\u4E0D\u4F1A\u81EA\u52A8\u68C0\u67E5\u3002",
       step: {
-        scopes: "\u786E\u8BA4\u6D88\u606F / \u8D44\u6E90 / \u9762\u677F\u7B49\u6743\u9650",
-        events: "\u786E\u8BA4\u957F\u8FDE\u63A5\u4E0E\u4E8B\u4EF6\u8BA2\u9605",
-        publish: "\u5982\u6709\u589E\u91CF\u6743\u9650\uFF0C\u5B8C\u6210\u53D1\u5E03\u5BA1\u6279",
+        scopes: "\u6743\u9650\uFF1A\u672A\u68C0\u67E5",
+        events: "\u4E8B\u4EF6\u8BA2\u9605\uFF1A\u672A\u68C0\u67E5",
+        publish: "\u53D1\u5E03\uFF1A\u672A\u68C0\u67E5",
         verify: "\u9A8C\u8BC1\u5E94\u7528\u4ECD\u53EF\u6362\u53D6 tenant token"
       },
-      done: "\u51ED\u636E\u53EF\u7528\uFF1B\u82E5\u6743\u9650\u4E0D\u8DB3\u8BF7\u6309\u98DE\u4E66\u63A7\u5236\u53F0\u8865\u9F50\u540E\u53D1\u5E03",
-      hint: "\u53C2\u8003\u53F7 {{ref}}\n{{detail}}\n\u7F3A\u6743\u9650\u65F6\u53EF\u5728\u98DE\u4E66\u5F00\u653E\u5E73\u53F0\u5BF9\u8BE5\u5E94\u7528\u589E\u91CF\u7533\u8BF7\u5E76\u53D1\u5E03\uFF1B\u804A\u5929\u4FA7 /repair \u547D\u4EE4\u540E\u7EED\u8865\u9F50\u3002",
-      failed: "\u65E0\u6CD5\u9A8C\u8BC1\u98DE\u4E66\u5E94\u7528\uFF08\u53C2\u8003\u53F7 {{ref}}\uFF09",
+      done: "\u4EC5\u6838\u5B9E\u4E86\u51ED\u636E\u4ECD\u80FD\u6362\u53D6 token\uFF1B\u6743\u9650\u3001\u4E8B\u4EF6\u8BA2\u9605\u548C\u53D1\u5E03\u6CA1\u6709\u81EA\u52A8\u68C0\u67E5\uFF0C\u8BF7\u5230\u98DE\u4E66\u5F00\u653E\u5E73\u53F0\u6838\u5BF9\u3002",
+      hint: "\u53C2\u8003\u53F7\uFF1A{{ref}}\n{{detail}}\n\u8BF7\u5230\u98DE\u4E66\u5F00\u653E\u5E73\u53F0\u6838\u5BF9\u6743\u9650\u3001\u4E8B\u4EF6\u8BA2\u9605\u548C\u53D1\u5E03\uFF1B\u8FD9\u4E09\u9879\u5747\u672A\u81EA\u52A8\u68C0\u67E5\u3002",
+      failed: "\u5DF2\u4FDD\u5B58\u7684\u51ED\u636E\u672A\u80FD\u6362\u53D6 token\uFF1B\u6743\u9650\u3001\u4E8B\u4EF6\u8BA2\u9605\u548C\u53D1\u5E03\u6CA1\u6709\u81EA\u52A8\u68C0\u67E5\uFF0C\u8BF7\u5230\u98DE\u4E66\u5F00\u653E\u5E73\u53F0\u6838\u5BF9\u3002",
       notLark: "\u8FD9\u4E00\u884C\u4E0D\u662F\u5DF2\u4FDD\u5B58\u7684\u98DE\u4E66\u673A\u5668\u4EBA\u3002"
     }
   },
@@ -139419,8 +139729,24 @@ var zh_CN_default = {
     copyFailed: "\u6CA1\u590D\u5236\u4E0A\u3002",
     removeFailed: "\u6CA1\u80FD\u5220\u6389\u8FD9\u4E2A\u673A\u5668\u4EBA\u3002",
     status: {
-      ready: "\u53EF\u7528",
-      incomplete: "\u8FD8\u6CA1\u586B\u5B8C"
+      ready: "\u5C31\u7EEA",
+      incomplete: "\u5F85\u8865\u5168",
+      connecting: "\u8FDE\u63A5\u4E2D",
+      connected: "\u5DF2\u8FDE\u63A5",
+      notConnected: "\u672A\u8FDE\u63A5"
+    },
+    connection: {
+      failed: "\u4E0A\u6B21\u8FDE\u63A5\u6CA1\u6709\u6210\u529F\u3002",
+      details: "\u8BE6\u60C5\uFF1A{{error}}",
+      reason: {
+        "not-available": "\u8FD9\u4E2A\u5E73\u53F0\u8FD8\u4E0D\u80FD\u8FDE\u63A5\u3002",
+        "invalid-app-id": "App ID \u683C\u5F0F\u4E0D\u6B63\u786E\u3002",
+        disconnected: "\u548C\u5E73\u53F0\u7684\u8FDE\u63A5\u65AD\u4E86\u3002",
+        "subscription-failed": "\u5E73\u53F0\u6CA1\u6709\u786E\u8BA4\u8BA2\u9605\u3002",
+        "token-unavailable": "\u6CA1\u80FD\u6362\u5230\u8BBF\u95EE\u4EE4\u724C\u3002",
+        "credentials-rejected": "\u5E73\u53F0\u62D2\u7EDD\u4E86\u51ED\u636E\u3002"
+      },
+      duplicate: "\u548C\u300C{{name}}\u300D\u7528\u7684\u662F\u540C\u4E00\u4EFD\u51ED\u636E\uFF0C\u53EA\u8FDE\u90A3\u4E00\u884C\u3002"
     },
     secret: {
       saved: "\u5DF2\u7ECF\u5B58\u8FC7\uFF0C\u7559\u7A7A\u5C31\u4FDD\u6301\u539F\u503C\u3002",
@@ -139601,6 +139927,16 @@ var makeModelPlan = (core, deps) => {
 // src/notifications.ts
 import { readThreadFailed, threadOrNull as threadOrNull5 } from "@ycodium-ai/plugin-api";
 
+// src/conclusionOutbox.ts
+var enqueueConclusion = (core, ledger, binding, debt, send) => core.outbound(
+  chatKeyOf(binding),
+  async () => {
+    if (debt === void 0) await send();
+    else await ledger.deliver(debt, send);
+  },
+  { droppable: debt !== void 0 }
+);
+
 // src/conclusionRecovery.ts
 var MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
 var recoverConclusions = async (core, ledger, delivery, failures) => {
@@ -139608,6 +139944,12 @@ var recoverConclusions = async (core, ledger, delivery, failures) => {
   core.host.onDispose(() => {
     disposed = true;
   });
+  const couldNotRecover = (debt, error) => {
+    core.host.log.warn("chat could not recover a conclusion", {
+      ...debt,
+      error: describeError(error)
+    });
+  };
   await core.ready;
   for (const debt of Object.values(conclusionDebtsOf(core.state))) {
     if (disposed) return;
@@ -139634,24 +139976,27 @@ var recoverConclusions = async (core, ledger, delivery, failures) => {
       }
       const binding = core.bindingForChatKey(debt.chatKey);
       if (binding === void 0) continue;
-      await ledger.deliver(debt, async () => {
-        if (latest.state === "error") {
-          return delivery.failure(
-            binding,
-            debt.threadId,
-            failures.forFailure(debt.threadId, execution.session?.lastError),
-            true,
-            latest.turnId
-          );
+      enqueueConclusion(core, ledger, binding, debt, async (owed) => {
+        try {
+          if (latest.state === "error") {
+            return delivery.sendText(
+              binding,
+              debt.threadId,
+              failures.forFailure(debt.threadId, execution.session?.lastError),
+              true,
+              latest.turnId,
+              owed
+            );
+          }
+          const send = await delivery.prepareConclusion(debt.threadId, latest.turnId);
+          return send(binding, { recovered: true, streaming: false, owed });
+        } catch (error) {
+          couldNotRecover(debt, error);
+          return false;
         }
-        const send = await delivery.prepareConclusion(debt.threadId, latest.turnId);
-        return send(binding, { recovered: true, streaming: false });
       });
     } catch (error) {
-      core.host.log.warn("chat could not recover a conclusion", {
-        ...debt,
-        error: describeError(error)
-      });
+      couldNotRecover(debt, error);
     }
   }
 };
@@ -139674,7 +140019,7 @@ var outcomeOfSession = (status) => {
 var THREAD_PROJECT_CACHE_LIMIT = 256;
 var makeNotifications = (core, deps) => {
   const { host, adapterFor, bindingForChatKey, ready } = core;
-  const { clearWorking } = deps;
+  const { takeWorking } = deps;
   const { turnCards } = deps.replyCards;
   const { failures, conclusions, delivery } = deps;
   void recoverConclusions(core, conclusions, delivery, failures);
@@ -139697,6 +140042,11 @@ var makeNotifications = (core, deps) => {
   });
   const streamsTo = (binding, threadId) => adapterFor(binding.platform)?.turnCards !== void 0 && owns(binding, threadId);
   const owns = (binding, threadId) => chatOfThread(core.state, threadId) === chatKeyOf(binding);
+  const later = (binding, work) => {
+    core.outbound(chatKeyOf(binding), async () => {
+      await work();
+    });
+  };
   const threadsWithSomethingToReport = /* @__PURE__ */ new Set();
   host.reactor({
     name: "im.assistant-messages",
@@ -139719,32 +140069,38 @@ var makeNotifications = (core, deps) => {
       const said = threadsWithSomethingToReport.delete(threadId);
       await ready;
       const targets = targetsForProject(threadId, await projectOfThread(threadId));
-      const owes = Object.values(conclusionDebtsOf(core.state)).some(
-        (debt2) => debt2.threadId === threadId
-      );
-      const { debt, handled, execution } = said || owes ? await conclusions.forTurn(threadId) : { debt: void 0, handled: false, execution: null };
+      const { debt, handled, execution } = await conclusions.forTurn(threadId);
       if (debt !== void 0) {
         const binding = bindingForChatKey(debt.chatKey);
         if (binding !== void 0 && !streamsTo(binding, threadId) && execution?.session?.activeTurnId == null && execution?.latestTurn?.state !== "running" && execution?.latestTurn?.state !== "error" && payload.session?.status !== "error") {
-          await conclusions.deliver(debt, async () => {
-            const send = await delivery.prepareConclusion(
-              threadId,
-              execution?.latestTurn?.turnId ?? null
-            );
-            return send(binding, { recovered: false, streaming: false });
+          const turnId = execution?.latestTurn?.turnId ?? null;
+          enqueueConclusion(core, conclusions, binding, debt, async (owed) => {
+            const send = await delivery.prepareConclusion(threadId, turnId);
+            return send(binding, { recovered: false, streaming: false, owed });
           });
         }
       } else if (said && !handled) {
         const send = await delivery.prepareConclusion(threadId);
         for (const binding of targets) {
-          await send(binding, {
-            recovered: false,
-            streaming: streamsTo(binding, threadId)
-          });
+          const streaming = streamsTo(binding, threadId);
+          enqueueConclusion(
+            core,
+            conclusions,
+            binding,
+            void 0,
+            () => send(binding, { recovered: false, streaming })
+          );
         }
       }
       const outcome = outcomeOfSession(payload.session?.status);
-      for (const binding of targets) await clearWorking(binding, threadId, outcome);
+      for (const binding of targets) {
+        const withdraw = takeWorking(binding, threadId, outcome);
+        turnCards.afterTurn(
+          threadId,
+          () => later(binding, withdraw),
+          execution?.latestTurn?.turnId ?? null
+        );
+      }
     }
   });
   host.events.on("thread.failed", async (event) => {
@@ -139753,7 +140109,7 @@ var makeNotifications = (core, deps) => {
     threadsWithSomethingToReport.delete(threadId);
     await ready;
     const targets = targetsForProject(threadId, await projectOfThread(threadId));
-    const { debt, handled } = await conclusions.forTurn(threadId);
+    const { debt, handled, execution } = await conclusions.forTurn(threadId);
     const debtBinding = debt === void 0 ? void 0 : bindingForChatKey(debt.chatKey);
     const recipients = debt !== void 0 ? debtBinding === void 0 ? [] : [debtBinding] : targets;
     const textTargets = handled ? [] : recipients.filter(
@@ -139763,16 +140119,20 @@ var makeNotifications = (core, deps) => {
     const notice = textTargets.length > 0 || drawingTurn !== null ? failures.forFailure(threadId, readThreadFailed(event)?.detail) : null;
     if (notice !== null && drawingTurn !== null)
       failures.holdForCard(threadId, drawingTurn, notice);
-    for (const binding of targets) {
-      await clearWorking(binding, threadId, "failed");
-    }
     if (notice !== null) {
       for (const binding of textTargets) {
-        const send = () => delivery.failure(binding, threadId, notice, false);
-        if (debt !== void 0) await conclusions.deliver(debt, send);
-        else await send();
+        const send = (owed) => delivery.sendText(binding, threadId, notice, false, null, owed);
+        enqueueConclusion(core, conclusions, binding, debt, send);
       }
     }
+    for (const binding of targets) {
+      const withdraw = takeWorking(binding, threadId, "failed");
+      turnCards.afterTurn(
+        threadId,
+        () => later(binding, withdraw),
+        execution?.latestTurn?.turnId ?? null
+      );
+    }
   });
   const rememberThreadProject = (threadId, projectId) => {
     projectByThread.set(threadId, projectId);
@@ -140333,32 +140693,6 @@ var makeProjectRows = (core) => {
   return { projectRowsFor, listedProjectsByChat };
 };
 
-// src/diagnostics.ts
-var PREFIX = {
-  conn: "IM-CONN",
-  msg: "IM-MSG",
-  setup: "IM-SETUP"
-};
-var shortSalt = () => {
-  const bytes = new Uint8Array(2);
-  crypto.getRandomValues(bytes);
-  return Array.from(bytes, (b) => b.toString(16).toUpperCase().padStart(2, "0")).join("");
-};
-var diagnosticRef = (kind, nowMs = Date.now()) => {
-  const stamp = nowMs.toString(36).toUpperCase();
-  return `${PREFIX[kind]}-${stamp}-${shortSalt()}`;
-};
-var formatDiagnosticCopy = (report) => [
-  `ref=${report.ref}`,
-  `ok=${report.ok ? "yes" : "no"}`,
-  `platform=${report.platform}`,
-  `bot=${report.botName}`,
-  `row=${report.rowId}`,
-  `stage=${report.stage}`,
-  `at=${report.at}`,
-  `detail=${report.detail}`
-].join("\n");
-
 // src/failureNotices.ts
 var makeFailureNotices = (core) => {
   const heldForCard = /* @__PURE__ */ new Map();
@@ -140450,20 +140784,12 @@ var trailingReply = (messages) => {
 var ROTATE = "rotate";
 var isDrawing = (live) => live.card !== null || live.reopen;
 var RECENT_ENDED_LIMIT = 256;
+var turnKey = (threadId, turnId) => JSON.stringify([threadId, turnId]);
 var makeTurnCards = (deps) => {
   const slots = /* @__PURE__ */ new Map();
-  const recentEnded = /* @__PURE__ */ new Map();
+  const recentEnded = makeBoundedSeen(RECENT_ENDED_LIMIT);
   const erroredThreads = /* @__PURE__ */ new Set();
   let disposed = false;
-  const rememberEnded = (threadId, turnId) => {
-    if (turnId === null) return;
-    recentEnded.delete(threadId);
-    recentEnded.set(threadId, turnId);
-    if (recentEnded.size > RECENT_ENDED_LIMIT) {
-      const oldest = recentEnded.keys().next().value;
-      if (oldest !== void 0) recentEnded.delete(oldest);
-    }
-  };
   const readTexts = async (live, progress) => {
     const texts = /* @__PURE__ */ new Map();
     for (const segment of progress.segments) {
@@ -140515,29 +140841,28 @@ var makeTurnCards = (deps) => {
     const turnId = progress.turnId ?? live?.turnId ?? null;
     const target2 = live?.target ?? deps.resolveTarget(threadId, turnId);
     if (target2 === null) return;
-    rememberEnded(threadId, turnId);
     if (end.status === "error") erroredThreads.add(threadId);
     const title = live?.title ?? await deps.titleOf(threadId);
     const view = await finalView(title, progress, live, end);
-    if (live?.card != null) {
-      const card = live.card;
-      const sent = await card.finish(view);
-      deps.onClosed(card.cardId);
-      if (deps.finalize !== void 0)
-        await deps.finalize(threadId, turnId, target2.chatKey, async () => sent);
-      return;
-    }
-    const send = async () => {
-      const card = await openCard(target2, view);
-      return card !== null || await deps.fallback(threadId, turnId, target2.chatKey, view);
-    };
-    if (deps.finalize === void 0) await send();
-    else await deps.finalize(threadId, turnId, target2.chatKey, send);
+    const card = live?.card ?? null;
+    const finished = card !== null && await card.finish(view);
+    if (card !== null) deps.onClosed(card.cardId);
+    const send = async () => finished || card === null && await openCard(target2, view) !== null;
+    const sent = deps.finalize === void 0 ? await send() : await deps.finalize(threadId, turnId, target2.chatKey, send);
+    if (!sent) await deps.fallback(threadId, turnId, target2.chatKey, view);
+    if (turnId !== null) recentEnded.claim(turnKey(threadId, turnId));
+    const callbacks = slot.afterTurn.get(turnId) ?? [];
+    slot.afterTurn.delete(turnId);
+    if (turnId !== null) {
+      callbacks.push(...slot.afterTurn.get(null) ?? []);
+      slot.afterTurn.delete(null);
+    }
+    for (const after of callbacks) after();
   };
   const handle = async (slot, threadId, item) => {
     await deps.ready;
     if (disposed) return;
-    if (item.turnId !== null && recentEnded.get(threadId) === item.turnId) return;
+    if (item.turnId !== null && recentEnded.has(turnKey(threadId, item.turnId))) return;
     let live = slot.live;
     if (live !== null) {
       const sameTurn = item.turnId === null || live.turnId === null || live.turnId === item.turnId;
@@ -140621,7 +140946,11 @@ var makeTurnCards = (deps) => {
       }
     } finally {
       slot.running = false;
-      if (slot.live === null && slot.queue.length === 0) slots.delete(threadId);
+      if (slot.live === null && slot.queue.length === 0) {
+        slots.delete(threadId);
+        for (const callbacks of slot.afterTurn.values()) for (const after of callbacks) after();
+        slot.afterTurn.clear();
+      }
     }
   };
   return {
@@ -140630,7 +140959,7 @@ var makeTurnCards = (deps) => {
       if (disposed) return;
       let slot = slots.get(threadId);
       if (slot === void 0) {
-        slot = { queue: [], running: false, live: null };
+        slot = { queue: [], running: false, live: null, afterTurn: /* @__PURE__ */ new Map() };
         slots.set(threadId, slot);
       }
       const last = slot.queue.at(-1);
@@ -140644,6 +140973,18 @@ var makeTurnCards = (deps) => {
         void pump(threadId, slot);
       }
     },
+    /** 撤回执只等所属轮次收尾；没有轮次 id 时仍等当前线程槽，不能在出站队列里等自己。 */
+    afterTurn: (threadId, work, turnId = null) => {
+      if (disposed) return;
+      const slot = slots.get(threadId);
+      if (slot === void 0 || turnId !== null && recentEnded.has(turnKey(threadId, turnId)))
+        work();
+      else {
+        const callbacks = slot.afterTurn.get(turnId) ?? [];
+        callbacks.push(work);
+        slot.afterTurn.set(turnId, callbacks);
+      }
+    },
     /**
      * 审批或提问答完了：封存这条会话开着的卡，下一拍另开一张。立刻返回；没有在画的卡、或
      * 平台不换卡，就什么都不做。
@@ -140670,7 +141011,10 @@ var makeTurnCards = (deps) => {
     /** 插件停用：放下所有在画的卡，不再发任何更新。卡会停在最后一拍，重启时被标「已中断」。 */
     dispose: () => {
       disposed = true;
-      for (const slot of slots.values()) slot.live?.card?.abandon();
+      for (const slot of slots.values()) {
+        slot.live?.card?.abandon();
+        slot.afterTurn.clear();
+      }
       slots.clear();
     }
   };
@@ -140678,7 +141022,7 @@ var makeTurnCards = (deps) => {
 
 // src/replyCards.ts
 var makeReplyCards = (core, failures, anchors, conclusions, delivery) => {
-  const { host, adapterFor, commit, deliver, bindingForChatKey, bindingOfThread, ready } = core;
+  const { host, adapterFor, commit, bindingForChatKey, bindingOfThread, ready } = core;
   const stopRequested = /* @__PURE__ */ new Set();
   const turnCards = makeTurnCards({
     ready,
@@ -140737,22 +141081,28 @@ var makeReplyCards = (core, failures, anchors, conclusions, delivery) => {
     onClosed: (cardId) => commit("turn-card-closed", { cardId }),
     finalize: async (threadId, turnId, chatKey, send) => {
       const { debt, handled } = await conclusions.forTurn(threadId, turnId);
-      if (handled) return;
-      if (debt === void 0) {
-        await send();
-        return;
-      }
-      if (!await conclusions.deliver(debt, send)) return;
+      if (handled) return true;
+      if (debt === void 0) return send();
+      if (!await conclusions.deliver(debt, send)) return false;
       const binding = bindingForChatKey(chatKey);
-      if (binding === void 0) return;
+      if (binding === void 0) return true;
       const sendConclusion = await delivery.prepareConclusion(threadId, turnId);
       await sendConclusion(binding, { recovered: false, streaming: true });
+      return true;
     },
     fallback: async (threadId, turnId, chatKey, view) => {
+      const { debt, handled } = await conclusions.forTurn(threadId, turnId);
+      if (handled) return;
       const binding = bindingForChatKey(chatKey);
-      if (binding === void 0) return false;
+      if (binding === void 0) return;
       const text4 = [view.body, view.errorText ?? ""].filter((part) => part !== "").join("\n\n");
-      return deliver(await anchors.anchored(binding, threadId, turnId), text4);
+      enqueueConclusion(
+        core,
+        conclusions,
+        binding,
+        debt,
+        (owed) => delivery.sendText(binding, threadId, text4, false, turnId, owed)
+      );
     },
     schedule: (run, delayMs) => {
       const timer = setTimeout(run, delayMs);
@@ -141122,7 +141472,7 @@ var makeSessions = (core) => {
 };
 
 // src/teamGoals.ts
-import * as NodeCrypto3 from "node:crypto";
+import * as NodeCrypto4 from "node:crypto";
 var isRecord2 = (value2) => typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 var teamGoalRequestId = (binding, messageId) => {
   const identity = JSON.stringify([
@@ -141132,7 +141482,7 @@ var teamGoalRequestId = (binding, messageId) => {
     binding.chatId,
     messageId
   ]);
-  return NodeCrypto3.createHash("sha256").update(identity).digest("hex");
+  return NodeCrypto4.createHash("sha256").update(identity).digest("hex");
 };
 var makeTeamGoals = (core) => {
   const { host, t, deliver, commit } = core;
@@ -141153,14 +141503,16 @@ var makeTeamGoals = (core) => {
   };
   const startTeamGoal = async (binding, message) => {
     try {
+      const requestId = teamGoalRequestId(binding, message.messageId);
+      const topicRoot = await message.topicRootForSession?.(requestId);
       const result = await host.plugins.invoke({
         pluginId: "team",
         command: "startGoal",
         payload: {
           projectId: binding.projectId,
-          goal: textWithInboundContext(message, binding.rowId, t),
+          goal: textWithInboundContext(message, binding.rowId, t, topicRoot?.reference),
           titleSeed: message.text,
-          requestId: teamGoalRequestId(binding, message.messageId)
+          requestId
         }
       });
       if (isRecord2(result) && result._tag === "TeamGoalRejection") {
@@ -141175,6 +141527,7 @@ var makeTeamGoals = (core) => {
       if (!isRecord2(result) || typeof result.leadThreadId !== "string" || result.leadThreadId === "" || result.leadName !== null && typeof result.leadName !== "string") {
         throw new Error("team startGoal returned an invalid result");
       }
+      topicRoot?.confirmConsumed();
       commit("team-goal-started", { chatKey: chatKeyOf(binding), threadId: result.leadThreadId });
       await deliver(
         binding,
@@ -141230,6 +141583,10 @@ var TelegramApiError = class extends Error {
     this.retryAfterSeconds = retryAfterSeconds;
   }
 };
+var telegramSendVerdict = (error) => error instanceof TelegramApiError && (error.code === 429 || error.code === 503 && error.retryAfterSeconds !== void 0) ? {
+  retry: true,
+  afterMs: error.retryAfterSeconds === void 0 ? void 0 : error.retryAfterSeconds * 1e3
+} : NO_RETRY;
 var isNotModified = (error) => error instanceof TelegramApiError && error.code === 400 && error.message.toLowerCase().includes("message is not modified");
 var PHOTO_NAME = "photo.jpg";
 var PHOTO_MIME = "image/jpeg";
@@ -141436,9 +141793,13 @@ var makeTelegramApi = (input) => {
       },
       POLL_CALL_TIMEOUT_MS
     ),
-    sendMessage: async (chatId, text4) => {
+    sendMessage: async (chatId, text4, retry) => {
       for (const chunk of splitForTelegram(text4)) {
-        await call("sendMessage", { ...target(chatId), text: chunk });
+        await sendWithRetry(
+          () => call("sendMessage", { ...target(chatId), text: chunk }),
+          telegramSendVerdict,
+          retry
+        );
       }
     },
     /**
@@ -141876,6 +142237,7 @@ var makeTelegramAdapter = (deps) => {
       const poll = async () => {
         for (; ; ) {
           if (!running) return;
+          let checkingConnection = true;
           try {
             const api = await apiFor(binding);
             liveApi = api;
@@ -141884,6 +142246,7 @@ var makeTelegramAdapter = (deps) => {
               const own = await api.getMe();
               botUsername = own.username ?? null;
               botId = own.id;
+              if (running) handlers.onConnectionState?.({ state: "connected" });
             }
             if (!running) return;
             if (!menuSent) {
@@ -141898,6 +142261,8 @@ var makeTelegramAdapter = (deps) => {
             acknowledged = offset;
             const updates = await api.getUpdates(offset);
             if (!running) return;
+            handlers.onConnectionState?.({ state: "connected" });
+            checkingConnection = false;
             backoff = BACKOFF_START_MS;
             for (const update of updates) {
               if (!running) break;
@@ -141982,6 +142347,7 @@ var makeTelegramAdapter = (deps) => {
             }
           } catch (error) {
             if (!running) return;
+            if (checkingConnection) handlers.onConnectionState?.({ state: "failed", error });
             handlers.onError(error instanceof Error ? error.message : String(error));
             await Promise.race([(deps.sleep ?? defaultSleep)(backoff), stopped]);
             backoff = Math.min(backoff * 2, BACKOFF_MAX_MS);
@@ -141999,9 +142365,9 @@ var makeTelegramAdapter = (deps) => {
         }
       };
     },
-    sendText: async (binding, text4) => {
+    sendText: async (binding, text4, options) => {
       const api = await apiFor(binding);
-      await api.sendMessage(binding.chatId, text4);
+      await api.sendMessage(binding.chatId, text4, options?.retry);
     },
     checkConnection: async (bot) => {
       const token = tokenOf(bot);
@@ -142260,6 +142626,7 @@ var makeTurns = (core, deps) => {
     const text4 = message.text;
     const threadId = await ensureThread(binding, text4 || message.resources[0]?.name || "Chat");
     if (threadId === null) return null;
+    const topicRoot = await message.topicRootForSession?.(threadId);
     const carried = waitingFor(chatKey, threadId);
     pendingByChat.delete(chatKey);
     const own = await collectResources(
@@ -142297,7 +142664,10 @@ var makeTurns = (core, deps) => {
         message: {
           messageId: userMessageId,
           role: "user",
-          text: [textWithInboundContext(message, binding.rowId, t), ...notes].join("\n"),
+          text: [
+            textWithInboundContext(message, binding.rowId, t, topicRoot?.reference),
+            ...notes
+          ].join("\n"),
           attachments: attachments.map(
             (attachment) => attachment.type === "image" ? { ...attachment, type: "image" } : { ...attachment, type: "file" }
           )
@@ -142307,6 +142677,7 @@ var makeTurns = (core, deps) => {
         interactionMode: interactionModeOf(chatKey),
         ...intentAction !== void 0 ? { intentAction } : {}
       });
+      topicRoot?.confirmConsumed();
       if (intentAction?.kind !== "steer") {
         deps.conclusions.owe({
           chatKey,
@@ -142435,8 +142806,15 @@ var ROW_ACTION_ITEM_SCHEMA = makeFlowItemSchema({
   doneRequired: ["messageKey", "fills"]
 });
 var botOf = (config2, adapters, rowId) => {
-  const adapterFor = (platform) => adapters.find((adapter) => adapter.platform === platform);
-  return readBots(config2, adapterFor).find((bot) => bot.rowId === rowId);
+  const table2 = config2[BOTS_FIELD];
+  if (typeof table2 !== "object" || table2 === null || Array.isArray(table2) || !Object.hasOwn(table2, rowId))
+    return void 0;
+  const row = table2[rowId];
+  if (typeof row !== "object" || row === null || Array.isArray(row)) return void 0;
+  const raw = row;
+  const platform = platformOf(raw);
+  const adapter = adapters.find((candidate) => candidate.platform === platform);
+  return { ...readBotView(rowId, raw, adapter ?? { label: platform }), platform };
 };
 var reportOf = (bot, stage, ok, detail, hint) => ({
   ref: diagnosticRef("conn"),
@@ -142452,12 +142830,9 @@ var reportOf = (bot, stage, ok, detail, hint) => ({
 var probe = async (adapters, bot) => {
   const adapter = adapters.find((candidate) => candidate.platform === bot.platform);
   if (adapter?.checkConnection === void 0) {
-    return reportOf(bot, "platform", false, `unsupported platform ${bot.platform}`);
-  }
-  const redactor = makeRedactor();
-  for (const column of adapter.columns) {
-    if (column.kind === "password") redactor.register(bot.values[column.key]);
+    return reportOf(bot, "platform", false, `unsupported platform ${bot.platform}`, "notAvailable");
   }
+  const redactor = botRedactor(adapter.columns, bot.values);
   try {
     const result = await adapter.checkConnection(bot);
     return reportOf(
@@ -142482,10 +142857,15 @@ var emitReport = (emit, report, action) => {
     });
     return;
   }
+  const suggested = report.hint !== void 0 && action.keyPrefix === "rowAction.checkConnection";
   emit({
     kind: "failed",
-    reasonKey: report.hint !== void 0 && action.keyPrefix === "rowAction.checkConnection" ? `rowAction.checkConnection.hint.${report.hint}` : `${action.keyPrefix}.failed`,
-    params: { ref: report.ref },
+    reasonKey: suggested && report.hint !== void 0 ? connectionHintKey(report.hint) : `${action.keyPrefix}.failed`,
+    // 参考号由界面写在细节第一行（「参考号：…」），结论句里不带。
+    params: {
+      ref: report.ref,
+      ...suggested && report.hint !== void 0 ? { hint: report.hint } : {}
+    },
     detail
   });
 };
@@ -142537,9 +142917,9 @@ var registerSettingsRowActions = (ctx, adapters) => {
       send({
         kind: "steps",
         steps: [
-          { id: "scopes", labelKey: "rowAction.larkRepair.step.scopes", state: "pending" },
-          { id: "events", labelKey: "rowAction.larkRepair.step.events", state: "pending" },
-          { id: "publish", labelKey: "rowAction.larkRepair.step.publish", state: "pending" },
+          { id: "scopes", labelKey: "rowAction.larkRepair.step.scopes", state: "skipped" },
+          { id: "events", labelKey: "rowAction.larkRepair.step.events", state: "skipped" },
+          { id: "publish", labelKey: "rowAction.larkRepair.step.publish", state: "skipped" },
           { id: "verify", labelKey: "rowAction.larkRepair.step.verify", state: "running" }
         ]
       });
@@ -142556,9 +142936,9 @@ var registerSettingsRowActions = (ctx, adapters) => {
       send({
         kind: "steps",
         steps: [
-          { id: "scopes", labelKey: "rowAction.larkRepair.step.scopes", state: "done" },
-          { id: "events", labelKey: "rowAction.larkRepair.step.events", state: "done" },
-          { id: "publish", labelKey: "rowAction.larkRepair.step.publish", state: "done" },
+          { id: "scopes", labelKey: "rowAction.larkRepair.step.scopes", state: "skipped" },
+          { id: "events", labelKey: "rowAction.larkRepair.step.events", state: "skipped" },
+          { id: "publish", labelKey: "rowAction.larkRepair.step.publish", state: "skipped" },
           {
             id: "verify",
             labelKey: "rowAction.larkRepair.step.verify",
@@ -142574,7 +142954,7 @@ var registerSettingsRowActions = (ctx, adapters) => {
           warnings: [
             {
               key: "rowAction.larkRepair.hint",
-              params: { ref, detail: formatDiagnosticCopy({ ...report, ref }) }
+              params: { ref, detail: formatDiagnosticCopy(report) }
             }
           ]
         });
@@ -142584,7 +142964,7 @@ var registerSettingsRowActions = (ctx, adapters) => {
         kind: "failed",
         reasonKey: "rowAction.larkRepair.failed",
         params: { ref },
-        detail: formatDiagnosticCopy({ ...report, ref })
+        detail: formatDiagnosticCopy(report)
       });
     }
   });
@@ -142784,8 +143164,29 @@ var generalWriteOptions = (payload, next) => {
   }
   return void 0;
 };
-var viewAfterWrite = async (ctx, adapters) => buildSettingsView(await ctx.settings.read(), adapters);
-var registerSettingsCommands = (ctx, adapters, updateSettings) => {
+var registerSettingsCommands = (ctx, adapters, updateSettings, connections) => {
+  const viewAfterWrite = async () => buildSettingsView(await ctx.settings.read(), adapters);
+  ctx.stream({
+    name: SETTINGS_CONNECTIONS_COMMAND,
+    description: "Read bot connection states as an initial snapshot and subsequent changes.",
+    scope: "read",
+    payloadSchema: EMPTY_PAYLOAD,
+    buffer: { latest: 1 },
+    handle: async (_payload, emit, signal) => {
+      if (signal.aborted) return;
+      const unsubscribe = connections.subscribe((snapshot) => {
+        if (!signal.aborted) emit(snapshot);
+      });
+      try {
+        await new Promise((resolve) => {
+          if (signal.aborted) resolve();
+          else signal.addEventListener("abort", () => resolve(), { once: true });
+        });
+      } finally {
+        unsubscribe();
+      }
+    }
+  });
   ctx.command({
     name: SETTINGS_VIEW_COMMAND,
     description: "Read the chat-bridge settings view, bot columns, and this machine's proxies.",
@@ -142812,7 +143213,7 @@ var registerSettingsCommands = (ctx, adapters, updateSettings) => {
       return { result, write: { config: next, options: { secrets, clearSecrets } } };
     });
     if (!edited.ok) return edited;
-    return { ok: true, rowId: edited.rowId, view: await viewAfterWrite(ctx, adapters) };
+    return { ok: true, rowId: edited.rowId, view: await viewAfterWrite() };
   };
   const removeRow2 = async (remove) => {
     const removed = await updateSettings((config2) => {
@@ -142820,7 +143221,7 @@ var registerSettingsCommands = (ctx, adapters, updateSettings) => {
       return next === null ? { result: false } : { result: true, write: { config: next } };
     });
     if (!removed) return { ok: false, code: "unknown-row" };
-    return { ok: true, view: await viewAfterWrite(ctx, adapters) };
+    return { ok: true, view: await viewAfterWrite() };
   };
   ctx.command({
     name: SETTINGS_SAVE_BOT_COMMAND,
@@ -142871,7 +143272,7 @@ var registerSettingsCommands = (ctx, adapters, updateSettings) => {
           write: options === void 0 ? { config: next } : { config: next, options }
         };
       });
-      return { ok: true, view: await viewAfterWrite(ctx, adapters) };
+      return { ok: true, view: await viewAfterWrite() };
     }
   });
 };
@@ -142899,12 +143300,13 @@ var makeWechatAdapter = (deps) => {
     columns: COLUMNS3,
     validate: wechatConfigIssues,
     isConfigured: (bot) => wechatConfigIssues(bot).length === 0,
-    connect: (bot, _handlers) => {
+    connect: (bot, handlers) => {
       deps.log.warn("wechat iLink connect is stubbed pending security-review gate (YCO-236)", {
         bot: bot.displayName,
         hasToken: tokenOf2(bot) !== "",
         textLimit: WECHAT_TEXT_MAX_CHARS
       });
+      handlers.onConnectionState?.({ state: "failed", reason: "not-available" });
       return { close: () => void 0 };
     },
     sendText: async (binding, _text) => {
@@ -142927,7 +143329,7 @@ var makeWechatAdapter = (deps) => {
 };
 
 // src/wecomUpload.ts
-import * as NodeCrypto4 from "node:crypto";
+import * as NodeCrypto5 from "node:crypto";
 var WECOM_CHUNK_BYTES = 512 * 1024;
 var WECOM_MAX_CHUNKS = 100;
 var WECOM_MIN_UPLOAD_BYTES = 5;
@@ -142960,7 +143362,7 @@ var uploadWecomMedia = async (input) => {
     filename: clampName(input.filename),
     total_size: bytes.byteLength,
     total_chunks: totalChunks,
-    md5: NodeCrypto4.createHash("md5").update(bytes).digest("hex")
+    md5: NodeCrypto5.createHash("md5").update(bytes).digest("hex")
   });
   const uploadId = init.upload_id;
   if (typeof uploadId !== "string" || uploadId === "") {
@@ -143047,7 +143449,7 @@ var wecomReplyReference = (quote) => {
 };
 
 // src/wecomApi.ts
-var DEFAULT_WECOM_ENDPOINT = "wss://openws.work.weixin.qq.com/wssvr/";
+var DEFAULT_WECOM_ENDPOINT = "wss://openws.work.weixin.qq.com";
 var PING_INTERVAL_MS = 3e4;
 var MAX_MISSED_PONGS = 2;
 var SUBSCRIBE_TIMEOUT_MS = 1e4;
@@ -143184,9 +143586,10 @@ var runWecomClient = (input) => {
     const message = parseWecomMessage(frame, input.botId);
     if (message !== null) input.handlers.onMessage(message);
   };
-  const finish = () => {
+  const finish = (error = new Error("WeCom connection closed"), reason = "disconnected") => {
     if (finished) return;
     finished = true;
+    if (!closed) input.handlers.onConnectionState?.({ state: "failed", error, reason });
     clearInterval(heartbeat);
     openStreams.clear();
     void input.socket.close().catch(() => void 0);
@@ -143204,6 +143607,7 @@ var runWecomClient = (input) => {
       if (!closed) {
         input.handlers.onError(error instanceof Error ? error.message : String(error));
       }
+      finish(error);
     }
     finish();
   };
@@ -143211,7 +143615,7 @@ var runWecomClient = (input) => {
     if (finished) return;
     if (missedPong >= MAX_MISSED_PONGS) {
       input.handlers.onError("socket hang up: missed pong");
-      finish();
+      finish(new Error("socket hang up: missed pong"));
       return;
     }
     missedPong += 1;
@@ -143232,10 +143636,13 @@ var runWecomClient = (input) => {
     settleAck(subscribeId, error instanceof Error ? error : new Error(String(error)));
   });
   const ready = subscribed.then(
-    () => true,
+    () => {
+      if (!finished && !closed) input.handlers.onConnectionState?.({ state: "connected" });
+      return !finished && !closed;
+    },
     (error) => {
       if (!closed) input.handlers.onError(error instanceof Error ? error.message : String(error));
-      finish();
+      finish(error, "subscription-failed");
       return false;
     }
   );
@@ -143370,7 +143777,7 @@ var runWecomClient = (input) => {
 };
 
 // src/wecomMedia.ts
-import * as NodeCrypto5 from "node:crypto";
+import * as NodeCrypto6 from "node:crypto";
 
 // src/wecomPadding.ts
 var PADDING_BLOCK = 32;
@@ -143401,7 +143808,7 @@ var decryptWecomMedia = (cipher, aesKey) => {
   if (cipher.byteLength === 0 || cipher.byteLength % AES_BLOCK !== 0) {
     throw new WecomDecryptError("the ciphertext is not a whole number of blocks");
   }
-  const decipher = NodeCrypto5.createDecipheriv("aes-256-cbc", key, key.subarray(0, IV_BYTES));
+  const decipher = NodeCrypto6.createDecipheriv("aes-256-cbc", key, key.subarray(0, IV_BYTES));
   decipher.setAutoPadding(false);
   const plain = Buffer.concat([decipher.update(cipher), decipher.final()]);
   const unpadded = stripPadding(plain);
@@ -143544,6 +143951,9 @@ ${kept}`;
           botSecret,
           handlers: {
             onError: handlers.onError,
+            onConnectionState: (state) => {
+              if (!stopped) handlers.onConnectionState?.(state);
+            },
             onMessage: (message) => {
               if (message.chatType !== "single") return;
               client.rememberRequest(message.chatId, message.requestId);
@@ -143585,6 +143995,8 @@ ${kept}`;
           try {
             if (await runOnce()) backoff = BACKOFF_START_MS2;
           } catch (error) {
+            if (stopped) return;
+            handlers.onConnectionState?.({ state: "failed", error, reason: "disconnected" });
             handlers.onError(error instanceof Error ? error.message : String(error));
           }
           if (stopped) return;
@@ -143602,6 +144014,7 @@ ${kept}`;
         }
       };
     },
+    // 不看 `options.retry`：长连接的回执没有核实过的限流码，也没有幂等键，失败一律说不清发没发出去。
     sendText: async (binding, text4) => {
       const client = clients.get(binding.rowId);
       if (client === void 0) {
@@ -143618,12 +144031,36 @@ ${kept}`;
           detail: "missing bot id or secret in saved config"
         };
       }
+      let stage = "websocket";
       try {
         const socket = await deps.connectSocket(endpoint);
-        await socket.close();
-        return { stage: "websocket", ok: true, detail: `endpoint reachable (${endpoint})` };
+        stage = "aibot_subscribe";
+        let detail = "WeCom connection closed before subscribe ack";
+        let closing;
+        const client = runWecomClient({
+          socket: {
+            send: (data) => socket.send(data),
+            messages: socket.messages,
+            close: () => closing ??= socket.close()
+          },
+          botId,
+          botSecret,
+          handlers: {
+            onMessage: () => void 0,
+            onError: (error) => {
+              detail = error;
+            }
+          }
+        });
+        try {
+          const ok = await client.ready;
+          return { stage, ok, detail: ok ? `subscription confirmed (${endpoint})` : detail };
+        } finally {
+          client.close();
+          await closing;
+        }
       } catch (error) {
-        return { stage: "websocket", ok: false, detail: describeError(error) };
+        return { stage, ok: false, detail: describeError(error) };
       }
     },
     askApproval: async (binding, request) => {
@@ -143680,18 +144117,25 @@ ${kept}`;
 // src/wecomAppApi.ts
 var WECOM_APP_DEFAULT_API_BASE = "https://qyapi.weixin.qq.com";
 var WECOM_APP_TEXT_MAX_BYTES = 2048;
+var REQUEST_TIMEOUT_MS = 15e3;
+var MEDIA_TIMEOUT_MS = 6e4;
 var WecomAppApiError = class extends Error {
   code;
   providerCode;
   hint;
+  invalidUsers;
   constructor(code2, message, extras) {
     super(message);
     this.name = "WecomAppApiError";
     this.code = code2;
     this.providerCode = extras?.providerCode;
     this.hint = extras?.hint;
+    this.invalidUsers = extras?.invalidUsers ?? [];
   }
 };
+var TOKEN_INVALID_CODES = /* @__PURE__ */ new Set(["40014", "42001"]);
+var RATE_LIMITED_CODES = /* @__PURE__ */ new Set(["45009", "45033"]);
+var wecomAppSendVerdict = (error) => error instanceof WecomAppApiError && error.providerCode !== void 0 && (RATE_LIMITED_CODES.has(error.providerCode) || TOKEN_INVALID_CODES.has(error.providerCode)) ? { retry: true } : NO_RETRY;
 var cleanString2 = (value2) => {
   if (typeof value2 !== "string") return null;
   const trimmed = value2.trim();
@@ -143727,6 +144171,7 @@ var splitUtf8ByBytes = (text4, maxBytes = WECOM_APP_TEXT_MAX_BYTES) => {
   if (current.length > 0) chunks.push(current);
   return chunks;
 };
+var parseInvalidUsers = (value2) => typeof value2 === "string" ? value2.split("|").map((user) => user.trim()).filter(Boolean) : [];
 var WecomAppApi = class {
   corpId;
   corpSecret;
@@ -143778,9 +144223,13 @@ var WecomAppApi = class {
   async sendText(input) {
     const chunks = splitUtf8ByBytes(input.content);
     for (const chunk of chunks) {
-      await this.#send(
-        { touser: input.userId, msgtype: "text", text: { content: chunk } },
-        input.signal
+      await sendWithRetry(
+        () => this.#send(
+          { touser: input.userId, msgtype: "text", text: { content: chunk } },
+          input.signal
+        ),
+        wecomAppSendVerdict,
+        input.retry
       );
     }
   }
@@ -143807,12 +144256,16 @@ var WecomAppApi = class {
       new Blob([new Uint8Array(input.bytes)], { type: input.mimeType }),
       input.name
     );
-    const payload = await this.#requestJson(url, {
-      method: "POST",
-      // 不设 content-type：multipart 的 boundary 要让 fetch 自己写。
-      body: form,
-      ...input.signal === void 0 ? {} : { signal: input.signal }
-    });
+    const payload = await this.#requestJson(
+      url,
+      {
+        method: "POST",
+        // 不设 content-type：multipart 的 boundary 要让 fetch 自己写。
+        body: form,
+        ...input.signal === void 0 ? {} : { signal: input.signal }
+      },
+      MEDIA_TIMEOUT_MS
+    );
     const mediaId = payload["media_id"];
     if (typeof mediaId === "string" && mediaId !== "") return mediaId;
     throw this.#apiError(Number(payload["errcode"] ?? -1), payload["errmsg"]);
@@ -143826,10 +144279,17 @@ var WecomAppApi = class {
     const url = new URL("/cgi-bin/media/get", this.apiBaseUrl);
     url.searchParams.set("access_token", token);
     url.searchParams.set("media_id", input.mediaId);
-    const response = await this.#fetch(url, {
-      method: "GET",
-      ...input.signal === void 0 ? {} : { signal: input.signal }
-    });
+    return this.#withRequest(
+      url,
+      {
+        method: "GET",
+        ...input.signal === void 0 ? {} : { signal: input.signal }
+      },
+      MEDIA_TIMEOUT_MS,
+      (response) => this.#readMedia(response, input.maxBytes)
+    );
+  }
+  async #readMedia(response, maxBytes) {
     const contentType = response.headers.get("content-type") ?? "";
     if (contentType.includes("application/json") || contentType.includes("text/plain")) {
       let payload = {};
@@ -143849,7 +144309,7 @@ var WecomAppApi = class {
         `WeCom media/get failed (HTTP ${String(response.status)}).`
       );
     }
-    const bytes = await readBodyLimited(response, input.maxBytes);
+    const bytes = await readBodyLimited(response, maxBytes);
     const name = filenameFromContentDisposition(response.headers.get("content-disposition"));
     const mimeType = contentType.split(";")[0]?.trim();
     return {
@@ -143868,55 +144328,76 @@ var WecomAppApi = class {
       body: JSON.stringify({ ...message, agentid: Number.parseInt(this.agentId, 10) }),
       ...signal === void 0 ? {} : { signal }
     });
-    const errcode = Number(payload["errcode"] ?? 0);
-    if (errcode !== 0) throw this.#apiError(errcode, payload["errmsg"]);
     const invalid = payload["invaliduser"];
     if (typeof invalid === "string" && invalid.trim() !== "") {
       throw new WecomAppApiError("invalid-user", `WeCom did not deliver to: ${invalid.trim()}.`, {
         providerCode: "81013",
-        hint: "\u786E\u8BA4\u63A5\u6536\u4EBA\u4ECD\u5728\u8FD9\u4E2A\u81EA\u5EFA\u5E94\u7528\u7684\u53EF\u89C1\u8303\u56F4\u5185\u3002"
+        hint: "wecomInvalidUser",
+        invalidUsers: parseInvalidUsers(invalid)
       });
     }
   }
-  #apiError(errcode, errmsg) {
+  #apiError(errcode, errmsg, invalidUsers) {
     const code2 = String(errcode);
     const message = typeof errmsg === "string" && errmsg !== "" ? `WeCom API failed (${code2}): ${errmsg}` : `WeCom API failed (${code2}).`;
-    if (errcode === 40014 || errcode === 42001) this.invalidateToken();
+    if (TOKEN_INVALID_CODES.has(code2)) this.invalidateToken();
     if (errcode === 60020) {
       return new WecomAppApiError("trusted-ip", "WeCom rejected the outbound IP (errcode 60020).", {
         providerCode: code2,
-        hint: "\u628A\u51FA\u7AD9\u516C\u7F51 IP \u52A0\u8FDB\u4F01\u4E1A\u5FAE\u4FE1\u540E\u53F0\u7684\u300C\u4F01\u4E1A\u53EF\u4FE1 IP\u300D\u3002"
+        hint: "wecomTrustedIp"
       });
     }
     if (errcode === 81013) {
       return new WecomAppApiError("invalid-user", message, {
         providerCode: code2,
-        hint: "\u6536\u4EF6\u4EBA\u3001\u90E8\u95E8\u6216\u6807\u7B7E\u4E0D\u5B58\u5728\uFF0C\u6216\u4E0D\u5728\u8FD9\u4E2A\u81EA\u5EFA\u5E94\u7528\u7684\u53EF\u89C1\u8303\u56F4\u5185\u3002"
+        hint: "wecomInvalidUser",
+        invalidUsers: parseInvalidUsers(invalidUsers)
       });
     }
     if (errcode === 40056) {
       return new WecomAppApiError("invalid-agent", message, {
         providerCode: code2,
-        hint: "AgentId \u4E0D\u5BF9\uFF0C\u6838\u5BF9\u81EA\u5EFA\u5E94\u7528\u7684 AgentId\u3002"
+        hint: "wecomInvalidAgent"
       });
     }
     return new WecomAppApiError("api-failed", message, { providerCode: code2 });
   }
-  async #requestJson(url, init) {
-    const response = await this.#fetch(url, init);
-    let payload;
+  async #withRequest(url, init, timeoutMs, read) {
+    const deadline = new AbortController();
+    const signal = AbortSignal.any([deadline.signal, ...init.signal ? [init.signal] : []]);
+    const timeout = new WecomAppApiError(
+      "timeout",
+      `WeCom ${url.pathname} timed out after ${timeoutMs}ms.`
+    );
+    const timer = setTimeout(() => deadline.abort(timeout), timeoutMs);
     try {
-      payload = await response.json();
-    } catch {
-      throw new WecomAppApiError(
-        "bad-response",
-        `WeCom returned non-JSON (HTTP ${String(response.status)}).`
-      );
-    }
-    if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
-      throw new WecomAppApiError("bad-response", "WeCom returned a non-object JSON body.");
+      return await read(await this.#fetch(url, { ...init, signal }));
+    } catch (error) {
+      if (signal.aborted) throw signal.reason;
+      throw error;
+    } finally {
+      clearTimeout(timer);
     }
-    return payload;
+  }
+  async #requestJson(url, init, timeoutMs = REQUEST_TIMEOUT_MS) {
+    return this.#withRequest(url, init, timeoutMs, async (response) => {
+      let payload;
+      try {
+        payload = await response.json();
+      } catch {
+        throw new WecomAppApiError(
+          "bad-response",
+          `WeCom returned non-JSON (HTTP ${String(response.status)}).`
+        );
+      }
+      if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+        throw new WecomAppApiError("bad-response", "WeCom returned a non-object JSON body.");
+      }
+      const result = payload;
+      const errcode = Number(result["errcode"] ?? 0);
+      if (errcode !== 0) throw this.#apiError(errcode, result["errmsg"], result["invaliduser"]);
+      return result;
+    });
   }
 };
 
@@ -143925,7 +144406,7 @@ import * as NodeHttp2 from "node:http";
 import * as NodeNet from "node:net";
 
 // src/wecomAppCrypto.ts
-import * as NodeCrypto6 from "node:crypto";
+import * as NodeCrypto7 from "node:crypto";
 var AES_KEY_BYTES = 32;
 var RANDOM_BYTES = 16;
 var WecomAppCryptoError = class extends Error {
@@ -143948,13 +144429,13 @@ var timingSafeEqualString2 = (a, b) => {
   const left = Buffer.from(a);
   const right = Buffer.from(b);
   if (left.length === 0 || left.length !== right.length) return false;
-  return NodeCrypto6.timingSafeEqual(left, right);
+  return NodeCrypto7.timingSafeEqual(left, right);
 };
-var computeSignature = (token, timestamp, nonce, encrypt) => NodeCrypto6.createHash("sha1").update([token, timestamp, nonce, encrypt].sort().join("")).digest("hex");
+var computeSignature = (token, timestamp, nonce, encrypt) => NodeCrypto7.createHash("sha1").update([token, timestamp, nonce, encrypt].sort().join("")).digest("hex");
 var verifySignature = (token, timestamp, nonce, encrypt, signature) => timingSafeEqualString2(computeSignature(token, timestamp, nonce, encrypt), signature);
 var decrypt = (encodingAESKey, encryptText, expectReceiveId) => {
   const { key, iv } = parseEncodingAESKey(encodingAESKey);
-  const decipher = NodeCrypto6.createDecipheriv("aes-256-cbc", key, iv);
+  const decipher = NodeCrypto7.createDecipheriv("aes-256-cbc", key, iv);
   decipher.setAutoPadding(false);
   let deciphered;
   try {
@@ -144013,7 +144494,7 @@ var createWecomAppCrypto = (input) => {
     decrypt: (encryptText) => decrypt(encodingAESKey, encryptText, corpId).message
   };
 };
-var deriveCallbackPathSecret = (token, encodingAESKey) => NodeCrypto6.createHash("sha256").update(`${token.trim()}:${encodingAESKey.trim()}`).digest("hex").slice(0, 24);
+var deriveCallbackPathSecret = (token, encodingAESKey) => NodeCrypto7.createHash("sha256").update(`${token.trim()}:${encodingAESKey.trim()}`).digest("hex").slice(0, 24);
 
 // src/wecomAppParse.ts
 var isRecord4 = (value2) => value2 !== null && typeof value2 === "object" && !Array.isArray(value2);
@@ -144460,6 +144941,7 @@ var WECOM_APP_IMAGE_BYTES = 10 * 1024 * 1024;
 var WECOM_APP_FILE_BYTES = 20 * 1024 * 1024;
 var WECOM_APP_MIN_BYTES = 5;
 var WECOM_APP_IMAGE_TYPES = /* @__PURE__ */ new Set(["image/jpeg", "image/png"]);
+var CREDENTIAL_ERROR_CODES = /* @__PURE__ */ new Set(["40001", "40013", "40014", "40056", "42001", "60020"]);
 var joinCallbackUrl = (baseOrOrigin, path) => `${baseOrOrigin}${path}`;
 var wecomAppPublicFields = (bot) => {
   const c = wecomAppCredentials(bot);
@@ -144485,6 +144967,8 @@ var OUTBOUND_COLUMNS = /* @__PURE__ */ new Set([
   "wecomAppSecret",
   "wecomAppApiBaseUrl"
 ]);
+var PROBE_BACKOFF_START_MS = 1e3;
+var PROBE_BACKOFF_MAX_MS = 6e4;
 var makeWecomAppAdapter = (deps) => {
   const apis = /* @__PURE__ */ new Map();
   const newApi = (c) => new WecomAppApi({
@@ -144495,17 +144979,30 @@ var makeWecomAppAdapter = (deps) => {
     fetch: deps.fetch
   });
   const callbackHub = makeWecomAppCallbackHub();
-  const apiFor = (binding) => {
+  const connectionFor = (binding) => {
     const api = apis.get(binding.rowId);
     if (api === void 0) {
       throw new ImNotConnectedError(`wecom-app bot '${binding.displayName}' is not connected.`);
     }
     return api;
   };
+  const deliver = async (binding, send) => {
+    const connection = connectionFor(binding);
+    try {
+      await send(connection.api);
+      connection.report({ state: "connected" });
+    } catch (error) {
+      if (error instanceof WecomAppApiError && error.providerCode !== void 0 && CREDENTIAL_ERROR_CODES.has(error.providerCode)) {
+        connection.report({ state: "failed", error, reason: "credentials-rejected" });
+      }
+      throw error;
+    }
+  };
   const sendMedia = async (binding, mediaType, file) => {
-    const api = apiFor(binding);
-    const mediaId = await api.uploadMedia({ mediaType, ...file });
-    await api.sendMedia({ userId: binding.chatId, mediaType, mediaId });
+    await deliver(binding, async (api) => {
+      const mediaId = await api.uploadMedia({ mediaType, ...file });
+      await api.sendMedia({ userId: binding.chatId, mediaType, mediaId });
+    });
     deps.log.info(`wecom-app delivered ${mediaType === "image" ? "an image" : "a file"}`, {
       name: file.name
     });
@@ -144556,6 +145053,19 @@ var makeWecomAppAdapter = (deps) => {
       (issue) => issue.code !== "required" && issue.column !== "wecomAppEncodingAESKey"
     ),
     publicFields: wecomAppPublicFields,
+    // 收件人不在应用可见范围（invaliduser / 81013）：说清是谁、为什么、怎么办。
+    describeDeliveryRejection: (error, binding) => {
+      if (!(error instanceof WecomAppApiError) || error.code !== "invalid-user") return void 0;
+      const recipients = [
+        ...new Set(error.invalidUsers.length > 0 ? error.invalidUsers : [binding.chatId])
+      ].sort();
+      return {
+        recipients,
+        summary: deps.translate("reply.wecomDeliveryFailed", { recipient: recipients.join(", ") }),
+        hint: error.hint,
+        providerCode: error.providerCode
+      };
+    },
     /**
      * 自建应用是回调式渠道：入站由企微推到我们的 listener，没有可探的长连接；能探的是出站
      * 凭据——和真实发送同一条路，向 gettoken 换一次 access_token。
@@ -144586,7 +145096,12 @@ var makeWecomAppAdapter = (deps) => {
           detail: "access_token ok (callback reachability is not probed)"
         };
       } catch (error) {
-        return { stage: "gettoken", ok: false, detail: describeError(error) };
+        return {
+          stage: "gettoken",
+          ok: false,
+          detail: describeError(error),
+          ...error instanceof WecomAppApiError && error.hint !== void 0 ? { hint: error.hint } : {}
+        };
       }
     },
     connect: async (bot, handlers) => {
@@ -144600,7 +145115,14 @@ var makeWecomAppAdapter = (deps) => {
       const lease = await callbackHub.acquire({ host: config2.listenHost, port: config2.listenPort });
       const server = lease.server;
       const api = newApi(c);
-      apis.set(bot.rowId, api);
+      let closed = false;
+      const report = (state) => {
+        if (closed) return;
+        handlers.onConnectionState?.(
+          state.state === "failed" && state.error instanceof WecomAppApiError && state.error.hint !== void 0 ? { ...state, hint: state.error.hint } : state
+        );
+      };
+      apis.set(bot.rowId, { api, report });
       let path;
       try {
         path = server.register({
@@ -144616,7 +145138,7 @@ var makeWecomAppAdapter = (deps) => {
         await lease.release();
         throw error;
       }
-      deps.log.info("wecom-app connected", {
+      deps.log.info("wecom-app callback listening", {
         bot: bot.displayName,
         callbackPath: path,
         callbackUrl: joinCallbackUrl(
@@ -144625,8 +145147,26 @@ var makeWecomAppAdapter = (deps) => {
         ),
         listen: `${server.host}:${String(server.port)}`
       });
+      const probe2 = new AbortController();
+      void (async () => {
+        let backoff = PROBE_BACKOFF_START_MS;
+        while (!probe2.signal.aborted) {
+          try {
+            await api.getAccessToken(probe2.signal);
+            report({ state: "connected" });
+            return;
+          } catch (error) {
+            if (probe2.signal.aborted) return;
+            report({ state: "failed", error, reason: "token-unavailable" });
+            await (deps.sleep ?? abortableSleep)(backoff, probe2.signal).catch(() => void 0);
+            backoff = Math.min(backoff * 2, PROBE_BACKOFF_MAX_MS);
+          }
+        }
+      })();
       return {
         close: () => {
+          closed = true;
+          probe2.abort();
           server.unregister(bot.rowId);
           apis.delete(bot.rowId);
           void lease.release().catch((error) => {
@@ -144642,15 +145182,18 @@ var makeWecomAppAdapter = (deps) => {
       if (options?.targetKind === "group") {
         throw new Error("wecom-app can only deliver to a user; group targets are not supported.");
       }
-      await apiFor(binding).sendText({ userId: binding.chatId, content: text4 });
+      await deliver(
+        binding,
+        (api) => api.sendText({ userId: binding.chatId, content: text4, retry: options?.retry })
+      );
     },
     // D376：企业微信自建应用没有表情回执也没有流式，开工时先回一句文字，结论照常另发。没有要撤的
     // 东西，回 null；发不出去由核心记一条 warn，不拦这一轮。
     acknowledge: async (binding) => {
-      await apiFor(binding).sendText({
-        userId: binding.chatId,
-        content: deps.translate("reply.received")
-      });
+      await deliver(
+        binding,
+        (api) => api.sendText({ userId: binding.chatId, content: deps.translate("reply.received") })
+      );
       return null;
     },
     sendImage: (binding, image2) => sendMedia(binding, "image", image2),
@@ -144661,11 +145204,16 @@ var makeWecomAppAdapter = (deps) => {
       minBytes: WECOM_APP_MIN_BYTES
     },
     imageMimeTypes: WECOM_APP_IMAGE_TYPES,
-    fetchResource: (binding, input) => apiFor(binding).downloadMedia({ mediaId: input.resource.key, maxBytes: input.maxBytes }),
+    fetchResource: (binding, input) => connectionFor(binding).api.downloadMedia({
+      mediaId: input.resource.key,
+      maxBytes: input.maxBytes
+    }),
     askApproval: async (binding, request) => {
-      const api = apis.get(binding.rowId);
-      if (api === void 0) return null;
-      await api.sendText({ userId: binding.chatId, content: numberedApprovalText(request) });
+      if (!apis.has(binding.rowId)) return null;
+      await deliver(
+        binding,
+        (api) => api.sendText({ userId: binding.chatId, content: numberedApprovalText(request) })
+      );
       return null;
     },
     answerByText: (_binding, text4, options) => answerByNumber(text4, options)
@@ -144675,7 +145223,7 @@ var makeWecomAppAdapter = (deps) => {
 // src/index.ts
 var imPlugin = definePlugin({
   id: "im",
-  apiVersion: 17,
+  apiVersion: 18,
   activate: async (ctx) => {
     const { t, setLanguage } = makeLiveTranslate(
       parseReplyLanguage(ctx.config[REPLY_LANGUAGE_FIELD])
@@ -144736,7 +145284,6 @@ var imPlugin = definePlugin({
     const updateSettings = makeSettingsUpdater(ctx.settings);
     registerLarkSetup(ctx, { updateSettings });
     registerSettingsRowActions(ctx, adapters);
-    registerSettingsCommands(ctx, adapters, updateSettings);
     const core = makeImCore({
       host: {
         log: ctx.log,
@@ -144771,7 +145318,7 @@ var imPlugin = definePlugin({
     );
     const teams = makeTeamGoals(core);
     const notifications = makeNotifications(core, {
-      clearWorking: acknowledgements.clearWorking,
+      takeWorking: acknowledgements.takeWorking,
       replyCards,
       failures,
       conclusions,
@@ -144847,6 +145394,7 @@ var imPlugin = definePlugin({
       ]
     });
     const connections = startConnections(core, inbound.inboundHandlersFor);
+    registerSettingsCommands(ctx, adapters, updateSettings, connections);
     const { bots, connecting } = connections.reconcile();
     const deliveryHttp = makeDeliveryHttp({
       // 每次请求按此刻的设置找目标：投递目标表改了不用重开监听。