openclaw-lark-multi-agent 1.8.17 → 1.8.18

package/dist/message-store.d.ts

@@ -315,6 +315,7 @@ export declare class MessageStore {
      */
     insert(msg: ChatMessage): number;
     getMessageId(messageId: string): number | null;
+    getMessageByRowId(rowId: number): ChatMessage | null;
     getMessageByMessageId(messageId: string): ChatMessage | null;
     getLatestMessageId(chatId: string): number;
     markMessageRecalled(messageId: string, chatId: string, recalledAt?: number, recallType?: string): void;

package/dist/message-store.js

@@ -1164,6 +1164,10 @@ export class MessageStore {
         const row = this.db.prepare(`SELECT id FROM messages WHERE message_id = ?`).get(messageId);
         return row?.id || this.db.prepare('SELECT message_row_id FROM platform_message_aliases WHERE message_id=?').get(messageId)?.message_row_id || null;
     }
+    getMessageByRowId(rowId) {
+        const row = this.db.prepare('SELECT message_id FROM messages WHERE id = ?').get(rowId);
+        return row ? this.getMessageByMessageId(row.message_id) : null;
+    }
     getMessageByMessageId(messageId) {
         const row = this.db.prepare(`SELECT * FROM messages WHERE message_id = ?`).get(messageId);
         if (!row)

package/dist/queued-presentation.js

@@ -428,51 +428,70 @@ export class QueuedPresentations {
         const evidence = this.store.getDeliveredRunReply(this.bot, this.app, chat, runId, epoch);
         if (!evidence)
             return;
-        const eligible = (row) => {
+        const witnesses = (row, preserveSealedPayload = false) => {
             const retry = row.view?.state === "replied" && !!row.linkedReply && !row.linkedReply.rendered &&
                 row.create === "accepted" && !!row.cardId && !Object.keys(row.editEffects || {}).length;
-            if ((!this.usable(row) && !retry) || row.retired || row.stopEpoch !== epoch || row.linkedReply?.rendered ||
+            const preserved = preserveSealedPayload && row.linkedReply?.rendered === 'reply_payload';
+            if ((!this.usable(row) && !retry && !preserved) || row.retired || row.stopEpoch !== epoch || row.linkedReply?.rendered && !preserved ||
                 evidence.createdAt < row.startedAt || (row.expectedInsertionRoot !== runId && row.runId !== runId))
-                return false;
-            const ordinary = row.runId === runId && !!row.ownerId && !!row.batchId ? row.ordinaryTriggerIds || [] : [];
+                return;
+            const ordinary = row.runId && row.ownerId && row.batchId ? row.ordinaryTriggerIds || [] : [];
             const extra = row.triggerIds.filter(id => !ordinary.includes(id));
-            return extra.length > 0 && extra.every(id => {
+            if (!extra.length)
+                return;
+            const proofs = [];
+            for (const id of row.triggerIds) {
+                const input = this.store.getMessageByRowId(id);
                 const item = this.store.getInsertion(this.bot, chat, id);
-                const input = item?.messageId ? this.store.getMessageByMessageId(item.messageId) : undefined;
-                return row.enqueueAcceptedIds?.includes(id) && item?.state === 'accepted' && item.stopEpoch === epoch &&
-                    item.expectedRunId === runId && (!evidence.sessionId || item.sessionId === evidence.sessionId) &&
-                    input?.id === id && input.chatId === chat && input.senderType === 'human' && input.timestamp <= evidence.createdAt;
-            });
+                const isOrdinary = ordinary.includes(id);
+                if (isOrdinary ? item && (item.state !== 'ordinary' || item.stopEpoch !== epoch) :
+                    !row.enqueueAcceptedIds?.includes(id) || item?.state !== 'accepted' || item.stopEpoch !== epoch)
+                    return;
+                if (!isOrdinary && !item.sessionId)
+                    return;
+                const root = isOrdinary ? row.runId : item.expectedRunId;
+                const proof = root ? this.store.getDeliveredRunReply(this.bot, this.app, chat, root, epoch) : undefined;
+                if (!proof || input?.id !== id || input.chatId !== chat || input.senderType !== 'human' || input.timestamp > proof.createdAt ||
+                    item && (item.messageId !== input.messageId || proof.sessionId && item.sessionId && item.sessionId !== proof.sessionId))
+                    return;
+                proofs.push(proof);
+            }
+            return proofs;
         };
         const flights = [];
         // There is no await in this staging loop: seal every currently eligible
         // cohort before the first SDK effect can allow new ingress to interleave.
         for (const snapshot of this.records(chat)) {
             const row = this.latest(snapshot);
-            if (!row || !eligible(row) || this.replyFlights.has(row.id) || (row.linkedReply?.retryAfter || 0) > Date.now())
+            if (!row || !witnesses(row) || this.replyFlights.has(row.id) || (row.linkedReply?.retryAfter || 0) > Date.now())
                 continue;
             const entry = this.hydrate(row);
             const current = this.latest(entry.record);
-            if (!current || !eligible(current) || current.lease !== entry.record.lease)
+            const proofs = current && witnesses(current);
+            if (!current || !proofs || current.lease !== entry.record.lease)
                 continue;
+            const latestProof = proofs.reduce((a, b) => a.deliveredAt >= b.deliveredAt ? a : b);
+            const proofIds = [...new Set(proofs.map(proof => proof.outboxId))].sort((a, b) => a - b);
             const ids = JSON.stringify(current.triggerIds);
-            const preservePayload = !!current.cardId && evidence.platformMessageIds.includes(current.cardId);
+            const preservePayload = !!current.cardId && proofs.some(proof => proof.platformMessageIds.includes(current.cardId));
             // Desired persistence may itself have failed while the controller became
             // terminal. A sealed, unrendered, clear-effect obligation permits only
             // the controller's own no-flight/no-unknown retry, not business replay.
             const retry = !!current.linkedReply && !current.linkedReply.rendered && !Object.keys(current.editEffects || {}).length;
             const attempts = (current.linkedReply?.attempts || 0) + 1;
-            this.save({ ...current, linkedReply: { runId, outboxId: evidence.outboxId, deliveredAt: evidence.deliveredAt, attempts,
+            this.save({ ...current, linkedReply: { runId: latestProof.runId, outboxId: latestProof.outboxId, deliveredAt: latestProof.deliveredAt,
+                    relatedOutboxIds: proofIds, attempts,
                     retryAfter: Date.now() + Math.min(15 * 60_000, 60_000 * 2 ** Math.min(attempts - 1, 4)),
                     ...(preservePayload ? { rendered: "reply_payload" } : {}) } });
             const flight = Promise.resolve().then(async () => {
                 const fresh = this.latest(entry.record);
-                const proof = this.store.getDeliveredRunReply(this.bot, this.app, chat, runId, epoch);
+                const freshProofs = fresh && witnesses(fresh, preservePayload);
                 if (this.disposed || !fresh || fresh.retired || fresh.lease !== entry.record.lease ||
                     fresh.stopEpoch !== this.store.getStopGeneration(this.bot, chat) || JSON.stringify(fresh.triggerIds) !== ids ||
-                    fresh.linkedReply?.outboxId !== evidence.outboxId || proof?.outboxId !== evidence.outboxId)
+                    fresh.linkedReply?.outboxId !== latestProof.outboxId || !freshProofs ||
+                    JSON.stringify([...new Set(freshProofs.map(proof => proof.outboxId))].sort((a, b) => a - b)) !== JSON.stringify(proofIds))
                     return;
-                await entry.live.linkedReplyDelivered(evidence.deliveredAt, preservePayload, retry);
+                await entry.live.linkedReplyDelivered(latestProof.deliveredAt, preservePayload, retry);
             }).catch(() => {
                 // Own rejection immediately: a later synchronous cohort read can fail
                 // before this method reaches allSettled. UI outages must not crash LMA.

package/docs/releases/1.8.18.md

@@ -0,0 +1,23 @@
+# 1.8.18 — Independently witness every reply in a historical mixed card
+
+Extends 1.8.17's presentation-only fix for a live race observed during validation:
+1.8.16 had already reused an old insertion's waiting card for a newer ordinary
+run. Closing it from only the old run's reply would be incorrect; leaving it
+waiting after both separate replies were delivered would also be misleading.
+
+The card now closes only when **each member's own associated run** has a complete
+original-Bot/application/chat/epoch platform reply receipt that postdates that
+member. The newer ordinary reply cannot substitute for the older insertion's
+reply, or vice versa. Elapsed time uses the latest verified delivery. Persist the
+exact related outbox IDs; revalidate all proofs and membership before the effect.
+If any verified reply already occupies the card, retain its business content
+without a compact replacement. Pending/unknown members still prevent closure.
+
+No input commitment/consumption, Get/DONE, model-sync, admission, business retry,
+Core/plugin/config or schema changes. Bridge activation only; native dependencies
+are unchanged. Existing unknown-effect fencing and UI-only zero-effect retries
+remain intact. 1.8.17 tags/packages are not replaced; this is a new immutable patch.
+
+Validation: bridge/plugins build, public SDK contract, **66 files / 1795 offline
+tests**, including 32 linked-card controls (4 new historical mixed-card cases).
+Live platform-card readback remains a separate deployment gate.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-lark-multi-agent",
-  "version": "1.8.17",
+  "version": "1.8.18",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {
@@ -78,7 +78,8 @@
     "docs/releases/1.8.11.md",
     "docs/releases/1.8.15.md",
     "docs/releases/1.8.16.md",
-    "docs/releases/1.8.17.md"
+    "docs/releases/1.8.17.md",
+    "docs/releases/1.8.18.md"
   ],
   "engines": {
     "node": ">=22"