openclaw-lark-multi-agent 1.1.1 → 1.2.0

package/README.md

@@ -37,6 +37,7 @@ All of them connect to the same OpenClaw Gateway while keeping sessions, queues,
 - Feishu image download and OpenClaw multimodal attachment forwarding
 - Bridge attachment marker protocol for generated files/images/documents
 - Feishu CardKit v2 Markdown rendering, including native table elements for pipe tables
+- Live status card: in non-verbose mode each run shows a single self-updating Feishu interactive card (title + recent activity window with per-line timestamps + elapsed/model footer, refreshed once per second), which collapses to a compact one-line summary on a clean finish and retains the recent activity on failure for debugging
 - Bridge-level slash commands and escaped OpenClaw slash commands
 - `/discuss` mode for barrier-style multi-bot group discussion, including per-round markers and no-reply status notices
 - `/chairman` role: a single per-group chairman that answers plain messages when no bot is in Free mode, and acts as host, challenger, and summarizer inside `/discuss`
@@ -231,10 +232,13 @@ Bridge-level commands use a single slash and are handled by this project:
 - `/status` — show bot model, token usage, and session state
 - `/compact` — compact the OpenClaw session
 - `/reset` — reset the OpenClaw session
+- `/stop` — force-stop a stuck run for this bot in this chat and unlock the queue
 - `/verbose` — toggle tool-call messages for this bot in this chat
+- `/livestatus [on|off]` — toggle, or explicitly enable/disable, the self-updating run-status card shown in non-verbose mode (default on)
 - `/free [on|off]` — toggle, or explicitly enable/disable, this bot's Free mode in the current group chat
 - `/mute` — toggle this bot's mute mode in the current group chat
 - `/mode` — show this bot's current mode in the current chat
+- `/model [id]` — show or switch this bot's bound model (persisted)
 - `/discuss on|off|status|stop|rounds N` — control group-level multi-bot discussion mode (requires a chairman to enable; default 10 rounds)
 - `/chairman [@Bot|off]` — set, view, or clear the single chairman for this group
 - `/locale [zh|en]` — set or view this group's language
@@ -323,7 +327,7 @@ Persistent constraints (such as "do not call Feishu send tools directly" and the
 `/discuss` is an explicit group-level multi-agent discussion scheduler. It is separate from Free mode:
 
 - `/free` controls whether a single bot may answer plain human messages.
-- `/discuss on` requires a chairman to be set first (`/chairman @Bot`). It lets one coordinator take over plain human messages and run all Free-mode bots plus the chairman in barrier-style rounds.
+- `/discuss on` requires a chairman to be set first (`/chairman @Bot`). It lets one coordinator take over plain human messages and run all non-muted bots plus the chairman in barrier-style rounds. Free mode is ignored inside discussion: every bot that is not muted participates regardless of its Free setting.
 - Targeted mentions still fall through to normal routing, so `@GPT hello` works even while discuss mode is enabled.
 - Each participant receives the same round prompt and does not see other participants' replies from the current round until the next round.
 - The chairman speaks last each round: it gives its own view, challenges weak points, mediates disagreements, and decides whether to continue or conclude.
@@ -396,6 +400,23 @@ The bridge subscribes to Feishu `im.message.recalled_v1` events. When a user rec
 
 Version 1 behavior intentionally does **not** abort an OpenClaw run that has already started processing the recalled message, and it does not recall bot replies that were already sent. The first goal is to make recall reliable for queued/not-yet-processed messages.
 
+## Session health and error recovery
+
+The bridge distinguishes a failed *run* from a dead *session*:
+
+- During an active run, a health monitor polls the OpenClaw session. Only true
+  session-death states (`killed` / `dead` / `crashed`, matched on word
+  boundaries) are treated as unhealthy; run-level outcomes such as `aborted`,
+  `error`, or `timeout` are not, because the session usually remains usable for
+  the next message. A short re-check guards against transient blips.
+- When a session is genuinely unhealthy, the bridge warns the user but does not
+  force a `/reset`: the current message is still attempted, and only an in-run
+  confirmation of death stops the wait. Users decide whether to retry.
+- Recoverable agent errors are not surfaced as failures. When OpenClaw emits a
+  recoverable lifecycle error (for example `Context overflow: prompt too large`)
+  it auto-compacts and keeps the same run alive; the bridge defers instead of
+  rejecting, so a later real final reply wins. Only a genuine stall falls back to
+  the deferred error via the idle timeout. Non-recoverable errors still fail fast.
 
 ## Markdown, tables, and attachments
 
@@ -408,6 +429,50 @@ Assistant replies are sent as Feishu CardKit v2 cards. Markdown is preprocessed
 
 For generated files/images/documents, agents should use the bridge attachment marker protocol instead of calling Feishu messaging tools directly. The bridge strips the marker from the visible reply, validates the file path under the configured attachment directory, uploads/sends the attachment, and records it in local context. Markdown documents can be converted into Feishu cloud documents through this path.
 
+## Live status
+
+In non-verbose mode, each run shows a single self-updating Feishu interactive
+card so users can see progress without the noise of per-tool-call messages.
+Verbose mode and live status are mutually exclusive: when `/verbose` is on, the
+bridge emits the existing per-tool messages instead of a live status card.
+
+While running, the card shows:
+
+- a title (`<bot> is working`);
+- a rolling window of the most recent activity lines (tool start `▸`, tool end
+  `✓`, and intermediate assistant text `•`), each prefixed with the relative
+  time `mm:ss` since the run started;
+- a footer with elapsed time and the bound model name.
+
+The card is created lazily (a fast reply that finishes within the create delay
+never spawns a card, to avoid flicker) and is updated with `im.message.patch`,
+which has no 20-edit cap. A 1-second ticker advances the elapsed timer even when
+no new activity arrives.
+
+When the run ends:
+
+- a clean finish (normal reply or `NO_REPLY`) collapses the card to a single
+  compact grey line: status emoji + total tool calls + total elapsed;
+- a failure (provider error, killed/unhealthy session, delivery error, or idle
+  timeout) keeps the recent activity window plus the summary, with an orange
+  header, so the steps leading up to the failure stay visible for debugging.
+
+The final answer is always delivered separately through the normal interactive-card
+delivery path, so Markdown renders correctly; the live status card is a distinct
+message and never replaces or blocks the final reply.
+
+Live status is on by default and can be toggled per bot/chat with
+`/livestatus [on|off]`. It can be disabled globally by setting
+`OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS=0`. Tunable defaults:
+
+| Environment variable | Default | Meaning |
+| --- | --- | --- |
+| `OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS` | `1` | Master switch; `0` disables live status for all bots |
+| `OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_DELAY_MS` | `800` | Delay before creating the card, so fast replies do not flicker one |
+| `OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_TICK_MS` | `1000` | How often the elapsed-time footer auto-refreshes |
+| `OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_HISTORY` | `6` | Number of recent activity lines kept in the card |
+| `OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_MAX_CHARS` | `120` | Per-line character cap before truncation |
+
 ## Data model
 
 SQLite state lives in the configured data directory. Important tables:
@@ -421,7 +486,7 @@ SQLite state lives in the configured data directory. Important tables:
 - `delivery_outbox` — durable user-visible delivery ledger with claim/dedupe state
 - `recalled_messages` — recalled user messages excluded from pending work and future context
 - `processed_events` — Feishu event de-duplication
-- `bot_chat_settings` — per-bot/per-chat settings such as verbose mode
+- `bot_chat_settings` — per-bot/per-chat settings such as verbose mode, mode, and live-status toggle
 
 ## Development
 

package/dist/feishu-bot.d.ts

@@ -34,6 +34,8 @@ export declare class FeishuBot {
     private delayedFailureTimers;
     /** Last time a real assistant-visible reply was successfully handed to the delivery pipeline. */
     private lastRealDeliveryAt;
+    /** Per-chat: whether we've already sent the high-context alert this cycle. */
+    private contextAlerted;
     /** Active chatSend trigger target so final replies and proactive session.message share one delivery key. */
     private activeDeliveryTargets;
     private adminOpenId;
@@ -117,6 +119,51 @@ export declare class FeishuBot {
     private isBridgeControlReply;
     private isLegacyBridgeControlMessage;
     private isRuntimeFailureText;
+    /**
+     * Is this main-run error worth auto-retrying (by resuming the session via the
+     * probe loop)? Mainly transient failures — request/response timeouts and
+     * aborted/incomplete runs. We do NOT auto-retry clearly terminal errors
+     * (auth/permission/quota/billing/model-not-supported), which would just fail
+     * again. The error text comes from collectReply's `Agent error: <msg>`.
+     */
+    private isRetryableAgentError;
+    /**
+     * Heuristic: does this reply look truncated / mid-task? Bias toward false
+     * positives (“宁可错杀不放过”) — a false positive only costs one invisible
+     * confirmation round, and the session self-check is the real arbiter. We gate
+     * only on cheap text shape here, never on stopReason (the upstream rarely
+     * provides one for normal-looking-but-truncated finals).
+     */
+    private looksTruncated;
+    /** Current context usage percent for a session (totalTokens / contextTokens),
+     *  or 0 if it cannot be determined. Same basis as /status. */
+    private getContextUsagePercent;
+    /**
+     * After a reply is delivered, alert the user once if context usage crossed the
+     * threshold (default 80%), so they can compact before a session bloats into the
+     * timeout/lock/overflow failure modes. We only alert on a fresh crossing: once
+     * alerted we stay quiet until usage drops back below the threshold (e.g. after
+     * a compact), then re-arm.
+     */
+    private maybeAlertHighContext;
+    /** True when the agent's reply is exactly a completion phrase (zh or en,
+     *  tolerant of trailing punctuation/whitespace and case). */
+    /**
+     * True when the agent's reply means “done”. We accept the exact phrase as well
+     * as common wrappers (“已经结束了” / “好的，结束了” / “yes, DONE”), but reject it
+     * when a negation/not-finished cue is present (“还没结束” / “not done”), so a
+     * “still working” answer never counts as completion.
+     */
+    private isDonePhrase;
+    /**
+     * Auto-retry loop: if `reply` looks truncated, ask the same session whether it
+     * finished. The session is the arbiter: if it replies exactly the done phrase,
+     * the ORIGINAL reply was the real result and we deliver that. Otherwise the
+     * session kept working and its new output becomes the latest reply, which we
+     * re-check. Loops until the session confirms completion, a reply no longer
+     * looks truncated, the budget is spent, or the session cannot answer.
+     */
+    private autoRetryUntilComplete;
     private cancelDelayedFailure;
     private setActiveDeliveryTarget;
     private scheduleDelayedFailure;
@@ -202,6 +249,17 @@ export declare class FeishuBot {
     /**
      * Handle /compact command: compress session context.
      */
+    /**
+     * Compact a session with a fallback chain:
+     *   1. OpenClaw's native (LLM-summary) compaction — best semantics.
+     *   2. If that did not compact (or threw), fall back to "tool-trim": rewrite
+     *      the transcript file to drop tool calls/results while keeping the
+     *      conversation. This needs no model, so it works no matter how large the
+     *      session is (the native path itself fails to fit an oversized session
+     *      into the model). A backup is always written before any file change.
+     * Returns a structured result describing what happened.
+     */
+    private compactWithFallback;
     private handleCompactCommand;
     /**
      * Handle /reset command: fire sessions.reset and confirm.

package/dist/feishu-bot.js

@@ -8,6 +8,7 @@ import { basename, extname, join, resolve } from "path";
 import { getBridgeAttachmentsDir, getDataDir } from "./paths.js";
 import { buildFeishuCardElements } from "./markdown.js";
 import { discussionManager } from "./discussion-manager.js";
+import { resolveSessionFilePath, toolTrimCompactFile } from "./session-file-compactor.js";
 const require = createRequire(import.meta.url);
 const LMA_VERSION = require("../package.json").version;
 const MAX_BOT_STREAK = 10;
@@ -17,6 +18,26 @@ const BRIDGE_ATTACHMENTS_DIR = getBridgeAttachmentsDir();
 const FEISHU_DOCS_DIR = join(getDataDir(), "feishu-docs");
 const SESSION_HEALTH_POLL_MS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_SESSION_HEALTH_POLL_MS || 5_000);
 const SESSION_HEALTH_CONFIRM_MS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_SESSION_HEALTH_CONFIRM_MS || 2_000);
+// Auto-retry: when a reply looks truncated/incomplete, ask the same session
+// whether it finished. If it did not, let it continue; loop until it confirms
+// completion or the retry budget is spent. Off by setting AUTO_RETRY=0.
+// Read at call time (not module load) so tests can toggle it per-case.
+function autoRetryEnabled() { return process.env.OPENCLAW_LARK_MULTI_AGENT_AUTO_RETRY !== "0"; }
+function autoRetryMax() { return Number(process.env.OPENCLAW_LARK_MULTI_AGENT_AUTO_RETRY_MAX || 5); }
+// The exact phrase the agent must reply to confirm completion. The probe asks
+// for the locale-appropriate phrase; detection accepts BOTH so either works.
+const AUTO_RETRY_DONE_PHRASE = process.env.OPENCLAW_LARK_MULTI_AGENT_AUTO_RETRY_DONE_PHRASE || "\u7ed3\u675f\u4e86";
+const AUTO_RETRY_DONE_PHRASE_EN = process.env.OPENCLAW_LARK_MULTI_AGENT_AUTO_RETRY_DONE_PHRASE_EN || "DONE";
+// When an auto-retry probe errors AND context usage is at/above this percent,
+// auto-compact the session once and keep retrying (instead of giving up). This
+// rescues the “session too heavy → run times out / lock contention” failure mode.
+function autoRetryCompactPct() { return Number(process.env.OPENCLAW_LARK_MULTI_AGENT_AUTO_RETRY_COMPACT_PCT || 50); }
+// How many of the most-recent tool calls (and their results) tool-trim keeps
+// intact — recent tool calls may still be relevant to the agent's next step.
+function toolTrimKeepRecent() { return Number(process.env.OPENCLAW_LARK_MULTI_AGENT_TOOLTRIM_KEEP_RECENT || 3); }
+// After a reply is delivered, if context usage reaches this percent, send the
+// user a one-time alert to compact. 0 disables the alert.
+function contextAlertPct() { return Number(process.env.OPENCLAW_LARK_MULTI_AGENT_CONTEXT_ALERT_PCT || 80); }
 class UnhealthySessionError extends Error {
     status;
     constructor(status) {
@@ -58,6 +79,8 @@ export class FeishuBot {
     delayedFailureTimers = new Map();
     /** Last time a real assistant-visible reply was successfully handed to the delivery pipeline. */
     lastRealDeliveryAt = new Map();
+    /** Per-chat: whether we've already sent the high-context alert this cycle. */
+    contextAlerted = new Map();
     /** Active chatSend trigger target so final replies and proactive session.message share one delivery key. */
     activeDeliveryTargets = new Map();
     adminOpenId;
@@ -1220,6 +1243,31 @@ export class FeishuBot {
                         onProgress: (event) => liveStatus?.progress(event),
                     }));
                 }
+                catch (mainErr) {
+                    // The main run failed before returning a reply. If it is a retryable
+                    // error (e.g. a request timeout) and not a session-health failure,
+                    // reuse the SAME auto-retry mechanism to let the session resume from
+                    // where it was interrupted, instead of giving up immediately.
+                    if (mainErr instanceof UnhealthySessionError)
+                        throw mainErr;
+                    const errText = mainErr?.message || String(mainErr);
+                    if (autoRetryEnabled() && !isNativeCommandTrigger && this.isRetryableAgentError(errText)) {
+                        console.warn(`[${this.config.name}] main run failed (${errText.slice(0, 80)}) for ${chatId.slice(-8)}; entering auto-retry`);
+                        reply = await this.autoRetryUntilComplete({
+                            chatId,
+                            sessionKey,
+                            senderName: lastHuman.senderName,
+                            triggerId,
+                            lastHumanMessageId: lastHuman.messageId || "",
+                            isNativeCommandTrigger,
+                            initialError: errText,
+                            liveStatus,
+                        });
+                    }
+                    else {
+                        throw mainErr;
+                    }
+                }
                 finally {
                     // OpenClaw may emit the final assistant session.message just after
                     // collectReply returns. Keep the trigger mapping briefly so proactive
@@ -1227,6 +1275,19 @@ export class FeishuBot {
                     releaseActiveDeliveryTarget();
                 }
                 console.log(`[${this.config.name}] OpenClaw reply collected for ${chatId.slice(-8)} in ${Date.now() - queueStartedAt}ms`);
+                // Auto-retry: if the reply looks truncated/incomplete, confirm with the
+                // session and loop until it reports done (or the budget is spent). This
+                // replaces `reply` with the final, confirmed result before delivery.
+                reply = await this.autoRetryUntilComplete({
+                    chatId,
+                    sessionKey,
+                    senderName: lastHuman.senderName,
+                    triggerId,
+                    lastHumanMessageId: lastHuman.messageId || "",
+                    isNativeCommandTrigger,
+                    initialReply: reply,
+                    liveStatus,
+                });
                 const parsedReply = this.extractBridgeAttachments(reply);
                 const visibleReply = parsedReply.text;
                 const trimmedReply = visibleReply.trim();
@@ -1325,6 +1386,8 @@ export class FeishuBot {
                             // not re-process any of them.
                             for (const id of mergedTriggerIds)
                                 this.store.markDeliveredReply(this.config.name, chatId, id, lastHuman.messageId);
+                            // After a successful reply, warn the user once if context is high.
+                            void this.maybeAlertHighContext(chatId);
                         }
                         catch (err) {
                             // enqueueAndDispatchDelivery already sent a user-visible delivery
@@ -1603,6 +1666,247 @@ export class FeishuBot {
     isRuntimeFailureText(text) {
         return text.startsWith("⚠️ Agent 未正常完成") || /\n原因:\s*rpc\b/.test(text);
     }
+    /**
+     * Is this main-run error worth auto-retrying (by resuming the session via the
+     * probe loop)? Mainly transient failures — request/response timeouts and
+     * aborted/incomplete runs. We do NOT auto-retry clearly terminal errors
+     * (auth/permission/quota/billing/model-not-supported), which would just fail
+     * again. The error text comes from collectReply's `Agent error: <msg>`.
+     */
+    isRetryableAgentError(errText) {
+        const t = (errText || "").toLowerCase();
+        // Terminal errors: never auto-retry.
+        if (/(unauthorized|permission|forbidden|invalid api key|quota|billing|insufficient|model_not_supported|not supported|invalid_request)/.test(t))
+            return false;
+        // Retryable: timeouts and transient interruptions.
+        return /(timed out|timeout|aborted|operation was aborted|no response|request failed|temporarily|connection|econnreset|socket hang|stream)/.test(t);
+    }
+    /**
+     * Heuristic: does this reply look truncated / mid-task? Bias toward false
+     * positives (“宁可错杀不放过”) — a false positive only costs one invisible
+     * confirmation round, and the session self-check is the real arbiter. We gate
+     * only on cheap text shape here, never on stopReason (the upstream rarely
+     * provides one for normal-looking-but-truncated finals).
+     */
+    looksTruncated(text) {
+        const t = (text || "").trim();
+        if (!t)
+            return false; // empty/NO_REPLY handled elsewhere
+        // Unbalanced code fence => almost certainly cut off mid-block.
+        const fences = (t.match(/```/g) || []).length;
+        if (fences % 2 === 1)
+            return true;
+        // Ends with an obvious continuation cue (dangling connector / lead-in).
+        if (/[，,：:、;；]\s*$/u.test(t))
+            return true;
+        if (/(接下来|然后|首先|现在我|让我|下一步|let me|now i|next,?|first,?)\s*$/iu.test(t))
+            return true;
+        // Core signal: ends without any sentence-ending punctuation / closer
+        // (“连句号都没有就感觉没成功”). Accept terminators across languages,
+        // closing brackets/quotes, code fences, and common emoji endings.
+        const endOk = /[。！？.!?…)\]」』】）"'`”’~～—✨✅👍🙏]\s*$/u.test(t)
+            || /```\s*$/.test(t)
+            || /[}\]]\s*$/.test(t);
+        return !endOk;
+    }
+    /** Current context usage percent for a session (totalTokens / contextTokens),
+     *  or 0 if it cannot be determined. Same basis as /status. */
+    async getContextUsagePercent(sessionKey) {
+        try {
+            const resp = await this.openclawClient.getSessionInfo(sessionKey);
+            const s = resp?.session;
+            const total = s?.totalTokens || 0;
+            const ctx = s?.contextTokens || 0;
+            return ctx > 0 ? Math.round((total / ctx) * 100) : 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+    /**
+     * After a reply is delivered, alert the user once if context usage crossed the
+     * threshold (default 80%), so they can compact before a session bloats into the
+     * timeout/lock/overflow failure modes. We only alert on a fresh crossing: once
+     * alerted we stay quiet until usage drops back below the threshold (e.g. after
+     * a compact), then re-arm.
+     */
+    async maybeAlertHighContext(chatId) {
+        const threshold = contextAlertPct();
+        if (threshold <= 0)
+            return;
+        try {
+            const sessionKey = this.getSessionKey(chatId);
+            const pct = await this.getContextUsagePercent(sessionKey);
+            if (pct <= 0)
+                return;
+            const alerted = this.contextAlerted.get(chatId) || false;
+            if (pct >= threshold) {
+                if (alerted)
+                    return; // already warned this cycle
+                this.contextAlerted.set(chatId, true);
+                const en = this.isEn(chatId);
+                const text = en
+                    ? `\u26a0\ufe0f Context is at ${pct}% (\u2265${threshold}%). Consider /compact soon to avoid timeouts/overflow.`
+                    : `\u26a0\ufe0f \u4e0a\u4e0b\u6587\u5df2\u8fbe ${pct}%\uff08\u2265${threshold}%\uff09\uff0c\u5efa\u8bae\u5c3d\u5feb /compact \u538b\u7f29\uff0c\u907f\u514d\u8d85\u65f6/\u7206\u4e0a\u4e0b\u6587\u3002`;
+                await this.sendMessage(chatId, text).catch(() => { });
+            }
+            else if (pct < threshold - 5) {
+                // Re-arm once usage clearly dropped (hysteresis to avoid flapping).
+                this.contextAlerted.set(chatId, false);
+            }
+        }
+        catch {
+            // best-effort; never block delivery
+        }
+    }
+    /** True when the agent's reply is exactly a completion phrase (zh or en,
+     *  tolerant of trailing punctuation/whitespace and case). */
+    /**
+     * True when the agent's reply means “done”. We accept the exact phrase as well
+     * as common wrappers (“已经结束了” / “好的，结束了” / “yes, DONE”), but reject it
+     * when a negation/not-finished cue is present (“还没结束” / “not done”), so a
+     * “still working” answer never counts as completion.
+     */
+    isDonePhrase(text) {
+        const raw = (text || "").trim();
+        if (!raw)
+            return false;
+        // Short replies only — a long continuation is the model working, not confirming.
+        if (raw.length > 24)
+            return false;
+        const stripped = raw.replace(/[。.!！~～\s“”"'，,]+/gu, "");
+        const zh = AUTO_RETRY_DONE_PHRASE; // e.g. 结束了
+        const en = AUTO_RETRY_DONE_PHRASE_EN.toUpperCase(); // e.g. DONE
+        const hasDone = stripped.includes(zh) || stripped.toUpperCase().includes(en);
+        if (!hasDone)
+            return false;
+        // Reject if a not-finished / negation cue is present.
+        if (/(没|未|不|还在|继续|not|isn'?t|aren'?t|no[t\s])/iu.test(raw))
+            return false;
+        return true;
+    }
+    /**
+     * Auto-retry loop: if `reply` looks truncated, ask the same session whether it
+     * finished. The session is the arbiter: if it replies exactly the done phrase,
+     * the ORIGINAL reply was the real result and we deliver that. Otherwise the
+     * session kept working and its new output becomes the latest reply, which we
+     * re-check. Loops until the session confirms completion, a reply no longer
+     * looks truncated, the budget is spent, or the session cannot answer.
+     */
+    async autoRetryUntilComplete(params) {
+        const { chatId, sessionKey, senderName, triggerId, lastHumanMessageId, isNativeCommandTrigger, liveStatus } = params;
+        let reply = params.initialReply ?? "";
+        // Whether we still owe at least one probe regardless of how `reply` looks.
+        // The timeout path starts in this state (no reply to inspect yet).
+        let forceProbe = params.initialError !== undefined && !params.initialReply;
+        if (!autoRetryEnabled() || isNativeCommandTrigger) {
+            if (forceProbe)
+                throw new Error(`Agent error: ${params.initialError}`);
+            return reply;
+        }
+        const maxRetry = autoRetryMax();
+        let compacted = false; // auto-compact at most once per auto-retry round
+        let probedAtLeastOnce = false;
+        for (let attempt = 1; attempt <= maxRetry; attempt++) {
+            if (!forceProbe) {
+                const parsed = this.extractBridgeAttachments(reply);
+                const trimmed = parsed.text.trim();
+                // Hard rule: a reply that produced attachments (image/file/doc) is a
+                // finished product — never auto-retry it (and never risk dropping the
+                // bridge attachment marker by replacing `reply` with a probe answer).
+                if (parsed.attachments.length > 0)
+                    return reply;
+                // Only engage for plausibly-successful-but-truncated text. Empty/NO_REPLY
+                // and runtime failures have their own handling upstream.
+                if (!trimmed || trimmed.toUpperCase() === "NO_REPLY" || this.isRuntimeFailureText(trimmed))
+                    return reply;
+                if (!this.looksTruncated(trimmed))
+                    return reply;
+            }
+            forceProbe = false; // consumed; subsequent rounds inspect the probe reply
+            const en = this.isEn(chatId);
+            await liveStatus?.progress(en
+                ? `⚠️ Reply looks incomplete — auto-checking (${attempt}/${maxRetry})…`
+                : `⚠️ 疑似任务未完成，正在自动重试（${attempt}/${maxRetry}）…`).catch(() => { });
+            // One short line, in the user's own voice (we intentionally do not change
+            // senderName). Each locale uses its own done-phrase so the English probe
+            // stays fully English; detection accepts both phrases.
+            const probe = en
+                ? `Is that done? If so just reply "${AUTO_RETRY_DONE_PHRASE_EN}", otherwise keep going.`
+                : `刚才那个任务结束了吗？结束了就回我“${AUTO_RETRY_DONE_PHRASE}”，没结束就接着做。`;
+            let probeReply;
+            try {
+                probeReply = await this.withSessionHealthMonitor(chatId, lastHumanMessageId, triggerId, this.openclawClient.chatSendWithContext({
+                    sessionKey,
+                    unsyncedMessages: [],
+                    currentMessage: probe,
+                    currentSenderName: senderName,
+                    deliver: false,
+                    timeoutMs: 1_800_000,
+                    includeContext: false,
+                    includeBridgeAttachmentHint: false,
+                    onProgress: (event) => liveStatus?.progress(event),
+                }));
+                probedAtLeastOnce = true;
+            }
+            catch (err) {
+                // Confirmation round failed (timeout/unhealthy). If the session is heavy
+                // (≥ threshold) and we have not compacted yet this round, auto-compact and
+                // keep retrying — a bloated session is the usual cause of these timeouts.
+                // Otherwise stop looping.
+                console.warn(`[${this.config.name}] auto-retry probe failed for ${chatId.slice(-8)}:`, this.errorSummary(err));
+                if (!compacted) {
+                    const pct = await this.getContextUsagePercent(sessionKey);
+                    if (pct >= autoRetryCompactPct()) {
+                        const en = this.isEn(chatId);
+                        await liveStatus?.progress(en
+                            ? `🧹 Context is large (${pct}%) and the retry failed — auto-compacting…`
+                            : `🧹 上下文过大（${pct}%）且重试出错，正在自动压缩…`).catch(() => { });
+                        try {
+                            const r = await this.compactWithFallback(sessionKey);
+                            compacted = true; // mark as attempted regardless, to avoid re-compacting in a loop
+                            if (r.compacted) {
+                                console.log(`[${this.config.name}] auto-retry: compacted session (${r.method}${r.detail ? " " + r.detail : ""}) at ${pct}% for ${chatId.slice(-8)}; continuing`);
+                                forceProbe = !reply; // if we still have no reply (timeout path), keep probing
+                                continue; // retry the probe on the now-lighter session
+                            }
+                            // Compact was a no-op; do not spin.
+                            console.warn(`[${this.config.name}] auto-retry: compact was a no-op for ${chatId.slice(-8)} (${r.reason || "no reason"})`);
+                        }
+                        catch (compactErr) {
+                            console.warn(`[${this.config.name}] auto-retry compact failed for ${chatId.slice(-8)}:`, this.errorSummary(compactErr));
+                        }
+                    }
+                }
+                // No reply to fall back to (timeout path) and retries exhausted/failed:
+                // re-throw so the caller surfaces the original failure.
+                if (!reply)
+                    throw (err instanceof Error ? err : new Error(`Agent error: ${params.initialError || "retry failed"}`));
+                return reply;
+            }
+            const probeText = this.extractBridgeAttachments(probeReply).text.trim();
+            if (!probeText || probeText.toUpperCase() === "NO_REPLY") {
+                if (!reply)
+                    throw new Error(`Agent error: ${params.initialError || "no reply after retry"}`);
+                return reply; // session could not answer; deliver existing result
+            }
+            if (this.isDonePhrase(probeText)) {
+                console.log(`[${this.config.name}] auto-retry: session confirmed done after ${attempt} check(s) for ${chatId.slice(-8)}`);
+                // On the timeout path we have no original reply; the done confirmation
+                // means the interrupted work actually finished — but we have nothing
+                // user-visible to deliver, so treat it as NO_REPLY rather than fabricate.
+                return reply || "NO_REPLY";
+            }
+            // Not done: the session kept working. Its output is the new latest reply.
+            console.log(`[${this.config.name}] auto-retry: session continued (attempt ${attempt}) for ${chatId.slice(-8)}`);
+            reply = probeReply;
+        }
+        console.warn(`[${this.config.name}] auto-retry budget (${maxRetry}) spent for ${chatId.slice(-8)}; delivering latest result`);
+        void probedAtLeastOnce;
+        if (!reply)
+            throw new Error(`Agent error: ${params.initialError || "retry budget exhausted"}`);
+        return reply;
+    }
     cancelDelayedFailure(chatId) {
         const timer = this.delayedFailureTimers.get(chatId);
         if (timer)
@@ -1940,10 +2244,24 @@ export class FeishuBot {
     }
     buildLiveStatusCard(view, chatId) {
         const en = this.isEn(chatId);
+        // 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.
+        if (view.state === "done") {
+            const statusEmoji = view.noReply ? "💤" : "✅";
+            const summary = en
+                ? `${statusEmoji} ${view.toolCalls} tool call${view.toolCalls === 1 ? "" : "s"} · ⏱ ${view.elapsed}`
+                : `${statusEmoji} 累计${view.toolCalls} 次工具调用 · ⏱ 耗时${view.elapsed}`;
+            return {
+                schema: "2.0",
+                config: { update_multi: true, width_mode: "fill" },
+                body: { elements: [{ tag: "markdown", content: `<font color='grey'>${summary}</font>` }] },
+            };
+        }
         const elements = [];
-        // Content area. While running: recent activity lines (each prefixed with the
-        // relative time mm:ss since the run started). When finished: a single run
-        // summary line (total tool calls + elapsed) instead of recent messages.
+        // Running OR failed: show the recent activity window (each line prefixed with
+        // the relative time mm:ss). On failure we deliberately KEEP the last lines so
+        // the steps leading up to the error/kill/timeout are visible for debugging.
         if (view.lines.length > 0) {
             const iconFor = (kind) => kind === "tool_start" ? "▸"
                 : kind === "tool_end" ? "✓"
@@ -1969,8 +2287,7 @@ export class FeishuBot {
         if (view.model)
             footerBits.push(`🧠 ${this.escapeCardText(view.model)}`);
         elements.push({ tag: "markdown", content: `<font color='grey'>${footerBits.join("  ·  ")}</font>` });
-        // Title color reflects state.
-        const template = view.state === "done" ? "green" : view.state === "failed" ? "orange" : "blue";
+        const template = view.state === "failed" ? "orange" : "blue";
         return {
             schema: "2.0",
             // update_multi is REQUIRED for im.message.patch to update the card; Feishu
@@ -2587,14 +2904,88 @@ export class FeishuBot {
     /**
      * Handle /compact command: compress session context.
      */
+    /**
+     * Compact a session with a fallback chain:
+     *   1. OpenClaw's native (LLM-summary) compaction — best semantics.
+     *   2. If that did not compact (or threw), fall back to "tool-trim": rewrite
+     *      the transcript file to drop tool calls/results while keeping the
+     *      conversation. This needs no model, so it works no matter how large the
+     *      session is (the native path itself fails to fit an oversized session
+     *      into the model). A backup is always written before any file change.
+     * Returns a structured result describing what happened.
+     */
+    async compactWithFallback(sessionKey) {
+        // 1. Native compaction first.
+        let nativeReason;
+        try {
+            const res = await this.openclawClient.compactSession(sessionKey);
+            if (res?.compacted === true)
+                return { compacted: true, method: "native" };
+            nativeReason = typeof res?.reason === "string" ? res.reason : undefined;
+        }
+        catch (err) {
+            nativeReason = err.message;
+        }
+        // 2. Fall back to tool-trim on the transcript file.
+        let sessionId;
+        try {
+            const info = await this.openclawClient.getSessionInfo(sessionKey);
+            sessionId = info?.session?.sessionId;
+        }
+        catch {
+            // ignore; handled below
+        }
+        if (!sessionId) {
+            return { compacted: false, method: "none", reason: nativeReason || "could not resolve session file" };
+        }
+        const filePath = resolveSessionFilePath(sessionKey, sessionId);
+        if (!filePath) {
+            return { compacted: false, method: "none", reason: nativeReason || "transcript file not found" };
+        }
+        const trim = toolTrimCompactFile(filePath, toolTrimKeepRecent());
+        if (!trim.ok) {
+            return { compacted: false, method: "none", reason: trim.reason || "tool-trim failed" };
+        }
+        const before = trim.bytesBefore || 0;
+        const after = trim.bytesAfter || 0;
+        if (before > 0 && after >= before) {
+            // Nothing meaningful trimmed.
+            return { compacted: false, method: "none", reason: trim.reason || "no tool content to trim" };
+        }
+        const pct = before > 0 ? Math.round((1 - after / before) * 100) : 0;
+        const mb = (n) => `${(n / 1024 / 1024).toFixed(1)}M`;
+        return {
+            compacted: true,
+            method: "tool-trim",
+            detail: `${mb(before)}→${mb(after)} (-${pct}%)`,
+        };
+    }
     async handleCompactCommand(chatId, messageId) {
         const sessionKey = this.getSessionKey(chatId);
+        const en = this.isEn(chatId);
         try {
-            await this.openclawClient.compactSession(sessionKey);
-            await this.replyMessage(messageId, `✅ Session 已压缩`);
+            const r = await this.compactWithFallback(sessionKey);
+            if (r.compacted) {
+                if (r.method === "tool-trim") {
+                    await this.replyMessage(messageId, en
+                        ? `✅ Session compacted (tool-trim${r.detail ? " " + r.detail : ""})`
+                        : `✅ Session 已压缩（删工具调用${r.detail ? " " + r.detail : ""}）`);
+                }
+                else {
+                    await this.replyMessage(messageId, en ? `✅ Session compacted` : `✅ Session 已压缩`);
+                }
+            }
+            else {
+                const reason = r.reason || (en ? "nothing to compact" : "无需压缩");
+                await this.replyMessage(messageId, en
+                    ? `ℹ️ Session not compacted (${reason})`
+                    : `ℹ️ Session 未压缩（${reason}）`);
+            }
         }
         catch (err) {
-            await this.replyMessage(messageId, `❌ 压缩失败: ${err.message}`);
+            await this.replyMessage(messageId, en
+                ? `❌ Compact failed: ${err.message}`
+                : `❌ 压缩失败: ${err.message}`);
         }
     }
     /**

package/dist/live-status.d.ts

@@ -16,6 +16,10 @@ export type LiveStatusView = {
     elapsed: string;
     /** Footer: model name, e.g. "phgeek-gw/claude-opus-4.8". */
     model?: string;
+    /** Total tool calls in the run (for the compact finished summary). */
+    toolCalls: number;
+    /** True when finished via noReply(): the model produced no user-visible reply. */
+    noReply: boolean;
     /** Terminal state: running / done / failed (lets renderer pick color). */
     state: "running" | "done" | "failed";
 };

package/dist/live-status.js

@@ -256,16 +256,26 @@ export class LiveStatusController {
             title = en ? `\u26A0\uFE0F ${this.opts.botName} stopped` : `\u26A0\uFE0F ${this.opts.botName} \u6267\u884c\u4e2d\u65ad`;
         else
             title = en ? `${this.opts.botName} is working` : `${this.opts.botName} \u6b63\u5728\u6267\u884c`;
-        // When finished, replace the recent-activity window with a run summary
-        // (total tool calls + total time) instead of the last few messages.
-        const lines = this.state === "running"
-            ? [...this.lines]
-            : [this.buildSummaryLine(en)];
+        // On a clean finish (done / NO_REPLY) show only the compact summary. On a
+        // failure (error / killed / timeout) keep the recent activity window too, so
+        // the last few steps before the failure are visible for debugging.
+        let lines;
+        if (this.state === "running") {
+            lines = [...this.lines];
+        }
+        else if (this.state === "failed") {
+            lines = [...this.lines, this.buildSummaryLine(en)];
+        }
+        else {
+            lines = [this.buildSummaryLine(en)];
+        }
         return {
             title,
             lines,
             elapsed: this.formatElapsed(),
             model: this.opts.model,
+            toolCalls: this.toolCallCount,
+            noReply: this.noReplyResult,
             state: this.state,
         };
     }

package/dist/openclaw-client.js

@@ -175,6 +175,17 @@ export class OpenClawClient {
                                 data: { text: textParts.join("\n") },
                             });
                         }
+                        else if (state === "error") {
+                            // A chat-level error (e.g. "Request timed out before a response")
+                            // must NOT be silently dropped — otherwise mid-run delta text gets
+                            // surfaced as if it were a normal reply and the run neither errors
+                            // nor retries. Record it so the collect loop can surface/handle it.
+                            this.agentEvents.get(sk).push({
+                                ...frame.payload,
+                                stream: "chatError",
+                                data: { error: frame.payload?.errorMessage || frame.payload?.error || "chat error" },
+                            });
+                        }
                     }
                     else {
                         this.agentEvents.get(sk).push(frame.payload);
@@ -835,6 +846,35 @@ export class OpenClawClient {
                             reject(new Error(`Agent error: ${errText}`));
                             return;
                         }
+                        if (ev.stream === "chatError") {
+                            // Chat-level error (most commonly a request timeout). Treat it like
+                            // a lifecycle error: recoverable ones defer (agent may auto-recover
+                            // and still produce a real final); otherwise reject so the bridge
+                            // 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.isRecoverableAgentError(errText)) {
+                                pendingRuntimeFailureText = `⚠️ Agent 未正常完成\n原因: ${errText}`;
+                                resetIdleTimer();
+                                console.warn(`[OpenClaw] recoverable chat error for runId=${evRunId || runId}; deferring: ${errText.slice(0, 120)}`);
+                                bucket.splice(i, 1);
+                                continue;
+                            }
+                            clearTimeout(idleTimer);
+                            clearInterval(poller);
+                            if (chatFinalTimer)
+                                clearTimeout(chatFinalTimer);
+                            if (lifecycleEndTimer)
+                                clearTimeout(lifecycleEndTimer);
+                            // 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.
+                            this.abortChat(targetSessionKey || sessionKey, evRunId || runId).catch((abortErr) => {
+                                console.warn(`[OpenClaw] abort after chat error failed:`, abortErr.message);
+                            });
+                            reject(new Error(`Agent error: ${errText}`));
+                            return;
+                        }
                     }
                 }
             }, 50);

package/dist/session-file-compactor.d.ts

@@ -0,0 +1,39 @@
+export type ToolTrimResult = {
+    ok: boolean;
+    reason?: string;
+    /** Bytes before / after, and line counts, for reporting. */
+    bytesBefore?: number;
+    bytesAfter?: number;
+    linesBefore?: number;
+    linesAfter?: number;
+    removedToolResults?: number;
+    strippedToolCalls?: number;
+    removedEmptyAssistants?: number;
+    keptRecentToolCalls?: number;
+    backupPath?: string;
+};
+/**
+ * Resolve the on-disk OpenClaw transcript file for a session.
+ *
+ * Session key looks like `agent:<agentId>:<label>` (e.g.
+ * `agent:main:lma-claude-oc_xxx`). The transcript lives at
+ * `<openclawHome>/agents/<agentId>/sessions/<sessionId>.jsonl`.
+ */
+export declare function resolveSessionFilePath(sessionKey: string, sessionId: string, openclawHome?: string): string | null;
+/**
+ * "Tool-trim" compaction: rewrite a session transcript in place, removing the
+ * tool-call noise while keeping the conversation intact:
+ *   - drop every toolResult message entirely;
+ *   - strip the `toolCall` parts from assistant messages but KEEP their text
+ *     (the model's "thinking out loud while acting"); if an assistant message
+ *     had only tool calls and no text, drop the whole line;
+ *   - fix `stopReason: "toolUse"` -> "stop" on messages that no longer have a
+ *     tool call, so the loader is not confused.
+ *
+ * This does NOT call any model, so it works no matter how large the session is
+ * (unlike OpenClaw's LLM-summary compaction, which itself fails to fit an
+ * oversized session into the model). A backup is always written first.
+ *
+ * Typical reduction is ~70-90% for tool-heavy sessions.
+ */
+export declare function toolTrimCompactFile(filePath: string, keepRecentToolCalls?: number): ToolTrimResult;

package/dist/session-file-compactor.js

@@ -0,0 +1,176 @@
+import { existsSync, copyFileSync, readFileSync, writeFileSync, renameSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+/**
+ * Resolve the on-disk OpenClaw transcript file for a session.
+ *
+ * Session key looks like `agent:<agentId>:<label>` (e.g.
+ * `agent:main:lma-claude-oc_xxx`). The transcript lives at
+ * `<openclawHome>/agents/<agentId>/sessions/<sessionId>.jsonl`.
+ */
+export function resolveSessionFilePath(sessionKey, sessionId, openclawHome) {
+    if (!sessionId)
+        return null;
+    const home = openclawHome
+        || process.env.OPENCLAW_HOME
+        || process.env.OPENCLAW_CONFIG_DIR
+        || join(homedir(), ".openclaw");
+    // agentId is the second segment of agent:<agentId>:<label>; default to "main".
+    const parts = sessionKey.split(":");
+    const agentId = parts.length >= 3 && parts[0] === "agent" ? parts[1] : "main";
+    const file = join(home, "agents", agentId, "sessions", `${sessionId}.jsonl`);
+    return existsSync(file) ? file : null;
+}
+/**
+ * "Tool-trim" compaction: rewrite a session transcript in place, removing the
+ * tool-call noise while keeping the conversation intact:
+ *   - drop every toolResult message entirely;
+ *   - strip the `toolCall` parts from assistant messages but KEEP their text
+ *     (the model's "thinking out loud while acting"); if an assistant message
+ *     had only tool calls and no text, drop the whole line;
+ *   - fix `stopReason: "toolUse"` -> "stop" on messages that no longer have a
+ *     tool call, so the loader is not confused.
+ *
+ * This does NOT call any model, so it works no matter how large the session is
+ * (unlike OpenClaw's LLM-summary compaction, which itself fails to fit an
+ * oversized session into the model). A backup is always written first.
+ *
+ * Typical reduction is ~70-90% for tool-heavy sessions.
+ */
+export function toolTrimCompactFile(filePath, keepRecentToolCalls = 3) {
+    if (!existsSync(filePath))
+        return { ok: false, reason: "transcript file not found" };
+    const original = readFileSync(filePath, "utf8");
+    const lines = original.split("\n");
+    const bytesBefore = Buffer.byteLength(original, "utf8");
+    // First pass: collect every toolCall id in order, so we can keep the most
+    // recent N of them (and their matching toolResults) intact. Recent tool calls
+    // are often still relevant to what the agent is doing next.
+    const toolCallIds = [];
+    for (const line of lines) {
+        if (line.trim() === "")
+            continue;
+        let d;
+        try {
+            d = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (d?.type !== "message")
+            continue;
+        const msg = d.message;
+        if (msg?.role === "assistant" && Array.isArray(msg.content)) {
+            for (const p of msg.content) {
+                if (p && typeof p === "object" && p.type === "toolCall" && p.id)
+                    toolCallIds.push(String(p.id));
+            }
+        }
+    }
+    const keepN = Math.max(0, Math.floor(keepRecentToolCalls));
+    const keepIds = new Set(keepN > 0 ? toolCallIds.slice(-keepN) : []);
+    const out = [];
+    let removedToolResults = 0;
+    let strippedToolCalls = 0;
+    let removedEmptyAssistants = 0;
+    let keptRecentToolCalls = 0;
+    let linesBefore = 0;
+    for (const line of lines) {
+        if (line.trim() === "") {
+            continue;
+        } // drop blank lines; we re-join with \n
+        linesBefore++;
+        let d;
+        try {
+            d = JSON.parse(line);
+        }
+        catch {
+            out.push(line);
+            continue;
+        }
+        if (d?.type !== "message") {
+            out.push(line);
+            continue;
+        }
+        const msg = d.message;
+        const role = msg?.role;
+        if (role === "toolResult") {
+            // Keep the toolResult only if its toolCall is in the recent keep-set.
+            if (msg?.toolCallId && keepIds.has(String(msg.toolCallId))) {
+                out.push(line);
+                continue;
+            }
+            removedToolResults++;
+            continue;
+        }
+        if (role === "assistant" && Array.isArray(msg?.content)) {
+            const content = msg.content;
+            const hasToolCall = content.some((p) => p && typeof p === "object" && p.type === "toolCall");
+            if (hasToolCall) {
+                // Keep toolCalls that are in the recent keep-set; strip the rest.
+                const kept = content.filter((p) => {
+                    if (!p || typeof p !== "object")
+                        return false;
+                    if (p.type !== "toolCall")
+                        return true;
+                    return p.id && keepIds.has(String(p.id));
+                });
+                const keptToolCall = kept.some((p) => p.type === "toolCall");
+                const hasText = kept.some((p) => p.type === "text" && typeof p.text === "string" && p.text.trim() !== "");
+                if (!keptToolCall && !hasText) {
+                    removedEmptyAssistants++;
+                    continue;
+                }
+                if (keptToolCall) {
+                    keptRecentToolCalls++;
+                    // stopReason stays toolUse since a toolCall remains.
+                    if (kept.length !== content.length)
+                        msg.content = kept;
+                    out.push(JSON.stringify(d));
+                    continue;
+                }
+                // All toolCalls stripped: keep text only, fix stopReason.
+                msg.content = kept;
+                if (msg.stopReason === "toolUse")
+                    msg.stopReason = "stop";
+                strippedToolCalls++;
+                out.push(JSON.stringify(d));
+                continue;
+            }
+        }
+        out.push(line);
+    }
+    // Safety: verify every output line is valid JSON before committing.
+    for (const l of out) {
+        try {
+            JSON.parse(l);
+        }
+        catch {
+            return { ok: false, reason: "produced invalid JSON; aborted" };
+        }
+    }
+    if (removedToolResults === 0 && strippedToolCalls === 0 && removedEmptyAssistants === 0) {
+        return { ok: true, reason: "no tool content to trim", bytesBefore, bytesAfter: bytesBefore, linesBefore, linesAfter: out.length, keptRecentToolCalls };
+    }
+    // Always back up first.
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const backupPath = `${filePath}.bak-tooltrim-${stamp}`;
+    copyFileSync(filePath, backupPath);
+    // Atomic write: temp file + rename.
+    const body = out.join("\n") + "\n";
+    const tmp = `${filePath}.tmp-tooltrim`;
+    writeFileSync(tmp, body, "utf8");
+    renameSync(tmp, filePath);
+    return {
+        ok: true,
+        bytesBefore,
+        bytesAfter: Buffer.byteLength(body, "utf8"),
+        linesBefore,
+        linesAfter: out.length,
+        removedToolResults,
+        strippedToolCalls,
+        removedEmptyAssistants,
+        keptRecentToolCalls,
+        backupPath,
+    };
+}

package/package.json

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