openclaw-lark-multi-agent 1.4.8 → 1.4.10

package/dist/openclaw-client.d.ts

@@ -1,3 +1,4 @@
+import { SessionWaitPaused, type SessionRuntimeStatus } from "./session-status.js";
 import { OpenClawConfig } from "./config.js";
 import { ChatMessage } from "./message-store.js";
 export type ProgressEvent = {
@@ -15,6 +16,9 @@ export type ProgressEvent = {
     kind: "lifecycle";
     text: string;
 };
+export declare class InactiveRunObservation extends Error {
+    constructor();
+}
 export type ChatAttachment = {
     type?: string;
     mimeType?: string;
@@ -37,6 +41,8 @@ export declare class OpenClawClient {
     private reconnectDelay;
     private maxReconnectDelay;
     private shouldReconnect;
+    /** Read-only reconciliation for a collector whose plugin reports no active run. */
+    private runStateChecks;
     /** Callbacks for tool events (verbose mode) */
     private toolEventCallbacks;
     private lastToolNamesByItemId;
@@ -102,8 +108,9 @@ export declare 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.
      */
     private collectReply;
     /**
@@ -179,6 +186,10 @@ export declare 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: string): void;
+    getSessionRuntimeStatus(sessionKey: string): Promise<SessionRuntimeStatus>;
+    private classifyWaitTimeout;
     getSessionInfo(sessionKey: string): Promise<any>;
     /**
      * Ensure session is using the expected model. If not, patch it back.
@@ -222,6 +233,7 @@ export declare class OpenClawClient {
         /** Called after chat.send RPC succeeds and OpenClaw has accepted the user message. */
         onSubmitted?: (runId: string) => void | Promise<void>;
         onProgress?: (event: ProgressEvent) => void | Promise<void>;
+        onWaitPaused?: (notice: SessionWaitPaused) => void | Promise<void>;
     }): Promise<string>;
     private shouldInjectBridgeAttachmentHint;
     private bridgeAttachmentHint;
@@ -255,6 +267,7 @@ export declare class OpenClawClient {
         /** Called after chat.send RPC succeeds and OpenClaw has accepted the combined message. */
         onSubmitted?: (runId: string) => void | Promise<void>;
         onProgress?: (event: ProgressEvent) => void | Promise<void>;
+        onWaitPaused?: (notice: SessionWaitPaused) => void | Promise<void>;
     }): Promise<string>;
     private formatContextLines;
     private writeContextSyncFile;

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();
@@ -222,7 +231,9 @@ export class OpenClawClient {
                             this.agentEvents.get(sk).push({
                                 ...frame.payload,
                                 stream: "chatFinal",
-                                data: { text: textParts.join("\n") },
+                                // Only the Gateway chat-final envelope confirms a handoff.
+                                // Never infer it from tool names, arguments or raw tool output.
+                                data: { text: textParts.join("\n"), gatewayYielded: frame.payload?.yielded === true },
                             });
                         }
                         else if (state === "error") {
@@ -458,6 +469,11 @@ export class OpenClawClient {
     /** Render protocol-4 structured tool args/results without `[object Object]`.
      * Prefer useful, non-secret fields and keep the fallback bounded. */
     formatToolValue(value, toolName, phase) {
+        // sessions_yield.message is private resumed context. Do not mirror its
+        // arguments/results (including JSON strings) into process cards or verbose
+        // tool replies. This is redaction only, never evidence of a handoff.
+        if (toolName === "sessions_yield")
+            return "";
         if (value === null || value === undefined || value === "")
             return "";
         if (typeof value === "string")
@@ -689,11 +705,13 @@ 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) {
-        return new Promise((resolve, reject) => {
+    collectReply(runId, timeoutMs = FOREGROUND_WAIT_MS, targetSessionKey, options) {
+        let cleanupObservation = () => { };
+        return new Promise((resolveResult, rejectResult) => {
             // 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;
             // this keeps unit tests that drive collectReply without a live socket from
@@ -702,6 +720,7 @@ export class OpenClawClient {
             let text = "";
             let chatDeltaText = "";
             let chatFinalText = "";
+            let chatFinalSeen = false;
             let transcriptAssistantText = "";
             let sessionKey = targetSessionKey ? `agent:main:${targetSessionKey.replace(/^agent:[^:]+:/, "")}` : "";
             let shortSessionKey = targetSessionKey ? targetSessionKey.replace(/^agent:[^:]+:/, "") : "";
@@ -727,37 +746,117 @@ 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;
+            // Close synchronously: a deferred yield notice must not overtake a final
+            // or error just because Promise.finally cleanup has not run yet.
+            const resolve = (value) => { observationClosed = true; resolveResult(value); };
+            const reject = (error) => { observationClosed = true; rejectResult(error); };
+            let checkingState = false;
+            let lastStateCheckAt = -Infinity;
+            let quietNotified = false;
+            let decidingTimeout = false;
+            let waitNoticeSent = false;
+            let foregroundPaused = false;
+            let foregroundYielded = false;
+            let turnYielded = 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");
+                        }
                     }
-                    else if (pendingRuntimeFailureText) {
-                        resolve(`${pendingRuntimeFailureText}\n\nLMA 已连续 ${Math.round(timeoutMs / 60000)} 分钟没有收到新的工具输出或最终回复，已停止等待。`);
+                    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 (lastActivitySummary) {
-                        resolve(`⚠️ Agent 长时间没有产生最终回复\n最后活动: ${lastActivitySummary}\n时间: ${new Date(lastActivityAt).toLocaleString()}\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 {
-                        resolve("(timeout: no reply received)");
+                }
+                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`);
                     }
-                }, timeoutMs);
+                    await checkRunState();
+                    if (!observationClosed) {
+                        const status = await this.getSessionRuntimeStatus(targetSessionKey || sessionKey);
+                        if (!observationClosed && status.running) {
+                            await handleTimeoutResult(new SessionWaitPaused(status));
+                            return;
+                        }
+                    }
+                    if (!observationClosed)
+                        resetIdleTimer(60_000, false);
+                }, delayMs);
             };
             const summarizeActivity = (ev) => {
                 if (ev.stream === "item") {
@@ -897,6 +996,16 @@ export class OpenClawClient {
                             }
                             continue;
                         }
+                        // After handoff, an unowned new run (including requester-settle)
+                        // retains its existing proactive delivery route. A session/lifecycle
+                        // start alone must not turn it into the old run's final. Discussion's
+                        // transcript mute marks scheduler-owned collection; retain its existing
+                        // anchored collector path rather than changing discussion routing.
+                        if (eventSessionMatches && foregroundYielded && evRunId && !matchesRun
+                            && !this.mutedProactiveSessions.has(sessionKey) && !this.mutedProactiveSessions.has(shortSessionKey)) {
+                            bucket.splice(i, 1);
+                            continue;
+                        }
                         if (eventSessionMatches && expectedUserText && !anchorSeen && !matchesRun) {
                             bucket.splice(i, 1);
                             preAnchorEvents.push(ev);
@@ -950,6 +1059,10 @@ export class OpenClawClient {
                         if (ev.stream !== "lifecycle") {
                             pendingRuntimeFailureText = "";
                         }
+                        // A matched resumed turn can again complete via the existing
+                        // assistant/transcript + lifecycle path, even without chat final.
+                        if (ev.stream === "lifecycle" && ev.data?.phase === "start")
+                            turnYielded = false;
                         if (ev.stream === "lifecycle" && ev.data?.phase === "start" && !lifecycleStartedLogged) {
                             lifecycleStartedLogged = true;
                             console.log(`[OpenClaw] lifecycle start for runId=${runId} after ${Date.now() - collectStartedAt}ms`);
@@ -982,17 +1095,48 @@ export class OpenClawClient {
                             }
                         }
                         if (ev.stream === "chatFinal") {
+                            chatFinalSeen = true;
+                            if (ev.data?.gatewayYielded === true) {
+                                // A yielded turn is not a terminal answer, even if its buffered
+                                // message contains a preface. Preserve the collector/queue owner
+                                // and final-delivery key; only pause foreground presentation.
+                                if (chatFinalText.trim())
+                                    continue; // an actual final wins
+                                foregroundYielded = true;
+                                turnYielded = true;
+                                text = chatDeltaText = transcriptAssistantText = "";
+                                if (chatFinalTimer) {
+                                    clearTimeout(chatFinalTimer);
+                                    chatFinalTimer = null;
+                                }
+                                if (lifecycleEndTimer) {
+                                    clearTimeout(lifecycleEndTimer);
+                                    lifecycleEndTimer = null;
+                                }
+                                // Finish scanning this batch first so an already-arrived real
+                                // final/error wins over a stale waiting notice. No status RPC
+                                // (or ten-minute budget) is needed to confirm this wire fact.
+                                if (options?.onWaitPaused)
+                                    void Promise.resolve().then(() => handleTimeoutResult(new SessionWaitPaused(normalizeSessionRuntimeStatus(undefined), false, "yield")));
+                                continue;
+                            }
                             chatFinalText = ev.data?.text || "";
+                            if (chatFinalText.trim())
+                                turnYielded = false;
+                            else if (turnYielded)
+                                continue;
                             // Fallback: if lifecycle end doesn't arrive within 5s, resolve
                             if (!chatFinalTimer) {
                                 chatFinalTimer = setTimeout(() => {
                                     console.warn(`[OpenClaw] collectReply: lifecycle end missing, using chatFinal fallback`);
-                                    this.abortChat(targetSessionKey || sessionKey, runId).catch((err) => {
-                                        console.warn(`[OpenClaw] abort after chatFinal fallback failed:`, err.message);
-                                    });
                                     // Prefer final chat message over accumulated deltas: some providers may
                                     // emit only partial deltas (e.g. "N") while final contains "NO_REPLY".
                                     const latestFinalText = this.pickBestCollectedText(chatFinalText, text, chatDeltaText, transcriptAssistantText);
+                                    // Never abort a yielded original run, nor an empty final.
+                                    if (!foregroundYielded && latestFinalText)
+                                        this.abortChat(targetSessionKey || sessionKey, runId).catch((err) => {
+                                            console.warn(`[OpenClaw] abort after chatFinal fallback failed:`, err.message);
+                                        });
                                     if (latestFinalText) {
                                         finish(latestFinalText);
                                     }
@@ -1007,6 +1151,11 @@ export class OpenClawClient {
                             }
                         }
                         if (ev.stream === "lifecycle" && ev.data?.phase === "end") {
+                            // paused/end_turn can beat the confirming chat event, including
+                            // discussion's emptyFinalAsNoReply path. It is neither success
+                            // nor failure and alone does NOT authorize a handoff notice.
+                            if (!chatFinalText.trim() && (turnYielded || (ev.data?.livenessState === "paused" && ev.data?.stopReason === "end_turn")))
+                                continue;
                             // Prefer final chat message over accumulated deltas: some providers may
                             // emit only partial deltas (e.g. "N") while final contains "NO_REPLY".
                             const finalText = this.pickBestCollectedText(chatFinalText, text, chatDeltaText, transcriptAssistantText);
@@ -1041,7 +1190,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`);
@@ -1051,7 +1207,12 @@ export class OpenClawClient {
                             };
                             // If lifecycle end beats chat final, a short delta like "N" can be a truncated
                             // final reply. Wait for chatFinal before resolving; otherwise suppress lone "N".
-                            if (!options?.emptyFinalAsNoReply && ev.data?.livenessState === "working" && !chatFinalText && text.length <= 1) {
+                            if ((!options?.emptyFinalAsNoReply && ev.data?.livenessState === "working" && !chatFinalText && text.length <= 1)
+                                || (options?.emptyFinalAsNoReply && !chatFinalSeen && !finalText)) {
+                                // A lifecycle-only empty discussion end also needs this small
+                                // window for a confirming yielded chat final, not instant NO_REPLY.
+                                if (lifecycleEndTimer)
+                                    clearTimeout(lifecycleEndTimer);
                                 lifecycleEndTimer = setTimeout(finishFromLifecycle, 5000);
                             }
                             else {
@@ -1076,6 +1237,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 +1270,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 +1284,7 @@ export class OpenClawClient {
                                             if (lifecycleEndTimer)
                                                 clearTimeout(lifecycleEndTimer);
                                             reject(new Error(`Agent error: ${detail}`));
-                                        });
+                                        }, error => { void handleTimeoutResult(error); });
                                     }, 350);
                                 }
                                 continue;
@@ -1121,6 +1296,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 +1324,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 +1392,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}）` : ""}`;
         }
@@ -1242,18 +1486,25 @@ export class OpenClawClient {
      */
     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("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" };
             }
-            const cancelPending = this.registerPendingSteer(key, text, displayText);
             return { status: "steered", cancelPending };
         }
         catch (err) {
+            cancelPending();
             const message = err?.message || String(err);
             console.warn(`[OpenClaw] lma.steer unavailable for ${key.slice(-8)}: ${message}`);
             return { status: "unavailable" };
@@ -1393,6 +1644,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) });
     }
@@ -1636,6 +1918,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
@@ -1667,7 +1950,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
@@ -1676,7 +1963,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) {
@@ -1728,6 +2018,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
@@ -1764,6 +2055,7 @@ export class OpenClawClient {
             onSendAttempt: params.onSendAttempt,
             onSubmitted: params.onSubmitted,
             onProgress: params.onProgress,
+            onWaitPaused: params.onWaitPaused,
         });
     }
     formatContextLines(messages) {