openclaw-lark-multi-agent 1.4.1 → 1.4.3

package/dist/live-status.d.ts

@@ -23,6 +23,15 @@ export type LiveStatusView = {
     /** Terminal state: running / done / failed (lets renderer pick color). */
     state: "running" | "done" | "failed";
 };
+/** Persisted metadata needed to turn the live-status card into the final answer. */
+export type LiveStatusFinalMeta = {
+    messageId: string;
+    toolCalls: number;
+    elapsed: string;
+    model?: string;
+    locale: "zh" | "en";
+    noReply?: boolean;
+};
 export type LiveStatusCallbacks = {
     /** Create the status card; returns the new message id. */
     create: (view: LiveStatusView) => Promise<string | undefined>;
@@ -71,6 +80,14 @@ export declare class LiveStatusController {
     start(initialDetail?: string): void;
     progress(event: ProgressEvent | string): Promise<void>;
     complete(): Promise<void>;
+    /**
+     * Freeze any successful terminal state (text, attachment-only, or NO_REPLY)
+     * without first emitting the compact done patch. The caller persists this
+     * metadata in the outbox, which owns the final patch/cleanup. If no card was
+     * created, the caller falls back to normal new-message delivery.
+     */
+    prepareTerminalDelivery(noReply?: boolean): Promise<LiveStatusFinalMeta | undefined>;
+    prepareFinalDelivery(): Promise<LiveStatusFinalMeta | undefined>;
     fail(): Promise<void>;
     /**
      * Finish when the model explicitly produced no reply (NO_REPLY) or an empty

package/dist/live-status.js

@@ -109,6 +109,33 @@ export class LiveStatusController {
             return;
         await this.safeEditFinal(this.buildView());
     }
+    /**
+     * Freeze any successful terminal state (text, attachment-only, or NO_REPLY)
+     * without first emitting the compact done patch. The caller persists this
+     * metadata in the outbox, which owns the final patch/cleanup. If no card was
+     * created, the caller falls back to normal new-message delivery.
+     */
+    async prepareTerminalDelivery(noReply = false) {
+        this.state = "done";
+        this.noReplyResult = noReply;
+        this.finalized = true;
+        this.stopTimers();
+        if (this.createPromise)
+            await this.createPromise.catch(() => { });
+        if (!this.messageId)
+            return undefined;
+        return {
+            messageId: this.messageId,
+            toolCalls: this.toolCallCount,
+            elapsed: this.formatElapsed(),
+            model: this.opts.model,
+            locale: this.opts.locale === "en" ? "en" : "zh",
+            noReply,
+        };
+    }
+    async prepareFinalDelivery() {
+        return this.prepareTerminalDelivery(false);
+    }
     async fail() {
         this.state = "failed";
         this.finalized = true;

package/dist/message-store.d.ts

@@ -41,6 +41,19 @@ export interface DeliveryOutboxItem {
     content: string;
     attachmentsJson: string;
     replyToMessageId: string;
+    /** Delivery mode. `patch_live_status` turns the existing live-status card
+     * into the final answer instead of creating a second Feishu message. */
+    deliveryMode?: "send" | "patch_live_status";
+    /** Existing interactive-card message id to patch for patch_live_status. */
+    targetMessageId?: string;
+    /** Persisted JSON footer metadata (tool calls / elapsed / model / locale). */
+    deliveryMetaJson?: string;
+    /** Durable stage checkpoint: final text/card is already visible. */
+    textDelivered?: boolean;
+    /** Durable stage checkpoint: number of attachments already delivered. */
+    attachmentCursor?: number;
+    /** Final status-card cleanup (done summary after fallback/dedupe) is pending. */
+    cleanupPending?: boolean;
     status: "pending" | "delivering" | "delivered" | "failed";
     attempts: number;
     createdAt: number;
@@ -69,6 +82,8 @@ export declare class MessageStore {
     markDeliveredReply(botName: string, chatId: string, triggerMessageRowId: number, replyMessageId?: string): void;
     enqueueDelivery(item: Omit<DeliveryOutboxItem, "id" | "status" | "attempts" | "createdAt" | "updatedAt">): number | null;
     getDeliveryBySource(sessionKey: string, sourceType: string, sourceId: string): DeliveryOutboxItem | null;
+    getDeliveryByKey(botName: string, chatId: string, deliveryKey: string): DeliveryOutboxItem | null;
+    listDeliveriesByKeyPrefix(botName: string, chatId: string, prefix: string): DeliveryOutboxItem[];
     getPendingDeliveries(chatId?: string, botName?: string, maxCount?: number): DeliveryOutboxItem[];
     markBotSeenInChat(botName: string, chatId: string): void;
     hasBotSeenInChat(botName: string, chatId: string): boolean;
@@ -78,13 +93,27 @@ export declare class MessageStore {
     hasAnyDeliveredToChat(botName: string, chatId: string): boolean;
     hasRecentSimilarDelivery(botName: string, chatId: string, contentHash: string, windowMs: number, sourceTypes?: string[]): boolean;
     hasRecentOverlappingDelivery(botName: string, chatId: string, content: string, attachmentsJson: string, windowMs: number, minShortLength?: number, sourceTypes?: string[]): boolean;
+    /** Recover in-flight rows after process restart. A new process cannot own a
+     * legitimate delivering row, so every matching row returns to pending—even if
+     * the previous process crashed on its nominal final attempt. The restarted
+     * process gets another chance to finish rather than silently losing payload. */
+    resetDeliveringOnStartup(botName: string): number;
     resetStaleDeliveries(botName: string, staleMs: number, maxAttempts: number): {
         restored: number;
         failed: number;
     };
     claimDelivery(id: number): boolean;
+    markDeliveryTextDelivered(id: number): void;
+    /** Atomically checkpoint fallback text and the remaining card cleanup. */
+    markDeliveryTextDeliveredWithCleanup(id: number): void;
+    markDeliveryAttachmentCursor(id: number, cursor: number): void;
+    /** Return a failed in-flight delivery to pending until its retry budget is spent. */
+    retryDelivery(id: number, maxAttempts: number): boolean;
+    markDeliveryCleanupPending(id: number, pending: boolean): void;
     markDeliveryDelivered(id: number): void;
     markDeliveryFailed(id: number): void;
+    /** Give a later explicit duplicate another chance after terminal failure. */
+    requeueFailedDelivery(id: number): boolean;
     private mapDelivery;
     /**
      * Get messages that haven't been synced to a bot's session yet.

package/dist/message-store.js

@@ -148,6 +148,12 @@ export class MessageStore {
         content TEXT NOT NULL DEFAULT '',
         attachments_json TEXT NOT NULL DEFAULT '[]',
         reply_to_message_id TEXT NOT NULL DEFAULT '',
+        delivery_mode TEXT NOT NULL DEFAULT 'send',
+        target_message_id TEXT NOT NULL DEFAULT '',
+        delivery_meta_json TEXT NOT NULL DEFAULT '{}',
+        text_delivered INTEGER NOT NULL DEFAULT 0,
+        attachment_cursor INTEGER NOT NULL DEFAULT 0,
+        cleanup_pending INTEGER NOT NULL DEFAULT 0,
         status TEXT NOT NULL DEFAULT 'pending',
         attempts INTEGER NOT NULL DEFAULT 0,
         created_at INTEGER NOT NULL,
@@ -183,6 +189,42 @@ export class MessageStore {
         catch {
             // Column already exists
         }
+        try {
+            this.db.exec(`ALTER TABLE delivery_outbox ADD COLUMN delivery_mode TEXT NOT NULL DEFAULT 'send'`);
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec(`ALTER TABLE delivery_outbox ADD COLUMN target_message_id TEXT NOT NULL DEFAULT ''`);
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec(`ALTER TABLE delivery_outbox ADD COLUMN delivery_meta_json TEXT NOT NULL DEFAULT '{}'`);
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec(`ALTER TABLE delivery_outbox ADD COLUMN text_delivered INTEGER NOT NULL DEFAULT 0`);
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec(`ALTER TABLE delivery_outbox ADD COLUMN attachment_cursor INTEGER NOT NULL DEFAULT 0`);
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec(`ALTER TABLE delivery_outbox ADD COLUMN cleanup_pending INTEGER NOT NULL DEFAULT 0`);
+        }
+        catch {
+            // Column already exists
+        }
         // Backfill stable keys for rows created by earlier outbox experiments before
         // creating indexes that reference the new columns.
         this.db.exec(`
@@ -194,9 +236,47 @@ export class MessageStore {
             this.db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_delivery_outbox_key ON delivery_outbox(bot_name, chat_id, delivery_key)`);
         }
         catch {
-            // Existing duplicate experimental rows can prevent index creation in dev DB.
-            // Fresh DBs still get the table-level UNIQUE constraint; dirty DBs still use
-            // source unique + short-window content hash until cleaned.
+            // Legacy experimental databases may contain duplicate logical deliveries.
+            // Keep the earliest owner (and its stage checkpoints) deterministically,
+            // remove later duplicates, then REQUIRE the unique index. Continuing
+            // without it would allow duplicate visible finals on explicit trigger keys.
+            // Merge durable progress into the earliest owner before deleting later
+            // duplicates. Prefer the most-complete state so upgrading a dirty legacy DB
+            // cannot replay already-visible text/attachments or lose delivered state.
+            this.db.exec(`
+        UPDATE delivery_outbox AS owner
+        SET
+          text_delivered = (
+            SELECT MAX(d.text_delivered) FROM delivery_outbox d
+            WHERE d.bot_name=owner.bot_name AND d.chat_id=owner.chat_id AND d.delivery_key=owner.delivery_key
+          ),
+          attachment_cursor = (
+            SELECT MAX(d.attachment_cursor) FROM delivery_outbox d
+            WHERE d.bot_name=owner.bot_name AND d.chat_id=owner.chat_id AND d.delivery_key=owner.delivery_key
+          ),
+          cleanup_pending = (
+            SELECT MAX(d.cleanup_pending) FROM delivery_outbox d
+            WHERE d.bot_name=owner.bot_name AND d.chat_id=owner.chat_id AND d.delivery_key=owner.delivery_key
+          ),
+          attempts = (
+            SELECT MAX(d.attempts) FROM delivery_outbox d
+            WHERE d.bot_name=owner.bot_name AND d.chat_id=owner.chat_id AND d.delivery_key=owner.delivery_key
+          ),
+          status = CASE
+            WHEN EXISTS(SELECT 1 FROM delivery_outbox d WHERE d.bot_name=owner.bot_name AND d.chat_id=owner.chat_id AND d.delivery_key=owner.delivery_key AND d.status='delivered') THEN 'delivered'
+            WHEN EXISTS(SELECT 1 FROM delivery_outbox d WHERE d.bot_name=owner.bot_name AND d.chat_id=owner.chat_id AND d.delivery_key=owner.delivery_key AND d.status='pending') THEN 'pending'
+            WHEN EXISTS(SELECT 1 FROM delivery_outbox d WHERE d.bot_name=owner.bot_name AND d.chat_id=owner.chat_id AND d.delivery_key=owner.delivery_key AND d.status='delivering') THEN 'pending'
+            ELSE 'failed'
+          END
+        WHERE owner.id IN (
+          SELECT MIN(id) FROM delivery_outbox GROUP BY bot_name, chat_id, delivery_key HAVING COUNT(*) > 1
+        );
+        DELETE FROM delivery_outbox
+        WHERE id NOT IN (
+          SELECT MIN(id) FROM delivery_outbox GROUP BY bot_name, chat_id, delivery_key
+        );
+      `);
+            this.db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_delivery_outbox_key ON delivery_outbox(bot_name, chat_id, delivery_key)`);
         }
         this.db.exec(`CREATE INDEX IF NOT EXISTS idx_delivery_outbox_content ON delivery_outbox(bot_name, chat_id, content_hash, created_at)`);
         // Migration: add delivery_outbox reply target if missing
@@ -404,9 +484,9 @@ export class MessageStore {
         const now = Date.now();
         const result = this.db.prepare(`
       INSERT OR IGNORE INTO delivery_outbox
-        (session_key, chat_id, bot_name, source_type, source_id, delivery_key, content_hash, content, attachments_json, reply_to_message_id, status, attempts, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', 0, ?, ?)
-    `).run(item.sessionKey, item.chatId, item.botName, item.sourceType, item.sourceId, item.deliveryKey, item.contentHash, item.content, item.attachmentsJson, item.replyToMessageId || '', now, now);
+        (session_key, chat_id, bot_name, source_type, source_id, delivery_key, content_hash, content, attachments_json, reply_to_message_id, delivery_mode, target_message_id, delivery_meta_json, text_delivered, attachment_cursor, cleanup_pending, status, attempts, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', 0, ?, ?)
+    `).run(item.sessionKey, item.chatId, item.botName, item.sourceType, item.sourceId, item.deliveryKey, item.contentHash, item.content, item.attachmentsJson, item.replyToMessageId || '', item.deliveryMode || 'send', item.targetMessageId || '', item.deliveryMetaJson || '{}', item.textDelivered ? 1 : 0, item.attachmentCursor || 0, item.cleanupPending ? 1 : 0, now, now);
         return result.changes ? Number(result.lastInsertRowid) : null;
     }
     getDeliveryBySource(sessionKey, sourceType, sourceId) {
@@ -416,6 +496,21 @@ export class MessageStore {
     `).get(sessionKey, sourceType, sourceId);
         return row ? this.mapDelivery(row) : null;
     }
+    getDeliveryByKey(botName, chatId, deliveryKey) {
+        const row = this.db.prepare(`
+      SELECT * FROM delivery_outbox
+      WHERE bot_name = ? AND chat_id = ? AND delivery_key = ?
+    `).get(botName, chatId, deliveryKey);
+        return row ? this.mapDelivery(row) : null;
+    }
+    listDeliveriesByKeyPrefix(botName, chatId, prefix) {
+        const rows = this.db.prepare(`
+      SELECT * FROM delivery_outbox
+      WHERE bot_name = ? AND chat_id = ? AND delivery_key LIKE ?
+      ORDER BY id ASC
+    `).all(botName, chatId, `${prefix}%`);
+        return rows.map((row) => this.mapDelivery(row));
+    }
     getPendingDeliveries(chatId, botName, maxCount = 20) {
         if (chatId && botName) {
             const rows = this.db.prepare(`
@@ -501,17 +596,29 @@ export class MessageStore {
         }
         return false;
     }
+    /** Recover in-flight rows after process restart. A new process cannot own a
+     * legitimate delivering row, so every matching row returns to pending—even if
+     * the previous process crashed on its nominal final attempt. The restarted
+     * process gets another chance to finish rather than silently losing payload. */
+    resetDeliveringOnStartup(botName) {
+        const result = this.db.prepare(`
+      UPDATE delivery_outbox
+      SET status = 'pending', updated_at = ?
+      WHERE bot_name = ? AND status = 'delivering'
+    `).run(Date.now(), botName);
+        return result.changes;
+    }
     resetStaleDeliveries(botName, staleMs, maxAttempts) {
         const cutoff = Date.now() - staleMs;
         const fail = this.db.prepare(`
       UPDATE delivery_outbox
       SET status = 'failed', updated_at = ?
-      WHERE bot_name = ? AND status = 'delivering' AND updated_at < ? AND attempts >= ?
+      WHERE bot_name = ? AND status = 'delivering' AND updated_at <= ? AND attempts >= ?
     `).run(Date.now(), botName, cutoff, maxAttempts);
         const restore = this.db.prepare(`
       UPDATE delivery_outbox
       SET status = 'pending', updated_at = ?
-      WHERE bot_name = ? AND status = 'delivering' AND updated_at < ? AND attempts < ?
+      WHERE bot_name = ? AND status = 'delivering' AND updated_at <= ? AND attempts < ?
     `).run(Date.now(), botName, cutoff, maxAttempts);
         return { restored: restore.changes, failed: fail.changes };
     }
@@ -521,6 +628,38 @@ export class MessageStore {
     `).run(Date.now(), id);
         return result.changes === 1;
     }
+    markDeliveryTextDelivered(id) {
+        this.db.prepare(`
+      UPDATE delivery_outbox SET text_delivered = 1, updated_at = ? WHERE id = ?
+    `).run(Date.now(), id);
+    }
+    /** Atomically checkpoint fallback text and the remaining card cleanup. */
+    markDeliveryTextDeliveredWithCleanup(id) {
+        this.db.prepare(`
+      UPDATE delivery_outbox
+      SET text_delivered = 1, cleanup_pending = 1, updated_at = ?
+      WHERE id = ?
+    `).run(Date.now(), id);
+    }
+    markDeliveryAttachmentCursor(id, cursor) {
+        this.db.prepare(`
+      UPDATE delivery_outbox SET attachment_cursor = ?, updated_at = ? WHERE id = ?
+    `).run(cursor, Date.now(), id);
+    }
+    /** Return a failed in-flight delivery to pending until its retry budget is spent. */
+    retryDelivery(id, maxAttempts) {
+        const result = this.db.prepare(`
+      UPDATE delivery_outbox
+      SET status = 'pending', updated_at = ?
+      WHERE id = ? AND status = 'delivering' AND attempts < ?
+    `).run(Date.now(), id, maxAttempts);
+        return result.changes === 1;
+    }
+    markDeliveryCleanupPending(id, pending) {
+        this.db.prepare(`
+      UPDATE delivery_outbox SET cleanup_pending = ?, updated_at = ? WHERE id = ?
+    `).run(pending ? 1 : 0, Date.now(), id);
+    }
     markDeliveryDelivered(id) {
         this.db.prepare(`
       UPDATE delivery_outbox SET status = 'delivered', updated_at = ? WHERE id = ?
@@ -531,6 +670,15 @@ export class MessageStore {
       UPDATE delivery_outbox SET status = 'failed', updated_at = ? WHERE id = ?
     `).run(Date.now(), id);
     }
+    /** Give a later explicit duplicate another chance after terminal failure. */
+    requeueFailedDelivery(id) {
+        const result = this.db.prepare(`
+      UPDATE delivery_outbox
+      SET status = 'pending', attempts = 0, updated_at = ?
+      WHERE id = ? AND status = 'failed'
+    `).run(Date.now(), id);
+        return result.changes === 1;
+    }
     mapDelivery(row) {
         return {
             id: row.id,
@@ -544,6 +692,12 @@ export class MessageStore {
             content: row.content || '',
             attachmentsJson: row.attachments_json || '[]',
             replyToMessageId: row.reply_to_message_id || '',
+            deliveryMode: row.delivery_mode === 'patch_live_status' ? 'patch_live_status' : 'send',
+            targetMessageId: row.target_message_id || '',
+            deliveryMetaJson: row.delivery_meta_json || '{}',
+            textDelivered: Boolean(row.text_delivered),
+            attachmentCursor: Number(row.attachment_cursor || 0),
+            cleanupPending: Boolean(row.cleanup_pending),
             status: row.status,
             attempts: row.attempts || 0,
             createdAt: row.created_at,

package/dist/openclaw-client.d.ts

@@ -105,6 +105,10 @@ export declare class OpenClawClient {
      * context-overflow / prompt-too-large, which OpenClaw recovers from via its
      * context-overflow-recovery + auto-compaction path.
      */
+    private isGenericChatError;
+    private resolveTerminalChatError;
+    private formatTerminalRunError;
+    private formatDurationSeconds;
     private isRecoverableAgentError;
     private pickBestCollectedText;
     createSession(params: {

package/dist/openclaw-client.js

@@ -527,6 +527,7 @@ export class OpenClawClient {
             let chatFinalTimer = null;
             let lifecycleEndTimer = null;
             let replayInvalidTimer = null;
+            let genericChatErrorTimer = null;
             let pendingRuntimeFailureText = "";
             let lastActivitySummary = "";
             let lastActivityAt = 0;
@@ -556,6 +557,8 @@ export class OpenClawClient {
                         clearTimeout(lifecycleEndTimer);
                     if (replayInvalidTimer)
                         clearTimeout(replayInvalidTimer);
+                    if (genericChatErrorTimer)
+                        clearTimeout(genericChatErrorTimer);
                     console.warn(`[OpenClaw] collectReply idle timeout for runId=${runId} sessionKey=${sessionKey}`);
                     this.abortChat(targetSessionKey || sessionKey, runId).catch((err) => {
                         console.warn(`[OpenClaw] abort after collectReply idle timeout failed:`, err.message);
@@ -633,6 +636,8 @@ export class OpenClawClient {
                     clearTimeout(lifecycleEndTimer);
                 if (replayInvalidTimer)
                     clearTimeout(replayInvalidTimer);
+                if (genericChatErrorTimer)
+                    clearTimeout(genericChatErrorTimer);
                 resolve(finalText);
             };
             const poller = setInterval(() => {
@@ -648,6 +653,8 @@ export class OpenClawClient {
                         clearTimeout(lifecycleEndTimer);
                     if (replayInvalidTimer)
                         clearTimeout(replayInvalidTimer);
+                    if (genericChatErrorTimer)
+                        clearTimeout(genericChatErrorTimer);
                     if (idleTimer)
                         clearTimeout(idleTimer);
                     const salvaged = this.pickBestCollectedText(chatFinalText, text, chatDeltaText, transcriptAssistantText);
@@ -904,6 +911,28 @@ export class OpenClawClient {
                             // surfaces the failure / lets auto-retry kick in — instead of
                             // surfacing whatever mid-run delta text happened to be collected.
                             const errText = String(ev.data?.error || "chat error");
+                            if (this.isGenericChatError(errText)) {
+                                // Gateway can emit a terminal chat error without errorMessage,
+                                // then persist a richer terminal snapshot a moment later. Do
+                                // not expose the placeholder "chat error" to users. Reconcile
+                                // through agent.wait, whose snapshot includes timeout phase,
+                                // stop reason, and the real upstream error when available.
+                                if (!genericChatErrorTimer) {
+                                    genericChatErrorTimer = setTimeout(() => {
+                                        genericChatErrorTimer = null;
+                                        void this.resolveTerminalChatError(evRunId || runId).then((detail) => {
+                                            clearTimeout(idleTimer);
+                                            clearInterval(poller);
+                                            if (chatFinalTimer)
+                                                clearTimeout(chatFinalTimer);
+                                            if (lifecycleEndTimer)
+                                                clearTimeout(lifecycleEndTimer);
+                                            reject(new Error(`Agent error: ${detail}`));
+                                        });
+                                    }, 350);
+                                }
+                                continue;
+                            }
                             if (this.isRecoverableAgentError(errText)) {
                                 pendingRuntimeFailureText = `⚠️ Agent 未正常完成\n原因: ${errText}`;
                                 resetIdleTimer();
@@ -917,6 +946,8 @@ export class OpenClawClient {
                                 clearTimeout(chatFinalTimer);
                             if (lifecycleEndTimer)
                                 clearTimeout(lifecycleEndTimer);
+                            if (genericChatErrorTimer)
+                                clearTimeout(genericChatErrorTimer);
                             // Abort the (possibly still-running) backgrounded run before we
                             // reject, so an auto-retry probe does not race a zombie run on the
                             // same session. Idempotent/best-effort.
@@ -939,6 +970,50 @@ export class OpenClawClient {
      * context-overflow / prompt-too-large, which OpenClaw recovers from via its
      * context-overflow-recovery + auto-compaction path.
      */
+    isGenericChatError(errText) {
+        const t = (errText || "").trim().toLowerCase();
+        return t === "chat error" || t === "agent error: chat error";
+    }
+    async resolveTerminalChatError(runId) {
+        try {
+            const snapshot = await this.rpc("agent.wait", { runId, timeoutMs: 1500 }, 2500);
+            return this.formatTerminalRunError(snapshot);
+        }
+        catch (err) {
+            const detail = err instanceof Error ? err.message : String(err);
+            return `OpenClaw 运行失败，但未返回具体原因${detail ? `（${detail}）` : ""}`;
+        }
+    }
+    formatTerminalRunError(snapshot) {
+        const rawError = typeof snapshot?.error === "string" ? snapshot.error.trim() : "";
+        const timeoutPhase = typeof snapshot?.timeoutPhase === "string" ? snapshot.timeoutPhase.trim() : "";
+        const stopReason = typeof snapshot?.stopReason === "string" ? snapshot.stopReason.trim() : "";
+        const status = typeof snapshot?.status === "string" ? snapshot.status.trim() : "";
+        const timedOut = status === "timeout" || Boolean(timeoutPhase) || /timed?\s*out|timeout/i.test(rawError);
+        if (timedOut) {
+            const startedAt = Number(snapshot?.startedAt);
+            const endedAt = Number(snapshot?.endedAt);
+            const elapsedSeconds = Number.isFinite(startedAt) && Number.isFinite(endedAt) && endedAt > startedAt
+                ? Math.round((endedAt - startedAt) / 1000)
+                : 0;
+            const elapsed = elapsedSeconds > 0 ? `（运行约 ${this.formatDurationSeconds(elapsedSeconds)}）` : "";
+            const phase = timeoutPhase ? `，阶段：${timeoutPhase}` : "";
+            return `Agent 运行超时${elapsed}${phase}，已被 OpenClaw 终止`;
+        }
+        if (rawError)
+            return rawError;
+        if (stopReason === "stop" || stopReason === "rpc")
+            return `Agent 被停止（${stopReason}）`;
+        const meta = [status && `状态=${status}`, stopReason && `原因=${stopReason}`, timeoutPhase && `阶段=${timeoutPhase}`].filter(Boolean).join("，");
+        return meta ? `OpenClaw 运行失败：${meta}` : "OpenClaw 运行失败，但未返回具体原因";
+    }
+    formatDurationSeconds(seconds) {
+        if (seconds % 3600 === 0)
+            return `${seconds / 3600} 小时`;
+        if (seconds % 60 === 0)
+            return `${seconds / 60} 分钟`;
+        return `${seconds} 秒`;
+    }
     isRecoverableAgentError(errText) {
         const t = (errText || "").toLowerCase();
         return t.includes("context overflow")

package/package.json

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