openclaw-lark-multi-agent 1.4.13 → 1.5.0

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;
@@ -316,14 +320,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 +349,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 +367,4 @@ export declare class FeishuBot {
      * Extract text content from a rich text (post) message.
      */
     private extractPostText;
-    private notifyModelDrift;
 }

package/dist/feishu-bot.js

@@ -44,12 +44,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 +212,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 +224,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 {
@@ -683,7 +681,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 +727,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 +1359,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 +1888,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 +1903,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 +2789,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 +2825,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 +2925,7 @@ export class FeishuBot {
                 toolCalls: view.toolCalls,
                 elapsed: view.elapsed,
                 model: view.model,
+                thinkingLevel: view.thinkingLevel,
                 locale: en ? "en" : "zh",
             }, statusEmoji);
             return {
@@ -2935,8 +2961,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 +3053,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",
@@ -3800,16 +3832,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 +3874,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 +3902,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 +4100,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 +4327,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.0",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {