openclaw-lark-multi-agent 1.8.7 → 1.8.9

package/dist/feishu-bot.js

@@ -1458,14 +1458,15 @@ export class FeishuBot {
                 // 息都发个这个"). Stay silent until it persists through several
                 // re-checks (~45s), then notify exactly once.
                 const unknownChecks = state === 'unknown' ? (Number(item.unknownChecks) || 0) + 1 : 0;
-                const unknownNotified = Boolean(item.unknownNotified) || (state === 'unknown' && unknownChecks >= 3);
-                const record = { ...item, attempted: valid ? (receipt.attempted ?? true) : true, sessionId: item.sessionId, reason: receipt.reason, unknownChecks, unknownNotified };
+                const record = { ...item, attempted: valid ? (receipt.attempted ?? true) : true, sessionId: item.sessionId, reason: receipt.reason, unknownChecks };
                 this.store.saveInsertion(this.config.name, chatId, item.rowId, item.insertionId, state, record, Date.now() + (state === 'unknown' ? 15_000 : 5000));
                 if (state === 'ordinary') {
+                    this.store.deletePendingInsertionNotices(this.config.name, chatId, item.insertionId);
                     void this.enqueueAndDispatchDelivery(chatId, 'insertion_status', `insertion:${item.insertionId}:ordinary`, 'ℹ️ 原 run 已明确结束，且这条消息确定未被插入；现已交回普通队列，只执行一次。', [], item.messageId, `insertion:${item.insertionId}:ordinary`).catch(() => { });
                     void this.processQueue(chatId).catch(() => { });
                 }
                 else if (state === 'accepted') {
+                    this.store.deletePendingInsertionNotices(this.config.name, chatId, item.insertionId);
                     this.store.clearPendingTrigger(this.config.name, chatId, item.rowId);
                     // Durable acceptance drives Get, including after bridge restart when
                     // its ephemeral pendingAckMessages array no longer exists.
@@ -1486,8 +1487,17 @@ export class FeishuBot {
                     if (item.state !== state)
                         void this.enqueueAndDispatchDelivery(chatId, 'insertion_status', `insertion:${item.insertionId}:${state}`, `ℹ️ 这条插入消息的状态为 ${state}，仍保留本地记录，未确认接收前不会显示 Get，也不会自动重复执行。${receipt.reason || ''}`, [], item.messageId, `insertion:${item.insertionId}:${state}`).catch(() => { });
                 }
-                else if (state === 'unknown' && unknownNotified && !item.unknownNotified) {
-                    void this.enqueueAndDispatchDelivery(chatId, 'insertion_status', `insertion:${item.insertionId}:unknown-prolonged`, `ℹ️ 这条插入消息约 45 秒仍未确认接收：本地记录保留中，不会自动重复执行；确认后会自动显示 Get。`, [], item.messageId, `insertion:${item.insertionId}:unknown-prolonged`).catch(() => { });
+                else if (state === 'unknown' && unknownChecks >= 4 && !item.unknownNotified) {
+                    // ~45s (attempt + 3 re-checks). Mark unknownNotified ONLY after the
+                    // outbox insert succeeds, so a failed enqueue retries next check
+                    // instead of silencing the notice forever.
+                    void this.enqueueAndDispatchDelivery(chatId, 'insertion_status', `insertion:${item.insertionId}:unknown-prolonged`, `ℹ️ 这条插入消息约 45 秒仍未确认接收：本地记录保留中，不会自动重复执行；确认后会自动显示 Get。`, [], item.messageId, `insertion:${item.insertionId}:unknown-prolonged`)
+                        .then(() => {
+                        const cur = this.store.getInsertion(this.config.name, chatId, item.rowId);
+                        const curRecord = (cur && cur.record) || record;
+                        this.store.saveInsertion(this.config.name, chatId, item.rowId, item.insertionId, (cur && cur.state) || state, { ...curRecord, unknownNotified: true }, Date.now() + 15_000);
+                    })
+                        .catch(() => { });
                 }
             }
         }

package/dist/message-store.d.ts

@@ -131,6 +131,9 @@ export declare class MessageStore {
     finishRunObservation(sessionKey: string, runId: string, state?: string): void;
     listRunObservations(sessionKey?: string, due?: number, limit?: number): any[];
     saveInsertion(bot: string, chat: string, row: number, id: string, state: string, record: object, next?: number): void;
+    /** Purge still-pending insertion status notices once the insertion resolves
+     *  (accepted/ordinary): a stale "unknown" notice must not fire after Get. */
+    deletePendingInsertionNotices(bot: string, chat: string, insertionId: string): number;
     claimInsertionAttempt(bot: string, chat: string, row: number): boolean;
     getInsertion(bot: string, chat: string, row: number): any;
     listInsertions(bot: string, chat?: string): any[];

package/dist/message-store.js

@@ -159,6 +159,13 @@ export class MessageStore {
       ON CONFLICT(bot_name,chat_id,message_row_id) DO UPDATE SET state=excluded.state,record_json=excluded.record_json,next_check_at=excluded.next_check_at
       WHERE insertion_custody.state NOT IN ('stopped','committed')`).run(bot, chat, row, id, JSON.stringify(record), state, next);
     }
+    /** Purge still-pending insertion status notices once the insertion resolves
+     *  (accepted/ordinary): a stale "unknown" notice must not fire after Get. */
+    deletePendingInsertionNotices(bot, chat, insertionId) {
+        const r = this.db.prepare(`DELETE FROM delivery_outbox WHERE bot_name=? AND chat_id=? AND delivery_key LIKE ? AND status='pending'`)
+            .run(bot, chat, `insertion:${insertionId}:%`);
+        return r.changes;
+    }
     claimInsertionAttempt(bot, chat, row) {
         return this.db.prepare(`UPDATE insertion_custody SET state='dispatching',record_json=json_set(record_json,'$.attempted',json('true'))
       WHERE bot_name=? AND chat_id=? AND message_row_id=? AND state='pending'`).run(bot, chat, row).changes === 1;

package/dist/openclaw-client.js

@@ -900,11 +900,12 @@ export class OpenClawClient {
             let lifecycleEndTimer = null;
             let replayInvalidTimer = null;
             let genericChatErrorTimer = null;
-            // A channel message-tool send marked terminate=true is the turn's intended
-            // user-visible output (2026-10-16 incident: it bypassed the bridge and the
-            // collector waited forever). Capture its text and settle on a short grace.
-            let terminatingSendText = "";
-            let terminatingSendTimer = null;
+            // A terminating message-tool send schedules ONE deferred exact-run
+            // reconciliation. The timer carries no settlement or delivery authority
+            // of its own; checkRunState still requires the gateway to confirm the
+            // root's recorded terminal state (all tools settled, no error, no async
+            // pending) before anything resolves.
+            let terminatingReconcileTimer = null;
             let pendingRuntimeFailureText = "";
             let lastActivitySummary = "";
             let lastActivityAt = 0;
@@ -1179,8 +1180,8 @@ export class OpenClawClient {
                     clearTimeout(replayInvalidTimer);
                 if (genericChatErrorTimer)
                     clearTimeout(genericChatErrorTimer);
-                if (terminatingSendTimer)
-                    clearTimeout(terminatingSendTimer);
+                if (terminatingReconcileTimer)
+                    clearTimeout(terminatingReconcileTimer);
                 resolve(finalText);
             };
             const collectEvents = () => {
@@ -1317,39 +1318,45 @@ export class OpenClawClient {
                         if (hasEffectiveActivity(ev))
                             resetIdleTimer();
                         rememberActivity(ev);
-                        // Terminating channel-send detection: a message-tool result carrying
-                        // terminate=true ends the turn with that send as its user-visible
-                        // output. The bridge is the delivery channel for LMA sessions, so
-                        // waiting for a further final would hang forever (2026-10-16 frozen
-                        // card incident). Capture the sent text at tool start; settle on a
-                        // short grace unless a real final arrives first.
+                        // Terminating channel-send detection (2026-10-16 frozen-card
+                        // incident, remediated per independent review): a message-tool
+                        // result carrying a top-level terminate=true is a batch-control
+                        // hint — NOT a delivery receipt and NOT settlement authority for
+                        // this collector. It only nudges the exact-run reconciliation:
+                        // checkRunState requires a recorded terminal time, all tools
+                        // settled, no error and no async pending before resolving; a run
+                        // that is still executing keeps waiting normally. No tool input is
+                        // ever re-delivered to the source chat by this path.
                         {
                             const tdata = ev.data || {};
                             if (ev.stream === "tool" || (ev.stream === "item" && tdata.kind === "tool")) {
                                 const toolName = String(tdata.name || tdata.toolName || "");
                                 const tphase = tdata.phase === "result" ? (tdata.isError || tdata.error ? "error" : "end") : tdata.phase;
-                                if (toolName === "message" && tphase === "start") {
-                                    const raw = tdata.input ?? tdata.args ?? tdata.meta ?? null;
-                                    if (raw !== null) {
-                                        try {
-                                            const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
-                                            if (parsed && typeof parsed.message === "string" && parsed.message.trim())
-                                                terminatingSendText = parsed.message;
+                                if (toolName === "message" && (tphase === "end" || tphase === "error")) {
+                                    const rawOut = tdata.output ?? tdata.result ?? tdata.error ?? null;
+                                    let terminating = false;
+                                    try {
+                                        if (rawOut && typeof rawOut === "object")
+                                            terminating = rawOut.terminate === true;
+                                        else if (typeof rawOut === "string") {
+                                            const trimmed = rawOut.trim();
+                                            if (trimmed.startsWith("{")) {
+                                                const parsed = JSON.parse(trimmed);
+                                                terminating = parsed && typeof parsed === "object" && parsed.terminate === true;
+                                            }
+                                            else
+                                                terminating = /^terminate\s*=\s*true$/i.test(trimmed);
                                         }
-                                        catch { /* non-JSON tool input */ }
                                     }
-                                }
-                                else if (toolName === "message" && (tphase === "end" || tphase === "error")) {
-                                    const out = String(JSON.stringify(tdata.output ?? tdata.result ?? tdata.error ?? ""));
-                                    if (/"?terminate"?\s*[:=]\s*true/i.test(out) && !terminatingSendTimer) {
-                                        terminatingSendTimer = setTimeout(() => {
-                                            terminatingSendTimer = null;
+                                    catch { /* unparseable output is not evidence */ }
+                                    if (terminating && !terminatingReconcileTimer) {
+                                        terminatingReconcileTimer = setTimeout(() => {
+                                            terminatingReconcileTimer = null;
                                             if (observationClosed)
                                                 return;
-                                            const best = (chatFinalText.trim() || text.trim() || terminatingSendText || "").trim();
-                                            finish(best || "NO_REPLY");
+                                            void checkRunState(() => true, true);
                                         }, 10_000);
-                                        terminatingSendTimer.unref?.();
+                                        terminatingReconcileTimer.unref?.();
                                     }
                                 }
                             }
@@ -1613,6 +1620,8 @@ export class OpenClawClient {
                                 clearTimeout(lifecycleEndTimer);
                             if (genericChatErrorTimer)
                                 clearTimeout(genericChatErrorTimer);
+                            if (terminatingReconcileTimer)
+                                clearTimeout(terminatingReconcileTimer);
                             // Abort the (possibly still-running) backgrounded run before we
                             // reject, so an auto-retry probe does not race a zombie run on the
                             // same session. Idempotent/best-effort.
@@ -1669,8 +1678,8 @@ export class OpenClawClient {
                     clearTimeout(replayInvalidTimer);
                 if (genericChatErrorTimer)
                     clearTimeout(genericChatErrorTimer);
-                if (terminatingSendTimer)
-                    clearTimeout(terminatingSendTimer);
+                if (terminatingReconcileTimer)
+                    clearTimeout(terminatingReconcileTimer);
                 if (observationKey && this.runStateChecks.get(observationKey) === checkAfterNoActiveRun)
                     this.runStateChecks.delete(observationKey);
             };

package/package.json

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