openclaw-lark-multi-agent 1.8.16 → 1.8.18

package/dist/feishu-bot.js

@@ -1713,6 +1713,10 @@ export class FeishuBot {
                         this.store.stopInsertionAtEpoch(this.config.name, chatId, item.rowId, item.stopEpoch);
                     continue;
                 }
+                // UI-only recovery uses durable original-chat receipts; do not make it
+                // depend on a new Core/session-info lookup after the reply was sent.
+                if (item.state === 'accepted')
+                    void this.queuedPresentations.reconcileDeliveredReply(chatId, item.expectedRunId).catch(() => { });
                 if (item.activityUnbound) {
                     await this.reconcileCurrentInputActivity(chatId, item.rowId, item.messageId, item.text);
                     if (!stillCurrent()) {
@@ -4310,6 +4314,12 @@ export class FeishuBot {
     }
     buildLiveStatusCard(view, chatId) {
         const en = this.isEn(chatId);
+        if (view.state === "replied") {
+            // Neutral UI-only closure, not a green business/input-completion claim.
+            const summary = en ? `💬 Linked run replied · ⏱ ${view.elapsed}` : `💬 关联轮次已回复 · ⏱ 耗时${view.elapsed}`;
+            return { schema: "2.0", config: { update_multi: true, width_mode: "fill" },
+                body: { elements: [{ tag: "markdown", content: `<font color='grey'>${summary}</font>` }] } };
+        }
         // Clean finish (done / NO_REPLY): keep it minimal — no header, no footer, just
         // one compact grey line (status emoji + tool-call count + total elapsed) so
         // the finished card does not take up much screen space.

package/dist/live-status.d.ts

@@ -23,8 +23,8 @@ export type LiveStatusView = {
     /** True when finished via noReply(): the model produced no user-visible reply. */
     noReply: boolean;
     /** Presentation only: queued/admitted do not claim model execution. */
-    state: "queued" | "admitted" | "running" | "done" | "failed";
-    phase?: "queued" | "admitted" | "working" | "waiting" | "done" | "failed";
+    state: "queued" | "admitted" | "running" | "done" | "failed" | "replied";
+    phase?: "queued" | "admitted" | "working" | "waiting" | "done" | "failed" | "replied";
 };
 /** Persisted metadata needed to turn the live-status card into the final answer. */
 export type LiveStatusFinalMeta = {
@@ -157,6 +157,9 @@ export declare class LiveStatusController {
     /** Release only local observation of a now-idle session, without claiming
      * the previous task succeeded or was aborted. Normal progress is unchanged. */
     pauseForUnconfirmedResult(detail: string, title?: string): Promise<void>;
+    /** Close only the display after the associated run's original-chat reply is
+     * platform-confirmed. This deliberately does not claim inserted-input commit. */
+    linkedReplyDelivered(deliveredAt: number, preserveReplyPayload?: boolean, retryZeroEffect?: boolean): Promise<void>;
     complete(): Promise<void>;
     /**
      * Freeze any successful terminal state (text, attachment-only, or NO_REPLY)

package/dist/live-status.js

@@ -84,6 +84,11 @@ export class LiveStatusController {
                 this.noReplyResult = restored.view.noReply;
                 this.waitingForResult = restored.view.phase === "waiting";
                 this.updatesFrozen = this.waitingForResult;
+                if (restored.view.state === "replied") {
+                    this.finalized = true;
+                    this.terminalOutcome = true;
+                    this.updatesFrozen = true;
+                }
             }
             // Attempted/unknown create survives process loss as a no-create fence.
             if (restored.blockCreate && !this.messageId)
@@ -259,6 +264,33 @@ export class LiveStatusController {
         view.title = title || (this.opts.locale === "en" ? `${this.opts.botName} result unconfirmed` : `${this.opts.botName} 结果未确认`);
         await this.finishView(view);
     }
+    /** Close only the display after the associated run's original-chat reply is
+     * platform-confirmed. This deliberately does not claim inserted-input commit. */
+    async linkedReplyDelivered(deliveredAt, preserveReplyPayload = false, retryZeroEffect = false) {
+        const safeRetry = retryZeroEffect && this.state === "replied" && !this.unknownEdits.size && !this.editPump && !this.pendingEdit;
+        if (this.disposed || this.terminalOutcome && !safeRetry || !Number.isFinite(deliveredAt) || deliveredAt < this.startedAt)
+            return;
+        this.state = "replied";
+        this.waitingForResult = false;
+        this.updatesFrozen = true;
+        this.finalized = true;
+        this.terminalOutcome = true;
+        this.stopTimers();
+        const seconds = Math.max(0, Math.floor((deliveredAt - this.startedAt) / 1000));
+        const elapsed = `${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, "0")}`;
+        const view = this.buildView();
+        view.title = this.opts.locale === "en" ? `${this.opts.botName} linked run replied` : `${this.opts.botName} 关联轮次已回复`;
+        view.elapsed = elapsed;
+        view.lines = [{ kind: "summary", text: this.opts.locale === "en" ? "Linked run reply delivered; input commitment is separate" : "关联轮次回复已送达；不据此确认追加输入提交", at: seconds }];
+        if (preserveReplyPayload) {
+            // The card itself already contains the business answer: never replace it
+            // with a compact status line or let this controller issue further writes.
+            this.callbacks.desired?.(view);
+            this.dispose();
+            return;
+        }
+        await this.finishView(view);
+    }
     async complete() {
         if (this.disposed || this.terminalOutcome)
             return;
@@ -683,6 +715,8 @@ export class LiveStatusController {
             title = en ? `\u2705 ${this.opts.botName} done` : `\u2705 ${this.opts.botName} \u5df2\u5b8c\u6210`;
         else if (this.state === "failed")
             title = en ? `\u26A0\uFE0F ${this.opts.botName} stopped` : `\u26A0\uFE0F ${this.opts.botName} \u6267\u884c\u4e2d\u65ad`;
+        else if (this.state === "replied")
+            title = en ? `${this.opts.botName} linked run replied` : `${this.opts.botName} 关联轮次已回复`;
         else if (this.waitingForResult)
             title = en ? `${this.opts.botName} waiting (card frozen)` : `${this.opts.botName} 等待后续结果（已停止刷新）`;
         else if (this.state === "queued")
@@ -713,7 +747,7 @@ export class LiveStatusController {
             toolCalls: this.toolCallCount,
             noReply: this.noReplyResult,
             state: this.state,
-            phase: this.state === "done" || this.state === "failed" ? this.state : this.waitingForResult ? "waiting" : this.state === "running" ? "working" : this.state,
+            phase: this.state === "done" || this.state === "failed" || this.state === "replied" ? this.state : this.waitingForResult ? "waiting" : this.state === "running" ? "working" : this.state,
         };
     }
     buildSummaryLine(en) {

package/dist/message-store.d.ts

@@ -145,6 +145,16 @@ export declare class MessageStore {
     stopExactRun(sessionKey: string, runId: string): void;
     isStoppedObservation(sessionKey: string, runId: string): boolean;
     hasUnconfirmedRunDelivery(bot: string, chat: string, runId: string): boolean;
+    /** UI-only witness of an exact run's visible reply in the original Bot/chat.
+     * Does not prove any legacy inserted input was committed or consumed. */
+    getDeliveredRunReply(bot: string, app: string, chat: string, runId: string, epoch: number): {
+        outboxId: number;
+        runId: string;
+        createdAt: number;
+        deliveredAt: number;
+        platformMessageIds: string[];
+        sessionId?: string;
+    } | undefined;
     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;
@@ -305,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

@@ -195,6 +195,30 @@ export class MessageStore {
         const finals = rows.filter(row => row.source_type.startsWith('assistant_visible'));
         return (finals.length ? finals : rows).some(row => this.getDeliveryDispatchOutcome(bot, chat, row.delivery_key).state !== 'delivered');
     }
+    /** UI-only witness of an exact run's visible reply in the original Bot/chat.
+     * Does not prove any legacy inserted input was committed or consumed. */
+    getDeliveredRunReply(bot, app, chat, runId, epoch) {
+        if (!runId || this.hasUnconfirmedRunDelivery(bot, chat, runId))
+            return;
+        const rows = this.db.prepare(`SELECT id,delivery_key,created_at,updated_at,delivery_meta_json FROM delivery_outbox
+      WHERE bot_name=? AND chat_id=? AND status='delivered' AND source_type IN ('assistant_visible','discussion')
+      AND json_extract(delivery_meta_json,'$.provenance.runId')=?
+      AND json_extract(delivery_meta_json,'$.provenance.final')=1
+      AND json_extract(delivery_meta_json,'$.botIdentity')=?
+      AND json_extract(delivery_meta_json,'$.deliveryStopEpoch')=? ORDER BY id DESC LIMIT 20`)
+            .all(bot, chat, runId, app, epoch);
+        for (const row of rows) {
+            if (this.getDeliveryDispatchOutcome(bot, chat, row.delivery_key).state !== 'delivered')
+                continue;
+            const receipts = this.listDeliveryReceipts(row.id);
+            const ids = [...new Set(receipts.map(receipt => receipt.messageId).filter(Boolean))];
+            if (!ids.length || !Number.isFinite(row.created_at) || !Number.isFinite(row.updated_at))
+                continue;
+            const meta = JSON.parse(row.delivery_meta_json || '{}');
+            return { outboxId: row.id, runId, createdAt: row.created_at, deliveredAt: row.updated_at, platformMessageIds: ids,
+                sessionId: meta.provenance?.sessionId };
+        }
+    }
     settleRunReactionIntents(bot, chat, runId) {
         if (this.hasUnconfirmedRunDelivery(bot, chat, runId))
             return;
@@ -1140,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.d.ts

@@ -11,6 +11,8 @@ export declare class QueuedPresentations {
     private readonly enabled;
     private readonly english;
     private entries;
+    /** UI effects only; never an admission/execution lock. */
+    private replyFlights;
     /** Receipt custody only: never a business busy/admission flag or SDK retry. */
     private repairs;
     private repairTimer?;
@@ -40,6 +42,10 @@ export declare class QueuedPresentations {
     claim(chat: string, ids: number[], ownerId: string, batchId: string, native?: boolean): LiveStatusController | undefined;
     attempted(live: LiveStatusController | undefined, submissionId: string, ownerId: string, batchId: string): void;
     insertionAccepted(chat: string, rowId: number, expectedRunId: string): Promise<void>;
+    /** A legacy insertion owns no actual run. Its card may nevertheless report
+     * the exact associated run's platform-delivered reply, without changing any
+     * insertion, reaction, sync or scheduling record. Recoverable after restart. */
+    reconcileDeliveredReply(chat: string, runId: string): Promise<void>;
     settleRun(chat: string, runId: string): Promise<void>;
     admit(live: LiveStatusController | undefined, runId: string, ownerId: string, batchId: string): Promise<void>;
     /** A deliberate same-task continuation has its own real ACK. Never infer

package/dist/queued-presentation.js

@@ -11,6 +11,8 @@ export class QueuedPresentations {
     enabled;
     english;
     entries = new Map();
+    /** UI effects only; never an admission/execution lock. */
+    replyFlights = new Map();
     /** Receipt custody only: never a business busy/admission flag or SDK retry. */
     repairs = new Map();
     repairTimer;
@@ -61,6 +63,9 @@ export class QueuedPresentations {
             if (create.state === "never")
                 delete row.createToken; // proven zero SDK
         }
+        const applied = repair.linkedReplyApplied;
+        if (applied && row.cardId === applied.cardId && row.linkedReply?.runId === applied.runId && row.linkedReply.outboxId === applied.outboxId)
+            row.linkedReply = { ...row.linkedReply, rendered: "summary" };
         for (const [token, receipt] of repair.edits) {
             if (receipt.state === "clear")
                 delete row.editEffects[token];
@@ -89,7 +94,11 @@ export class QueuedPresentations {
                 if (receipt.state === "clear" ? !row.editEffects?.[token]
                     : row.editEffects?.[token] === "unknown" || !row.editEffects?.[token] && row.lease !== receipt.lease)
                     repair.edits.delete(token);
-            if (!repair.create && !repair.edits.size)
+            const applied = repair.linkedReplyApplied;
+            if (applied && row.cardId === applied.cardId && row.linkedReply?.runId === applied.runId &&
+                row.linkedReply.outboxId === applied.outboxId && row.linkedReply.rendered === "summary")
+                repair.linkedReplyApplied = undefined;
+            if (!repair.create && !repair.edits.size && !repair.linkedReplyApplied)
                 this.repairs.delete(row.id);
         }
         if (!this.repairs.size) {
@@ -112,8 +121,10 @@ export class QueuedPresentations {
             repair.create = { token, lease: record.lease, state, cardId };
         this.scheduleRepair(true);
     }
-    editReceipt(record, token, state) {
+    editReceipt(record, token, state, linkedReplyApplied) {
         const repair = this.repairFor(record);
+        if (linkedReplyApplied)
+            repair.linkedReplyApplied = linkedReplyApplied;
         if (repair.edits.get(token)?.state !== "clear" || state === "clear")
             repair.edits.set(token, { lease: record.lease, state });
         this.scheduleRepair(true);
@@ -156,11 +167,11 @@ export class QueuedPresentations {
     }
     usable(row) {
         return !row.retired && row.stopEpoch === this.store.getStopGeneration(this.bot, row.chatId)
-            && row.view?.state !== "done" && row.view?.state !== "failed";
+            && !row.linkedReply?.rendered && row.view?.state !== "done" && row.view?.state !== "failed" && row.view?.state !== "replied";
     }
     current(record) {
         const row = this.latest(record);
-        return !!row && this.usable(row) && row.lease === record.lease && this.enabled(record.chatId);
+        return !!row && this.usable(row) && !row.linkedReply && row.lease === record.lease && this.enabled(record.chatId);
     }
     hydrate(record) {
         const cached = this.entries.get(record.id);
@@ -279,6 +290,7 @@ export class QueuedPresentations {
             edit: async (id, view, effect) => {
                 const token = randomUUID();
                 let attempted = false, settled = false;
+                let linkedReplyApplied;
                 try {
                     await base.edit(id, view, { run: send => effect.run(async () => {
                             try {
@@ -286,6 +298,8 @@ export class QueuedPresentations {
                                 if (!row || row.lease !== record.lease || row.retired || row.stopEpoch !== this.store.getStopGeneration(this.bot, row.chatId)
                                     || !this.enabled(row.chatId) || row.cardId !== id)
                                     throw new LiveStatusEffectSuppressedError("presentation edit suppressed before transport");
+                                if (view.state === "replied" && row.linkedReply)
+                                    linkedReplyApplied = { runId: row.linkedReply.runId, outboxId: row.linkedReply.outboxId, cardId: id };
                                 try {
                                     this.save({ ...row, editEffects: { ...row.editEffects, [token]: "attempted" } });
                                 }
@@ -311,7 +325,7 @@ export class QueuedPresentations {
                             settled = true;
                             // Clear only THIS successful token; do not replay the SDK or erase
                             // another unknown progress/terminal operation if SQLite is busy.
-                            this.editReceipt(record, token, "clear");
+                            this.editReceipt(record, token, "clear", linkedReplyApplied);
                         }) });
                     // D2 has recorded the successful effect before local persistence.
                     this.flushRepairs();
@@ -324,7 +338,8 @@ export class QueuedPresentations {
             },
         }, {
             botName: this.bot, locale: this.english(record.chatId) ? "en" : "zh", initialPhase: "queued",
-            restore: { messageId: record.cardId, view: record.view, startedAt: record.startedAt,
+            restore: { messageId: record.cardId, view: record.linkedReply?.rendered && record.view
+                    ? { ...record.view, state: "replied", phase: "replied" } : record.view, startedAt: record.startedAt,
                 blockCreate: record.create !== "never", blockEdits: Object.keys(record.editEffects || {}).length > 0 },
         });
         const entry = { record, live };
@@ -334,12 +349,17 @@ export class QueuedPresentations {
     receive(chat, rowId, messageId, native = false, activeRunId) {
         if (native || !rowId || !this.enabled(chat))
             return undefined;
-        const rows = this.records(chat).filter(row => this.usable(row));
+        const all = this.records(chat);
+        const replied = all.find(row => !row.retired && row.stopEpoch === this.store.getStopGeneration(this.bot, chat)
+            && (row.view?.state === "replied" || !!row.linkedReply?.rendered) && row.triggerIds.includes(rowId));
+        if (replied)
+            return this.hydrate(replied).live;
+        const rows = all.filter(row => this.usable(row));
         // Repeated ingress and steering bursts reuse one card. A foreign/old run
         // is never selected merely because it happens to have a card in this chat.
         let record = rows.find(row => row.triggerIds.includes(rowId))
-            || rows.find(row => !row.runId && !row.submissionId)
-            || (activeRunId ? rows.find(row => row.runId === activeRunId && row.view?.phase !== "waiting") : undefined);
+            || rows.find(row => !row.runId && !row.submissionId && !row.linkedReply)
+            || (activeRunId ? rows.find(row => row.runId === activeRunId && row.view?.phase !== "waiting" && !row.linkedReply) : undefined);
         if (!record) {
             record = { id: randomUUID(), chatId: chat, messageId, triggerIds: [], stopEpoch: this.store.getStopGeneration(this.bot, chat),
                 startedAt: Date.now(), lease: "", create: "never" };
@@ -380,7 +400,7 @@ export class QueuedPresentations {
         this.save(row);
     }
     async insertionAccepted(chat, rowId, expectedRunId) {
-        const row = this.records(chat).find(row => this.usable(row) && row.triggerIds.includes(rowId)
+        const row = this.records(chat).find(row => this.usable(row) && !row.linkedReply && row.triggerIds.includes(rowId)
             && (!row.runId || row.runId === expectedRunId));
         if (!row || !expectedRunId)
             return;
@@ -398,9 +418,94 @@ export class QueuedPresentations {
         else
             await live.showInputWaiting(detail, this.english(chat) ? `${this.bot} enqueued · input confirmation pending` : `${this.bot} 已排队 · 追加输入回执待确认`);
     }
+    /** A legacy insertion owns no actual run. Its card may nevertheless report
+     * the exact associated run's platform-delivered reply, without changing any
+     * insertion, reaction, sync or scheduling record. Recoverable after restart. */
+    async reconcileDeliveredReply(chat, runId) {
+        if (!runId || !this.enabled(chat))
+            return;
+        const epoch = this.store.getStopGeneration(this.bot, chat);
+        const evidence = this.store.getDeliveredRunReply(this.bot, this.app, chat, runId, epoch);
+        if (!evidence)
+            return;
+        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;
+            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;
+            const ordinary = row.runId && row.ownerId && row.batchId ? row.ordinaryTriggerIds || [] : [];
+            const extra = row.triggerIds.filter(id => !ordinary.includes(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 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 || !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);
+            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 && 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: 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 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 !== 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(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.
+            }).finally(() => { if (this.replyFlights.get(current.id) === flight)
+                this.replyFlights.delete(current.id); });
+            this.replyFlights.set(current.id, flight);
+            flights.push(flight);
+        }
+        await Promise.allSettled(flights);
+    }
     async settleRun(chat, runId) {
         if (!runId || !this.enabled(chat))
             return;
+        await this.reconcileDeliveredReply(chat, runId);
         for (const row of this.records(chat))
             if (this.usable(row) && row.runId === runId)
                 await this.hydrate(row).live.complete();
@@ -467,5 +572,6 @@ export class QueuedPresentations {
         for (const entry of this.entries.values())
             entry.live.dispose();
         this.entries.clear();
+        this.replyFlights.clear();
     }
 }

package/docs/releases/1.8.17.md

@@ -0,0 +1,30 @@
+# 1.8.17 — Close linked insertion status cards after the original-chat reply
+
+Presentation-only correction to 1.8.16. A legacy insertion's independent queued
+card can now compact to **关联轮次已回复 / Linked run replied** when the exact
+associated run has a complete, platform-confirmed final reply in the same
+Bot/application/chat/stop epoch. Elapsed time uses delivery time, not repair time.
+
+This is deliberately **not** proof that the inserted input was committed,
+consumed or completed. No insertion acceptance, Get/DONE, model-sync, ordinary
+admission, task execution, business replay or delivery custody semantics change.
+
+- Require exact message identity, input timestamp, run/session compatibility and
+  all accepted members of a coalesced cohort; reject incomplete/unknown delivery,
+  nonfinal/error/verbose notices, foreign roots, old epochs and earlier replies.
+- Seal all eligible card cohorts before asynchronous effects, so a new input is
+  never silently included in a closing card. Preserve a card already containing
+  the actual business answer rather than replacing that answer with a status.
+- Recover known cards after restart from durable original-chat SDK receipts.
+  Persist desired versus rendered UI status separately. Proven-zero-effect edits
+  may retry with bounded backoff; attempted/unknown effects remain fenced.
+  Successful edit receipts survive local journal-write failures without another
+  transport call.
+- No schema migration, Core/plugin or Gateway configuration change is needed.
+  Bridge activation is needed; preserve runtime native dependencies and existing
+  business/insertion records. Do not replay or reset sessions to repair a card.
+
+Validation: bridge and all bundled plugin builds; public SDK type contract;
+complete offline suite **66 files / 1791 tests passed**, including 28 linked-card
+regressions and existing insertion-honesty/no-replay tests. Live activation and
+original-card platform acceptance are separate deployment gates.

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.16",
+  "version": "1.8.18",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {
@@ -77,7 +77,9 @@
     "docs/releases/1.8.10.md",
     "docs/releases/1.8.11.md",
     "docs/releases/1.8.15.md",
-    "docs/releases/1.8.16.md"
+    "docs/releases/1.8.16.md",
+    "docs/releases/1.8.17.md",
+    "docs/releases/1.8.18.md"
   ],
   "engines": {
     "node": ">=22"