openclaw-lark-multi-agent 1.8.1 → 1.8.3

package/dist/feishu-bot.d.ts

@@ -50,6 +50,11 @@ export declare class FeishuBot {
      * DONE when that batch completes successfully; cleared (unflipped) when the
      * batch scope ends any other way. */
     private admittedSteerAcks;
+    /** Identity token of the CURRENT queue owner per chat. Steer acks carry
+     *  the token of the batch that admitted them; a completion path only flips
+     *  acks of its OWN batch, so a superseded inner can never DONE a newer
+     *  batch's steered inputs (2026-10-16 audit B9). */
+    private queueRunTokens;
     /** Go / Go-Checker supervision controller (per-bot instance). */
     private readonly goDeliveryReceipts;
     private readonly goReceiptApis;

package/dist/feishu-bot.js

@@ -5,6 +5,7 @@ import { persistBotModel } from "./config.js";
 import { getI18n, normalizeLocale } from "./i18n.js";
 import { InactiveRunObservation } from "./openclaw-client.js";
 import { SessionWaitPaused, isWaitTimeout, normalizeSessionRuntimeStatus, formatSessionFooter, FOREGROUND_WAIT_MS } from "./session-status.js";
+import { SupersededObservation } from "./openclaw-client.js";
 import { LiveStatusController } from "./live-status.js";
 import { CompactProgressController } from "./compact-progress.js";
 import { GoController } from "./go-controller.js";
@@ -148,6 +149,11 @@ export class FeishuBot {
      * DONE when that batch completes successfully; cleared (unflipped) when the
      * batch scope ends any other way. */
     admittedSteerAcks = new Map();
+    /** Identity token of the CURRENT queue owner per chat. Steer acks carry
+     *  the token of the batch that admitted them; a completion path only flips
+     *  acks of its OWN batch, so a superseded inner can never DONE a newer
+     *  batch's steered inputs (2026-10-16 audit B9). */
+    queueRunTokens = new Map();
     /** Go / Go-Checker supervision controller (per-bot instance). */
     goDeliveryReceipts = new AsyncLocalStorage();
     goReceiptApis = new WeakSet();
@@ -1226,7 +1232,7 @@ export class FeishuBot {
                         // never (2026.9.9 removed mirrors); either way the message belongs
                         // to this batch for the Get -> DONE flip.
                         const steerAckList = this.admittedSteerAcks.get(chatId) || [];
-                        steerAckList.push({ messageId, insertedId });
+                        steerAckList.push({ messageId, insertedId, batch: this.queueRunTokens.get(chatId) });
                         this.admittedSteerAcks.set(chatId, steerAckList);
                     }
                     if (insertedId > 0 && !consumedBeforeAck) {
@@ -1253,8 +1259,17 @@ export class FeishuBot {
                             this.admittedSteerAcks.set(chatId, (this.admittedSteerAcks.get(chatId) || []).filter((a) => a.insertedId !== insertedId));
                             console.log(`[${this.config.name}] steer fallback restored after failed run for ${chatId.slice(-8)}: "${cleanText.substring(0, 40)}..."`);
                             // Deferred: the current queue run is still active here; a fresh
-                            // drain must start after its finally releases the chat.
-                            setTimeout(() => { void this.processQueue(chatId).catch(() => { }); }, 0).unref?.();
+                            // drain must start after its finally releases the chat. A 0ms
+                            // timer is NOT enough — the owner's catch block still has
+                            // in-flight awaits (error delivery), so processQueue would join
+                            // the dying owner and return, stranding the restored trigger
+                            // until the next user message (2026-10-16 audit finding).
+                            const ownerNow = this.queueRuns.get(chatId);
+                            const drainRestored = () => { void this.processQueue(chatId).catch(() => { }); };
+                            if (ownerNow)
+                                void ownerNow.then(drainRestored, drainRestored).catch(() => { });
+                            else
+                                setTimeout(drainRestored, 0).unref?.();
                         });
                         this.runFailureObservers.set(chatId, observers);
                         const owner = this.queueRuns.get(chatId);
@@ -1293,8 +1308,14 @@ export class FeishuBot {
                 // path and it will never settle). Force-expire it and process this input
                 // NOW instead of queueing behind a dead promise forever.
                 if (steer.status === "no_active_run" && this.queueRuns.has(chatId)) {
+                    const ownerAtCheck = this.queueRuns.get(chatId);
                     const live = await this.openclawClient.getSessionRuntimeStatus(sessionKeyForSteer).catch(() => null);
-                    if (live && !live.running) {
+                    // B1 (2026-10-16 audit): require POSITIVE idle evidence. An RPC
+                    // failure normalizes to {status:"unknown", running:false} and must
+                    // never authorize expiring a legitimately running owner. The owner
+                    // identity is also CAS-checked across the status RPC: a newer batch
+                    // that took over meanwhile must not be expired by stale evidence.
+                    if (live && !live.running && live.status !== "unknown" && this.queueRuns.get(chatId) === ownerAtCheck) {
                         console.warn(`[${this.config.name}] gateway reports session idle while queue owner exists for ${chatId.slice(-8)} — expiring zombie owner (status=${live.status})`);
                         this.forceExpireQueueOwner(chatId, `gateway idle (steer=${steer.status}, session=${live.status})`);
                         // Fall through to the normal send path below; the durable trigger
@@ -1468,7 +1489,9 @@ export class FeishuBot {
             console.log(`[${this.config.name}] processQueue already running for ${chatId.slice(-8)}, joining existing run`);
             return existing;
         }
-        const run = this.processQueueInner(chatId).finally(() => {
+        const batchToken = {};
+        this.queueRunTokens.set(chatId, batchToken);
+        const run = this.processQueueInner(chatId, batchToken).finally(() => {
             // Ownership token guard: only the CURRENT owner may release the slot. A
             // zombie owner that settles after forceExpireQueueOwner must not delete
             // the replacement owner's entry (that would open a concurrent-run window).
@@ -1476,6 +1499,7 @@ export class FeishuBot {
                 this.queueRuns.delete(chatId);
                 this.runFailureObservers.delete(chatId);
                 this.admittedSteerAcks.delete(chatId);
+                this.queueRunTokens.delete(chatId);
             }
         });
         this.queueRuns.set(chatId, run);
@@ -1493,13 +1517,21 @@ export class FeishuBot {
         if (!owner)
             return false;
         console.warn(`[${this.config.name}] force-expiring zombie queue owner for ${chatId.slice(-8)}: ${reason}`);
+        // Fence the stale batch's local observation BEFORE releasing custody: an
+        // alive old poller would keep destructively consuming the replacement
+        // batch's frames from the shared session bucket (2026-10-16 regression).
+        try {
+            this.openclawClient.revokeSessionCollectors(this.getSessionKey(chatId), `queue owner force-expired: ${reason}`);
+        }
+        catch { /* isolated */ }
         this.queueRuns.delete(chatId);
         this.fireRunFailureObservers(chatId);
         this.runFailureObservers.delete(chatId);
         this.admittedSteerAcks.delete(chatId);
+        this.queueRunTokens.delete(chatId);
         return true;
     }
-    async processQueueInner(chatId) {
+    async processQueueInner(chatId, batchToken) {
         while (true) {
             // A fresh batch starts: steered inputs admitted into the PREVIOUS batch
             // completed with it (consumed or not); their failure observers are stale.
@@ -1981,9 +2013,15 @@ export class FeishuBot {
                 this.pendingAckMessages.set(chatId, remainingAcks);
                 // Steered messages admitted into THIS batch were consumed with it:
                 // flip their Get → DONE alongside the batch's own triggers.
-                const admittedSteers = this.admittedSteerAcks.get(chatId) || [];
+                // B9 (2026-10-16 audit): flip only THIS batch's admitted steer acks. A
+                // superseded inner completing late must never DONE a newer batch's
+                // steered inputs — foreign acks stay for their owning batch.
+                const allSteers = this.admittedSteerAcks.get(chatId) || [];
+                const admittedSteers = allSteers.filter((s) => s.batch === batchToken);
+                if (allSteers.length > 0) {
+                    this.admittedSteerAcks.set(chatId, allSteers.filter((s) => s.batch !== batchToken));
+                }
                 if (admittedSteers.length > 0) {
-                    this.admittedSteerAcks.delete(chatId);
                     for (const s of admittedSteers) {
                         await this.removeReaction(s.messageId, "Get").catch(() => { });
                         await this.addReaction(s.messageId, "DONE").catch(() => { });
@@ -1993,6 +2031,14 @@ export class FeishuBot {
                 }
             }
             catch (err) {
+                if (err instanceof SupersededObservation) {
+                    // This batch's local observation was fenced by a newer batch (or a
+                    // custody revocation). The new owner handles delivery from here; end
+                    // quietly — no error notice, no replay, no Gateway abort. The old
+                    // run's eventual reply still flows through the proactive path.
+                    console.log(`[${this.config.name}] batch observation superseded for ${chatId.slice(-8)}; ending quietly`);
+                    break;
+                }
                 let pause = err instanceof SessionWaitPaused ? err : undefined;
                 if (!pause && isWaitTimeout(err instanceof Error ? err.message : String(err))) {
                     const state = await this.readSessionStatus(chatId);

package/dist/openclaw-client.d.ts

@@ -21,6 +21,16 @@ export type ProgressEvent = {
 export declare class InactiveRunObservation extends Error {
     constructor();
 }
+/** The local collectReply observation was fenced because a newer batch took
+ *  over this session's queue custody. Purely local: no Gateway run was stopped,
+ *  and the superseded run's eventual reply still flows through the proactive
+ *  delivery path. Introduced for the 2026-10-16 stale-collector regression:
+ *  an alive old poller destructively consumed the replacement batch's frames
+ *  from the shared session bucket, starving the new collector's idle clock and
+ *  swallowing its final. */
+export declare class SupersededObservation extends Error {
+    constructor(reason?: string);
+}
 export type ChatAttachment = {
     type?: string;
     mimeType?: string;
@@ -59,6 +69,11 @@ export declare class OpenClawClient {
     private recentToolEventKeys;
     private sessionMessageCallbacks;
     private progressCallbacks;
+    /** Live collectReply fences per canonical session key. The most recent
+     *  collector for a session owns the shared event bucket; a new batch (or a
+     *  queue-custody revocation) fences stale ones synchronously so they cannot
+     *  steal frames from the replacement (2026-10-16 regression). */
+    private sessionCollectorFences;
     /** Per-session steered messages awaiting consumption confirmation. Each
      * accepted message is retained independently so identical/overlapping text
      * cannot overwrite another correlation. */
@@ -209,6 +224,11 @@ export declare class OpenClawClient {
      */
     /** Stop claiming an exact run's final output after observation has paused. */
     releasePausedWait(runId: string): void;
+    /** Synchronously fence every live collectReply observation for a session.
+     *  Local only — never aborts a Gateway run. Returns the number superseded.
+     *  Used when queue custody is revoked or a new chat.send takes over, so a
+     *  stale poller cannot steal the replacement batch's frames (2026-10-16). */
+    revokeSessionCollectors(sessionKey: string, reason: string): number;
     getSessionRuntimeStatus(sessionKey: string): Promise<SessionRuntimeStatus>;
     private classifyWaitTimeout;
     getSessionInfo(sessionKey: string): Promise<any>;

package/dist/openclaw-client.js

@@ -12,6 +12,19 @@ export class InactiveRunObservation extends Error {
         this.name = "InactiveRunObservation";
     }
 }
+/** The local collectReply observation was fenced because a newer batch took
+ *  over this session's queue custody. Purely local: no Gateway run was stopped,
+ *  and the superseded run's eventual reply still flows through the proactive
+ *  delivery path. Introduced for the 2026-10-16 stale-collector regression:
+ *  an alive old poller destructively consumed the replacement batch's frames
+ *  from the shared session bucket, starving the new collector's idle clock and
+ *  swallowing its final. */
+export class SupersededObservation extends Error {
+    constructor(reason = "本地观察已被更新的批次取代") {
+        super(`${reason}（未停止网关运行）`);
+        this.name = "SupersededObservation";
+    }
+}
 export const GATEWAY_PROTOCOL_MIN = 4;
 export const GATEWAY_PROTOCOL_MAX = 4;
 const REQUIRED_GATEWAY_METHODS = [
@@ -63,6 +76,11 @@ export class OpenClawClient {
     recentToolEventKeys = new Map();
     sessionMessageCallbacks = new Map();
     progressCallbacks = new Map();
+    /** Live collectReply fences per canonical session key. The most recent
+     *  collector for a session owns the shared event bucket; a new batch (or a
+     *  queue-custody revocation) fences stale ones synchronously so they cannot
+     *  steal frames from the replacement (2026-10-16 regression). */
+    sessionCollectorFences = new Map();
     /** Per-session steered messages awaiting consumption confirmation. Each
      * accepted message is retained independently so identical/overlapping text
      * cannot overwrite another correlation. */
@@ -852,9 +870,14 @@ export class OpenClawClient {
                         return;
                     if (snapshot.status === "ok" && snapshot.yielded !== true) {
                         const terminal = snapshot.terminalReply;
+                        // B6 (2026-10-16 audit): disposition "empty" is an authoritative
+                        // no-visible-text terminal — never recycle an interim draft as the
+                        // final answer. Only genuinely unspecified metadata may fall back.
                         const visible = terminal?.disposition === "visible" && typeof terminal.text === "string"
-                            ? terminal.text : terminal?.disposition === "silent" ? "NO_REPLY"
-                            : this.pickBestCollectedText(chatFinalText, text, chatDeltaText, transcriptAssistantText);
+                            ? terminal.text
+                            : terminal?.disposition === "silent" || terminal?.disposition === "empty"
+                                ? "NO_REPLY"
+                                : this.pickBestCollectedText(chatFinalText, text, chatDeltaText, transcriptAssistantText);
                         resolve(visible || "NO_REPLY");
                     }
                     else if (snapshot.status === "error" || snapshot.status === "timeout") {
@@ -1356,7 +1379,9 @@ export class OpenClawClient {
                                 return;
                             }
                             if (isWaitTimeout(errText)) {
-                                bucket.splice(i, 1);
+                                // B5 (2026-10-16 audit): already dequeued by the unified splice
+                                // above; a second splice here deleted the NEXT buffered frame
+                                // (a real chatFinal following a timeout error was swallowed).
                                 if (!decidingTimeout) {
                                     decidingTimeout = true;
                                     void this.classifyWaitTimeout(errText, targetSessionKey || sessionKey).then(handleTimeoutResult);
@@ -1410,11 +1435,13 @@ export class OpenClawClient {
                             if (this.isRecoverableAgentError(errText)) {
                                 pendingRuntimeFailureText = `⚠️ Agent 未正常完成\n原因: ${safeErrorSummary(errText)}`;
                                 console.warn(`[OpenClaw] recoverable chat error for runId=${evRunId || runId}; deferring: ${safeErrorSummary(errText)}`);
-                                bucket.splice(i, 1);
+                                // B5: already dequeued above — no second splice.
                                 continue;
                             }
                             if (isWaitTimeout(errText)) {
-                                bucket.splice(i, 1);
+                                // B5 (2026-10-16 audit): already dequeued by the unified splice
+                                // above; a second splice here deleted the NEXT buffered frame
+                                // (a real chatFinal following a timeout error was swallowed).
                                 if (!decidingTimeout) {
                                     decidingTimeout = true;
                                     void this.classifyWaitTimeout(errText, targetSessionKey || sessionKey).then(handleTimeoutResult);
@@ -1479,6 +1506,34 @@ export class OpenClawClient {
                 if (observationKey && this.runStateChecks.get(observationKey) === checkAfterNoActiveRun)
                     this.runStateChecks.delete(observationKey);
             };
+            // Fence registration: a newer batch on this session must be able to end
+            // THIS observation synchronously (local cleanup + superseded settlement)
+            // so the shared bucket is no longer destructively consumed by a stale
+            // poller. The Gateway run is never aborted by fencing.
+            const fenceSuperseded = () => {
+                if (observationClosed)
+                    return;
+                cleanupObservation();
+                reject(new SupersededObservation());
+            };
+            if (observationKey) {
+                let fences = this.sessionCollectorFences.get(observationKey);
+                if (!fences) {
+                    fences = new Set();
+                    this.sessionCollectorFences.set(observationKey, fences);
+                }
+                fences.add(fenceSuperseded);
+                const unregisterFence = () => {
+                    const current = this.sessionCollectorFences.get(observationKey);
+                    if (current) {
+                        current.delete(fenceSuperseded);
+                        if (current.size === 0)
+                            this.sessionCollectorFences.delete(observationKey);
+                    }
+                };
+                const baseCleanup = cleanupObservation;
+                cleanupObservation = () => { baseCleanup(); unregisterFence(); };
+            }
         }).finally(() => cleanupObservation());
     }
     /**
@@ -1787,6 +1842,25 @@ export class OpenClawClient {
         this.ownedDeliveryRunTimers.delete(runId);
         this.ownedDeliveryRuns.delete(runId);
     }
+    /** Synchronously fence every live collectReply observation for a session.
+     *  Local only — never aborts a Gateway run. Returns the number superseded.
+     *  Used when queue custody is revoked or a new chat.send takes over, so a
+     *  stale poller cannot steal the replacement batch's frames (2026-10-16). */
+    revokeSessionCollectors(sessionKey, reason) {
+        const key = this.canonicalSessionKey(sessionKey);
+        const fences = this.sessionCollectorFences.get(key);
+        if (!fences || fences.size === 0)
+            return 0;
+        const count = fences.size;
+        for (const fence of [...fences]) {
+            try {
+                fence();
+            }
+            catch { /* each fence is isolated */ }
+        }
+        console.warn(`[OpenClaw] superseded ${count} stale collector(s) for ${key.slice(-24)}: ${reason}`);
+        return count;
+    }
     async getSessionRuntimeStatus(sessionKey) {
         let timer;
         try {
@@ -2360,6 +2434,10 @@ export class OpenClawClient {
             let result;
             const sendStartedAt = Date.now();
             try {
+                // A stale collector from a previous batch must not steal this batch's
+                // frames from the shared session bucket (2026-10-16 regression). Fence
+                // any still-live local observation BEFORE issuing chat.send.
+                this.revokeSessionCollectors(sk, "new chat.send supersedes stale observation");
                 await params.onSendAttempt?.();
                 const sendChat = () => this.rpc("chat.send", {
                     sessionKey: this.canonicalSessionKey(sk),
@@ -2407,8 +2485,15 @@ export class OpenClawClient {
             // collectReply returns. Keep a short grace window so normal chat replies
             // are not delivered twice via the proactive-message path. Cron/LMA runs
             // are unaffected because they do not go through chatSend.
-            this.progressCallbacks.delete(sk);
-            this.progressCallbacks.delete(fullSessionKey);
+            // CAS: a superseded send's finally must not delete a newer send's
+            // progress callback (the fence settles the old promise after the new
+            // batch may already have registered its own callback).
+            if (params.onProgress) {
+                if (this.progressCallbacks.get(sk) === params.onProgress)
+                    this.progressCallbacks.delete(sk);
+                if (this.progressCallbacks.get(fullSessionKey) === params.onProgress)
+                    this.progressCallbacks.delete(fullSessionKey);
+            }
             if (waitPaused)
                 this.releasePausedWait(ownedRunId);
             else

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-lark-multi-agent",
-  "version": "1.8.1",
+  "version": "1.8.3",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {