openclaw-lark-multi-agent 1.8.19 → 1.8.21

package/dist/queued-presentation.js

@@ -1,3 +1,4 @@
+import { inputPreview, visibleInputPreview } from "./input-status-display.js";
 import { randomUUID } from "node:crypto";
 import { LiveStatusController, LiveStatusEffectRejectedError, LiveStatusEffectUnknownError, LiveStatusEffectSuppressedError } from "./live-status.js";
 /** One unbound cohort per chat, or reuse the exact active-root presentation.
@@ -173,6 +174,44 @@ export class QueuedPresentations {
         const row = this.latest(record);
         return !!row && this.usable(row) && !row.linkedReply && row.lease === record.lease && this.enabled(record.chatId);
     }
+    inputContext(record, change) {
+        const row = this.latest(record);
+        if (!row || row.lease !== record.lease || row.retired || row.stopEpoch !== this.store.getStopGeneration(this.bot, row.chatId))
+            return undefined;
+        const messages = { ...row.inputMessageIds }, states = { ...row.inputStates };
+        for (const id of row.triggerIds) {
+            if (messages[id] !== undefined)
+                continue;
+            const source = this.store.getMessageByRowId(id);
+            messages[id] = source?.chatId === row.chatId && source.senderType === 'human' ? source.messageId : '';
+        }
+        const phaseKind = () => row.view?.state === 'replied' ? 'replied' : row.view?.state === 'failed' ? 'failed' :
+            row.view?.state === 'done' ? (row.view.noReply ? 'no_reply' : 'completed') : row.view?.phase === 'waiting' ? 'waiting' :
+                row.view?.phase === 'working' ? 'processing' : row.view?.phase === 'admitted' ? 'accepted' : row.submissionId ? 'submitting' : 'queued';
+        if (change) {
+            const ids = change.ids || (change.kind === 'replied' ? row.triggerIds : row.ordinaryTriggerIds || row.triggerIds);
+            if (change.kind === 'partial' && !ids.length)
+                row.inputNote = { kind: 'partial', detail: change.detail, at: change.at };
+            else {
+                if (['queued', 'accepted', 'submitting', 'replied'].includes(change.kind))
+                    delete row.inputNote;
+                for (const id of ids)
+                    if (row.triggerIds.includes(id) && states[id]?.kind !== change.kind) {
+                        const known = states[id]?.kind || (row.enqueueAcceptedIds?.includes(id) ? 'append_queued' : row.runId && row.ordinaryTriggerIds?.includes(id) ? phaseKind() : undefined);
+                        if (change.kind === 'received' && known && !['received', 'queued'].includes(known))
+                            continue;
+                        states[id] = { kind: change.kind, detail: change.detail, at: change.at };
+                    }
+            }
+            row.inputStates = states;
+            row.inputMessageIds = messages;
+            this.save(row);
+        }
+        return { botName: this.bot, appId: this.app, chatId: row.chatId, stopEpoch: row.stopEpoch, note: row.inputNote,
+            items: row.triggerIds.map(id => ({ ...states[id], rowId: id, messageId: messages[id], preview: row.inputPreviews?.[id], previewSource: row.inputPreviewSources?.[id], kind: states[id]?.kind ||
+                    (row.linkedReply?.rendered ? 'replied' : row.ordinaryTriggerIds?.includes(id) ? phaseKind() : row.enqueueAcceptedIds?.includes(id) ? 'append_queued' : 'received'),
+                at: states[id]?.at || 0 })) };
+    }
     hydrate(record) {
         const cached = this.entries.get(record.id);
         if (cached && cached.record.lease === record.lease)
@@ -204,6 +243,7 @@ export class QueuedPresentations {
         };
         const live = new LiveStatusController({
             warn: base.warn,
+            inputStatus: change => this.inputContext(record, change),
             desired,
             unconfirmedInputs: outcome => {
                 try {
@@ -221,7 +261,15 @@ export class QueuedPresentations {
                     if (!pending.length)
                         return undefined;
                     const en = this.english(row.chatId);
+                    const ordinaryIds = ordinary.filter(id => !pending.includes(id));
+                    if (!ordinaryIds.length)
+                        return {
+                            title: en ? `${this.bot} input confirmation pending` : `${this.bot} 输入接收待确认`,
+                            detail: en ? `${pending.length} input(s) retain local/submission receipts; no ordinary run acceptance confirmed; no replay.` :
+                                `${pending.length} 条输入保留本地/提交回执；尚未确认普通运行接收，不重放。`, ordinaryIds,
+                        };
                     return {
+                        ordinaryIds,
                         title: en ? `${this.bot} ${ordinary.length ? outcome === "failed" ? "run ended · " : "partial result · " : ""}input confirmation pending`
                             : `${this.bot} ${ordinary.length ? outcome === "failed" ? "本轮结束 · " : "部分完成 · " : ""}追加输入回执待确认`,
                         detail: en ? `${pending.length} additional input(s) have only local/enqueue receipts; actual receiver, commitment and result are unconfirmed. Root completion covers only ordinary inputs; no automatic replay.`
@@ -346,9 +394,12 @@ export class QueuedPresentations {
         this.entries.set(record.id, entry);
         return entry;
     }
-    receive(chat, rowId, messageId, native = false, activeRunId) {
+    receive(chat, rowId, messageId, native = false, activeRunId, displayText) {
         if (native || !rowId || !this.enabled(chat))
             return undefined;
+        const input = this.store.getMessageByRowId(rowId);
+        if (!input || input.chatId !== chat || input.messageId !== messageId || input.senderType !== 'human')
+            return undefined;
         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));
@@ -366,9 +417,17 @@ export class QueuedPresentations {
         }
         if (!record.triggerIds.includes(rowId))
             record.triggerIds.push(rowId);
+        record.inputMessageIds = { ...record.inputMessageIds, [rowId]: messageId };
+        const visible = typeof displayText === 'object' && displayText.source === 'visible';
+        const text = typeof displayText === 'string' ? displayText : displayText?.text;
+        if (text !== undefined && (record.inputPreviews?.[rowId] === undefined || visible && record.inputPreviewSources?.[rowId] !== 'visible')) {
+            record.inputPreviews = { ...record.inputPreviews, [rowId]: text.trim() ? (visible ? visibleInputPreview(text, 512, true) : inputPreview(text, 512, true)) : '' };
+            if (visible)
+                record.inputPreviewSources = { ...record.inputPreviewSources, [rowId]: 'visible' };
+        }
         this.save(record); // local receipt already exists; UI record is separate
         const { live } = this.hydrate(record);
-        live.received(this.english(chat) ? "Input durably received locally; acceptance not yet confirmed" : "消息已在本地可靠收件；尚未确认 Gateway 接收");
+        live.received(this.english(chat) ? "Input durably received locally; acceptance not yet confirmed" : "消息已在本地可靠收件；尚未确认 Gateway 接收", [rowId]);
         live.start();
         return live;
     }
@@ -398,6 +457,7 @@ export class QueuedPresentations {
         // The actual public submission key seals this cohort. It is NOT a run ID.
         row.submissionId = submissionId;
         this.save(row);
+        live?.submitting();
     }
     async insertionAccepted(chat, rowId, expectedRunId) {
         const row = this.records(chat).find(row => this.usable(row) && !row.linkedReply && row.triggerIds.includes(rowId)
@@ -414,9 +474,9 @@ export class QueuedPresentations {
         const live = this.hydrate(row).live;
         const detail = this.english(chat) ? "Input enqueued; actual receiver, commitment and result unconfirmed" : "追加输入已进入队列；实际接收方、提交及处理结果未确认";
         if (row.runId)
-            live.received(detail); // ordinary A can still show its own real progress
+            live.received(detail, [rowId], 'append_queued'); // ordinary A keeps its own activity phase
         else
-            await live.showInputWaiting(detail, this.english(chat) ? `${this.bot} enqueued · input confirmation pending` : `${this.bot} 已排队 · 追加输入回执待确认`);
+            await live.showInputWaiting(detail, this.english(chat) ? `${this.bot} enqueued · input confirmation pending` : `${this.bot} 已排队 · 追加输入回执待确认`, [rowId], 'append_queued');
     }
     /** A legacy insertion owns no actual run. Its card may nevertheless report
      * the exact associated run's platform-delivered reply, without changing any
@@ -552,6 +612,51 @@ export class QueuedPresentations {
         const row = this.records(chat).find(row => this.usable(row) && row.runId === runId);
         return row ? this.hydrate(row).live : undefined;
     }
+    /** Recall invalidates copied UI previews, including frozen/terminal cards.
+     * It never changes input custody or recreates/retargets an uncertain effect. */
+    async refreshRecalledInput(chat, rowId, messageId) {
+        const source = this.store.getMessageByRowId(rowId);
+        if (!source || source.chatId !== chat || source.messageId !== messageId || source.senderType !== 'human' || !this.store.isMessageRecalled(messageId))
+            return;
+        const effects = [];
+        for (const snapshot of this.records(chat)) {
+            if (!snapshot.triggerIds.includes(rowId) || snapshot.inputMessageIds?.[rowId] && snapshot.inputMessageIds[rowId] !== messageId)
+                continue;
+            const row = this.latest(snapshot);
+            if (!row)
+                continue;
+            const previews = { ...row.inputPreviews }, sources = { ...row.inputPreviewSources };
+            delete previews[rowId];
+            delete sources[rowId];
+            const view = row.view ? { ...row.view, lines: row.view.lines.filter(line => line.kind !== 'steer'), inputStatus: row.view.inputStatus ? {
+                    ...row.view.inputStatus, items: row.view.inputStatus.items.map(item => {
+                        if (item.rowId !== rowId && item.messageId !== messageId)
+                            return item;
+                        const { preview, previewSource, ...reference } = item;
+                        return reference;
+                    }),
+                } : undefined } : undefined;
+            this.save({ ...row, inputPreviews: previews, inputPreviewSources: sources, view });
+            if (row.retired || row.stopEpoch !== this.store.getStopGeneration(this.bot, chat) || row.linkedReply?.rendered === 'reply_payload')
+                continue;
+            let entry = this.entries.get(row.id);
+            if (entry?.record.lease !== row.lease)
+                entry = undefined;
+            if (!entry && row.create === 'accepted' && row.cardId && !Object.keys(row.editEffects || {}).length)
+                entry = this.hydrate(this.latest(row));
+            if (!entry)
+                continue; // unknown/no-ID restoration: persist redaction only
+            const owned = entry;
+            const effectCurrent = () => {
+                const fresh = this.latest(owned.record);
+                return !this.disposed && !!fresh && !fresh.retired && fresh.lease === owned.record.lease && this.enabled(chat) &&
+                    fresh.stopEpoch === this.store.getStopGeneration(this.bot, chat) && fresh.create === 'accepted' && !!fresh.cardId &&
+                    fresh.cardId === owned.live.id && !Object.keys(fresh.editEffects || {}).length && fresh.linkedReply?.rendered !== 'reply_payload';
+            };
+            effects.push(owned.live.redactRecalledInput(effectCurrent));
+        }
+        await Promise.allSettled(effects);
+    }
     retire(chat) {
         // Stop old callbacks even when the UI journal is temporarily unavailable.
         for (const entry of this.entries.values())

package/dist/terminal-errors.d.ts

@@ -1,6 +1,9 @@
 /** Only gateway envelopes / committed assistant metadata populate this record. */
 export interface ErrorProvenance {
     sessionKey: string;
+    sessionId?: string;
+    botIdentity?: string;
+    stopEpoch?: number;
     runId: string;
     source: "chat" | "session.message";
     state: string;
@@ -8,6 +11,13 @@ export interface ErrorProvenance {
     detail?: string;
     userStop?: boolean;
 }
+export type ClosedStopReason = 'timeout' | 'restart' | 'superseded' | 'aborted' | 'error' | 'stop' | 'rpc';
+export declare const closedStopReason: (value: unknown) => ClosedStopReason | undefined;
+/** Carries original public terminal metadata, never model/prompt-derived cause. */
+export declare class RunTerminalError extends Error {
+    readonly provenance: ErrorProvenance;
+    constructor(provenance: ErrorProvenance);
+}
 export interface ProactiveMessageMeta {
     /** Bridge-local Go result owner; never derived from an untrusted model body. */
     goJobId?: number;
@@ -39,10 +49,12 @@ export interface ErrorVerdict {
     reason: string;
     task?: TaskEvidence;
     terminalKey?: string;
+    stopReason?: ClosedStopReason;
     text?: string;
 }
 export type ReadRPC = (method: string, params: Record<string, unknown>, timeoutMs: number) => Promise<any>;
 export declare const errorIdentity: (sessionKey: string, runId: string) => string;
+export declare const errorNoticeIdentity: (p: ErrorProvenance) => string;
 export declare const genericFailure: (text: string) => boolean;
 export declare function announceCandidate(p: ErrorProvenance): {
     runId: string;

package/dist/terminal-errors.js

@@ -1,6 +1,19 @@
 import { createHash } from "node:crypto";
 import { safeErrorSummary } from "./provider-errors.js";
+export const closedStopReason = (value) => typeof value === 'string' && ['timeout', 'restart', 'superseded', 'aborted', 'error', 'stop', 'rpc'].includes(value) ? value : undefined;
+/** Carries original public terminal metadata, never model/prompt-derived cause. */
+export class RunTerminalError extends Error {
+    provenance;
+    constructor(provenance) {
+        super(`Agent error: ${provenance.detail || provenance.stopReason || 'aborted'}`);
+        this.provenance = provenance;
+        this.name = 'RunTerminalError';
+    }
+}
 export const errorIdentity = (sessionKey, runId) => createHash("sha256").update(JSON.stringify([sessionKey, runId])).digest("hex");
+export const errorNoticeIdentity = (p) => p.sessionId && p.botIdentity && Number.isSafeInteger(p.stopEpoch)
+    ? errorIdentity(JSON.stringify([p.sessionKey, p.sessionId, p.botIdentity, p.stopEpoch]), p.runId)
+    : errorIdentity(p.sessionKey, p.runId);
 export const genericFailure = (text) => text.trim() === "The agent run failed before producing a reply.";
 // These are candidate locators, NOT business identities. Verify every component
 // against tasks.list + a fresh tasks.get. Unsupported/batch forms stay unknown.
@@ -39,11 +52,16 @@ export async function inspectError(p, rpc) {
     if (!p.runId)
         return pending("missing_run_identity");
     if (!announce) {
+        if (p.source === 'chat' && p.state === 'aborted' && closedStopReason(p.stopReason))
+            return {
+                state: 'terminal', reason: 'closed_gateway_terminal', terminalKey: `run-error:${errorNoticeIdentity(p)}`,
+                text: '⚠️ 该次运行已终止，未能完成回复。',
+            };
         // Ordinary chat.error is a gateway terminal envelope (after gateway retry
         // grace). Do not rewrite normal collector/auth/parameter/tool-error handling.
         if (p.source === "chat" && (p.state === "error" || (p.state === "final" && p.stopReason === "error")))
             return {
-                state: "terminal", reason: "ordinary_gateway_error", terminalKey: `run-error:${errorIdentity(p.sessionKey, p.runId)}`,
+                state: "terminal", reason: "ordinary_gateway_error", terminalKey: `run-error:${errorNoticeIdentity(p)}`,
                 text: `⚠️ Agent run failed${p.detail ? `: ${safeErrorSummary(p.detail)}` : ""}`,
             };
         try {
@@ -52,10 +70,12 @@ export async function inspectError(p, rpc) {
             const started = wait?.startedAt;
             const terminalTime = typeof ended === "number" && Number.isFinite(ended) && ended > 0
                 && (started === undefined || (typeof started === "number" && Number.isFinite(started) && started >= 0 && ended >= started));
-            if (wait?.runId === p.runId && wait?.status === "error" && wait?.pendingError !== true
+            if (wait?.runId === p.runId && (wait?.status === "error" || wait?.status === 'timeout') && wait?.pendingError !== true
+                && !['queue', 'gateway_draining'].includes(wait?.timeoutPhase) && (!p.sessionId || !wait.sessionId || wait.sessionId === p.sessionId)
                 && wait?.yielded !== true && terminalTime)
                 return {
-                    state: "terminal", reason: "exact_run_terminal_error", terminalKey: `run-error:${errorIdentity(p.sessionKey, p.runId)}`,
+                    state: "terminal", reason: "exact_run_terminal_error", terminalKey: `run-error:${errorNoticeIdentity(p)}`,
+                    stopReason: closedStopReason(wait.stopReason) || (wait.status === 'timeout' ? 'timeout' : undefined),
                     text: "⚠️ 该次运行已终止，未能完成回复。",
                 };
             return pending("wait_not_terminal_failure");

package/docs/releases/1.8.20.md

@@ -0,0 +1,30 @@
+# LMA 1.8.20
+
+## Live cards identify the actual input
+
+All live input-delivery hints now use a brief localized `【emoji status】` followed by the corresponding original message body or an explicitly bounded excerpt. Local receipt, queueing, submission pending, append queueing, acceptance, processing, waiting/paused, unconfirmed/partial, delivery pending, round ended, no-content, linked reply, interrupted and not-submitted states retain their distinct meaning.
+
+- Concurrent, merged and appended inputs retain independent source references and phases across card updates and recovery. One root's result does not certify another appended input's commitment.
+- Necessary unknown/receipt qualifications remain separate from the message preview. Display records do not grant admission, Get/DONE, retry or business-completion authority.
+- Literal human text is preserved instead of being mistaken for legacy media/routing markers. Structured media uses visible captions/names/type markers, not server paths, private keys or hydrated document bodies.
+- Source identity and recall are checked at the card boundary. Existing known UI cards redact recalled previews without waiting for unrelated reaction network operations; unknown UI effects remain fenced and protected business-answer payloads are not overwritten.
+- Complete outer request budgeting preserves newest inputs and marks omissions; user markup cannot create active mentions or card actions.
+
+## Private-chat ownership survives bot renaming
+
+Private ownership is pinned to the receiving application's stable identity. Same-app display-name changes preserve intake/startup access and proven previous-name deduplication. App/chat/message ingress tombstones, including owner-rejected inputs, prevent historical commands from executing again after a rename.
+
+Foreign/malformed pins and unmatched unpinned legacy owners remain fail-closed. Only a separately verified, targeted operator migration can establish a lost legacy alias. No broad takeover or historical-message replay is performed.
+
+## Terminal errors retain their real cause and one delivery owner
+
+Closed run/session abort metadata now survives the foreground collector. Proven total-deadline termination is no longer presented as merely paused waiting; bare `aborted` remains unknown instead of being guessed as a human stop or timeout.
+
+Foreground and late proactive failures coordinate through the existing exact-run error journal/outbox, including compatible legacy owners. Original app/session/physical target/stop epoch/recall checks apply immediately before ordinary admitted-error SDK sends too. New same-run progress during an awaited cause lookup fences stale provisional abort decisions. Finals and explicit stop receipts retain priority.
+
+## Compatibility and operational boundaries
+
+- Runtime dependency constraints and the consolidated plugin contract are unchanged. Preserve compatible target-native dependencies; build and test locally rather than installing/building on deployment hosts.
+- Existing history, business namespaces, sync labels and old delivered/unknown-attempt custody are not bulk renamed or replayed.
+- This LMA package does not itself upgrade or patch OpenClaw Core, change model selection, increase configured execution deadlines, or alter model permissions.
+- Automated acceptance uses offline actual receiver/controller/outbox/Card2 SDK boundaries and synthetic HTTP transport. Real target process activation, original-message delivery and Feishu client appearance require separate deployment/acceptance receipts.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-lark-multi-agent",
-  "version": "1.8.19",
+  "version": "1.8.21",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {
@@ -80,7 +80,8 @@
     "docs/releases/1.8.16.md",
     "docs/releases/1.8.17.md",
     "docs/releases/1.8.18.md",
-    "docs/releases/1.8.19.md"
+    "docs/releases/1.8.19.md",
+    "docs/releases/1.8.20.md"
   ],
   "engines": {
     "node": ">=22"
@@ -88,4 +89,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}