openclaw-lark-multi-agent 1.8.8 → 1.8.10

package/dist/cli.js

@@ -24,6 +24,7 @@ Usage:
   ${CLI_NAME} install-windows-service [--state-dir DIR] [--no-start]
   ${CLI_NAME} install-core-plugin [--no-force]
   ${CLI_NAME} install-steer-plugin [--no-force]  (compatibility alias)
+  ${CLI_NAME} check-core-plugin  (read-only runtime protocol check)
   ${CLI_NAME} doctor [--state-dir DIR]
   ${CLI_NAME} --help
 
@@ -250,6 +251,23 @@ function cmdInstallCorePlugin(args) {
     console.log(`Load/reload with the Gateway's supported plugin control path, then verify the read-only capability endpoint:`);
     console.log(`  openclaw gateway call lma.steer.capabilities --params '{}'`);
     console.log(`  (expect protocol:2, durableAttempts:true, acceptanceCallback:true, atomicRunBound:false)`);
+    console.log(`  ${CLI_NAME} check-core-plugin  (read-only validation; generic core capabilities alone are insufficient)`);
+}
+function cmdCheckCorePlugin(args) {
+    if (args.length)
+        throw new Error(`Unknown check-core-plugin arguments: ${args.join(' ')}`);
+    const bin = process.env.OPENCLAW_BIN || 'openclaw';
+    let capability;
+    try {
+        const raw = execFileSync(bin, ['gateway', 'call', 'lma.steer.capabilities', '--params', '{}', '--json'], { encoding: 'utf8', shell: process.platform === 'win32', timeout: 15_000, stdio: ['ignore', 'pipe', 'pipe'] });
+        capability = JSON.parse(raw);
+    }
+    catch {
+        throw new Error('lma.steer.capabilities unavailable or invalid: callback/durable insertion is NOT verified. Activate the coordinated lma-core plugin via supported Gateway controls, then recheck.');
+    }
+    if (capability?.protocol !== 2 || capability?.durableAttempts !== true || capability?.acceptanceCallback !== true || capability?.sessionGenerationBound !== true)
+        throw new Error('lma.steer.capabilities incompatible: require protocol=2, durableAttempts=true, acceptanceCallback=true, sessionGenerationBound=true; generic lma.core.capabilities is not activation proof.');
+    console.log('OK: runtime lma.steer.capabilities protocol=2; callback acceptance, durable attempts and session generation binding verified (not model consumption or final-effect CAS).');
 }
 function cmdDoctor(args) {
     const stateDir = resolve(takeOption(args, "--state-dir") || DEFAULT_STATE_DIR);
@@ -277,6 +295,8 @@ async function main() {
         return cmdInstallCorePlugin(args);
     if (cmd === "doctor")
         return cmdDoctor(args);
+    if (cmd === "check-core-plugin")
+        return cmdCheckCorePlugin(args);
     if (cmd === "start") {
         const configPath = args[0] ? resolve(args[0]) : DEFAULT_CONFIG_PATH;
         return startApp(configPath);

package/dist/feishu-bot.d.ts

@@ -118,6 +118,13 @@ export declare class FeishuBot {
     static getByName(name: string): FeishuBot | undefined;
     static findByOpenId(openId: string): FeishuBot | undefined;
     private handleMessage;
+    /** With no local owner, the Gateway can still have externally admitted work.
+     * Read public activity and pin its exact root before choosing insertion. Missing
+     * identity is durable unbound custody, never a fabricated run or blind send. */
+    private reconcileCurrentInputActivity;
+    /** CAS includes the actual batch, not merely the queue Promise, and excludes
+     * local admission/RPC windows even if the host briefly reports idle. */
+    private reconcileDispatchCustody;
     private stopGeneration;
     private reactionChecks;
     private receiptReaction;
@@ -250,6 +257,7 @@ export declare class FeishuBot {
     /** Both initial and CONTINUE results enter the same ordinary LMA outbox.
      * No host proactive-send assumption, no fake platform receipt. */
     private deliverGoExecutorResult;
+    private insertionNoticeCurrent;
     private dispatchPendingDeliveries;
     private hasFreeModeBot;
     private mentionedBotNames;

package/dist/feishu-bot.js

@@ -1225,11 +1225,11 @@ export class FeishuBot {
                 // Reserve BEFORE the first health/reaction await. Otherwise an ending
                 // owner can ordinary-drain this row while its handler is still waiting,
                 // and the later steer would submit the same message a second time.
-                const ingressOwner = this.queueOwners.get(chatId);
-                if (this.queueRuns.has(chatId) && !ingressOwner?.triggerIds?.has(insertedId)) {
+                const ingressOwner = this.queueOwners.get(chatId) || this.store.getDispatchCustody(this.config.name, chatId);
+                if ((this.queueRuns.has(chatId) || ingressOwner) && !ingressOwner?.triggerIds?.has(insertedId)) {
                     this.store.saveInsertion(this.config.name, chatId, insertedId, JSON.stringify([this.config.appId, chatId, messageId]), 'pending', {
                         messageId, text: cleanText, stopEpoch: this.stopGeneration(chatId), expectedRunId: ingressOwner?.runId || '',
-                        ownerId: ingressOwner?.id, batchId: ingressOwner?.batchId, sessionKey: this.getSessionKey(chatId)
+                        ownerId: ingressOwner?.id, batchId: ingressOwner?.batchId, sessionId: ingressOwner?.sessionId, sessionKey: this.getSessionKey(chatId)
                     });
                     reservedAtIngress = true;
                 }
@@ -1249,6 +1249,20 @@ export class FeishuBot {
             if (unhealthy) {
                 await this.warnUnhealthySessionAndContinue(chatId, messageId, unhealthy);
             }
+            // Inspect current public activity, not just the local promise. A yielded
+            // task (or a settled/uncached old root with authoritative idle history)
+            // keeps its result observer but cannot monopolize independent new input.
+            const dispatchReleased = await this.reconcileDispatchCustody(chatId);
+            if (this.stopGeneration(chatId) !== inputStopEpoch)
+                return;
+            if (!isBot && insertedId > 0 && !dispatchReleased && !this.queueRuns.has(chatId) && !this.store.getDispatchCustody(this.config.name, chatId))
+                await this.reconcileCurrentInputActivity(chatId, insertedId, messageId, cleanText);
+            if (this.stopGeneration(chatId) !== inputStopEpoch)
+                return;
+            if (this.store.isInsertionReserved(this.config.name, chatId, insertedId))
+                reservedAtIngress = true;
+            if (reservedAtIngress && !this.store.isInsertionReserved(this.config.name, chatId, insertedId))
+                reservedAtIngress = false;
             // Another ingress handler may already have selected/admitted this row
             // as an ordinary batch while this handler awaited health. Do not re-steer
             // a message that already belongs to that batch.
@@ -1265,11 +1279,11 @@ export class FeishuBot {
             // --- Queue-based sending: if agent is busy, just accumulate ---
             // The actual queue owner, not elapsed wall time, decides whether input
             // should steer/queue. Long healthy runs must not lose their busy ownership.
-            const isBusy = reservedAtIngress || this.queueRuns.has(chatId);
+            const isBusy = reservedAtIngress || this.queueRuns.has(chatId) || !!this.store.getDispatchCustody(this.config.name, chatId);
             if (isBusy) {
-                const owner = this.queueOwners.get(chatId);
+                const owner = this.queueOwners.get(chatId) || this.store.getDispatchCustody(this.config.name, chatId);
                 const record = { messageId, text: cleanText, stopEpoch: this.stopGeneration(chatId),
-                    expectedRunId: owner?.runId || '', ownerId: owner?.id, batchId: owner?.batchId, sessionKey: this.getSessionKey(chatId) };
+                    expectedRunId: owner?.runId || '', ownerId: owner?.id, batchId: owner?.batchId, sessionId: owner?.sessionId, sessionKey: this.getSessionKey(chatId) };
                 if (insertedId > 0 && !this.store.getInsertion(this.config.name, chatId, insertedId))
                     this.store.saveInsertion(this.config.name, chatId, insertedId, JSON.stringify([this.config.appId, chatId, messageId]), 'pending', record);
                 // Reservation is durable BEFORE any RPC. Ordinary drain cannot race a
@@ -1279,12 +1293,103 @@ export class FeishuBot {
                 return;
             }
             // Not busy: admission callback, not local queueing, flips Typing -> Get.
-            await this.processQueue(chatId);
+            await this.processQueue(chatId, true);
         }
         catch (err) {
             console.error(`[${this.config.name}] Error:`, safeErrorSummary(err));
         }
     }
+    /** With no local owner, the Gateway can still have externally admitted work.
+     * Read public activity and pin its exact root before choosing insertion. Missing
+     * identity is durable unbound custody, never a fabricated run or blind send. */
+    async reconcileCurrentInputActivity(chatId, rowId, messageId, text) {
+        if (!this.openclawClient.getSessionRuntimeStatus || !this.openclawClient.getSessionDispatchStatus)
+            return;
+        const epoch = this.stopGeneration(chatId);
+        // A different ingress handler can ordinary-admit AND finish this row while
+        // a public lookup is in flight. Check message custody, not just an empty
+        // owner map, at every boundary so a late lookup can never reinsert it.
+        const unsubmitted = () => this.stopGeneration(chatId) === epoch &&
+            this.store.getPendingTriggerIds(this.config.name, chatId).has(rowId) &&
+            !this.queueOwners.get(chatId)?.triggerIds?.has(rowId);
+        if (!unsubmitted())
+            return;
+        await this.openclawClient.waitForSessionStop?.(this.getSessionKey(chatId));
+        if (!unsubmitted())
+            return;
+        // Session creation/model setup is not agent admission. Initialize a truly
+        // new chat before asking for its live activity; never infer idle from a
+        // missing describe response. Setup errors keep the existing queue error path.
+        try {
+            await this.ensureSession(chatId);
+        }
+        catch {
+            return;
+        }
+        if (!unsubmitted() || this.queueRuns.has(chatId) || this.store.getDispatchCustody(this.config.name, chatId))
+            return;
+        const status = await this.openclawClient.getSessionRuntimeStatus(this.getSessionKey(chatId));
+        if (!unsubmitted() || this.queueRuns.has(chatId) || this.store.getDispatchCustody(this.config.name, chatId))
+            return;
+        const current = this.store.getInsertion(this.config.name, chatId, rowId);
+        if (current && (!current.activityUnbound || current.attempted))
+            return;
+        const activity = await this.openclawClient.getSessionDispatchStatus(this.getSessionKey(chatId));
+        if (!unsubmitted() || this.queueRuns.has(chatId) || this.store.getDispatchCustody(this.config.name, chatId))
+            return;
+        // Another recovery/ingress lookup may have identified the root and begun
+        // dispatch while this one awaited history. Never restore its older
+        // never-attempted snapshot over an attempted/unknown/accepted journal.
+        const fresh = this.store.getInsertion(this.config.name, chatId, rowId);
+        if (current ? fresh?.insertionId !== current.insertionId || fresh.state !== 'pending' || fresh.attempted === true || !fresh.activityUnbound || !!fresh.expectedRunId : !!fresh)
+            return;
+        const compatible = !activity.sessionId || !status.sessionId || activity.sessionId === status.sessionId;
+        const idle = compatible && !status.archived && !activity.archived && !activity.busyConfirmed &&
+            (status.idleConfirmed && !!status.sessionId || activity.idleConfirmed && !!activity.sessionId);
+        if (idle) {
+            if (current)
+                this.store.saveInsertion(this.config.name, chatId, rowId, current.insertionId, 'ordinary', { ...current, activityUnbound: false });
+            return;
+        }
+        const identified = compatible && !!activity.activeRunId && !!activity.sessionId && !activity.archived && !status.archived;
+        this.store.saveInsertion(this.config.name, chatId, rowId, current?.insertionId || JSON.stringify([this.config.appId, chatId, messageId]), 'pending', {
+            messageId, text, stopEpoch: epoch, sessionKey: this.getSessionKey(chatId), sessionId: identified ? activity.sessionId : status.sessionId,
+            expectedRunId: identified ? activity.activeRunId : '', ownerId: identified ? `external:${activity.activeRunId}` : undefined,
+            batchId: identified ? activity.activeRunId : undefined, activityUnbound: !identified, attempted: false,
+            reason: identified ? 'current Gateway run observed; insertion custody only' : 'current Gateway activity/run identity unavailable; retained without admission',
+        }, Date.now() + (identified ? 0 : 5000));
+    }
+    /** CAS includes the actual batch, not merely the queue Promise, and excludes
+     * local admission/RPC windows even if the host briefly reports idle. */
+    async reconcileDispatchCustody(chatId) {
+        const local = this.queueOwners.get(chatId);
+        const saved = this.store.getDispatchCustody(this.config.name, chatId);
+        if (!saved?.runId || !saved.batchId || !saved.sessionId || !saved.admitted && !saved.yielded)
+            return false;
+        if (local && (local.id !== saved.id || local.batchId !== saved.batchId || !local.admitted && !local.yielded || !local.collecting))
+            return false;
+        const batch = local?.batch, runId = local?.runId, epoch = this.stopGeneration(chatId);
+        const unchanged = () => {
+            const now = this.store.getDispatchCustody(this.config.name, chatId);
+            return this.stopGeneration(chatId) === epoch && now?.id === saved.id && now?.batchId === saved.batchId && now?.runId === saved.runId &&
+                this.queueOwners.get(chatId) === local && (!local || local.batch === batch && local.runId === runId && (local.admitted === true || local.yielded === true) && local.collecting === true);
+        };
+        if (!saved.yielded) {
+            const activity = await this.openclawClient.getSessionDispatchStatus?.(this.getSessionKey(chatId)).catch(() => null);
+            if (!unchanged() || !activity?.idleConfirmed || activity.archived || activity.sessionId !== saved.sessionId)
+                return false;
+        }
+        const status = await this.openclawClient.getSessionRuntimeStatus(this.getSessionKey(chatId)).catch(() => null);
+        if (!unchanged() || !status?.idleConfirmed || status.archived || status.sessionId !== saved.sessionId)
+            return false;
+        if (!this.store.releaseDispatchCustody(this.config.name, chatId, saved.id, saved.batchId))
+            return false;
+        // The target was committed on admission and survives this local cleanup.
+        // Only this exact old owner can be revoked; never a replacement batch.
+        if (local)
+            this.forceExpireQueueOwner(chatId, 'current session confirmed schedulable; exact result observation retained');
+        return true;
+    }
     stopGeneration(chatId) {
         return this.stopEpoch.get(chatId) ?? this.store.getStopGeneration(this.config.name, chatId);
     }
@@ -1350,7 +1455,7 @@ export class FeishuBot {
         this.insertionTimer = setTimeout(() => {
             this.insertionTimer = undefined;
             const chats = [...new Set([...this.store.listInsertions(this.config.name), ...this.store.listReactionIntents(this.config.name)].map(x => x.chatId))];
-            void Promise.allSettled(chats.map(async (chat) => { await this.reconcileReactions(chat); await this.reconcileInsertions(chat); })).finally(() => this.scheduleInsertionRecovery());
+            void Promise.allSettled(chats.flatMap(chat => [this.reconcileReactions(chat), this.reconcileInsertions(chat)])).finally(() => this.scheduleInsertionRecovery());
         }, 5000);
         this.insertionTimer.unref?.();
     }
@@ -1359,14 +1464,30 @@ export class FeishuBot {
             return;
         this.insertionChecks.add(chatId);
         try {
+            const released = await this.reconcileDispatchCustody(chatId);
+            if (released)
+                void this.processQueue(chatId, true).catch(() => { });
             for (const item of this.store.listInsertions(this.config.name, chatId)) {
                 if (item.nextCheckAt > Date.now())
                     continue;
-                const stillCurrent = () => this.stopGeneration(chatId) === item.stopEpoch && this.store.getInsertion(this.config.name, chatId, item.rowId)?.state !== 'stopped';
+                const stillCurrent = () => this.stopGeneration(chatId) === item.stopEpoch && !['stopped', 'ordinary', 'committed'].includes(this.store.getInsertion(this.config.name, chatId, item.rowId)?.state);
                 if (!stillCurrent()) {
-                    this.store.stopInsertions(this.config.name, chatId);
+                    if (this.stopGeneration(chatId) !== item.stopEpoch)
+                        this.store.stopInsertionAtEpoch(this.config.name, chatId, item.rowId, item.stopEpoch);
                     continue;
                 }
+                if (item.activityUnbound) {
+                    await this.reconcileCurrentInputActivity(chatId, item.rowId, item.messageId, item.text);
+                    if (!stillCurrent()) {
+                        if (this.store.getInsertion(this.config.name, chatId, item.rowId)?.state === 'ordinary')
+                            void this.processQueue(chatId, true).catch(() => { });
+                        continue;
+                    }
+                    const refreshed = this.store.getInsertion(this.config.name, chatId, item.rowId);
+                    if (!refreshed?.expectedRunId)
+                        continue;
+                    Object.assign(item, refreshed);
+                }
                 const owner = this.queueOwners.get(chatId);
                 if (!item.expectedRunId && owner?.id === item.ownerId && owner?.batchId === item.batchId && owner?.runId)
                     item.expectedRunId = owner.runId;
@@ -1377,7 +1498,7 @@ export class FeishuBot {
                 }
                 // Pin the real session generation BEFORE the dispatching journal. A
                 // crash/lost response can then query using precisely the same identity.
-                const info = await this.openclawClient.getSessionInfo(item.sessionKey).catch(() => null);
+                const info = await this.openclawClient.getSessionInfo(item.sessionKey, 1500).catch(() => null);
                 if (!stillCurrent())
                     continue;
                 const sessionId = info?.session?.sessionId;
@@ -1427,9 +1548,9 @@ export class FeishuBot {
                     continue;
                 const valid = receipt.insertionId === item.insertionId && receipt.expectedRunId === item.expectedRunId && (!receipt.sessionId || receipt.sessionId === item.sessionId);
                 let state = valid ? receipt.status : 'unknown';
-                // Explicit no-effect means a real old-run terminal can hand this SAME
-                // input back to the ordinary queue once. Time elapsed never authorizes
-                // this handoff. An attempted unknown can never take this branch.
+                // Explicit no-effect plus confirmed current schedulability can hand
+                // this SAME input back once without claiming old task settlement.
+                // Time elapsed and attempted-unknown receipts never authorize replay.
                 if (valid && receipt.attempted === false && receipt.ordinaryEligible !== false && ['pending', 'target_ended'].includes(state) &&
                     ['target_not_ready', 'backend_rejected_no_effect', 'original run ended without an insertion attempt'].includes(receipt.reason || '')) {
                     const status = await this.openclawClient.getSessionRuntimeStatus(item.sessionKey).catch(() => null);
@@ -1438,8 +1559,15 @@ export class FeishuBot {
                     const rootSettled = await this.openclawClient.exactRunSettled?.(item.expectedRunId);
                     if (!stillCurrent())
                         continue;
+                    const activity = !owner && !rootSettled && status?.idleConfirmed ? await this.openclawClient.getSessionDispatchStatus?.(item.sessionKey).catch(() => null) : null;
+                    if (!stillCurrent())
+                        continue;
+                    const currentIdle = activity?.idleConfirmed === true && activity.sessionId === item.sessionId && !activity.archived && status?.sessionId === item.sessionId;
                     const unchanged = this.queueOwners.get(chatId) === owner && owner?.batch === batchAtCheck && owner?.runId === runAtCheck;
-                    if (rootSettled === true && status?.idleConfirmed === true && unchanged) {
+                    const target = this.store.getDeliveryRunTarget(this.config.name, chatId, item.expectedRunId);
+                    const dispatchReleased = target?.dispatchReleased === true && target.dispatchOwnerId === item.ownerId && target.dispatchBatchId === item.batchId &&
+                        target.sessionId === item.sessionId && status?.sessionId === item.sessionId && !status?.archived;
+                    if ((rootSettled === true || dispatchReleased || currentIdle) && status?.idleConfirmed === true && unchanged) {
                         state = 'ordinary';
                         // Never expire a successor merely to schedule the old input.
                         if (runAtCheck === item.expectedRunId)
@@ -1454,18 +1582,19 @@ export class FeishuBot {
                     state = 'pending';
                 // Unknown is the NORMAL transient state right after a steer attempt
                 // (the backend acceptance receipt has not landed yet); surfacing it on
-                // every insertion spams the chat (user report 2026-10-16: "每次插入消
-                // 息都发个这个"). Stay silent until it persists through several
-                // re-checks (~45s), then notify exactly once.
+                // every insertion spams the chat. Use real elapsed time from the first
+                // unknown observation, not query count, and commit one reminder intent.
                 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,
+                    unknownSince: state === 'unknown' ? (item.state === 'unknown' && Number.isFinite(item.unknownSince) ? item.unknownSince : Date.now()) : undefined };
                 this.store.saveInsertion(this.config.name, chatId, item.rowId, item.insertionId, state, record, Date.now() + (state === 'unknown' ? 15_000 : 5000));
                 if (state === 'ordinary') {
-                    void this.enqueueAndDispatchDelivery(chatId, 'insertion_status', `insertion:${item.insertionId}:ordinary`, 'ℹ️ 原 run 已明确结束，且这条消息确定未被插入；现已交回普通队列，只执行一次。', [], item.messageId, `insertion:${item.insertionId}:ordinary`).catch(() => { });
-                    void this.processQueue(chatId).catch(() => { });
+                    this.store.deletePendingInsertionNotices(this.config.name, chatId, item.insertionId);
+                    void this.enqueueAndDispatchDelivery(chatId, 'insertion_status', `insertion:${item.insertionId}:ordinary`, 'ℹ️ 当前会话已确认可接收新轮次，且这条消息确定未被插入；现已交回普通队列，只执行一次。', [], item.messageId, `insertion:${item.insertionId}:ordinary`).catch(() => { });
+                    void this.processQueue(chatId, true).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 +1615,15 @@ 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' && Date.now() - record.unknownSince >= 45_000 && !item.unknownNotified) {
+                    const text = 'ℹ️ 这条插入消息约 45 秒仍未确认接收：本地记录保留中，不会自动重复执行；确认后会自动显示 Get。';
+                    const key = `insertion:${item.insertionId}:unknown-prolonged`;
+                    if (this.store.queueInsertionUnknownNotice(this.config.name, chatId, item.rowId, {
+                        sessionKey: this.getSessionKey(chatId), chatId, botName: this.config.name, sourceType: 'insertion_status', sourceId: key, deliveryKey: key,
+                        contentHash: this.stableHash(`${text}|[]`), content: text, attachmentsJson: '[]', replyToMessageId: item.messageId,
+                        deliveryMetaJson: JSON.stringify({ botIdentity: this.config.appId, insertionNotice: { rowId: item.rowId, insertionId: item.insertionId, sessionId: item.sessionId, stopEpoch: item.stopEpoch } }),
+                    }))
+                        void this.dispatchPendingDeliveries(chatId).catch(() => { });
                 }
             }
         }
@@ -1614,12 +1750,46 @@ export class FeishuBot {
             catch { /* observer failures are isolated */ }
         }
     }
-    async processQueue(chatId) {
+    async processQueue(chatId, activityChecked = false) {
         const existing = this.queueRuns.get(chatId);
         if (existing) {
             console.log(`[${this.config.name}] processQueue already running for ${chatId.slice(-8)}, joining existing run`);
             return existing;
         }
+        const detached = this.store.getDispatchCustody(this.config.name, chatId);
+        if (detached) {
+            // Startup/recovery can reach the queue without an ingress handler. Pin
+            // unsent triggers synchronously before consulting live host activity.
+            for (const message of this.store.getPendingTriggerMessages(this.config.name, chatId)) {
+                if (!message.id || message.senderType !== 'human' || this.store.getInsertion(this.config.name, chatId, message.id))
+                    continue;
+                this.store.saveInsertion(this.config.name, chatId, message.id, JSON.stringify([this.config.appId, chatId, message.messageId]), 'pending', {
+                    messageId: message.messageId, text: message.content, stopEpoch: this.stopGeneration(chatId), expectedRunId: detached.runId,
+                    ownerId: detached.id, batchId: detached.batchId, sessionId: detached.sessionId, sessionKey: this.getSessionKey(chatId),
+                });
+            }
+            if (await this.reconcileDispatchCustody(chatId))
+                return this.processQueue(chatId, true);
+            void this.reconcileInsertions(chatId).catch(() => { });
+            this.scheduleInsertionRecovery();
+            return;
+        }
+        if (!activityChecked && typeof this.openclawClient.getSessionRuntimeStatus === 'function' && typeof this.openclawClient.getSessionDispatchStatus === 'function') {
+            const candidates = this.store.getPendingTriggerMessages(this.config.name, chatId)
+                .filter(message => message.id && message.senderType === 'human' && !this.store.isInsertionReserved(this.config.name, chatId, message.id));
+            if (!candidates.length)
+                return;
+            for (const message of candidates)
+                await this.reconcileCurrentInputActivity(chatId, message.id, message.messageId, message.content);
+            // Re-enter through the ordinary owner CAS after all awaits. Any concurrent
+            // admission now owns its batch; never submit in parallel with that owner.
+            const eligible = this.store.getPendingTriggerMessages(this.config.name, chatId).some(message => message.id && message.senderType === 'human' && !this.store.isInsertionReserved(this.config.name, chatId, message.id));
+            if (eligible)
+                return this.processQueue(chatId, true);
+            void this.reconcileInsertions(chatId).catch(() => { });
+            this.scheduleInsertionRecovery();
+            return;
+        }
         const owner = { id: randomUUID(), token: {}, revoked: false, stopEpoch: this.stopGeneration(chatId) };
         this.queueOwners.set(chatId, owner);
         const run = this.processQueueInner(chatId, owner).finally(() => {
@@ -1645,13 +1815,16 @@ export class FeishuBot {
      * the proactive path are invisible to them. Steer-fallback triggers are
      * restored via the failure observers so their input drains normally.
      */
-    forceExpireQueueOwner(chatId, reason) {
+    forceExpireQueueOwner(chatId, reason, preserveDispatch = false) {
         const owner = this.queueRuns.get(chatId);
         if (!owner)
             return false;
         const context = this.queueOwners.get(chatId);
+        if (context?.batchId && !preserveDispatch)
+            this.store.clearDispatchCustody(this.config.name, chatId, context.id, context.batchId);
         if (context)
             context.revoked = true;
+        this.busyChats.set(chatId, 0);
         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
@@ -1679,6 +1852,10 @@ export class FeishuBot {
             owner.batchId = randomUUID();
             owner.triggerIds = undefined;
             owner.runId = undefined;
+            owner.admitted = false;
+            owner.collecting = false;
+            owner.yielded = false;
+            owner.sessionId = undefined;
             this.queueRunTokens.set(chatId, batchToken);
             // A fresh batch starts: steered inputs admitted into the PREVIOUS batch
             // completed with it (consumed or not); their failure observers are stale.
@@ -1836,6 +2013,9 @@ export class FeishuBot {
             try {
                 sessionKey = await this.ensureSession(chatId);
                 guard();
+                const generation = await this.openclawClient.getSessionInfo(sessionKey, 1500).catch(() => null);
+                guard();
+                owner.sessionId = generation?.session?.sessionId;
             }
             catch (err) {
                 if (!current())
@@ -1923,11 +2103,14 @@ export class FeishuBot {
                             // OpenClaw accepts it, retrying would duplicate the same message.
                             markSubmittedBatch("send-attempt");
                         },
-                        onRunIdentified: (runId) => { guard(); owner.runId = runId; foregroundRunId = runId; },
+                        onRunIdentified: (runId, identity) => { guard(); owner.runId = runId; owner.sessionId = identity?.sessionId || owner.sessionId; foregroundRunId = runId; },
                         onSubmitted: async (runId) => {
                             guard();
                             owner.runId = runId;
+                            owner.admitted = true;
+                            this.store.saveDispatchCustody(this.config.name, chatId, { id: owner.id, batchId: owner.batchId, runId, sessionId: owner.sessionId, admitted: true, stopEpoch: owner.stopEpoch, sessionKey });
                             void this.reconcileInsertions(chatId).catch(() => { });
+                            this.bindRunDeliveryTarget(chatId, runId, { triggerId, messageId: lastHuman.messageId || '', liveStatus });
                             for (const ack of this.pendingAckMessages.get(chatId) || []) {
                                 if (!mergedTriggerIdSet.has(ack.rowId))
                                     continue;
@@ -1950,6 +2133,21 @@ export class FeishuBot {
                             markSubmittedBatch(`submitted:${runId}`);
                         },
                         onProgress: (event) => current() ? liveStatus?.progress(event) : undefined,
+                        onCollectionStarted: runId => { guard(); if (owner.runId === runId)
+                            owner.collecting = true; },
+                        onYieldHandoff: runId => {
+                            guard();
+                            if (owner.runId !== runId || !owner.batchId)
+                                throw new Error('Yield root/batch identity mismatch');
+                            // All durable result routing commits synchronously before the
+                            // collector is fenced and before another input may take custody.
+                            this.bindRunDeliveryTarget(chatId, runId, { triggerId, messageId: lastHuman.messageId || '', liveStatus });
+                            owner.yielded = true;
+                            this.store.saveDispatchCustody(this.config.name, chatId, { id: owner.id, batchId: owner.batchId, runId, sessionId: owner.sessionId, admitted: owner.admitted === true, yielded: true, stopEpoch: owner.stopEpoch, sessionKey });
+                            this.forceExpireQueueOwner(chatId, 'trusted exact-root yield; background result custody retained', true);
+                            void this.reconcileInsertions(chatId).catch(() => { });
+                            this.scheduleInsertionRecovery();
+                        },
                         onWaitPaused: async (notice) => {
                             guard();
                             await liveStatus?.showWaitingForResult(notice.message);
@@ -2189,6 +2387,10 @@ export class FeishuBot {
             }
             catch (err) {
                 if (!current() || err instanceof SupersededObservation) {
+                    if (current()) {
+                        this.busyChats.set(chatId, 0);
+                        owner.revoked = true;
+                    }
                     // 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
@@ -2295,8 +2497,11 @@ export class FeishuBot {
                 break;
             }
             finally {
-                if (current())
+                if (current()) {
                     this.busyChats.set(chatId, 0);
+                    if (owner.batchId && !owner.yielded)
+                        this.store.clearDispatchCustody(this.config.name, chatId, owner.id, owner.batchId);
+                }
             }
             // Check if more messages arrived while we were busy
             // Small delay to let any in-flight messages settle
@@ -2793,7 +2998,7 @@ export class FeishuBot {
         const previous = this.deliveryTargetsByRun.get(key);
         if (previous?.timer)
             clearTimeout(previous.timer);
-        this.store.bindDeliveryRun(this.config.name, chatId, runId, { triggerId: target.triggerId, messageId: target.messageId, runId, sessionKey: `agent:main:${this.getSessionKey(chatId).replace(/^agent:[^:]+:/, '')}` });
+        this.store.bindDeliveryRun(this.config.name, chatId, runId, { ...this.store.getDeliveryRunTarget(this.config.name, chatId, runId), triggerId: target.triggerId, messageId: target.messageId, runId, stopGeneration: this.stopGeneration(chatId), sessionKey: `agent:main:${this.getSessionKey(chatId).replace(/^agent:[^:]+:/, '')}` });
         this.deliveryTargetsByRun.set(key, {
             triggerId: target.triggerId,
             messageId: target.messageId,
@@ -3152,7 +3357,7 @@ export class FeishuBot {
                 this.store.saveErrorNotice(record);
                 if (verdict.state === "terminal" && verdict.terminalKey && verdict.text) {
                     // Independent identity: never take the result's trigger/final key.
-                    await this.enqueueAndDispatchDelivery(chatId, "run_error", verdict.terminalKey, verdict.text, [], undefined, verdict.terminalKey, undefined, { sourceType: "run_error", runId: record.provenance.runId, error: record.provenance, terminalEvidence: verdict }, record.noticeId);
+                    await this.enqueueAndDispatchDelivery(chatId, "run_error", verdict.terminalKey, verdict.text, [], undefined, verdict.terminalKey, undefined, { sourceType: "run_error", sessionKey: record.provenance.sessionKey, runId: record.provenance.runId, error: record.provenance, terminalEvidence: verdict }, record.noticeId);
                     // The send-time recheck may have parked or suppressed the observation.
                     const refreshed = this.store.getErrorNotice(this.config.name, chatId, record.noticeId);
                     if (refreshed?.verdict && ["pending", "suppressed", "stopped"].includes(refreshed.verdict.state))
@@ -3202,6 +3407,14 @@ export class FeishuBot {
         if (this.store.getDeliveryByKey(this.config.name, chatId, source)?.status !== "delivered")
             throw new Error("Go executor outbox delivery pending/unconfirmed");
     }
+    insertionNoticeCurrent(chatId, notice) {
+        if (!notice)
+            return true;
+        const current = this.store.getInsertion(this.config.name, chatId, notice.rowId);
+        return current?.insertionId === notice.insertionId && current.state === 'unknown' && current.stopEpoch === notice.stopEpoch &&
+            this.stopGeneration(chatId) === notice.stopEpoch && current.sessionId === notice.sessionId &&
+            Number.isFinite(current.unknownSince) && Date.now() - current.unknownSince >= 45_000;
+    }
     async dispatchPendingDeliveries(chatId, replyToMessageId) {
         this.installGoReceiptCapture();
         for (const id of this.localDeliveryRetryCustody.get(chatId) || []) {
@@ -3220,6 +3433,20 @@ export class FeishuBot {
             if (pending.length === 0)
                 break;
             for (const item of pending) {
+                const notice = JSON.parse(item.deliveryMetaJson || '{}').insertionNotice;
+                if (notice) {
+                    const info = await this.openclawClient.getSessionInfo(this.getSessionKey(chatId), 1500).catch(() => null);
+                    if (!this.insertionNoticeCurrent(chatId, notice) || info?.session?.archived === true ||
+                        info?.session?.sessionId && info.session.sessionId !== notice.sessionId) {
+                        this.store.markDeliveryFailed(item.id);
+                        continue;
+                    }
+                    if (!info?.session?.sessionId) {
+                        this.scheduleDeliveryRetry(chatId, 1);
+                        retryScheduled = true;
+                        continue;
+                    }
+                }
                 const ownerId = JSON.parse(item.deliveryMetaJson || "{}").provenance?.goJobId;
                 const deliveryJob = ownerId ? this.store.getGoJobById(ownerId) : this.store.getActiveGoJob(this.config.name, chatId);
                 const receipts = [
@@ -3228,6 +3455,8 @@ export class FeishuBot {
                 ];
                 await this.sendOrdered(chatId, () => this.goDeliveryReceipts.run({ receipts, goId: deliveryJob?.id, outboxId: item.id, chatId, stage: "body", ordinals: new Map(), effectGuard: () => {
                         const meta = JSON.parse(item.deliveryMetaJson || '{}'), p = meta.provenance;
+                        if (!this.insertionNoticeCurrent(chatId, meta.insertionNotice))
+                            throw Object.assign(new Error('Insertion notice no longer current'), { deliveryStopped: true });
                         if ((p?.final || item.sourceType === 'run_error') &&
                             (typeof meta.deliveryStopEpoch === 'number' && meta.deliveryStopEpoch !== this.stopGeneration(chatId) ||
                                 p?.sessionKey && p.runId && this.store.isStoppedObservation(p.sessionKey, p.runId))) {
@@ -3370,6 +3599,12 @@ export class FeishuBot {
                             }
                         }
                         this.store.markDeliveryDelivered(item.id);
+                        if (item.sourceType === 'run_error' && provenance?.terminalEvidence?.state === 'terminal' && provenance.runId && !provenance.runId.startsWith('announce:')) {
+                            this.store.settleRunReactionIntents(this.config.name, chatId, provenance.runId);
+                            if (provenance.sessionKey)
+                                this.store.finishRunObservation(provenance.sessionKey, provenance.runId);
+                            void this.reconcileReactions(chatId).catch(() => { });
+                        }
                         if (provenance?.final && provenance.runId) {
                             this.store.settleRunReactionIntents(this.config.name, chatId, provenance.runId);
                             void this.reconcileReactions(chatId).catch(() => { });
@@ -4877,7 +5112,10 @@ export class FeishuBot {
             this.store.stopInsertions(this.config.name, chatId);
             this.store.cancelReactionIntents(this.config.name, chatId, this.stopGeneration(chatId));
             void this.openclawClient.cancelSteerSession?.(sessionKey, this.stopGeneration(chatId)).catch(() => { });
-            // Fire reset (no response expected)
+            this.forceExpireQueueOwner(chatId, 'explicit session reset');
+            this.store.clearAllPendingTriggers(this.config.name, chatId);
+            // Fire reset (no response expected). Client fences old exact observations
+            // and exposes its reset barrier to new post-cutoff human inputs.
             this.openclawClient.resetSession(sessionKey).catch(() => { });
             // Wait a moment for it to take effect
             await new Promise((r) => setTimeout(r, 2000));

package/dist/message-store.d.ts

@@ -114,6 +114,13 @@ export declare class MessageStore {
     listReactionIntents(bot: string, chat?: string): any[];
     bindDeliveryRun(bot: string, chat: string, runId: string, record: object): void;
     getDeliveryRunTarget(bot: string, chat: string, runId: string): any;
+    /** Scheduling custody is independent of exact-run result custody. */
+    saveDispatchCustody(bot: string, chat: string, record: object): void;
+    getDispatchCustody(bot: string, chat: string): any;
+    clearDispatchCustody(bot: string, chat: string, ownerId: string, batchId: string): boolean;
+    /** Atomic release of proven never-attempted reservations only. Unknown and
+     * accepted inputs retain their exact target and never enter ordinary drain. */
+    releaseDispatchCustody(bot: string, chat: string, ownerId: string, batchId: string): boolean;
     /** Reserved is persisted before the send-attempt callback; dispatching is
      * persisted before the RPC. Only reserved + unchanged stop generation proves
      * no business effect and may be restored on startup. Unknown never replays. */
@@ -125,16 +132,25 @@ export declare class MessageStore {
     settleRunReactionIntents(bot: string, chat: string, runId: string): void;
     cancelReactionIntents(bot: string, chat: string, epoch: number): void;
     saveRunObservation(sessionKey: string, runId: string, record: object, nextCheckAt?: number): void;
+    hasYieldedObservation(sessionKey: string): boolean;
+    getRunObservation(sessionKey: string, runId: string): any;
     runObservationState(sessionKey: string, runId: string): string | undefined;
     stopSessionObservations(sessionKey: string): void;
     settleExactRunReactions(sessionKey: string, runId: string): void;
     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;
+    /** Reminder intent and its outbox row commit together. Never write a stale
+     * reconciliation snapshot over a later accepted/stopped insertion. */
+    queueInsertionUnknownNotice(bot: string, chat: string, row: number, delivery: Omit<DeliveryOutboxItem, 'id' | 'status' | 'attempts' | 'createdAt' | 'updatedAt'>): boolean;
     claimInsertionAttempt(bot: string, chat: string, row: number): boolean;
     getInsertion(bot: string, chat: string, row: number): any;
     listInsertions(bot: string, chat?: string): any[];
     isInsertionReserved(bot: string, chat: string, row: number): boolean;
+    stopInsertionAtEpoch(bot: string, chat: string, row: number, epoch: number): void;
     stopInsertions(bot: string, chat: string): void;
     hasUnknownDeliveryOperation(outbox: number): boolean;
     /** Retain the full known result BEFORE the fallible main-journal checkpoint.