openclaw-lark-multi-agent 1.4.13 → 1.5.1

package/dist/compact-progress.d.ts

@@ -1,5 +1,5 @@
 /** Coarse phase of the compaction flow, drives the card's primary line. */
-export type CompactPhase = "native" | "transcript-trim";
+export type CompactPhase = "native" | "transcript-trim" | "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. */
@@ -50,6 +50,8 @@ export declare class CompactProgressController {
     get id(): string | undefined;
     /** Begin the flow; schedules lazy card creation after delayMs. */
     start(): void;
+    /** Switch straight into explicit transcript-trim mode (user-requested trim). */
+    toTrim(): void;
     /** Native compaction gave up; switch to Gateway-owned transcript-tail trim. */
     toTranscriptTrim(): Promise<void>;
     /** Finished successfully; patch the card to the done state with a detail line. */

package/dist/compact-progress.js

@@ -45,6 +45,12 @@ export class CompactProgressController {
         }, this.opts.delayMs ?? DEFAULT_DELAY_MS);
         this.createTimer.unref?.();
     }
+    /** Switch straight into explicit transcript-trim mode (user-requested trim). */
+    toTrim() {
+        if (this.finalized || this.phase === "trim" || this.phase === "transcript-trim")
+            return;
+        this.phase = "trim";
+    }
     /** Native compaction gave up; switch to Gateway-owned transcript-tail trim. */
     async toTranscriptTrim() {
         if (this.finalized || this.phase === "transcript-trim")

package/dist/config.d.ts

@@ -5,6 +5,8 @@ export interface BotConfig {
     appSecret: string;
     model: string;
     locale?: Locale;
+    /** Optional per-bot thinking level (informational fallback for footers). */
+    thinking?: string;
 }
 export interface OpenClawConfig {
     baseUrl: string;

package/dist/feishu-bot.d.ts

@@ -219,6 +219,10 @@ export declare class FeishuBot {
     private isBotAvailableInChat;
     private getDiscussionParticipants;
     private getChairmanParticipant;
+    /** Resolve the session's current thinking label for the live-status footer.
+     * Prefers a live session override (set via //think / sessions.patch), falls
+     * back to the session's default, then the bot's config-level thinking. */
+    private fetchThinkingLabel;
     private asDiscussionParticipant;
     private runDiscussionTurn;
     private buildLiveStatusCard;
@@ -286,6 +290,15 @@ export declare class FeishuBot {
      */
     private sendErrorNotice;
     private sendFinalMessage;
+    /** Feishu code 230025: message content over the per-message limit. */
+    private isContentTooLongError;
+    /** Split text into Feishu-safe chunks (default well under the 4000-char text limit).
+     * Prefers paragraph, then line boundaries; hard-cuts only when a single line
+     * is longer than the limit. Joining all chunks reproduces the original text. */
+    private splitIntoChunks;
+    /** Deliver oversized content as multiple plain-text messages (used on 230025).
+     * Keeps the model footer on the final chunk. Returns the first message id. */
+    private sendChunkedText;
     private sendMessage;
     /**
      * Enqueue a message send to guarantee ordering per chat.
@@ -316,14 +329,15 @@ export declare class FeishuBot {
      * Handle /compact command: compress session context.
      */
     /**
-     * Compact a session with a Gateway-owned fallback chain:
-     *   1. Semantic compaction through `sessions.compact`.
-     *   2. If summarization cannot run, ask the same RPC to retain only a bounded
-     *      transcript tail via `maxLines`. This works with legacy JSONL and the
-     *      SQLite session store introduced in OpenClaw 2026.8.x, and preserves
-     *      OpenClaw's write locks, transcript invariants, and migration ownership.
+     * Compact a session via Gateway-owned RPCs. LMA deliberately never opens or
+     * rewrites OpenClaw transcript storage.
      *
-     * LMA deliberately never opens or rewrites OpenClaw transcript storage.
+     * Modes (kept strictly separate so the flows are never mixed):
+     *   - "trim" (default): `sessions.compact` with `maxLines` — permanently keeps
+     *     only the last N transcript events. Model-free, fast, never times out on
+     *     oversized sessions.
+     *   - "semantic": LLM summarization via the same RPC; on failure falls back to
+     *     a trim so the session is still reclaimed.
      */
     private compactWithFallback;
     private handleCompactCommand;
@@ -344,9 +358,6 @@ export declare class FeishuBot {
      * Called once per chat on first message.
      */
     private fetchAndCacheChatInfo;
-    /**
-     * Send a model-drift notification to the affected chat.
-     */
     private hydrateInlineImageKeys;
     private hydrateFeishuDocsInMessage;
     private extractFeishuDocRefs;
@@ -365,5 +376,4 @@ export declare class FeishuBot {
      * Extract text content from a rich text (post) message.
      */
     private extractPostText;
-    private notifyModelDrift;
 }

package/dist/feishu-bot.js

@@ -37,6 +37,40 @@ const AUTO_RETRY_DONE_PHRASE_EN = process.env.OPENCLAW_LARK_MULTI_AGENT_AUTO_RET
 // it is a NEW user message that arrived while it was still working, and should
 // be handled together with the current task. The live-status card and reactions
 // still key off the ORIGINAL text; only what OpenClaw receives is wrapped.
+/** Damerau-Levenshtein distance (insert/delete/substitute/transpose), bounded. */
+function damerauLevenshtein(a, b) {
+    const la = a.length, lb = b.length;
+    if (Math.abs(la - lb) > 1)
+        return 2; // fast reject for threshold-1 use
+    const d = Array.from({ length: la + 1 }, () => new Array(lb + 1).fill(0));
+    for (let i = 0; i <= la; i++)
+        d[i][0] = i;
+    for (let j = 0; j <= lb; j++)
+        d[0][j] = j;
+    for (let i = 1; i <= la; i++) {
+        for (let j = 1; j <= lb; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+            if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+                d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+            }
+        }
+    }
+    return d[la][lb];
+}
+/** Find a bridge command within one edit of `name` (typo hint); undefined if none. */
+function findNearMissCommand(name, commands) {
+    if (!name.startsWith("/") || name.length < 3)
+        return undefined;
+    let best;
+    for (const cmd of commands) {
+        if (damerauLevenshtein(name, cmd) <= 1) {
+            if (best === undefined || cmd.length < best.length)
+                best = cmd;
+        }
+    }
+    return best;
+}
 function steerInjectionPrefix(en) {
     const zh = process.env.OPENCLAW_LARK_MULTI_AGENT_STEER_PREFIX
         || "【用户中途插入的新消息，请与当前任务一起处理】";
@@ -44,12 +78,12 @@ function steerInjectionPrefix(en) {
         || "[New message inserted by the user mid-task; please handle it together with the current task]";
     return en ? enText : zh;
 }
-// Emergency transcript trim used only when semantic compaction cannot run.
-// The Gateway owns the transcript store (JSONL before 2026.8, SQLite after it),
-// so LMA must use sessions.compact instead of mutating storage directly.
+// Default transcript-tail trim depth for /compact. Tool-heavy group sessions can
+// easily carry 300+ events of pure tool noise, so keep a generous tail: the
+// Gateway truncates to the last N transcript events. Env override stays.
 function compactFallbackMaxLines() {
-    const value = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_COMPACT_FALLBACK_MAX_LINES || 200);
-    return Number.isFinite(value) ? Math.max(20, Math.floor(value)) : 200;
+    const value = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_COMPACT_FALLBACK_MAX_LINES || 800);
+    return Number.isFinite(value) ? Math.max(20, Math.floor(value)) : 800;
 }
 // After a reply is delivered, if context usage reaches this percent, send the
 // user a one-time alert to compact. 0 disables the alert.
@@ -212,7 +246,6 @@ export class FeishuBot {
             const corrected = await this.openclawClient.ensureModel(sessionKey, this.config.model);
             if (corrected) {
                 console.log(`[${this.config.name}] Model auto-corrected to ${this.config.model}`);
-                await this.notifyModelDrift(chatId, sessionKey);
             }
             return sessionKey;
         }
@@ -225,7 +258,6 @@ export class FeishuBot {
                 const corrected = await this.openclawClient.ensureModel(sessionKey, this.config.model);
                 if (corrected) {
                     console.log(`[${this.config.name}] Model auto-corrected to ${this.config.model}`);
-                    await this.notifyModelDrift(chatId, sessionKey);
                 }
             }
             else {
@@ -572,6 +604,28 @@ export class FeishuBot {
             const commandName = preliminaryCommandName;
             const bridgeCommands = preliminaryBridgeCommands;
             const isCommand = isBridgeCommand && bridgeCommands.has(commandName);
+            // Typo hint: a near-miss single-slash command (e.g. "/chiarman") must not
+            // silently fall through into the chairman/model chat path — that is how
+            // "I set the chairman but someone else keeps answering" confusion starts.
+            if (!isCommand && isBridgeCommand) {
+                const nearMiss = findNearMissCommand(commandName, bridgeCommands);
+                if (nearMiss) {
+                    const groupBotCount = Array.from(FeishuBot.allBots.values()).filter((bot) => bot.store === this.store).length;
+                    const shouldHint = chatType === "p2p"
+                        || (routing.hasTargetedMention ? routing.isCurrentBotMentioned : (groupBotCount === 1 || this.isDiscussionCoordinator()));
+                    if (shouldHint) {
+                        const en = this.isEn(chatId);
+                        await this.replyMessage(messageId, en
+                            ? `❓ Unknown command \`${commandName}\`. Did you mean \`${nearMiss}\`?\nRe-send the correct command to execute it. Commands starting with // are passed to OpenClaw.`
+                            : `❓ 未知命令 \`${commandName}\`，你是想输入 \`${nearMiss}\` 吗？\n重新发送正确命令即可执行；双斜杠 // 开头的命令会转交给 OpenClaw。`);
+                        if (insertedId > 0) {
+                            this.store.markSynced(this.config.name, chatId, insertedId);
+                            this.store.clearPendingTrigger(this.config.name, chatId, insertedId);
+                        }
+                        return;
+                    }
+                }
+            }
             if (isCommand) {
                 // In group chats, most bridge commands must be explicitly routed to this
                 // bot or @all. /discuss is a group-level command, so an unmentioned
@@ -683,7 +737,7 @@ export class FeishuBot {
                         `━━━━━━━━━━━━━━━━━━`,
                         `桥接层命令（单斜杠，由 openclaw-lark-multi-agent 本地处理）`,
                         `📊 /status  — 查看当前模型、Token 用量、Session 状态`,
-                        `🧹 /compact — 压缩当前 bot 的 OpenClaw session`,
+                        `🧹 /compact [N|maxLines=N|semantic] — 裁剪转录尾部（默认，保留最近事件）；N 指定保留条数；semantic 走 LLM 总结`,
                         `🔄 /reset   — 重置当前 bot 的 OpenClaw session`,
                         `⏹️ /stop    — 强制停止当前 bot 在本聊天的卡死 run，解锁队列`,
                         `🔊 /verbose — 开关当前聊天里的 Tool Call 显示`,
@@ -729,7 +783,8 @@ export class FeishuBot {
                 }
                 if (commandName === "/compact") {
                     await this.ensureSession(chatId);
-                    await this.handleCompactCommand(chatId, messageId);
+                    const compactArgs = cleanText.trim().split(/\s+/).slice(1).join(" ").trim();
+                    await this.handleCompactCommand(chatId, messageId, compactArgs);
                     markCommandSynced();
                     return;
                 }
@@ -1360,6 +1415,7 @@ export class FeishuBot {
                     }, {
                         botName: this.config.name,
                         model: this.config.model,
+                        thinkingLevel: await this.fetchThinkingLabel(sessionKey),
                         locale: this.isEn(chatId) ? "en" : "zh",
                     })
                     : undefined;
@@ -1888,7 +1944,12 @@ export class FeishuBot {
         const core = en
             ? `${emoji} ${meta.toolCalls} tool call${meta.toolCalls === 1 ? "" : "s"} · ⏱ ${meta.elapsed}`
             : `${emoji} 累计${meta.toolCalls} 次工具调用 · ⏱ 耗时${meta.elapsed}`;
-        return meta.model?.trim() ? `${core} · 🧠 ${this.escapeCardText(meta.model.trim())}` : core;
+        if (!meta.model?.trim())
+            return core;
+        const modelLabel = meta.thinkingLevel?.trim()
+            ? `${meta.model.trim()} · ${meta.thinkingLevel.trim()}`
+            : meta.model.trim();
+        return `${core} · 🧠 ${this.escapeCardText(modelLabel)}`;
     }
     /** Best-effort terminal cleanup for status-only rows and legacy v1.4.3
      * outbox entries that once targeted the live-status card. */
@@ -1898,6 +1959,7 @@ export class FeishuBot {
             lines: [],
             elapsed: meta.elapsed,
             model: meta.model,
+            thinkingLevel: meta.thinkingLevel,
             toolCalls: meta.toolCalls,
             noReply: Boolean(meta.noReply),
             state: "done",
@@ -2783,6 +2845,24 @@ export class FeishuBot {
         const bot = Array.from(FeishuBot.allBots.values()).find((candidate) => candidate.store === this.store && candidate.config.name === chairman && this.isBotAvailableInChat(candidate, chatId));
         return bot ? this.asDiscussionParticipant(bot, chatId) : undefined;
     }
+    /** Resolve the session's current thinking label for the live-status footer.
+     * Prefers a live session override (set via //think / sessions.patch), falls
+     * back to the session's default, then the bot's config-level thinking. */
+    async fetchThinkingLabel(sessionKey) {
+        try {
+            const info = await this.openclawClient.getSessionInfo(sessionKey);
+            const s = info?.session;
+            const label = (typeof s?.thinkingLevel === "string" && s.thinkingLevel.trim())
+                || (typeof s?.thinkingDefault === "string" && s.thinkingDefault.trim())
+                || (typeof this.config.thinking === "string" && this.config.thinking.trim())
+                || "";
+            return label || undefined;
+        }
+        catch {
+            const cfg = typeof this.config.thinking === "string" ? this.config.thinking.trim() : "";
+            return cfg || undefined;
+        }
+    }
     asDiscussionParticipant(bot, chatId) {
         return {
             name: bot.config.name,
@@ -2801,6 +2881,7 @@ export class FeishuBot {
             }, {
                 botName: this.config.name,
                 model: this.config.model,
+                thinkingLevel: await this.fetchThinkingLabel(sessionKey),
                 locale: this.isEn(chatId) ? "en" : "zh",
             })
             : undefined;
@@ -2900,6 +2981,7 @@ export class FeishuBot {
                 toolCalls: view.toolCalls,
                 elapsed: view.elapsed,
                 model: view.model,
+                thinkingLevel: view.thinkingLevel,
                 locale: en ? "en" : "zh",
             }, statusEmoji);
             return {
@@ -2935,8 +3017,12 @@ export class FeishuBot {
         // Keep the active model visible while the run is in progress or failed.
         // The final reply also keeps model attribution so it remains self-contained.
         const footerBits = [en ? `⏱ ${view.elapsed}` : `⏱ 已用 ${view.elapsed}`];
-        if (view.model?.trim())
-            footerBits.push(`🧠 ${this.escapeCardText(view.model.trim())}`);
+        if (view.model?.trim()) {
+            const modelBit = view.thinkingLevel?.trim()
+                ? `🧠 ${this.escapeCardText(view.model.trim())} · ${this.escapeCardText(view.thinkingLevel.trim())}`
+                : `🧠 ${this.escapeCardText(view.model.trim())}`;
+            footerBits.push(modelBit);
+        }
         elements.push({ tag: "markdown", content: `<font color='grey'>${footerBits.join("  ·  ")}</font>` });
         const template = view.state === "failed" ? "orange" : "blue";
         return {
@@ -3023,7 +3109,9 @@ export class FeishuBot {
         // Running: phase line + ticking elapsed footer.
         const phaseLine = view.phase === "transcript-trim"
             ? (en ? "🧹 Semantic compaction unavailable — trimming transcript safely…" : "🧹 语义压缩不可用，正在安全裁剪转录…")
-            : (en ? "🧹 Compacting session…" : "🧹 正在压缩 session…");
+            : view.phase === "trim"
+                ? (en ? "🧹 Trimming transcript tail (keeping the most recent events)…" : "🧹 正在裁剪转录尾部（保留最近的事件）…")
+                : (en ? "🧹 Compacting session…" : "🧹 正在压缩 session…");
         const footer = en ? `⏱ ${view.elapsed}` : `⏱ 已用 ${view.elapsed}`;
         return {
             schema: "2.0",
@@ -3117,6 +3205,16 @@ export class FeishuBot {
         const model = this.replyModelFooters.get(messageId);
         const status = this.replyStatusFooters.get(messageId);
         const card = this.buildMarkdownCard(text, model, status);
+        // Best-effort chat resolution for chunked/error paths: the reply target is
+        // normally a stored inbound message, so the store knows its chat.
+        const resolveChatId = () => {
+            try {
+                return this.store.getMessageByMessageId(messageId)?.chatId || undefined;
+            }
+            catch {
+                return undefined;
+            }
+        };
         try {
             const res = await this.client.im.message.reply({
                 path: { message_id: messageId },
@@ -3127,17 +3225,35 @@ export class FeishuBot {
             });
             return res?.data?.message_id || res?.message_id;
         }
-        catch {
+        catch (err) {
+            const chatId = resolveChatId();
+            if (this.isOutOfChatError(err) && chatId)
+                this.markCurrentBotUnavailable(chatId, err);
+            // Content over Feishu's per-message limit: chunk and deliver instead of
+            // retrying the same oversized payload (retries would fail forever).
+            if (this.isContentTooLongError(err) && chatId) {
+                return await this.sendChunkedText(chatId, text, model, status, messageId);
+            }
             // Fallback to plain text if card fails; retain model attribution.
             const fallbackText = model?.trim() ? `${text}\n\n🧠 ${model.trim()}${status ? ` · ${status}` : ""}` : text;
-            const res = await this.client.im.message.reply({
-                path: { message_id: messageId },
-                data: {
-                    content: JSON.stringify({ text: fallbackText }),
-                    msg_type: "text",
-                },
-            });
-            return res?.data?.message_id || res?.message_id;
+            try {
+                const res = await this.client.im.message.reply({
+                    path: { message_id: messageId },
+                    data: {
+                        content: JSON.stringify({ text: fallbackText }),
+                        msg_type: "text",
+                    },
+                });
+                return res?.data?.message_id || res?.message_id;
+            }
+            catch (fallbackErr) {
+                if (this.isOutOfChatError(fallbackErr) && chatId)
+                    this.markCurrentBotUnavailable(chatId, fallbackErr);
+                if (this.isContentTooLongError(fallbackErr) && chatId) {
+                    return await this.sendChunkedText(chatId, text, model, status, messageId);
+                }
+                throw fallbackErr;
+            }
         }
     }
     extractBridgeAttachments(reply) {
@@ -3485,6 +3601,59 @@ export class FeishuBot {
             this.sendStatusFooters.delete(chatId);
         }
     }
+    /** Feishu code 230025: message content over the per-message limit. */
+    isContentTooLongError(err) {
+        const e = err;
+        const code = e?.response?.data?.code ?? e?.data?.code ?? e?.code;
+        const msg = String(e?.response?.data?.msg ?? e?.data?.msg ?? e?.message ?? e?.msg ?? "");
+        return code === 230025 || msg.includes("230025") || /length of the message content/i.test(msg);
+    }
+    /** Split text into Feishu-safe chunks (default well under the 4000-char text limit).
+     * Prefers paragraph, then line boundaries; hard-cuts only when a single line
+     * is longer than the limit. Joining all chunks reproduces the original text. */
+    splitIntoChunks(text, limit = 3200) {
+        if (text.length <= limit)
+            return [text];
+        const chunks = [];
+        let rest = text;
+        while (rest.length > limit) {
+            let cut = rest.lastIndexOf("\n\n", limit);
+            if (cut < limit * 0.5)
+                cut = rest.lastIndexOf("\n", limit);
+            if (cut < limit * 0.5)
+                cut = rest.lastIndexOf(" ", limit);
+            if (cut < limit * 0.5)
+                cut = limit;
+            chunks.push(rest.slice(0, cut));
+            rest = rest.slice(cut).replace(/^\n+/, "");
+        }
+        if (rest.length > 0)
+            chunks.push(rest);
+        return chunks;
+    }
+    /** Deliver oversized content as multiple plain-text messages (used on 230025).
+     * Keeps the model footer on the final chunk. Returns the first message id. */
+    async sendChunkedText(chatId, text, model, status, replyTo) {
+        const suffix = model?.trim() ? `\n\n🧠 ${model.trim()}${status ? ` · ${status}` : ""}` : "";
+        const chunks = this.splitIntoChunks(text);
+        if (suffix && chunks.length > 0)
+            chunks[chunks.length - 1] += suffix;
+        let firstId;
+        for (let i = 0; i < chunks.length; i++) {
+            const payload = {
+                content: JSON.stringify({ text: chunks[i] }),
+                msg_type: "text",
+            };
+            const res = replyTo
+                ? await this.client.im.message.reply({ path: { message_id: replyTo }, data: payload })
+                : await this.client.im.message.create({ params: { receive_id_type: "chat_id" }, data: { receive_id: chatId, ...payload } });
+            const id = res?.data?.message_id || res?.message_id;
+            if (i === 0)
+                firstId = id;
+        }
+        this.store.clearBotUnavailableInChat(this.config.name, chatId);
+        return firstId;
+    }
     async sendMessage(chatId, text) {
         const model = this.sendModelFooters.get(chatId);
         const status = this.sendStatusFooters.get(chatId);
@@ -3505,6 +3674,17 @@ export class FeishuBot {
             console.warn(`[${this.config.name}] sendMessage interactive failed:`, JSON.stringify(err?.response?.data || err?.data || { message: err.message }));
             if (this.isOutOfChatError(err))
                 this.markCurrentBotUnavailable(chatId, err);
+            // Content over Feishu's per-message limit: chunk and deliver instead of
+            // retrying the same oversized payload (retries would fail forever).
+            if (this.isContentTooLongError(err)) {
+                try {
+                    return await this.sendChunkedText(chatId, text, model, status);
+                }
+                catch (chunkErr) {
+                    console.warn(`[${this.config.name}] sendMessage chunked delivery failed:`, chunkErr.message);
+                    throw chunkErr;
+                }
+            }
             // Fallback to plain text; retain model attribution.
             try {
                 const fallbackText = model?.trim() ? `${text}\n\n🧠 ${model.trim()}${status ? ` · ${status}` : ""}` : text;
@@ -3523,6 +3703,9 @@ export class FeishuBot {
                 console.warn(`[${this.config.name}] sendMessage text failed:`, JSON.stringify(fallbackErr?.response?.data || fallbackErr?.data || { message: fallbackErr.message }));
                 if (this.isOutOfChatError(fallbackErr))
                     this.markCurrentBotUnavailable(chatId, fallbackErr);
+                if (this.isContentTooLongError(fallbackErr)) {
+                    return await this.sendChunkedText(chatId, text, model, status);
+                }
                 throw fallbackErr;
             }
         }
@@ -3800,16 +3983,37 @@ export class FeishuBot {
      * Handle /compact command: compress session context.
      */
     /**
-     * Compact a session with a Gateway-owned fallback chain:
-     *   1. Semantic compaction through `sessions.compact`.
-     *   2. If summarization cannot run, ask the same RPC to retain only a bounded
-     *      transcript tail via `maxLines`. This works with legacy JSONL and the
-     *      SQLite session store introduced in OpenClaw 2026.8.x, and preserves
-     *      OpenClaw's write locks, transcript invariants, and migration ownership.
+     * Compact a session via Gateway-owned RPCs. LMA deliberately never opens or
+     * rewrites OpenClaw transcript storage.
      *
-     * LMA deliberately never opens or rewrites OpenClaw transcript storage.
+     * Modes (kept strictly separate so the flows are never mixed):
+     *   - "trim" (default): `sessions.compact` with `maxLines` — permanently keeps
+     *     only the last N transcript events. Model-free, fast, never times out on
+     *     oversized sessions.
+     *   - "semantic": LLM summarization via the same RPC; on failure falls back to
+     *     a trim so the session is still reclaimed.
      */
-    async compactWithFallback(sessionKey, onPhase) {
+    async compactWithFallback(sessionKey, onPhase, opts = {}) {
+        const mode = opts.mode === "semantic" ? "semantic" : "trim";
+        const trimMaxLines = Number.isFinite(opts.maxLines) && opts.maxLines >= 20
+            ? Math.floor(opts.maxLines)
+            : compactFallbackMaxLines();
+        if (mode === "trim") {
+            onPhase?.("trim");
+            try {
+                const trimmed = await this.openclawClient.compactSession(sessionKey, { maxLines: trimMaxLines });
+                if (trimmed?.compacted === true) {
+                    const kept = typeof trimmed?.kept === "number" ? trimmed.kept : trimMaxLines;
+                    return { compacted: true, method: "transcript-trim", detail: `kept ${kept} transcript events` };
+                }
+                const trimReason = typeof trimmed?.reason === "string" ? trimmed.reason : undefined;
+                return { compacted: false, method: "none", reason: trimReason || "transcript trim made no change" };
+            }
+            catch (err) {
+                return { compacted: false, method: "none", reason: err.message };
+            }
+        }
+        // semantic mode: LLM summarize first, trim as fallback.
         let nativeReason;
         try {
             const res = await this.openclawClient.compactSession(sessionKey);
@@ -3821,11 +4025,10 @@ export class FeishuBot {
             nativeReason = err.message;
         }
         onPhase?.("transcript-trim");
-        const maxLines = compactFallbackMaxLines();
         try {
-            const trimmed = await this.openclawClient.compactSession(sessionKey, { maxLines });
+            const trimmed = await this.openclawClient.compactSession(sessionKey, { maxLines: trimMaxLines });
             if (trimmed?.compacted === true) {
-                const kept = typeof trimmed?.kept === "number" ? trimmed.kept : maxLines;
+                const kept = typeof trimmed?.kept === "number" ? trimmed.kept : trimMaxLines;
                 return {
                     compacted: true,
                     method: "transcript-trim",
@@ -3850,25 +4053,42 @@ export class FeishuBot {
             };
         }
     }
-    async handleCompactCommand(chatId, messageId) {
+    async handleCompactCommand(chatId, messageId, args = "") {
         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 transcript-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.
+        // Argument parsing — modes are strictly separated:
+        //   /compact                 → transcript tail trim (default, model-free)
+        //   /compact semantic        → LLM summarization (trim fallback on failure)
+        //   /compact 500             → tail trim keeping the last 500 events
+        //   /compact maxLines=500    → same as above
+        const argTokens = args.split(/\s+/).filter(Boolean);
+        let mode = "trim";
+        let maxLines;
+        for (const tok of argTokens) {
+            const semanticMatch = /^(semantic|summarize|llm)$/i.exec(tok);
+            if (semanticMatch) {
+                mode = "semantic";
+                continue;
+            }
+            const linesMatch = /^(?:maxlines|max_lines)[=:](\d{2,})$/i.exec(tok) || /^(\d{2,})$/.exec(tok);
+            if (linesMatch) {
+                maxLines = Number(linesMatch[1] || linesMatch[2]);
+                continue;
+            }
+        }
         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" });
+        if (mode === "trim")
+            progress.toTrim();
         progress.start();
         try {
             const r = await this.compactWithFallback(sessionKey, (phase) => {
                 if (phase === "transcript-trim")
                     void progress.toTranscriptTrim().catch(() => { });
-            });
+            }, { mode, maxLines });
             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.
@@ -4031,9 +4251,6 @@ export class FeishuBot {
             console.warn(`[${this.config.name}] Failed to fetch chat info:`, err.message);
         }
     }
-    /**
-     * Send a model-drift notification to the affected chat.
-     */
     async hydrateInlineImageKeys(text, messageId) {
         const imageKeyPattern = /\[Image: (img_[^\]\n]+)\]/g;
         const replacements = [];
@@ -4261,24 +4478,4 @@ export class FeishuBot {
         }
         return this.cleanMentions(parts.join(" "));
     }
-    async notifyModelDrift(chatId, _sessionKey) {
-        try {
-            const chatInfo = this.store.getChatInfo(chatId);
-            const chatLabel = chatInfo?.chatName || chatId.slice(-8);
-            await this.client.im.message.create({
-                params: { receive_id_type: "chat_id" },
-                data: {
-                    receive_id: chatId,
-                    content: JSON.stringify({
-                        text: `⚠️ 模型漂移已自动纠正\n期望: ${this.config.model}\n已恢复`,
-                    }),
-                    msg_type: "text",
-                },
-            });
-            console.log(`[${this.config.name}] Drift notification sent to ${chatLabel}`);
-        }
-        catch (err) {
-            console.warn(`[${this.config.name}] Failed to notify drift:`, err.message);
-        }
-    }
 }

package/dist/live-status.d.ts

@@ -16,6 +16,8 @@ export type LiveStatusView = {
     elapsed: string;
     /** Footer: model name, e.g. "phgeek-gw/claude-opus-4.8". */
     model?: string;
+    /** Footer: current thinking level label, e.g. "high" / "adaptive". */
+    thinkingLevel?: 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. */
@@ -29,6 +31,7 @@ export type LiveStatusFinalMeta = {
     toolCalls: number;
     elapsed: string;
     model?: string;
+    thinkingLevel?: string;
     locale: "zh" | "en";
     noReply?: boolean;
 };
@@ -46,6 +49,8 @@ export type LiveStatusOptions = {
     maxChars?: number;
     /** Model name shown in the footer. */
     model?: string;
+    /** Thinking level label shown after the model name in the footer. */
+    thinkingLevel?: string;
     /** Number of recent activity lines kept in the content area. */
     historySize?: number;
     /** Footer/auto-refresh cadence in ms. */

package/dist/live-status.js

@@ -172,6 +172,7 @@ export class LiveStatusController {
             toolCalls: this.toolCallCount,
             elapsed: this.formatElapsed(),
             model: this.opts.model,
+            thinkingLevel: this.opts.thinkingLevel,
             locale: this.opts.locale === "en" ? "en" : "zh",
             noReply,
         };
@@ -403,6 +404,7 @@ export class LiveStatusController {
             lines,
             elapsed: this.formatElapsed(),
             model: this.opts.model,
+            thinkingLevel: this.opts.thinkingLevel,
             toolCalls: this.toolCallCount,
             noReply: this.noReplyResult,
             state: this.state,

package/dist/openclaw-client.d.ts

@@ -143,6 +143,14 @@ export declare class OpenClawClient {
         model?: string;
         label?: string;
     }): Promise<any>;
+    /** True when an RPC error is the Gateway's "session is archived" refusal. */
+    isArchivedSessionError(err: unknown): boolean;
+    /**
+     * Restore an archived session (e.g. auto-archived by the Gateway's
+     * active-session-cap) so new work can start. sessions.patch requires
+     * expectedSessionId, so describe first, then patch archived=false.
+     */
+    unarchiveSession(key: string): Promise<boolean>;
     getSessionStatus(key: string): Promise<any>;
     injectAssistantMessage(params: {
         sessionKey: string;

package/dist/openclaw-client.js

@@ -1545,6 +1545,34 @@ export class OpenClawClient {
     async patchSession(params) {
         return this.rpc("sessions.patch", { ...params, key: this.canonicalSessionKey(params.key) }, 10000);
     }
+    /** True when an RPC error is the Gateway's "session is archived" refusal. */
+    isArchivedSessionError(err) {
+        const msg = err instanceof Error ? err.message : String(err ?? "");
+        return /is archived[.,]|Restore it before starting new work/i.test(msg);
+    }
+    /**
+     * Restore an archived session (e.g. auto-archived by the Gateway's
+     * active-session-cap) so new work can start. sessions.patch requires
+     * expectedSessionId, so describe first, then patch archived=false.
+     */
+    async unarchiveSession(key) {
+        const canonical = this.canonicalSessionKey(key);
+        try {
+            const info = await this.rpc("sessions.describe", { key: canonical }, 15000);
+            const sessionId = info?.session?.sessionId;
+            if (!sessionId)
+                return false;
+            if (info?.session?.archived !== true)
+                return true; // already active
+            const res = await this.rpc("sessions.patch", { key: canonical, expectedSessionId: sessionId, archived: false }, 15000);
+            console.log(`[OpenClaw] unarchived session ${key}: ${res?.ok === true ? "ok" : "unexpected response"}`);
+            return res?.ok === true;
+        }
+        catch (err) {
+            console.warn(`[OpenClaw] unarchive failed for ${key}:`, err instanceof Error ? err.message : err);
+            return false;
+        }
+    }
     async getSessionStatus(key) {
         return this.rpc("sessions.describe", { key: this.canonicalSessionKey(key) });
     }
@@ -1801,8 +1829,20 @@ export class OpenClawClient {
         const maxLines = Number.isFinite(options.maxLines)
             ? Math.max(1, Math.floor(options.maxLines))
             : undefined;
+        const sendCompact = () => this.rpc("sessions.compact", { key: this.canonicalSessionKey(key), ...(maxLines !== undefined ? { maxLines } : {}) }, 10 * 60 * 1000);
         try {
-            return await this.rpc("sessions.compact", { key: this.canonicalSessionKey(key), ...(maxLines !== undefined ? { maxLines } : {}) }, 10 * 60 * 1000);
+            try {
+                return await sendCompact();
+            }
+            catch (err) {
+                if (!this.isArchivedSessionError(err))
+                    throw err;
+                console.warn(`[OpenClaw] sessions.compact hit archived session for ${key}; restoring and retrying once`);
+                const restored = await this.unarchiveSession(key);
+                if (!restored)
+                    throw err;
+                return await sendCompact();
+            }
         }
         finally {
             const mode = maxLines === undefined ? "semantic" : `maxLines=${maxLines}`;
@@ -2052,13 +2092,28 @@ export class OpenClawClient {
             const sendStartedAt = Date.now();
             try {
                 await params.onSendAttempt?.();
-                result = await this.rpc("chat.send", {
+                const sendChat = () => this.rpc("chat.send", {
                     sessionKey: this.canonicalSessionKey(sk),
                     message: params.message,
                     attachments: params.attachments,
                     deliver: params.deliver ?? false,
                     idempotencyKey: randomUUID(),
                 });
+                try {
+                    result = await sendChat();
+                }
+                catch (err) {
+                    // The Gateway auto-archives sessions past the active-session cap; an
+                    // archived session refuses new work. Restore it once and retry — the
+                    // user should never have to fix this by hand.
+                    if (!this.isArchivedSessionError(err))
+                        throw err;
+                    console.warn(`[OpenClaw] chat.send hit archived session for ${sk}; restoring and retrying once`);
+                    const restored = await this.unarchiveSession(sk);
+                    if (!restored)
+                        throw err;
+                    result = await sendChat();
+                }
             }
             finally {
                 releaseChatSendSlot();

package/package.json

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