openclaw-lark-multi-agent 1.4.7 → 1.4.9

package/dist/openclaw-client.js

@@ -1,8 +1,15 @@
 import WebSocket from "ws";
+import { SessionWaitPaused, normalizeSessionRuntimeStatus, isWaitTimeout, FOREGROUND_WAIT_MS } from "./session-status.js";
 import { randomUUID } from "crypto";
 import { mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
 import { basename, extname, join, resolve, sep } from "path";
 import { getBridgeAttachmentsDir, getDataDir } from "./paths.js";
+export class InactiveRunObservation extends Error {
+    constructor() {
+        super("Gateway 确认当前会话已空闲，但旧运行结果未能确认；追加消息将继续处理，未停止任何后台任务。");
+        this.name = "InactiveRunObservation";
+    }
+}
 export const GATEWAY_PROTOCOL_MIN = 4;
 export const GATEWAY_PROTOCOL_MAX = 4;
 const REQUIRED_GATEWAY_METHODS = [
@@ -38,6 +45,8 @@ export class OpenClawClient {
     reconnectDelay = 1000;
     maxReconnectDelay = 30000;
     shouldReconnect = true;
+    /** Read-only reconciliation for a collector whose plugin reports no active run. */
+    runStateChecks = new Map();
     /** Callbacks for tool events (verbose mode) */
     toolEventCallbacks = new Map();
     lastToolNamesByItemId = new Map();
@@ -689,10 +698,12 @@ export class OpenClawClient {
      * Collect agent reply by polling accumulated events.
      * Matches by initial runId OR sessionKey to handle multi-turn tool calling
      * where OpenClaw creates new runIds for each tool-call round.
-     * No aggressive timeout — waits for lifecycle end as the source of truth.
-     * 30-minute safety net only for catastrophic WS disconnection.
+     * Existing event/anchor matching is retained. After 30 minutes of silence,
+     * reconcile the original run instead of aborting or treating a draft as final.
+     * Explicit terminal/error/disconnect paths keep their existing behavior.
      */
-    collectReply(runId, timeoutMs = 1800000, targetSessionKey, options) {
+    collectReply(runId, timeoutMs = FOREGROUND_WAIT_MS, targetSessionKey, options) {
+        let cleanupObservation = () => { };
         return new Promise((resolve, reject) => {
             // Whether we were connected when the run started. We only treat a later
             // disconnect as a mid-run gateway drop (fail fast) if we began connected;
@@ -727,37 +738,111 @@ export class OpenClawClient {
                 return actual === expected || actual.includes(expected) || expected.includes(actual);
             };
             let idleTimer;
-            const resetIdleTimer = () => {
-                if (idleTimer)
-                    clearTimeout(idleTimer);
-                idleTimer = setTimeout(() => {
-                    clearInterval(poller);
-                    if (chatFinalTimer)
-                        clearTimeout(chatFinalTimer);
-                    if (lifecycleEndTimer)
-                        clearTimeout(lifecycleEndTimer);
-                    if (replayInvalidTimer)
-                        clearTimeout(replayInvalidTimer);
-                    if (genericChatErrorTimer)
-                        clearTimeout(genericChatErrorTimer);
-                    console.warn(`[OpenClaw] collectReply idle timeout for runId=${runId} sessionKey=${sessionKey}`);
-                    this.abortChat(targetSessionKey || sessionKey, runId).catch((err) => {
-                        console.warn(`[OpenClaw] abort after collectReply idle timeout failed:`, err.message);
-                    });
-                    const visibleText = this.pickBestCollectedText(chatFinalText, text, chatDeltaText, transcriptAssistantText);
-                    if (visibleText) {
-                        resolve(visibleText);
+            let observationClosed = false;
+            let checkingState = false;
+            let lastStateCheckAt = -Infinity;
+            let quietNotified = false;
+            let decidingTimeout = false;
+            let waitNoticeSent = false;
+            let foregroundPaused = false;
+            let foregroundWaitTimer;
+            const handleTimeoutResult = async (error) => {
+                if (observationClosed)
+                    return;
+                if (chatFinalText.trim()) {
+                    finish(chatFinalText);
+                    return;
+                }
+                if (error instanceof SessionWaitPaused && options?.onWaitPaused) {
+                    // Foreground notice, background observation. Keep the original queue
+                    // owner/progress path so later input still steers into the same run.
+                    foregroundPaused = true;
+                    if (foregroundWaitTimer)
+                        clearTimeout(foregroundWaitTimer);
+                    if (!waitNoticeSent) {
+                        waitNoticeSent = true;
+                        try {
+                            await options.onWaitPaused(error);
+                        }
+                        catch {
+                            console.warn("[OpenClaw] wait notice delivery pending; observation retained");
+                        }
+                    }
+                    decidingTimeout = false;
+                    if (!observationClosed)
+                        resetIdleTimer(60_000, false);
+                    return;
+                }
+                reject(error);
+            };
+            const checkRunState = async () => {
+                if (observationClosed || checkingState || Date.now() - lastStateCheckAt < 60_000)
+                    return;
+                checkingState = true;
+                lastStateCheckAt = Date.now();
+                try {
+                    const snapshot = await this.rpc("agent.wait", { runId, timeoutMs: 1500 }, 2500);
+                    if (observationClosed || snapshot?.runId !== runId || snapshot?.pendingError === true
+                        || snapshot?.timeoutPhase === "queue" || snapshot?.timeoutPhase === "gateway_draining")
+                        return;
+                    // A bare wait timeout is not an execution timeout. Require a recorded
+                    // terminal time; never infer failure from stopReason or replay flags.
+                    const ended = snapshot.endedAt;
+                    if (typeof ended !== "number" || !Number.isFinite(ended) || ended <= 0
+                        || (typeof snapshot.startedAt === "number" && ended < snapshot.startedAt))
+                        return;
+                    if (snapshot.status === "ok" && snapshot.yielded !== true) {
+                        const terminal = snapshot.terminalReply;
+                        const visible = terminal?.disposition === "visible" && typeof terminal.text === "string"
+                            ? terminal.text : terminal?.disposition === "silent" ? "NO_REPLY"
+                            : this.pickBestCollectedText(chatFinalText, text, chatDeltaText, transcriptAssistantText);
+                        resolve(visible || "NO_REPLY");
                     }
-                    else if (pendingRuntimeFailureText) {
-                        resolve(`${pendingRuntimeFailureText}\n\nLMA 已连续 ${Math.round(timeoutMs / 60000)} 分钟没有收到新的工具输出或最终回复，已停止等待。`);
+                    else if (snapshot.status === "error" || snapshot.status === "timeout") {
+                        if (snapshot.status === "timeout" || isWaitTimeout(String(snapshot.error || ""))) {
+                            const status = await this.getSessionRuntimeStatus(targetSessionKey || sessionKey);
+                            if (!observationClosed && status.running) {
+                                await handleTimeoutResult(new SessionWaitPaused(status, true));
+                                return;
+                            }
+                        }
+                        if (observationClosed)
+                            return;
+                        reject(new Error(`Agent error: ${typeof snapshot.error === "string" && snapshot.error.trim()
+                            ? snapshot.error : `Gateway 已确认运行以 ${snapshot.status} 结束`}`));
                     }
-                    else if (lastActivitySummary) {
-                        resolve(`⚠️ Agent 长时间没有产生最终回复\n最后活动: ${lastActivitySummary}\n时间: ${new Date(lastActivityAt).toLocaleString()}\n\nLMA 已连续 ${Math.round(timeoutMs / 60000)} 分钟没有收到新的工具输出或最终回复，已停止等待。`);
+                }
+                catch { /* Unavailable evidence means keep waiting, never abort/replay. */ }
+                finally {
+                    checkingState = false;
+                }
+            };
+            const resetIdleTimer = (delayMs = timeoutMs, activity = true) => {
+                if (activity) {
+                    if (!foregroundPaused)
+                        waitNoticeSent = false;
+                    quietNotified = false;
+                }
+                if (idleTimer)
+                    clearTimeout(idleTimer);
+                if (observationClosed)
+                    return;
+                idleTimer = setTimeout(async () => {
+                    if (!quietNotified) {
+                        quietNotified = true;
+                        console.warn(`[OpenClaw] quiet run ${runId}; checking Gateway state without stopping execution`);
                     }
-                    else {
-                        resolve("(timeout: no reply received)");
+                    await checkRunState();
+                    if (!observationClosed) {
+                        const status = await this.getSessionRuntimeStatus(targetSessionKey || sessionKey);
+                        if (!observationClosed && status.running) {
+                            await handleTimeoutResult(new SessionWaitPaused(status));
+                            return;
+                        }
                     }
-                }, timeoutMs);
+                    if (!observationClosed)
+                        resetIdleTimer(60_000, false);
+                }, delayMs);
             };
             const summarizeActivity = (ev) => {
                 if (ev.stream === "item") {
@@ -1041,7 +1126,14 @@ export class OpenClawClient {
                                         return;
                                     }
                                     if (state !== "working") {
-                                        finish(failureText);
+                                        if (isWaitTimeout(failureText)) {
+                                            if (!decidingTimeout) {
+                                                decidingTimeout = true;
+                                                void this.classifyWaitTimeout(failureText, targetSessionKey || sessionKey).then(handleTimeoutResult);
+                                            }
+                                        }
+                                        else
+                                            finish(failureText);
                                         return;
                                     }
                                     console.warn(`[OpenClaw] empty lifecycle end ignored for runId=${evRunId || runId}; waiting for real text or idle timeout`);
@@ -1076,6 +1168,14 @@ export class OpenClawClient {
                                 console.warn(`[OpenClaw] recoverable lifecycle error for runId=${evRunId || runId}; deferring (agent may auto-recover): ${errText.slice(0, 120)}`);
                                 return;
                             }
+                            if (isWaitTimeout(errText)) {
+                                bucket.splice(i, 1);
+                                if (!decidingTimeout) {
+                                    decidingTimeout = true;
+                                    void this.classifyWaitTimeout(errText, targetSessionKey || sessionKey).then(handleTimeoutResult);
+                                }
+                                continue;
+                            }
                             clearTimeout(idleTimer);
                             clearInterval(poller);
                             if (chatFinalTimer)
@@ -1101,7 +1201,13 @@ export class OpenClawClient {
                                 if (!genericChatErrorTimer) {
                                     genericChatErrorTimer = setTimeout(() => {
                                         genericChatErrorTimer = null;
-                                        void this.resolveTerminalChatError(evRunId || runId).then((detail) => {
+                                        void this.resolveTerminalChatError(evRunId || runId, targetSessionKey || sessionKey).then((detail) => {
+                                            if (observationClosed)
+                                                return;
+                                            if (chatFinalText.trim()) {
+                                                finish(chatFinalText);
+                                                return;
+                                            }
                                             clearTimeout(idleTimer);
                                             clearInterval(poller);
                                             if (chatFinalTimer)
@@ -1109,7 +1215,7 @@ export class OpenClawClient {
                                             if (lifecycleEndTimer)
                                                 clearTimeout(lifecycleEndTimer);
                                             reject(new Error(`Agent error: ${detail}`));
-                                        });
+                                        }, error => { void handleTimeoutResult(error); });
                                     }, 350);
                                 }
                                 continue;
@@ -1121,6 +1227,14 @@ export class OpenClawClient {
                                 bucket.splice(i, 1);
                                 continue;
                             }
+                            if (isWaitTimeout(errText)) {
+                                bucket.splice(i, 1);
+                                if (!decidingTimeout) {
+                                    decidingTimeout = true;
+                                    void this.classifyWaitTimeout(errText, targetSessionKey || sessionKey).then(handleTimeoutResult);
+                                }
+                                continue;
+                            }
                             clearTimeout(idleTimer);
                             clearInterval(poller);
                             if (chatFinalTimer)
@@ -1141,7 +1255,61 @@ export class OpenClawClient {
                     }
                 }
             }, 50);
-        });
+            const observationKey = targetSessionKey ? this.canonicalSessionKey(targetSessionKey) : "";
+            const checkAfterNoActiveRun = async () => {
+                await checkRunState();
+                if (observationClosed || !observationKey)
+                    return;
+                try {
+                    // Used only after the plugin reports no active run. Missing terminal
+                    // history is not failure, but an explicit idle session must not keep
+                    // a phantom queue owner blocking this newly-arrived user message.
+                    const history = await this.rpc("chat.history", { sessionKey: observationKey, limit: 1 }, 2500);
+                    if (!observationClosed && history?.sessionKey === observationKey && history?.sessionInfo?.hasActiveRun === false) {
+                        reject(new InactiveRunObservation());
+                    }
+                }
+                catch { /* Unknown activity cannot authorize releasing an active owner. */ }
+            };
+            if (observationKey)
+                this.runStateChecks.set(observationKey, checkAfterNoActiveRun);
+            // Fixed foreground budget: tool/assistant activity must not keep a card
+            // refreshing indefinitely. The original result observer stays alive.
+            if (options?.onWaitPaused) {
+                foregroundWaitTimer = setTimeout(async () => {
+                    if (observationClosed || foregroundPaused)
+                        return;
+                    await checkRunState();
+                    if (observationClosed || foregroundPaused)
+                        return;
+                    const status = await this.getSessionRuntimeStatus(targetSessionKey || sessionKey);
+                    if (!observationClosed && !foregroundPaused)
+                        await handleTimeoutResult(new SessionWaitPaused(status));
+                }, timeoutMs);
+                foregroundWaitTimer.unref?.();
+            }
+            // Bound local resources without cancelling an execution we cannot prove stuck.
+            const observationHorizon = setTimeout(() => reject(new Error("LMA 本地监听达到 24 小时上限，结果未确认；未发送停止请求，请检查原运行。")), 24 * 60 * 60_000);
+            observationHorizon.unref?.();
+            cleanupObservation = () => {
+                observationClosed = true;
+                clearTimeout(idleTimer);
+                if (foregroundWaitTimer)
+                    clearTimeout(foregroundWaitTimer);
+                clearTimeout(observationHorizon);
+                clearInterval(poller);
+                if (chatFinalTimer)
+                    clearTimeout(chatFinalTimer);
+                if (lifecycleEndTimer)
+                    clearTimeout(lifecycleEndTimer);
+                if (replayInvalidTimer)
+                    clearTimeout(replayInvalidTimer);
+                if (genericChatErrorTimer)
+                    clearTimeout(genericChatErrorTimer);
+                if (observationKey && this.runStateChecks.get(observationKey) === checkAfterNoActiveRun)
+                    this.runStateChecks.delete(observationKey);
+            };
+        }).finally(() => cleanupObservation());
     }
     /**
      * Recoverable agent errors are lifecycle errors that OpenClaw can self-heal
@@ -1155,12 +1323,19 @@ export class OpenClawClient {
         const t = (errText || "").trim().toLowerCase();
         return t === "chat error" || t === "agent error: chat error";
     }
-    async resolveTerminalChatError(runId) {
+    async resolveTerminalChatError(runId, sessionKey) {
         try {
             const snapshot = await this.rpc("agent.wait", { runId, timeoutMs: 1500 }, 2500);
+            if (sessionKey && (snapshot?.status === "timeout" || isWaitTimeout(String(snapshot?.error || "")))) {
+                const status = await this.getSessionRuntimeStatus(sessionKey);
+                if (status.running)
+                    throw new SessionWaitPaused(status, true);
+            }
             return this.formatTerminalRunError(snapshot);
         }
         catch (err) {
+            if (err instanceof SessionWaitPaused)
+                throw err;
             const detail = err instanceof Error ? err.message : String(err);
             return `OpenClaw 运行失败，但未返回具体原因${detail ? `（${detail}）` : ""}`;
         }
@@ -1228,39 +1403,41 @@ export class OpenClawClient {
         return this.rpc("chat.inject", { ...params, sessionKey: this.canonicalSessionKey(params.sessionKey) }, 10000);
     }
     /**
-     * Submit a mid-run message through OpenClaw's public atomic steer path.
-     * OpenClaw 2026.8 deprecated the synchronous plugin primitive previously used
-     * by `lma-steer`: its boolean only represented immediate eligibility and could
-     * still be rejected asynchronously. `chat.send queueMode=steer` owns admission
-     * and transcript persistence. LMA still treats the RPC result as provisional;
-     * the Feishu reaction flips to Get only after a matching `session.message`
-     * confirms that the input was committed/consumed.
+     * Submit a mid-run message through the lma-steer plugin.
+     *
+     * OpenClaw's public `chat.send { queueMode: "steer" }` returns `started` even
+     * when it falls through to a later ordinary run; it therefore cannot tell the
+     * bridge whether THIS message entered the active run. The plugin resolves the
+     * active embedded run and reports `steered` only when it actually queued there.
+     * A matching session.message remains the final consumption confirmation.
+     *
+     * If the plugin is missing, stale, or rejects the injection, return unavailable
+     * and let LMA's durable trigger run normally after the current turn. Never use
+     * the ambiguous public admission as a realtime-insertion success signal.
      */
     async steer(sessionKey, text, displayText) {
         const key = this.canonicalSessionKey(sessionKey);
+        // Consumption can arrive before the plugin RPC response at a tool boundary.
+        const cancelPending = this.registerPendingSteer(key, text, displayText);
         try {
-            const res = await this.rpc("chat.send", {
-                sessionKey: key,
-                message: text,
-                queueMode: "steer",
-                deliver: false,
-                idempotencyKey: randomUUID(),
-            }, 10000);
-            const status = res?.status;
-            if (status !== "started" && status !== "in_flight" && status !== "ok") {
+            const res = await this.rpc("lma.steer", { sessionKey: key, text }, 10000);
+            if (res?.status !== "steered") {
+                // A locally busy collector can outlive the actual Gateway turn. Check
+                // its exact terminal record now, rather than parking input for 30 min.
+                if (res?.status === "no_active_run")
+                    await this.runStateChecks.get(key)?.();
+                if (res?.status && res.status !== "no_active_run") {
+                    console.warn(`[OpenClaw] lma.steer ${res.status} for ${key.slice(-8)}`);
+                }
+                cancelPending();
                 return { status: "unavailable" };
             }
-            // This records only a provisional accepted input. Actual success is driven
-            // by handleSteerConsumption after the canonical transcript event arrives.
-            const cancelPending = this.registerPendingSteer(key, text, displayText);
-            return {
-                status: "steered",
-                runId: typeof res?.runId === "string" ? res.runId : undefined,
-                cancelPending,
-            };
+            return { status: "steered", cancelPending };
         }
         catch (err) {
-            console.warn(`[OpenClaw] native steer failed for ${key.slice(-8)}: ${err?.message || String(err)}`);
+            cancelPending();
+            const message = err?.message || String(err);
+            console.warn(`[OpenClaw] lma.steer unavailable for ${key.slice(-8)}: ${message}`);
             return { status: "unavailable" };
         }
     }
@@ -1398,6 +1575,37 @@ export class OpenClawClient {
     /**
      * Get session info (model, tokens, etc.) for status display.
      */
+    /** Stop claiming an exact run's final output after observation has paused. */
+    releasePausedWait(runId) {
+        if (!runId)
+            return;
+        const timer = this.ownedDeliveryRunTimers.get(runId);
+        if (timer)
+            clearTimeout(timer);
+        this.ownedDeliveryRunTimers.delete(runId);
+        this.ownedDeliveryRuns.delete(runId);
+    }
+    async getSessionRuntimeStatus(sessionKey) {
+        let timer;
+        try {
+            const value = await Promise.race([
+                this.rpc("sessions.describe", { key: this.canonicalSessionKey(sessionKey) }, 1500),
+                new Promise((_, reject) => { timer = setTimeout(() => reject(new Error("status lookup timeout")), 1500); }),
+            ]);
+            return normalizeSessionRuntimeStatus(value);
+        }
+        catch {
+            return normalizeSessionRuntimeStatus(undefined);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    async classifyWaitTimeout(text, sessionKey) {
+        const status = await this.getSessionRuntimeStatus(sessionKey).catch(() => normalizeSessionRuntimeStatus(undefined));
+        return status.running ? new SessionWaitPaused(status, true) : new Error(`Agent error: ${text}`);
+    }
     async getSessionInfo(sessionKey) {
         return this.rpc("sessions.describe", { key: this.canonicalSessionKey(sessionKey) });
     }
@@ -1641,6 +1849,7 @@ export class OpenClawClient {
         const fullSessionKey = this.canonicalSessionKey(params.sessionKey);
         this.clearVerboseAssistantState(sk);
         let ownedRunId = "";
+        let waitPaused = false;
         try {
             // Drop stale buffered events for this session before starting a new run.
             // This prevents an old final text (e.g. previous "ok") from being consumed by
@@ -1672,7 +1881,11 @@ export class OpenClawClient {
                 this.progressCallbacks.set(fullSessionKey, params.onProgress);
                 void params.onProgress({ kind: "lifecycle", text: "等待 OpenClaw 回复" });
             }
-            return await this.collectReply(result.runId, params.timeoutMs || 1800000, sk, { emptyFinalAsNoReply: params.emptyFinalAsNoReply, expectedUserText: params.message });
+            return await this.collectReply(result.runId, params.timeoutMs || FOREGROUND_WAIT_MS, sk, { emptyFinalAsNoReply: params.emptyFinalAsNoReply, expectedUserText: params.message, onWaitPaused: params.onWaitPaused });
+        }
+        catch (error) {
+            waitPaused = error instanceof SessionWaitPaused;
+            throw error;
         }
         finally {
             // OpenClaw can emit the final assistant session.message a moment after
@@ -1681,7 +1894,10 @@ export class OpenClawClient {
             // are unaffected because they do not go through chatSend.
             this.progressCallbacks.delete(sk);
             this.progressCallbacks.delete(fullSessionKey);
-            this.releaseOwnedDeliveryRunAfter(ownedRunId, 30000);
+            if (waitPaused)
+                this.releasePausedWait(ownedRunId);
+            else
+                this.releaseOwnedDeliveryRunAfter(ownedRunId, 30000);
         }
     }
     shouldInjectBridgeAttachmentHint(text) {
@@ -1733,6 +1949,7 @@ export class OpenClawClient {
                 onSendAttempt: params.onSendAttempt,
                 onSubmitted: params.onSubmitted,
                 onProgress: params.onProgress,
+                onWaitPaused: params.onWaitPaused,
             });
         }
         // Build context block + actual message in one chat.send, or write the
@@ -1769,6 +1986,7 @@ export class OpenClawClient {
             onSendAttempt: params.onSendAttempt,
             onSubmitted: params.onSubmitted,
             onProgress: params.onProgress,
+            onWaitPaused: params.onWaitPaused,
         });
     }
     formatContextLines(messages) {

package/dist/session-status.d.ts

@@ -0,0 +1,18 @@
+/** Frontend budget only; does not change Gateway execution limits. */
+export declare const FOREGROUND_WAIT_MS: number;
+export type SessionRuntimeStatus = {
+    status: string;
+    running: boolean;
+    checkedAt: number;
+    contextUsedTokens?: number;
+    contextLimitTokens?: number;
+};
+export declare const isWaitTimeout: (text: string) => boolean;
+export declare function normalizeSessionRuntimeStatus(value: any): SessionRuntimeStatus;
+/** Compact presentation only; never replaces the actual status/model values. */
+export declare function formatSessionFooter(snapshot: SessionRuntimeStatus): string;
+/** Local observation has ended, NOT an assertion that execution failed. */
+export declare class SessionWaitPaused extends Error {
+    readonly snapshot: SessionRuntimeStatus;
+    constructor(snapshot: SessionRuntimeStatus, reportedTimeout?: boolean);
+}

package/dist/session-status.js

@@ -0,0 +1,39 @@
+/** Frontend budget only; does not change Gateway execution limits. */
+export const FOREGROUND_WAIT_MS = 10 * 60_000;
+export const isWaitTimeout = (text) => /\btimeout\b|timed\s*out|超时/i.test(text) && !/invalid|validation|schema|malformed|permission denied|forbidden|unauthorized|authentication failed|quota|rate limit|无效参数|参数错误|校验失败/i.test(text);
+export function normalizeSessionRuntimeStatus(value) {
+    const session = value?.session || value?.sessionInfo;
+    const raw = typeof session?.status === "string" ? session.status.trim().toLowerCase() : "unknown";
+    const status = /^[a-z][a-z0-9 _|,-]{0,63}$/.test(raw) ? raw : "unknown";
+    const running = session?.hasActiveRun === true || status.split(/[|,]/).some((part) => part.trim() === "running");
+    // Same context counters as /status, not cumulative input/output billing.
+    // A missing/stale count must not be presented as an empty context.
+    const used = session?.totalTokens;
+    const limit = session?.contextTokens;
+    const contextUsedTokens = session?.totalTokensFresh !== false && typeof used === "number" && Number.isFinite(used) && used >= 0 ? used : undefined;
+    const contextLimitTokens = typeof limit === "number" && Number.isFinite(limit) && limit > 0 ? limit : undefined;
+    return { status: running ? "running" : status, running, checkedAt: Date.now(),
+        ...(contextUsedTokens !== undefined ? { contextUsedTokens } : {}),
+        ...(contextLimitTokens !== undefined ? { contextLimitTokens } : {}),
+    };
+}
+/** Compact presentation only; never replaces the actual status/model values. */
+export function formatSessionFooter(snapshot) {
+    const { contextUsedTokens: used, contextLimitTokens: limit } = snapshot;
+    if (used === undefined && limit === undefined)
+        return snapshot.status;
+    const usedK = used === undefined ? "?" : Math.round(used / 1000);
+    const limitK = limit === undefined ? "?" : Math.max(1, Math.round(limit / 1000));
+    return `${snapshot.status} · ${usedK}K/${limitK}K`;
+}
+/** Local observation has ended, NOT an assertion that execution failed. */
+export class SessionWaitPaused extends Error {
+    snapshot;
+    constructor(snapshot, reportedTimeout = false) {
+        super(reportedTimeout
+            ? "⏳ 本轮返回了超时，LMA 已暂停本次等待，但不据此认定整个会话已经结束。会话状态见下方；你可以继续等待后续结果。"
+            : "⏳ 本次等待时间已到，LMA 暂停本轮等待，先返回会话状态供你判断。\n没有因此停止运行或自动重发本次请求；你可以继续等待后续结果。");
+        this.snapshot = snapshot;
+        this.name = "SessionWaitPaused";
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-lark-multi-agent",
-  "version": "1.4.7",
+  "version": "1.4.9",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {
@@ -8,13 +8,13 @@
     "build:steer-plugin": "tsc -p plugins/lma-steer/tsconfig.json",
     "start": "node dist/index.js",
     "dev": "tsx src/index.ts",
-    "test": "vitest run",
-    "test:coverage": "vitest run --coverage",
+    "test": "vitest run --config tests/normal-flow-offline.config.ts",
+    "test:coverage": "vitest run --config tests/normal-flow-offline.config.ts --coverage",
     "prepack": "npm run build",
     "prepublishOnly": "npm test && npm pack --dry-run"
   },
   "dependencies": {
-    "@larksuiteoapi/node-sdk": "^1.62.1",
+    "@larksuiteoapi/node-sdk": "^1.73.3",
     "@types/ws": "^8.18.1",
     "better-sqlite3": "^12.9.0",
     "ws": "^8.20.0"

package/plugins/lma-steer/README.md

@@ -1,38 +1,45 @@
-# lma-steer (legacy compatibility plugin)
+# lma-steer
 
-This plugin is retained for older `openclaw-lark-multi-agent` deployments that
-called the private `lma.steer` Gateway method.
+`lma-steer` provides observable mid-run insertion for
+`openclaw-lark-multi-agent`.
 
-Current LMA releases on OpenClaw 2026.8+ do **not** use this plugin. They submit
-mid-run input through the public protocol API:
+OpenClaw's public `chat.send { queueMode: "steer" }` acknowledges admission with
+`started` even when the message falls through to a later ordinary run. That is
+not enough for LMA to tell users whether a message actually entered the active
+run. This plugin resolves the active embedded run and reports one of:
 
-```text
-chat.send { queueMode: "steer" }
-```
+- `steered` — queued into the active embedded run;
+- `no_active_run` — no active embedded run was found;
+- `rejected` — the runtime refused queueing.
 
-The public path owns admission, while LMA retains its durable fallback trigger
-until a matching `session.message` confirms transcript consumption. Only then
-is the Feishu acknowledgement changed from Typing to Get, so provisional
-acceptance and actual model consumption remain distinct.
+LMA treats `steered` as provisional until the matching `session.message`
+confirms transcript consumption. Any other outcome remains in LMA's durable
+normal queue.
 
-## Legacy installation
+## Installation
 
-Only install this plugin when maintaining an older LMA release that explicitly
-requires `lma.steer`:
+Realtime mid-run insertion requires this plugin:
 
 ```bash
 lma install-steer-plugin
 ```
 
-Restart the OpenClaw Gateway after installation. For new deployments, skip this
-step.
+Restart the OpenClaw Gateway after installation. LMA itself remains functional
+without the plugin, but messages received during a run wait safely in the
+normal queue.
 
-## Legacy method
+## Gateway method
 
 - method: `lma.steer`
 - params: `{ sessionKey: string, text: string }`
 - result: `{ status: "steered" | "no_active_run" | "rejected", sessionId?: string }`
 
-Its synchronous `steered` result reflects immediate queue eligibility only; it
-cannot prove later runtime consumption. This limitation is why current LMA uses
-the public native steering path instead.
+## 0.1.1 compatibility refresh
+
+This release retains the existing `lma.steer` runtime behavior. A synchronous
+`steered` result is provisional; LMA waits for a matching transcript message
+before reporting consumption. The experimental steer V2 and question service
+are not part of this release. A previously installed strict `questionBridge`
+configuration shape is accepted for upgrade compatibility only; the plugin
+ignores it and does not enable question handling. Existing values need not be
+removed or exposed during this update.