openclaw-lark-multi-agent 1.1.2 → 1.2.1

package/dist/feishu-bot.js

@@ -3,11 +3,13 @@ import { createRequire } from "module";
 import { persistBotModel } from "./config.js";
 import { getI18n, normalizeLocale } from "./i18n.js";
 import { LiveStatusController } from "./live-status.js";
+import { CompactProgressController } from "./compact-progress.js";
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
 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 +19,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 +80,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 +1244,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 +1276,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 +1387,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 +1667,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,25 +2245,24 @@ export class FeishuBot {
     }
     buildLiveStatusCard(view, chatId) {
         const en = this.isEn(chatId);
-        // Finished (done/failed): keep it minimal — no header, no footer, just one
-        // compact body line with three signals: status emoji + tool-call count +
-        // total elapsed. This avoids taking up much screen space after the run ends.
-        if (view.state !== "running") {
-            const statusEmoji = view.state === "failed" ? "⚠️" : view.noReply ? "💤" : "✅";
+        // 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}`;
-            // Grey + small like the footer, so the finished card stays unobtrusive.
-            const compact = `<font color='grey'>${summary}</font>`;
             return {
                 schema: "2.0",
                 config: { update_multi: true, width_mode: "fill" },
-                body: { elements: [{ tag: "markdown", content: compact }] },
+                body: { elements: [{ tag: "markdown", content: `<font color='grey'>${summary}</font>` }] },
             };
         }
         const elements = [];
-        // Running: recent activity lines (each prefixed with the relative time mm:ss
-        // since the run started).
+        // 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" ? "✓"
@@ -1984,6 +2288,7 @@ export class FeishuBot {
         if (view.model)
             footerBits.push(`🧠 ${this.escapeCardText(view.model)}`);
         elements.push({ tag: "markdown", content: `<font color='grey'>${footerBits.join("  ·  ")}</font>` });
+        const template = view.state === "failed" ? "orange" : "blue";
         return {
             schema: "2.0",
             // update_multi is REQUIRED for im.message.patch to update the card; Feishu
@@ -1991,7 +2296,7 @@ export class FeishuBot {
             config: { update_multi: true, width_mode: "fill" },
             header: {
                 title: { tag: "plain_text", content: view.title },
-                template: "blue",
+                template,
             },
             body: { elements },
         };
@@ -2035,6 +2340,73 @@ export class FeishuBot {
             data: { content: JSON.stringify(this.buildLiveStatusCard(view, chatId)) },
         });
     }
+    /**
+     * Render the /compact progress card. While running it shows a phase line plus a
+     * ticking elapsed footer so the user can see compaction is in progress; when
+     * terminal it collapses to a single compact line (success/skip/fail).
+     */
+    buildCompactProgressCard(view, chatId) {
+        const en = this.isEn(chatId);
+        if (view.state !== "running") {
+            let line;
+            if (view.state === "done") {
+                line = en
+                    ? `✅ Session compacted${view.detail ? ` (${view.detail})` : ""} · ⏱ ${view.elapsed}`
+                    : `✅ Session 已压缩${view.detail ? `（${view.detail}）` : ""} · ⏱ 耗时 ${view.elapsed}`;
+            }
+            else if (view.state === "noop") {
+                line = en
+                    ? `ℹ️ Session not compacted${view.detail ? ` (${view.detail})` : ""}`
+                    : `ℹ️ Session 未压缩${view.detail ? `（${view.detail}）` : ""}`;
+            }
+            else {
+                line = en
+                    ? `❌ Compact failed${view.detail ? `: ${view.detail}` : ""}`
+                    : `❌ 压缩失败${view.detail ? `：${view.detail}` : ""}`;
+            }
+            return {
+                schema: "2.0",
+                config: { update_multi: true, width_mode: "fill" },
+                body: { elements: [{ tag: "markdown", content: `<font color='grey'>${this.escapeCardText(line)}</font>` }] },
+            };
+        }
+        // Running: phase line + ticking elapsed footer.
+        const phaseLine = view.phase === "tool-trim"
+            ? (en ? "🧹 Native compaction is slow — switching to fast trim…" : "🧹 原生压缩较慢，已切换快速压缩…")
+            : (en ? "🧹 Compacting session…" : "🧹 正在压缩 session…");
+        const footer = en ? `⏱ ${view.elapsed}` : `⏱ 已用 ${view.elapsed}`;
+        return {
+            schema: "2.0",
+            config: { update_multi: true, width_mode: "fill" },
+            header: {
+                title: { tag: "plain_text", content: en ? "Compacting" : "正在压缩" },
+                template: "blue",
+            },
+            body: {
+                elements: [
+                    { tag: "markdown", content: this.escapeCardText(phaseLine) },
+                    { tag: "hr" },
+                    { tag: "markdown", content: `<font color='grey'>${footer}</font>` },
+                ],
+            },
+        };
+    }
+    async replyCompactCard(messageId, view, chatId) {
+        const res = await this.client.im.message.reply({
+            path: { message_id: messageId },
+            data: {
+                content: JSON.stringify(this.buildCompactProgressCard(view, chatId)),
+                msg_type: "interactive",
+            },
+        });
+        return res?.data?.message_id || res?.message_id;
+    }
+    async patchCompactCard(messageId, view, chatId) {
+        await this.client.im.message.patch({
+            path: { message_id: messageId },
+            data: { content: JSON.stringify(this.buildCompactProgressCard(view, chatId)) },
+        });
+    }
     async sendTextMessage(chatId, text) {
         try {
             const res = await this.client.im.message.create({
@@ -2600,14 +2972,115 @@ 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, onPhase) {
+        // 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. Tell the caller so a
+        //    progress card can flip from "compacting" to "fast-trim" (this is the
+        //    slow→still-working transition the user most needs to see).
+        onPhase?.("tool-trim");
+        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);
+        // Large sessions can take tens of seconds to compact (native compaction may
+        // even time out before the tool-trim fallback kicks in). Show a ticking
+        // "compacting…" card so the user can SEE it is working instead of staring at
+        // nothing and assuming nothing is happening. The card is created lazily, so
+        // a fast compaction that finishes quickly never flashes a card at all.
+        const progress = new CompactProgressController({
+            create: (view) => this.sendOrdered(chatId, () => this.replyCompactCard(messageId, view, chatId)),
+            edit: (id, view) => this.sendOrdered(chatId, () => this.patchCompactCard(id, view, chatId)),
+            warn: (msg, err) => console.warn(`[${this.config.name}] ${msg}`, err instanceof Error ? err.message : err),
+        }, { locale: en ? "en" : "zh" });
+        progress.start();
         try {
-            await this.openclawClient.compactSession(sessionKey);
-            await this.replyMessage(messageId, `✅ Session 已压缩`);
+            const r = await this.compactWithFallback(sessionKey, (phase) => {
+                if (phase === "tool-trim")
+                    void progress.toToolTrim().catch(() => { });
+            });
+            if (r.compacted) {
+                // If a card was shown, patch it in place; otherwise (fast finish, no card)
+                // fall back to a normal reply so the user still gets confirmation.
+                const detail = r.method === "tool-trim" && r.detail
+                    ? (en ? `tool-trim ${r.detail}` : `删工具调用 ${r.detail}`)
+                    : (en ? "native" : "原生压缩");
+                await progress.done(detail);
+                if (!progress.id) {
+                    await this.replyMessage(messageId, r.method === "tool-trim"
+                        ? (en ? `✅ Session compacted (tool-trim${r.detail ? " " + r.detail : ""})` : `✅ Session 已压缩（删工具调用${r.detail ? " " + r.detail : ""}）`)
+                        : (en ? `✅ Session compacted` : `✅ Session 已压缩`));
+                }
+            }
+            else {
+                const reason = r.reason || (en ? "nothing to compact" : "无需压缩");
+                await progress.noop(reason);
+                if (!progress.id) {
+                    await this.replyMessage(messageId, en
+                        ? `ℹ️ Session not compacted (${reason})`
+                        : `ℹ️ Session 未压缩（${reason}）`);
+                }
+            }
         }
         catch (err) {
-            await this.replyMessage(messageId, `❌ 压缩失败: ${err.message}`);
+            const reason = err.message;
+            await progress.fail(reason);
+            if (!progress.id) {
+                await this.replyMessage(messageId, en
+                    ? `❌ Compact failed: ${reason}`
+                    : `❌ 压缩失败: ${reason}`);
+            }
         }
     }
     /**

package/dist/live-status.js

@@ -256,11 +256,19 @@ 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,