openclaw-lark-multi-agent 1.2.0 → 1.2.2

package/dist/compact-progress.d.ts

@@ -0,0 +1,75 @@
+/** Coarse phase of the compaction flow, drives the card's primary line. */
+export type CompactPhase = "native" | "tool-trim";
+/** Terminal outcome used by the renderer to pick color/emoji. */
+export type CompactState = "running" | "done" | "failed" | "noop";
+/** Structured snapshot the renderer turns into a Feishu interactive card. */
+export type CompactProgressView = {
+    state: CompactState;
+    /** Current phase while running (ignored once terminal). */
+    phase: CompactPhase;
+    /** Elapsed time like "0:42". */
+    elapsed: string;
+    /** Terminal detail line, e.g. "12.3M→4.1M (-67%)" or an error/skip reason. */
+    detail?: string;
+};
+export type CompactProgressCallbacks = {
+    /** Create the status card; returns the new message id (undefined disables). */
+    create: (view: CompactProgressView) => Promise<string | undefined>;
+    /** Patch the existing status card. */
+    edit: (messageId: string, view: CompactProgressView) => Promise<void>;
+    warn?: (message: string, err?: unknown) => void;
+};
+export type CompactProgressOptions = {
+    locale?: "zh" | "en";
+    /** Delay before the card first appears, to avoid flashing on fast compactions. */
+    delayMs?: number;
+    /** Footer/auto-refresh cadence in ms. */
+    tickMs?: number;
+};
+/**
+ * Lifecycle: start() → (optional) toToolTrim() when native gives up → one of
+ * done()/noop()/fail(). The card is created lazily after `delayMs` so a fast
+ * compaction that finishes first never shows a card at all. All terminal calls
+ * are idempotent and safe even if the card was never created.
+ */
+export declare class CompactProgressController {
+    private readonly callbacks;
+    private readonly opts;
+    private messageId?;
+    private startedAt;
+    private phase;
+    private state;
+    private detail?;
+    private createTimer?;
+    private tickTimer?;
+    private createPromise?;
+    private finalized;
+    private disabled;
+    private lastSignature;
+    constructor(callbacks: CompactProgressCallbacks, opts?: CompactProgressOptions);
+    get id(): string | undefined;
+    /** Begin the flow; schedules lazy card creation after delayMs. */
+    start(): void;
+    /** Native compaction gave up (timeout/no-op); switch the card to fast-trim. */
+    toToolTrim(): Promise<void>;
+    /** Finished successfully; patch the card to the done state with a detail line. */
+    done(detail?: string): Promise<void>;
+    /** Nothing to compact; patch the card to a neutral "no-op" state. */
+    noop(detail?: string): Promise<void>;
+    /** Failed; patch the card to the failed state with an error detail line. */
+    fail(detail?: string): Promise<void>;
+    /** Tear down timers without sending anything (e.g. on unexpected disposal). */
+    dispose(): void;
+    private finish;
+    private refresh;
+    private ensureCreatedNow;
+    private ensureCreated;
+    /** Refresh the elapsed-time footer periodically even with no phase change. */
+    private startTicker;
+    private safeEdit;
+    private stopTimers;
+    /** Dedupe key; includes elapsed so the ticking footer still advances. */
+    private signature;
+    private formatElapsed;
+    buildView(): CompactProgressView;
+}

package/dist/compact-progress.js

@@ -0,0 +1,177 @@
+// A tiny live-status controller dedicated to the /compact (and auto-compact)
+// flow, so the user gets a visible "正在压缩…" card that ticks while a large
+// session is being compacted — instead of staring at nothing for tens of
+// seconds while native compaction grinds (and sometimes times out).
+//
+// It deliberately does NOT reuse LiveStatusController: that one models a tool
+// run (activity window, tool-call count, model footer). Compaction has just a
+// few coarse phases and a single elapsed timer, so a focused, self-contained
+// controller keeps the card clean and the logic trivial to test.
+const DEFAULT_DELAY_MS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_COMPACT_STATUS_DELAY_MS || 500);
+const DEFAULT_TICK_MS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_COMPACT_STATUS_TICK_MS || 1000);
+/**
+ * Lifecycle: start() → (optional) toToolTrim() when native gives up → one of
+ * done()/noop()/fail(). The card is created lazily after `delayMs` so a fast
+ * compaction that finishes first never shows a card at all. All terminal calls
+ * are idempotent and safe even if the card was never created.
+ */
+export class CompactProgressController {
+    callbacks;
+    opts;
+    messageId;
+    startedAt = Date.now();
+    phase = "native";
+    state = "running";
+    detail;
+    createTimer;
+    tickTimer;
+    createPromise;
+    finalized = false;
+    disabled = false;
+    lastSignature = "";
+    constructor(callbacks, opts = {}) {
+        this.callbacks = callbacks;
+        this.opts = opts;
+    }
+    get id() { return this.messageId; }
+    /** Begin the flow; schedules lazy card creation after delayMs. */
+    start() {
+        if (this.disabled || this.finalized || this.createTimer || this.messageId)
+            return;
+        this.startedAt = Date.now();
+        this.createTimer = setTimeout(() => {
+            this.createTimer = undefined;
+            this.createPromise = this.ensureCreated();
+        }, this.opts.delayMs ?? DEFAULT_DELAY_MS);
+        this.createTimer.unref?.();
+    }
+    /** Native compaction gave up (timeout/no-op); switch the card to fast-trim. */
+    async toToolTrim() {
+        if (this.finalized || this.phase === "tool-trim")
+            return;
+        this.phase = "tool-trim";
+        await this.refresh();
+    }
+    /** Finished successfully; patch the card to the done state with a detail line. */
+    async done(detail) {
+        await this.finish("done", detail);
+    }
+    /** Nothing to compact; patch the card to a neutral "no-op" state. */
+    async noop(detail) {
+        await this.finish("noop", detail);
+    }
+    /** Failed; patch the card to the failed state with an error detail line. */
+    async fail(detail) {
+        await this.finish("failed", detail);
+    }
+    /** Tear down timers without sending anything (e.g. on unexpected disposal). */
+    dispose() {
+        this.finalized = true;
+        this.stopTimers();
+    }
+    async finish(state, detail) {
+        if (this.finalized)
+            return;
+        this.state = state;
+        this.detail = detail;
+        this.finalized = true;
+        this.stopTimers();
+        // Wait for any in-flight lazy create so we can patch (not orphan) the card.
+        if (this.createPromise)
+            await this.createPromise.catch(() => { });
+        if (!this.messageId || this.disabled)
+            return;
+        await this.safeEdit(true);
+    }
+    async refresh() {
+        if (this.finalized || this.disabled)
+            return;
+        await this.ensureCreatedNow();
+        await this.safeEdit();
+    }
+    async ensureCreatedNow() {
+        if (this.createTimer) {
+            clearTimeout(this.createTimer);
+            this.createTimer = undefined;
+            this.createPromise = this.ensureCreated();
+        }
+        if (this.createPromise)
+            await this.createPromise.catch(() => { });
+    }
+    async ensureCreated() {
+        if (this.disabled || this.finalized || this.messageId)
+            return;
+        try {
+            const id = await this.callbacks.create(this.buildView());
+            if (!id) {
+                this.disabled = true;
+                return;
+            }
+            this.messageId = id;
+            this.lastSignature = this.signature();
+            this.startTicker();
+        }
+        catch (err) {
+            this.disabled = true;
+            this.callbacks.warn?.("compact progress create failed", err);
+        }
+    }
+    /** Refresh the elapsed-time footer periodically even with no phase change. */
+    startTicker() {
+        if (this.tickTimer || this.disabled || this.finalized)
+            return;
+        const tickMs = this.opts.tickMs ?? DEFAULT_TICK_MS;
+        this.tickTimer = setInterval(() => {
+            if (this.finalized || this.disabled || !this.messageId)
+                return;
+            void this.safeEdit();
+        }, tickMs);
+        this.tickTimer.unref?.();
+    }
+    async safeEdit(force = false) {
+        if (!this.messageId || this.disabled)
+            return;
+        if (!force && this.finalized)
+            return;
+        const sig = this.signature();
+        if (!force && sig === this.lastSignature)
+            return;
+        try {
+            await this.callbacks.edit(this.messageId, this.buildView());
+            this.lastSignature = sig;
+        }
+        catch (err) {
+            this.disabled = true;
+            this.stopTimers();
+            this.callbacks.warn?.("compact progress edit failed", err);
+        }
+    }
+    stopTimers() {
+        if (this.createTimer) {
+            clearTimeout(this.createTimer);
+            this.createTimer = undefined;
+        }
+        if (this.tickTimer) {
+            clearInterval(this.tickTimer);
+            this.tickTimer = undefined;
+        }
+    }
+    /** Dedupe key; includes elapsed so the ticking footer still advances. */
+    signature() {
+        return `${this.state}|${this.phase}|${this.formatElapsed()}|${this.detail || ""}`;
+    }
+    formatElapsed() {
+        const totalSec = Math.max(0, Math.floor((Date.now() - this.startedAt) / 1000));
+        const m = Math.floor(totalSec / 60);
+        const s = totalSec % 60;
+        return `${m}:${String(s).padStart(2, "0")}`;
+    }
+    buildView() {
+        return {
+            state: this.state,
+            phase: this.phase,
+            elapsed: this.formatElapsed(),
+            detail: this.detail,
+        };
+    }
+}

package/dist/feishu-bot.d.ts

@@ -135,6 +135,18 @@ export declare class FeishuBot {
      * provides one for normal-looking-but-truncated finals).
      */
     private looksTruncated;
+    /**
+     * Did the model type a tool call as plain text instead of emitting a real
+     * function call? When that happens the visible reply ends with a dangling
+     * invoke / parameter / function_calls tag (with or without the `antml:`
+     * prefix), because the tool-call markup leaked into the text channel and the
+     * tool never actually ran. We detect such a tag anchored at the END of the
+     * message — that dangling tag is the tell-tale Stephen flagged ("如果监测到
+     * 这个结尾，说明 tool call 格式出了问题"). On detection the auto-retry loop
+     * sends an explicit "invoke 格式错了，请重试" probe so the agent re-issues the
+     * tool call correctly rather than the generic done-check.
+     */
+    private looksLikeBrokenToolCall;
     /** Current context usage percent for a session (totalTokens / contextTokens),
      *  or 0 if it cannot be determined. Same basis as /status. */
     private getContextUsagePercent;
@@ -200,12 +212,48 @@ export declare class FeishuBot {
     private sendLiveStatusCard;
     private replyLiveStatusCard;
     private patchLiveStatusCard;
+    /**
+     * 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).
+     */
+    private buildCompactProgressCard;
+    private replyCompactCard;
+    private patchCompactCard;
     private sendTextMessage;
     private replyTextMessage;
     private editTextMessage;
     private deleteMessageById;
     private replyMessage;
     private extractBridgeAttachments;
+    /**
+     * Locate one bridge-attachment marker in `text` and recover its JSON payload,
+     * tolerating arbitrary corruption of the OPENING tag (lost prefix, or no
+     * opening tag at all). Strategy:
+     *   1. Find a closing tag — the full `</LMA_BRIDGE_ATTACHMENTS>`, or a partial
+     *      suffix of it (e.g. `_BRIDGE_ATTACHMENTS>`, `RIDGE_ATTACHMENTS>`), or the
+     *      `</parameter>` the marker sometimes degrades into.
+     *   2. From just before that closer, brace-match BACKWARDS to the start of the
+     *      JSON value (`{...}` or `[...]`), so the opening marker is irrelevant.
+     *   3. Return the span to strip [start,end) plus the extracted JSON string.
+     * `start` extends left to swallow any leftover opening-marker remnant (so no
+     * `RIDGE_ATTACHMENTS>` text leaks into the visible reply).
+     */
+    private findBridgeAttachmentMarker;
+    /**
+     * Regex matching a trailing remnant of the opening marker `<LMA_BRIDGE_ATTACHMENTS>`
+     * at the END of a string. Built from every suffix of the full marker so that
+     * however many leading characters the model dropped (`_BRIDGE_ATTACHMENTS>`,
+     * `RIDGE_ATTACHMENTS>`, `>` …), the leftover is fully stripped from the visible
+     * text. Trailing `>` and surrounding whitespace are also consumed.
+     */
+    private openMarkerRemnant;
+    /**
+     * Given the index of a closing tag, walk backwards to extract the balanced
+     * JSON value (`{...}` or `[...]`) that ends just before it. Returns the JSON
+     * string and its start offset, or null if no balanced value is found.
+     */
+    private extractJsonBeforeIndex;
     private pushBridgeAttachment;
     private validateBridgeAttachmentPath;
     private inferFeishuFileType;

package/dist/feishu-bot.js

@@ -3,6 +3,7 @@ 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";
@@ -28,6 +29,14 @@ function autoRetryMax() { return Number(process.env.OPENCLAW_LARK_MULTI_AGENT_AU
 // 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 the previous reply ended with a dangling tool-call tag (the model typed
+// an invoke/tool call as plain text and it never ran), the auto-retry probe
+// explicitly tells the agent its invoke format was broken and to retry, instead
+// of the generic done-check. It still accepts the done phrase if actually done.
+const AUTO_RETRY_BROKEN_TOOL_PROBE = process.env.OPENCLAW_LARK_MULTI_AGENT_AUTO_RETRY_BROKEN_TOOL_PROBE
+    || `刚才的任务是不是没结束，invoke 格式错了，invoke 格式错了，请重试。如果结束了，回复“${AUTO_RETRY_DONE_PHRASE}”。`;
+const AUTO_RETRY_BROKEN_TOOL_PROBE_EN = process.env.OPENCLAW_LARK_MULTI_AGENT_AUTO_RETRY_BROKEN_TOOL_PROBE_EN
+    || `Your last task did not finish — the invoke format was broken, the invoke format was broken, please retry. If it is actually done, reply "${AUTO_RETRY_DONE_PHRASE_EN}".`;
 // 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.
@@ -1709,6 +1718,23 @@ export class FeishuBot {
             || /[}\]]\s*$/.test(t);
         return !endOk;
     }
+    /**
+     * Did the model type a tool call as plain text instead of emitting a real
+     * function call? When that happens the visible reply ends with a dangling
+     * invoke / parameter / function_calls tag (with or without the `antml:`
+     * prefix), because the tool-call markup leaked into the text channel and the
+     * tool never actually ran. We detect such a tag anchored at the END of the
+     * message — that dangling tag is the tell-tale Stephen flagged ("如果监测到
+     * 这个结尾，说明 tool call 格式出了问题"). On detection the auto-retry loop
+     * sends an explicit "invoke 格式错了，请重试" probe so the agent re-issues the
+     * tool call correctly rather than the generic done-check.
+     */
+    looksLikeBrokenToolCall(text) {
+        const t = (text || "").trim();
+        if (!t)
+            return false;
+        return /<\/?\s*(?:antml:)?(?:invoke|parameter|function_calls)\b[^>]*>\s*$/i.test(t);
+    }
     /** Current context usage percent for a session (totalTokens / contextTokens),
      *  or 0 if it cannot be determined. Same basis as /status. */
     async getContextUsagePercent(sessionKey) {
@@ -1807,7 +1833,12 @@ export class FeishuBot {
         const maxRetry = autoRetryMax();
         let compacted = false; // auto-compact at most once per auto-retry round
         let probedAtLeastOnce = false;
+        // Set per-iteration when the reply under inspection ended with a dangling
+        // tool-call tag (model typed an invoke as plain text); selects the explicit
+        // "invoke format was broken, retry" probe instead of the generic done-check.
+        let brokenToolCall = false;
         for (let attempt = 1; attempt <= maxRetry; attempt++) {
+            brokenToolCall = false;
             if (!forceProbe) {
                 const parsed = this.extractBridgeAttachments(reply);
                 const trimmed = parsed.text.trim();
@@ -1820,20 +1851,32 @@ export class FeishuBot {
                 // and runtime failures have their own handling upstream.
                 if (!trimmed || trimmed.toUpperCase() === "NO_REPLY" || this.isRuntimeFailureText(trimmed))
                     return reply;
-                if (!this.looksTruncated(trimmed))
+                // A dangling invoke/tool-call tag is a strong "tool call leaked as text"
+                // signal — engage even if the generic truncation heuristic would miss it.
+                brokenToolCall = this.looksLikeBrokenToolCall(trimmed);
+                if (!this.looksTruncated(trimmed) && !brokenToolCall)
                     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(() => { });
+                ? (brokenToolCall
+                    ? `⚠️ Tool-call format looked broken — asking it to retry (${attempt}/${maxRetry})…`
+                    : `⚠️ Reply looks incomplete — auto-checking (${attempt}/${maxRetry})…`)
+                : (brokenToolCall
+                    ? `⚠️ 工具调用格式疑似出错，正在让它重试（${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}”，没结束就接着做。`;
+            // stays fully English; detection accepts both phrases. When the previous
+            // reply ended with a dangling tool-call tag, send the explicit "invoke
+            // format was broken, retry" probe instead of the generic done-check so the
+            // agent re-issues the tool call correctly.
+            const probe = brokenToolCall
+                ? (en ? AUTO_RETRY_BROKEN_TOOL_PROBE_EN : AUTO_RETRY_BROKEN_TOOL_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({
@@ -2339,6 +2382,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({
@@ -2407,24 +2517,47 @@ export class FeishuBot {
     }
     extractBridgeAttachments(reply) {
         const attachments = [];
-        // Some models occasionally corrupt the attachment marker while preserving
-        // the exact JSON payload: the closing tag can become </parameter>, or the
-        // opening "<LMA" prefix can be truncated leaving "_BRIDGE_ATTACHMENTS>".
-        // Treat these as recoverable shapes; otherwise the marker leaks as
-        // user-visible text and attachments are not sent.
-        const markerPattern = /(?:<LMA_BRIDGE_ATTACHMENTS>|_BRIDGE_ATTACHMENTS>)([\s\S]*?)(?:<\/LMA_BRIDGE_ATTACHMENTS>|<\/parameter>)/g;
-        let text = reply.replace(markerPattern, (_match, jsonText) => {
+        // Models occasionally corrupt the attachment marker. The opening tag is the
+        // least reliable part: we have seen it lose the "<LMA" prefix ("_BRIDGE_…"),
+        // lose even more ("RIDGE_ATTACHMENTS>"), or drop entirely. The closing tag is
+        // far more reliably emitted. So instead of enumerating opening-tag shapes,
+        // anchor on the closer and recover the JSON payload by brace-balancing
+        // backwards from it — robust no matter how many leading chars are dropped.
+        let text = reply;
+        let guard = 0;
+        for (;;) {
+            if (guard++ > 50)
+                break; // safety: never loop unbounded on pathological input
+            const found = this.findBridgeAttachmentMarker(text);
+            if (!found)
+                break;
+            const { start, end, json } = found;
+            let consumed = false;
             try {
-                const parsed = JSON.parse(String(jsonText).trim());
-                const rawAttachments = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.attachments) ? parsed.attachments : [parsed];
+                const parsed = JSON.parse(json);
+                const rawAttachments = Array.isArray(parsed)
+                    ? parsed
+                    : Array.isArray(parsed?.attachments) ? parsed.attachments : [parsed];
+                const before = attachments.length;
                 for (const item of rawAttachments)
                     this.pushBridgeAttachment(attachments, item);
+                // Only strip the span if it actually yielded at least one attachment;
+                // otherwise leave the text alone rather than eat unrelated content.
+                consumed = attachments.length > before;
             }
             catch (err) {
                 console.warn(`[${this.config.name}] Failed to parse bridge attachment marker:`, err.message);
             }
-            return "";
-        });
+            if (consumed) {
+                text = (text.slice(0, start) + text.slice(end)).replace(/[^\S\n]+\n/g, "\n");
+            }
+            else {
+                // Could not use this span; blank it out so we do not re-find it forever,
+                // but keep scanning in case another valid marker exists earlier.
+                text = text.slice(0, start) + text.slice(end);
+            }
+        }
+        text = text.trim();
         // Compatibility fallback for agents that use OpenClaw's channel directive
         // syntax instead of the LMA marker. In Feishu/LMA, leaving MEDIA:<path> in
         // plain text only shows the path, so parse it into bridge attachments.
@@ -2439,6 +2572,111 @@ export class FeishuBot {
         }).trim();
         return { text, attachments };
     }
+    /**
+     * Locate one bridge-attachment marker in `text` and recover its JSON payload,
+     * tolerating arbitrary corruption of the OPENING tag (lost prefix, or no
+     * opening tag at all). Strategy:
+     *   1. Find a closing tag — the full `</LMA_BRIDGE_ATTACHMENTS>`, or a partial
+     *      suffix of it (e.g. `_BRIDGE_ATTACHMENTS>`, `RIDGE_ATTACHMENTS>`), or the
+     *      `</parameter>` the marker sometimes degrades into.
+     *   2. From just before that closer, brace-match BACKWARDS to the start of the
+     *      JSON value (`{...}` or `[...]`), so the opening marker is irrelevant.
+     *   3. Return the span to strip [start,end) plus the extracted JSON string.
+     * `start` extends left to swallow any leftover opening-marker remnant (so no
+     * `RIDGE_ATTACHMENTS>` text leaks into the visible reply).
+     */
+    findBridgeAttachmentMarker(text) {
+        // Closing-tag candidates, longest/most-specific first. We accept partial
+        // suffixes of the real closing tag because the opening corruption pattern
+        // (dropped leading chars) also happens to the closer.
+        const closeRe = /<\/LMA_BRIDGE_ATTACHMENTS>|[A-Z_]*BRIDGE_ATTACHMENTS>\s*<\/LMA_BRIDGE_ATTACHMENTS>|<\/parameter>/g;
+        // The JSON sits between an (often corrupted) opener and the closer. Find the
+        // closer first, then walk back to the JSON. Prefer the canonical closer.
+        const closers = [];
+        const canonical = /<\/LMA_BRIDGE_ATTACHMENTS>/g;
+        let m;
+        while ((m = canonical.exec(text)))
+            closers.push({ idx: m.index, len: m[0].length });
+        if (closers.length === 0) {
+            // Degraded closer: `</parameter>` immediately after the JSON payload.
+            const param = /<\/parameter>/g;
+            while ((m = param.exec(text)))
+                closers.push({ idx: m.index, len: m[0].length });
+        }
+        void closeRe; // (kept for documentation of accepted shapes)
+        for (const c of closers) {
+            const json = this.extractJsonBeforeIndex(text, c.idx);
+            if (!json)
+                continue;
+            // Extend `start` left over any opening-marker remnant + surrounding space,
+            // so the visible text does not keep a dangling `RIDGE_ATTACHMENTS>` etc.
+            // The remnant is always some trailing SUFFIX of `<LMA_BRIDGE_ATTACHMENTS>`
+            // (corruption drops leading chars), so match any such suffix.
+            let start = json.start;
+            const lead = text.slice(Math.max(0, start - 48), start);
+            const leadMarker = this.openMarkerRemnant().exec(lead);
+            if (leadMarker)
+                start = Math.max(0, start - (lead.length - leadMarker.index));
+            return { start, end: c.idx + c.len, json: json.text };
+        }
+        return null;
+    }
+    /**
+     * Regex matching a trailing remnant of the opening marker `<LMA_BRIDGE_ATTACHMENTS>`
+     * at the END of a string. Built from every suffix of the full marker so that
+     * however many leading characters the model dropped (`_BRIDGE_ATTACHMENTS>`,
+     * `RIDGE_ATTACHMENTS>`, `>` …), the leftover is fully stripped from the visible
+     * text. Trailing `>` and surrounding whitespace are also consumed.
+     */
+    openMarkerRemnant() {
+        const full = "<LMA_BRIDGE_ATTACHMENTS>";
+        const suffixes = [];
+        for (let i = 0; i < full.length; i++)
+            suffixes.push(full.slice(i).replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+        // Longest suffixes first so the regex prefers the most complete remnant.
+        return new RegExp(`(?:${suffixes.join("|")})\\s*$`);
+    }
+    /**
+     * Given the index of a closing tag, walk backwards to extract the balanced
+     * JSON value (`{...}` or `[...]`) that ends just before it. Returns the JSON
+     * string and its start offset, or null if no balanced value is found.
+     */
+    extractJsonBeforeIndex(text, closeIdx) {
+        // Skip whitespace immediately before the closer.
+        let end = closeIdx;
+        while (end > 0 && /\s/.test(text[end - 1]))
+            end--;
+        if (end === 0)
+            return null;
+        const lastChar = text[end - 1];
+        const open = lastChar === "}" ? "{" : lastChar === "]" ? "[" : null;
+        if (!open)
+            return null;
+        const close = lastChar;
+        // Brace-balance backwards, ignoring braces inside strings.
+        let depth = 0;
+        let inStr = false;
+        for (let i = end - 1; i >= 0; i--) {
+            const ch = text[i];
+            if (inStr) {
+                if (ch === '"' && text[i - 1] !== "\\")
+                    inStr = false;
+                continue;
+            }
+            if (ch === '"') {
+                inStr = true;
+                continue;
+            }
+            if (ch === close)
+                depth++;
+            else if (ch === open) {
+                depth--;
+                if (depth === 0)
+                    return { text: text.slice(i, end), start: i };
+            }
+        }
+        return null;
+    }
     pushBridgeAttachment(attachments, item) {
         if (!item || typeof item.path !== "string")
             return;
@@ -2914,7 +3152,7 @@ export class FeishuBot {
      *      into the model). A backup is always written before any file change.
      * Returns a structured result describing what happened.
      */
-    async compactWithFallback(sessionKey) {
+    async compactWithFallback(sessionKey, onPhase) {
         // 1. Native compaction first.
         let nativeReason;
         try {
@@ -2926,7 +3164,10 @@ export class FeishuBot {
         catch (err) {
             nativeReason = err.message;
         }
-        // 2. Fall back to tool-trim on the transcript file.
+        // 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);
@@ -2963,29 +3204,53 @@ export class FeishuBot {
     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 {
-            const r = await this.compactWithFallback(sessionKey);
+            const r = await this.compactWithFallback(sessionKey, (phase) => {
+                if (phase === "tool-trim")
+                    void progress.toToolTrim().catch(() => { });
+            });
             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 已压缩`);
+                // 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 this.replyMessage(messageId, en
-                    ? `ℹ️ Session not compacted (${reason})`
-                    : `ℹ️ Session 未压缩（${reason}）`);
+                await progress.noop(reason);
+                if (!progress.id) {
+                    await this.replyMessage(messageId, en
+                        ? `ℹ️ Session not compacted (${reason})`
+                        : `ℹ️ Session 未压缩（${reason}）`);
+                }
             }
         }
         catch (err) {
-            await this.replyMessage(messageId, en
-                ? `❌ Compact failed: ${err.message}`
-                : `❌ 压缩失败: ${err.message}`);
+            const reason = err.message;
+            await progress.fail(reason);
+            if (!progress.id) {
+                await this.replyMessage(messageId, en
+                    ? `❌ Compact failed: ${reason}`
+                    : `❌ 压缩失败: ${reason}`);
+            }
         }
     }
     /**

package/package.json

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