openclaw-lark-multi-agent 1.4.12 → 1.5.0

package/dist/feishu-bot.js

@@ -6,6 +6,7 @@ import { InactiveRunObservation } from "./openclaw-client.js";
 import { SessionWaitPaused, isWaitTimeout, normalizeSessionRuntimeStatus, formatSessionFooter, FOREGROUND_WAIT_MS } from "./session-status.js";
 import { LiveStatusController } from "./live-status.js";
 import { CompactProgressController } from "./compact-progress.js";
+import { errorIdentity } from "./terminal-errors.js";
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
 import { basename, extname, join, resolve } from "path";
 import { getBridgeAttachmentsDir, getDataDir } from "./paths.js";
@@ -43,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.
@@ -117,6 +118,8 @@ export class FeishuBot {
      * message falls back to a normal run, cancel these before submission so a
      * later identical steer cannot consume the stale observer/correlation. */
     pendingSteerCleanups = new Map();
+    errorNoticeTimers = new Map();
+    errorNoticeChecks = new Map();
     adminOpenId;
     locale;
     configPath;
@@ -209,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;
         }
@@ -222,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 {
@@ -249,6 +250,19 @@ export class FeishuBot {
         this.openclawClient.setVerboseTranscriptDelivery(sessionKey, this.store.getBotVerbose(this.config.name, chatId));
         await this.openclawClient.subscribeSession(sessionKey, async (text, meta) => {
             try {
+                let provenance = meta?.error;
+                if (!provenance && meta?.genericErrorCandidate && meta.runId && meta.sessionKey) {
+                    provenance = this.store.getErrorNotice(this.config.name, chatId, errorIdentity(meta.sessionKey, meta.runId))?.provenance;
+                }
+                if (meta?.sourceType === "run_error" || provenance) {
+                    if (provenance) {
+                        this.store.observeRunError(this.config.name, chatId, provenance);
+                        await this.reconcileErrorNotices(chatId);
+                    }
+                    else
+                        console.warn(`[${this.config.name}] Uncorrelated run_error retained in logs; no finality evidence`);
+                    return; // errors never cancel pending results or complete live cards
+                }
                 const sourceType = meta?.sourceType === "verbose_transcript" ? "verbose_transcript" : "assistant_visible";
                 console.log(`[${this.config.name}] ${sourceType === "verbose_transcript" ? "Verbose transcript" : "Proactive message"} for ${chatId.slice(-8)}`);
                 const parsed = this.extractBridgeAttachments(text);
@@ -260,7 +274,7 @@ export class FeishuBot {
                     ? candidateTarget
                     : undefined);
                 try {
-                    await this.enqueueAndDispatchDelivery(chatId, sourceType, this.deliverySourceId(sourceType === "verbose_transcript" ? "verbose" : "proactive", `${Date.now()}:${Math.random()}:${parsed.text.trim()}|${JSON.stringify(parsed.attachments)}`), parsed.text.trim(), parsed.attachments, activeTarget?.messageId, activeTarget ? `trigger:${activeTarget.triggerId}` : undefined, sourceType === "verbose_transcript" ? undefined : this.config.model);
+                    await this.enqueueAndDispatchDelivery(chatId, sourceType, this.deliverySourceId(sourceType === "verbose_transcript" ? "verbose" : "proactive", `${Date.now()}:${Math.random()}:${parsed.text.trim()}|${JSON.stringify(parsed.attachments)}`), parsed.text.trim(), parsed.attachments, activeTarget?.messageId, activeTarget ? `trigger:${activeTarget.triggerId}` : undefined, sourceType === "verbose_transcript" ? undefined : this.config.model, meta);
                     if (sourceType !== "verbose_transcript" && (parsed.text.trim() || parsed.attachments.length > 0)) {
                         await activeTarget?.liveStatus?.complete().catch(() => { });
                         if (meta?.runId && runTarget)
@@ -363,6 +377,7 @@ export class FeishuBot {
                 }
                 // Re-subscribe to existing sessions
                 await this.ensureSession(chat.chatId);
+                drainTasks.push(this.reconcileErrorNotices(chat.chatId));
                 // Drain only messages that were explicitly marked as reply triggers.
                 // Context-only messages should not start an OpenClaw run after restart.
                 const pendingTriggerIds = this.store.getPendingTriggerIds(this.config.name, chat.chatId);
@@ -666,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 显示`,
@@ -712,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;
                 }
@@ -1343,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;
@@ -1871,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. */
@@ -1881,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",
@@ -2263,23 +2286,33 @@ export class FeishuBot {
         const sourceId = `discussion-system:${Date.now()}:${Math.random().toString(36).slice(2)}`;
         await this.enqueueAndDispatchDelivery(chatId, "discussion_system", sourceId, text);
     }
-    async enqueueAndDispatchDelivery(chatId, sourceType, sourceId, text, attachments = [], replyToMessageId, deliveryKey, finalReplyModel) {
+    async enqueueAndDispatchDelivery(chatId, sourceType, sourceId, text, attachments = [], replyToMessageId, deliveryKey, finalReplyModel, provenance, errorNoticeId) {
         if (!text.trim() && attachments.length === 0)
             return;
         const attachmentsJson = JSON.stringify(attachments);
         const normalizedPayload = `${text.trim()}|${attachmentsJson}`;
         const contentHash = this.stableHash(normalizedPayload);
         const finalDeliveryKey = deliveryKey || sourceId;
-        const deliveryMetaJson = finalReplyModel?.trim()
-            ? JSON.stringify({ model: finalReplyModel.trim() })
-            : "{}";
+        const deliveryMetaJson = JSON.stringify({
+            ...(finalReplyModel?.trim() ? { model: finalReplyModel.trim() } : {}),
+            ...(provenance ? { provenance } : {}), ...(errorNoticeId ? { errorNoticeId } : {}),
+        });
+        const correlatedFinal = sourceType === "assistant_visible" && provenance?.final && Boolean(provenance.runId && provenance.sessionKey);
+        if (correlatedFinal) {
+            const identity = { sessionKey: provenance.sessionKey, runId: provenance.runId };
+            this.store.promoteExactRunFinal(this.config.name, chatId, identity.sessionKey, identity.runId, contentHash, text, attachmentsJson);
+            if (!deliveryKey && this.store.hasExactRunFinalPayload(this.config.name, chatId, identity, text, attachmentsJson)) {
+                await this.dispatchPendingDeliveries(chatId);
+                return;
+            }
+        }
         if (sourceType === "verbose_transcript") {
             if (this.store.hasRecentSimilarDelivery(this.config.name, chatId, contentHash, 60_000, ["verbose_transcript"]))
                 return;
             if (this.store.hasRecentOverlappingDelivery(this.config.name, chatId, text, attachmentsJson, 60_000, 8, ["verbose_transcript"]))
                 return;
         }
-        else if (!deliveryKey) {
+        else if (!deliveryKey && !correlatedFinal) {
             if (this.store.hasRecentSimilarDelivery(this.config.name, chatId, contentHash, 60_000, [sourceType]))
                 return;
             if (this.store.hasRecentOverlappingDelivery(this.config.name, chatId, text, attachmentsJson, 60_000, 8, [sourceType]))
@@ -2306,6 +2339,15 @@ export class FeishuBot {
             // answer again on a second card. The original outbox row remains the sole
             // owner of text delivery; a different newly-frozen card is only collapsed.
             const existing = this.store.getDeliveryByKey(this.config.name, chatId, finalDeliveryKey);
+            if (sourceType === "run_error") {
+                // A withdrawn unsent notice may become terminal later. Keep its one
+                // task key; never use the result recovery/correction/attachment paths.
+                if (existing?.status === "failed" && !existing.textDelivered && existing.attempts < DELIVERY_MAX_ATTEMPTS) {
+                    this.store.renewUnsentErrorDelivery(existing.id, text, contentHash, deliveryMetaJson);
+                }
+                await this.dispatchPendingDeliveries(chatId);
+                return;
+            }
             // A failed owner must not permanently poison a logical trigger. Re-enqueue
             // the payload under a deterministic recovery key so a later authoritative
             // delivery gets a fresh retry budget.
@@ -2408,6 +2450,124 @@ export class FeishuBot {
             this.lastRealDeliveryAt.set(chatId, Date.now());
         }
     }
+    async inspectErrorNotice(record) {
+        if (this.store.hasRunFinalDelivery(this.config.name, record.chatId, record.provenance, true)) {
+            return { state: "suppressed", reason: "exact_run_final_platform_delivery_confirmed" };
+        }
+        if (this.store.hasRunFinalDelivery(this.config.name, record.chatId, record.provenance, false)) {
+            return { state: "pending", reason: "exact_run_final_delivery_pending" };
+        }
+        let verdict;
+        try {
+            verdict = await this.openclawClient.inspectRunError(record.provenance);
+        }
+        catch {
+            verdict = { state: "pending", reason: "inspection_unavailable" };
+        }
+        // A stop or final may have arrived during the read-only lookup.
+        const latest = this.store.getErrorNotice(this.config.name, record.chatId, record.noticeId);
+        if (latest?.provenance.userStop) {
+            record.provenance.userStop = true;
+            return { state: "stopped", reason: "explicit_bridge_stop" };
+        }
+        if (latest && (latest.provenance.source !== record.provenance.source || latest.provenance.state !== record.provenance.state || latest.provenance.stopReason !== record.provenance.stopReason)) {
+            record.provenance = latest.provenance;
+            record.checks = latest.checks;
+            return { state: "pending", reason: "stronger_terminal_evidence_observed" };
+        }
+        if (this.store.hasRunFinalDelivery(this.config.name, record.chatId, record.provenance, true)) {
+            return { state: "suppressed", reason: "exact_run_final_platform_delivery_confirmed" };
+        }
+        if (this.store.hasRunFinalDelivery(this.config.name, record.chatId, record.provenance, false)) {
+            return { state: "pending", reason: "exact_run_final_delivery_pending" };
+        }
+        return verdict;
+    }
+    deferErrorNotice(record, verdict) {
+        const delays = [15_000, 60_000, 120_000, 300_000, FOREGROUND_WAIT_MS];
+        record.verdict = verdict;
+        // Known-live task/delivery state is not an unknown diagnosis. Continue
+        // low-frequency checks across the Gateway's 30-minute retry window, bounded
+        // by the existing 24-hour observation horizon. Unknown evidence stays capped.
+        if (verdict.reason === "matching_task_or_delivery_continuing")
+            record.hasObservedContinuingTask = true;
+        const continuing = record.hasObservedContinuingTask === true;
+        const budget = continuing ? 300 : 6;
+        record.status = record.checks >= budget || Date.now() - record.createdAt >= 24 * 60 * 60_000 ? "parked" : "pending";
+        record.nextCheckAt = Date.now() + (continuing && record.checks >= 4 ? 300_000 : (delays[Math.max(0, record.checks - 1)] || FOREGROUND_WAIT_MS));
+        this.store.saveErrorNotice(record);
+        this.scheduleErrorNoticeCheck(record.chatId);
+    }
+    scheduleErrorNoticeCheck(chatId) {
+        const previous = this.errorNoticeTimers.get(chatId);
+        if (previous)
+            clearTimeout(previous);
+        this.errorNoticeTimers.delete(chatId);
+        const next = this.store.listPendingErrorNotices(this.config.name, chatId)[0];
+        if (!next)
+            return;
+        const timer = setTimeout(() => {
+            this.errorNoticeTimers.delete(chatId);
+            void this.reconcileErrorNotices(chatId).catch(err => console.warn(`[${this.config.name}] Error notice check unavailable:`, this.errorSummary(err)));
+        }, Math.max(1000, next.nextCheckAt - Date.now()));
+        timer.unref?.();
+        this.errorNoticeTimers.set(chatId, timer);
+    }
+    /** Bounded read-only diagnosis; known live tasks retain low-frequency observation. */
+    async reconcileErrorNotices(chatId) {
+        const running = this.errorNoticeChecks.get(chatId);
+        if (running)
+            return running;
+        const work = async () => {
+            const timer = this.errorNoticeTimers.get(chatId);
+            if (timer)
+                clearTimeout(timer);
+            this.errorNoticeTimers.delete(chatId);
+            for (const snapshot of this.store.listPendingErrorNotices(this.config.name, chatId)) {
+                // Earlier awaits may have observed a stop/stronger envelope for this row.
+                const record = this.store.getErrorNotice(this.config.name, chatId, snapshot.noticeId);
+                if (!record || record.status !== "pending")
+                    continue;
+                if (record.nextCheckAt > Date.now())
+                    continue;
+                if (record.checks >= (record.hasObservedContinuingTask || record.verdict?.reason === "matching_task_or_delivery_continuing" ? 300 : 6)) {
+                    // Normal exhausted checks are already parked. A still-pending row at
+                    // the cap can be a crash after budget reservation / before verdict or
+                    // outbox creation. Reserve one durable recovery probe, never per boot.
+                    if (record.recoveryProbeUsed) {
+                        this.deferErrorNotice(record, record.verdict || { state: "pending", reason: "budget_exhausted" });
+                        continue;
+                    }
+                    record.recoveryProbeUsed = true;
+                }
+                record.checks++;
+                // Reserve the budget before awaiting RPC, including crash/disconnect.
+                this.store.saveErrorNotice(record);
+                const verdict = await this.inspectErrorNotice(record);
+                console.log(`[${this.config.name}] Error notice ${record.noticeId}: ${verdict.state}/${verdict.reason}`);
+                if (verdict.state === "pending") {
+                    this.deferErrorNotice(record, verdict);
+                    continue;
+                }
+                record.verdict = verdict;
+                this.store.saveErrorNotice(record);
+                if (verdict.state === "terminal" && verdict.terminalKey && verdict.text) {
+                    // Independent identity: never take the result's trigger/final key.
+                    await this.enqueueAndDispatchDelivery(chatId, "run_error", verdict.terminalKey, verdict.text, [], undefined, verdict.terminalKey, undefined, { sourceType: "run_error", runId: record.provenance.runId, error: record.provenance, terminalEvidence: verdict }, record.noticeId);
+                    // The send-time recheck may have parked or suppressed the observation.
+                    const refreshed = this.store.getErrorNotice(this.config.name, chatId, record.noticeId);
+                    if (refreshed?.verdict && ["pending", "suppressed", "stopped"].includes(refreshed.verdict.state))
+                        continue;
+                }
+                record.status = verdict.state;
+                this.store.saveErrorNotice(record);
+            }
+            this.scheduleErrorNoticeCheck(chatId);
+        };
+        const promise = work().finally(() => { this.errorNoticeChecks.delete(chatId); });
+        this.errorNoticeChecks.set(chatId, promise);
+        return promise;
+    }
     scheduleDeliveryRetry(chatId, attempt) {
         if (this.deliveryRetryTimers.has(chatId))
             return;
@@ -2454,7 +2614,32 @@ export class FeishuBot {
                             const finalStatus = needsStatus ? formatSessionFooter(await this.readSessionStatus(chatId)) : undefined;
                             if (needsStatus && !finalModel)
                                 finalModel = this.config.model;
-                            if (shouldReplyToSource) {
+                            if (item.sourceType === "run_error") {
+                                const meta = JSON.parse(item.deliveryMetaJson || "{}");
+                                const record = this.store.getErrorNotice(this.config.name, chatId, meta.errorNoticeId || "");
+                                const verdict = record ? await this.inspectErrorNotice(record) : { state: "pending", reason: "missing_persisted_provenance" };
+                                if (verdict.state !== "terminal" || verdict.terminalKey !== item.deliveryKey || verdict.text !== item.content) {
+                                    this.store.withdrawErrorDelivery(item.id);
+                                    if (record) {
+                                        if (verdict.state === "pending" || verdict.state === "terminal")
+                                            this.deferErrorNotice(record, { ...verdict, state: "pending" });
+                                        else {
+                                            record.status = verdict.state;
+                                            record.verdict = verdict;
+                                            this.store.saveErrorNotice(record);
+                                        }
+                                    }
+                                    return;
+                                }
+                                record.verdict = verdict;
+                                this.store.saveErrorNotice(record);
+                            }
+                            if (item.sourceType === "run_error") {
+                                // Exactly one platform operation per guarded attempt. A card/text
+                                // fallback must not bypass a fresh finality check.
+                                await this.sendErrorNotice(chatId, item.content);
+                            }
+                            else if (shouldReplyToSource) {
                                 try {
                                     await this.replyFinalMessage(replyTarget, item.content, finalModel, finalStatus);
                                 }
@@ -2515,6 +2700,8 @@ export class FeishuBot {
                             return;
                         }
                         this.store.markDeliveryFailed(item.id);
+                        if (item.sourceType === "run_error")
+                            return;
                         const label = failureStage === "attachment" ? "附件发送失败" : "最终回复发送失败";
                         const errorText = `⚠️ ${label}（已重试 ${DELIVERY_MAX_ATTEMPTS} 次）：${this.errorSummary(err)}`;
                         const replyTarget = item.replyToMessageId || replyToMessageId;
@@ -2602,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,
@@ -2620,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;
@@ -2719,6 +2925,7 @@ export class FeishuBot {
                 toolCalls: view.toolCalls,
                 elapsed: view.elapsed,
                 model: view.model,
+                thinkingLevel: view.thinkingLevel,
                 locale: en ? "en" : "zh",
             }, statusEmoji);
             return {
@@ -2754,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 {
@@ -2842,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",
@@ -3280,6 +3493,16 @@ export class FeishuBot {
     /**
      * Send a proactive message to a chat (not a reply).
      */
+    async sendErrorNotice(chatId, text) {
+        const res = await this.client.im.message.create({
+            params: { receive_id_type: "chat_id" },
+            data: { receive_id: chatId, msg_type: "text", content: JSON.stringify({ text }) },
+        });
+        const id = res?.data?.message_id || res?.message_id;
+        if (!id)
+            throw new Error("Error notice send returned no confirmed message id");
+        return id;
+    }
     async sendFinalMessage(chatId, text, model, status) {
         if (!model?.trim())
             return this.sendMessage(chatId, text);
@@ -3609,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);
@@ -3630,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",
@@ -3659,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.
@@ -3840,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 = [];
@@ -4070,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,