@tea-agent/loop-agent 0.39.0-next.3 → 0.39.0-next.31

package/dist/worker/console/static-src/operator-chat/useChatStream.js

@@ -1,8 +1,8 @@
 import { useCallback, useEffect } from "react";
 import { formatOperatorUserError } from "../../operator-user-error.js";
 import { confirmationToken, requestId, sleep } from "./format.js";
-import { classifyCreateTurnNetworkFailure, classifyCreateTurnResponse, createPendingSubmission, isRuntimeBusyUnion, isSubmissionCurrent, isTerminalTurnState, keepAmbiguousAfterRetry, reconcilePendingSubmissionFromState, resolveAmbiguousFromState, } from "./turn-submission.js";
-import { applyAbortDecision, applyPendingReconcileDecision, classifyAbortResponse, markStopRequested, operatorChatAbortUrl, operatorChatEventsUrl, operatorChatStateUrl, operatorChatTurnsUrl, releaseOwnershipOnTerminalEvidence, releaseSubmitOwnership as releaseOwnershipBag, requestStopOnOwnership, settleCreateTurnOutcome, } from "./turn-stream-controller.js";
+import { classifyCreateTurnNetworkFailure, classifyCreateTurnResponse, createPendingSubmission, decideSubmissionRoute, isRuntimeBusyUnion, isSubmissionCurrent, isTerminalTurnState, keepAmbiguousAfterRetry, reconcileDeferredSubmissionFromState, reconcilePendingSubmissionFromState, resolveAmbiguousFromState, } from "./turn-submission.js";
+import { applyAbortDecision, applyPendingReconcileDecision, classifyAbortResponse, markStopRequested, operatorChatAbortUrl, operatorChatEventsUrl, operatorChatStateUrl, operatorChatTurnsUrl, releaseOwnershipOnTerminalEvidence, releaseSubmitOwnership as releaseOwnershipBag, requestStopOnOwnership, settleCreateTurnOutcome, turnPhaseFromOwnership, } from "./turn-stream-controller.js";
 /** Project ChatRefs into the executable ownership bag used by the controller. */
 function ownershipBagFromRefs(refs) {
     return {
@@ -57,7 +57,7 @@ function clearEmptyAssistant(setMessages, assistantId) {
  * detached Turn resource only; it never opens a second inline SSE consumer. */
 export function useChatStream(params) {
     const { origin, refs, session, thread, composer, setError, setAutoScroll, setNotice, recoveryVersion = 0, watchSessionTitle, } = params;
-    const { applySseBlock, setMessages, setStreaming, setStreamingAssistantId, streaming, } = thread;
+    const { applySseBlock, setMessages, setStreaming, setStreamingAssistantId, streaming, setTurnPhase, setDeferredTurn, } = thread;
     const { setInput, setPendingImages } = composer;
     const showNotice = useCallback((message) => {
         if (!setNotice)
@@ -78,9 +78,10 @@ export function useChatStream(params) {
         refs.assistantIdRef.current = null;
         refs.stoppingTurnIdRef.current = null;
         setStreaming(false);
+        setTurnPhase("idle");
         setStreamingAssistantId(null);
         clearEmptyAssistant(setMessages, assistantId);
-    }, [refs, setStreaming, setStreamingAssistantId, setMessages]);
+    }, [refs, setStreaming, setTurnPhase, setStreamingAssistantId, setMessages]);
     /** Follow one session's event stream until it is explicitly aborted. The
      * server's `stream_ready` marker separates replay from live events; this
      * means replay cannot render duplicate messages while live text remains
@@ -242,9 +243,13 @@ export function useChatStream(params) {
     /** Issue real POST /abort for a known turnId (Stop never disposes Session). */
     const postAbortForTurn = useCallback(async (sessionId, generation, turnId) => {
         refs.stoppingTurnIdRef.current = turnId;
-        // Keep streaming/busy while abort is in flight (UIS-stopping).
-        refs.streamingRef.current = true;
-        setStreaming(true);
+        // Optimistic visual stop: remove the running spinner immediately, but
+        // retain ownership as `stopping` until the server proves a terminal state.
+        // This keeps the composer responsive without falsely advertising idle.
+        refs.streamingRef.current = false;
+        setStreaming(false);
+        setTurnPhase("stopping");
+        setStreamingAssistantId(null);
         try {
             const res = await fetch(operatorChatAbortUrl(origin, sessionId, turnId), {
                 method: "POST",
@@ -278,6 +283,7 @@ export function useChatStream(params) {
                     markIdle: () => markIdleIfCurrent(sessionId, generation, refs.assistantIdRef.current),
                 });
                 applyOwnershipBagToRefs(refs, bag);
+                setTurnPhase(turnPhaseFromOwnership(bag));
                 return;
             }
             applyAbortDecision(bag, decision, noticeSink(), {
@@ -285,6 +291,11 @@ export function useChatStream(params) {
                 markIdle: () => markIdleIfCurrent(sessionId, generation, refs.assistantIdRef.current),
             });
             applyOwnershipBagToRefs(refs, bag);
+            setTurnPhase(turnPhaseFromOwnership(bag));
+            // Sync the post-decision busy state back to React: optimistic stop
+            // flipped it idle up front; pending/keep-busy outcomes restore it.
+            if (bag.streaming)
+                setStreaming(true);
         }
         catch {
             // Abort network failure: keep busy (UIS-abort-network-fail).
@@ -297,11 +308,17 @@ export function useChatStream(params) {
                 networkError: true,
             }), noticeSink());
             applyOwnershipBagToRefs(refs, bag);
+            // Network failure: the optimistic idle was premature — restore busy
+            // so the turn is not silently dropped; /state reconcile converges.
+            refs.streamingRef.current = true;
+            setStreaming(true);
+            setTurnPhase("stopping");
         }
     }, [
         origin,
         refs,
         setStreaming,
+        setTurnPhase,
         markIdleIfCurrent,
         fetchSessionState,
         noticeSink,
@@ -351,10 +368,12 @@ export function useChatStream(params) {
             },
         });
         applyOwnershipBagToRefs(refs, bag);
+        setTurnPhase(turnPhaseFromOwnership(bag));
     }, [
         refs,
         noticeSink,
         setStreaming,
+        setTurnPhase,
         setStreamingAssistantId,
         setPendingImages,
         watchSessionTitle,
@@ -363,20 +382,199 @@ export function useChatStream(params) {
         setError,
         postAbortForTurn,
     ]);
+    const queueDeferredTurn = useCallback(async (input) => {
+        const activeSession = refs.sessionRef.current;
+        if (!activeSession || (!input.text.trim() && input.images.length === 0))
+            return { action: "handled" };
+        const existing = thread.deferredTurn;
+        showNotice("正在排队…");
+        const acceptDeferred = (deferredTurn) => {
+            setDeferredTurn(deferredTurn);
+            setInput("");
+            setPendingImages([]);
+            setError(null);
+            showNotice(existing ? "已更新停止后发送的消息" : "已排队，将在上一轮停止后自动发送");
+        };
+        const acceptDispatched = () => {
+            setDeferredTurn(null);
+            setInput("");
+            setPendingImages([]);
+            setError(null);
+            showNotice("消息已进入发送");
+        };
+        const putOnce = async () => {
+            const response = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(activeSession.sessionId)}/deferred-turn`, {
+                method: "PUT",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-loop-console-confirmation": confirmationToken(),
+                },
+                credentials: "include",
+                body: JSON.stringify({
+                    clientRequestId: input.clientRequestId,
+                    blockedByTurnId: input.blockedByTurnId,
+                    text: input.text,
+                    images: input.images,
+                    ...(existing ? { expectedRevision: existing.revision } : {}),
+                }),
+            });
+            const body = (await response.json().catch(() => ({})));
+            return { response, body };
+        };
+        try {
+            for (let attempt = 0; attempt < 2; attempt += 1) {
+                const { response, body } = await putOnce();
+                if (response.ok && body.accepted && body.deferredTurn) {
+                    acceptDeferred(body.deferredTurn);
+                    return { action: "handled" };
+                }
+                if (body.deferredTurn)
+                    setDeferredTurn(body.deferredTurn);
+                if (body.error?.code !== "TURN_NOT_STOPPING") {
+                    setError(body.error?.message ??
+                        `待发送消息未被服务端接受（HTTP ${response.status}）`);
+                    return { action: "handled" };
+                }
+                const canonical = await fetchSessionState(activeSession.sessionId);
+                const decision = reconcileDeferredSubmissionFromState({
+                    clientRequestId: input.clientRequestId,
+                    blockedByTurnId: input.blockedByTurnId,
+                    state: canonical ?? undefined,
+                });
+                if (decision.action === "deferred") {
+                    acceptDeferred(decision.deferredTurn);
+                    return { action: "handled" };
+                }
+                if (decision.action === "accepted") {
+                    acceptDispatched();
+                    return { action: "handled" };
+                }
+                if (decision.action === "retry-deferred" && attempt === 0)
+                    continue;
+                if (decision.action === "send-now" && !existing) {
+                    showNotice("上一轮已停止，正在发送当前消息…");
+                    return { action: "send-now" };
+                }
+                setError(body.error?.message ?? "停止状态已变化，当前消息仍保留在输入框");
+                return { action: "handled" };
+            }
+            return { action: "handled" };
+        }
+        catch (error) {
+            const canonical = await fetchSessionState(activeSession.sessionId);
+            const decision = reconcileDeferredSubmissionFromState({
+                clientRequestId: input.clientRequestId,
+                blockedByTurnId: input.blockedByTurnId,
+                state: canonical ?? undefined,
+            });
+            if (decision.action === "deferred") {
+                acceptDeferred(decision.deferredTurn);
+                return { action: "handled" };
+            }
+            if (decision.action === "accepted") {
+                acceptDispatched();
+                return { action: "handled" };
+            }
+            if (decision.action === "send-now" && !existing) {
+                showNotice("上一轮已停止，正在发送当前消息…");
+                return { action: "send-now" };
+            }
+            setError(error instanceof Error
+                ? `无法确认消息是否已排队：${error.message}`
+                : "无法确认消息是否已排队，请刷新后查看服务端状态");
+            return { action: "handled" };
+        }
+    }, [
+        origin,
+        refs,
+        thread.deferredTurn,
+        setDeferredTurn,
+        setInput,
+        setPendingImages,
+        setError,
+        showNotice,
+        fetchSessionState,
+    ]);
+    const cancelDeferredTurn = useCallback(async () => {
+        const activeSession = refs.sessionRef.current;
+        const deferred = thread.deferredTurn;
+        if (!activeSession || !deferred)
+            return;
+        try {
+            const response = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(activeSession.sessionId)}/deferred-turn`, {
+                method: "DELETE",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-loop-console-confirmation": confirmationToken(),
+                },
+                credentials: "include",
+                body: JSON.stringify({
+                    clientRequestId: deferred.clientRequestId,
+                    expectedRevision: deferred.revision,
+                }),
+            });
+            const body = (await response.json().catch(() => ({})));
+            if (!response.ok || !body.cancelled) {
+                setError(body.error?.message ?? "待发送消息撤回失败");
+                return;
+            }
+            setDeferredTurn(null);
+            setInput(body.deferredTurn?.text ?? "");
+            setPendingImages(body.deferredTurn?.images ?? []);
+            setError(null);
+            showNotice("待发送消息已移回输入框");
+        }
+        catch (error) {
+            setError(error instanceof Error ? error.message : String(error));
+        }
+    }, [
+        origin,
+        refs,
+        thread.deferredTurn,
+        setDeferredTurn,
+        setInput,
+        setPendingImages,
+        setError,
+        showNotice,
+    ]);
     const sendPrompt = useCallback(async (text, images) => {
+        const initialSession = refs.sessionRef.current;
+        if (!initialSession || (!text.trim() && images.length === 0))
+            return;
+        const ownership = ownershipBagFromRefs(refs);
+        const route = decideSubmissionRoute({
+            turnPhase: turnPhaseFromOwnership(ownership),
+            blockedByTurnId: ownership.stoppingTurnId ?? ownership.activeTurnId,
+        });
+        const clientRequestId = requestId("chat-submit");
+        if (route.action === "hold") {
+            if (turnPhaseFromOwnership(ownership) === "stopping")
+                showNotice("正在确认上一轮停止状态，当前消息已保留");
+            return;
+        }
+        if (route.action === "queue-deferred") {
+            const deferred = await queueDeferredTurn({
+                text,
+                images,
+                clientRequestId,
+                blockedByTurnId: route.blockedByTurnId,
+            });
+            if (deferred.action !== "send-now")
+                return;
+        }
         const activeSession = refs.sessionRef.current;
         const generation = refs.sessionGenerationRef.current;
         if (!activeSession ||
+            activeSession.sessionId !== initialSession.sessionId ||
             (!text.trim() && images.length === 0) ||
             refs.streamingRef.current ||
             refs.submitInFlightRef.current ||
             // AC-R5-002: ownership lease blocks send until terminal release.
-            Boolean(refs.pendingSubmissionRef.current))
+            refs.pendingSubmissionRef.current)
             return;
         // AC-001: acquire synchronous submit ownership before the first await.
         refs.submitInFlightRef.current = true;
         const submitGeneration = ++refs.submitGenerationRef.current;
-        const clientRequestId = requestId("chat-submit");
         const userMessageId = requestId("u");
         const assistantId = requestId("a");
         const draftText = text.trim();
@@ -424,6 +622,7 @@ export function useChatStream(params) {
         setAutoScroll(true);
         setError(null);
         refs.streamingRef.current = true;
+        setTurnPhase("running");
         refs.assistantIdRef.current = assistantId;
         setStreaming(true);
         setStreamingAssistantId(assistantId);
@@ -519,7 +718,9 @@ export function useChatStream(params) {
         setAutoScroll,
         setError,
         setStreaming,
+        setTurnPhase,
         setStreamingAssistantId,
+        queueDeferredTurn,
     ]);
     const handleStop = useCallback(async () => {
         // AC-R5-001: durable stopRequested is set synchronously before any await so
@@ -535,6 +736,7 @@ export function useChatStream(params) {
             notice: noticeSink(),
         });
         applyOwnershipBagToRefs(refs, bag);
+        setTurnPhase("stopping");
         // Immediate abort already scheduled for a known turnId — coalesce via
         // abortPostedTurnIds; stopInFlight only gates concurrent in-flight POSTs.
         if (stopResult.abortedTurnId) {
@@ -643,6 +845,9 @@ export function useChatStream(params) {
                         },
                     });
                     applyOwnershipBagToRefs(refs, bag);
+                    setTurnPhase(turnPhaseFromOwnership(bag));
+                    if (state && "deferredTurn" in state)
+                        setDeferredTurn(state.deferredTurn ?? null);
                     if (result === "bound") {
                         // US-BUSY-ACTIVE-BOUND: keep streaming/busy with same id.
                         setStreaming(true);
@@ -742,6 +947,7 @@ export function useChatStream(params) {
         refs,
         session,
         streaming,
+        setTurnPhase,
         markIdleIfCurrent,
         releaseSubmitOwnership,
         postAbortForTurn,
@@ -763,5 +969,5 @@ export function useChatStream(params) {
             }
         };
     }, [session, recoveryVersion, refs, startEventsStream]);
-    return { sendPrompt, handleStop, openEventsStream };
+    return { sendPrompt, handleStop, cancelDeferredTurn, openEventsStream };
 }

package/dist/worker/console/static-src/operator-chat/useChatThread.js

@@ -1,6 +1,5 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
-import { parseAssistantContent } from "../../chat/assistant-content.js";
-import { buildTurnProcessGroups } from "../../chat/turn-process.js";
+import { buildTurnProcessGroups, hydrateSessionThread, selectRecentTurnGroups, } from "../../chat/turn-process.js";
 import { createChatSseEventApplier, } from "./chat-sse-events.js";
 import { taskContextUnchanged } from "./format.js";
 const EMPTY_USAGE = {
@@ -32,6 +31,8 @@ export function useChatThread(params) {
     const [contextLoading, setContextLoading] = useState(false);
     const [usage, setUsage] = useState(EMPTY_USAGE);
     const [streaming, setStreaming] = useState(false);
+    const [turnPhase, setTurnPhase] = useState("idle");
+    const [deferredTurn, setDeferredTurn] = useState(null);
     /** Assistant bubble id for the in-flight turn; only this row shows the streaming cursor. */
     const [streamingAssistantId, setStreamingAssistantId] = useState(null);
     const [showSystemInMessages] = useState(false);
@@ -45,6 +46,8 @@ export function useChatThread(params) {
         setHumanGateCards,
         setArtifactCards,
         setStreaming,
+        setTurnPhase,
+        setDeferredTurn,
         setStreamingAssistantId,
         setUnread,
         setOperationCards,
@@ -121,9 +124,7 @@ export function useChatThread(params) {
         }, 350);
         return () => window.clearTimeout(timer);
     }, [sessionId, operationCards, humanGateCards, interview, loadTaskContext]);
-    const visibleMessages = useMemo(() => messages
-        .filter((m) => m.role !== "system" || showSystemInMessages)
-        .slice(-historyLimit), [messages, showSystemInMessages, historyLimit]);
+    const timelineMessages = useMemo(() => messages.filter((m) => m.role !== "system" || showSystemInMessages), [messages, showSystemInMessages]);
     useEffect(() => {
         const onVisibility = () => {
             if (!document.hidden)
@@ -158,12 +159,30 @@ export function useChatThread(params) {
             statusKind,
         };
     }, [toolCalls]);
-    const turnGroups = useMemo(() => buildTurnProcessGroups({
-        messages: visibleMessages,
+    const turnGroups = useMemo(() => {
+        const all = buildTurnProcessGroups({
+            messages: timelineMessages,
+            toolCalls,
+            streaming,
+            activeAssistantId: streamingAssistantId,
+        });
+        return selectRecentTurnGroups(all, historyLimit);
+    }, [
+        timelineMessages,
         toolCalls,
         streaming,
-        activeAssistantId: streamingAssistantId,
-    }), [visibleMessages, toolCalls, streaming, streamingAssistantId]);
+        streamingAssistantId,
+        historyLimit,
+    ]);
+    const visibleMessages = useMemo(() => {
+        const next = [];
+        for (const group of turnGroups) {
+            if (group.user)
+                next.push(group.user);
+            next.push(...group.assistants);
+        }
+        return next;
+    }, [turnGroups]);
     /** Reset all session-scoped projections before adopting a fresh session. */
     const resetForNewSession = useCallback(() => {
         setMessages([]);
@@ -175,6 +194,8 @@ export function useChatThread(params) {
         setTaskContext(null);
         setUsage(EMPTY_USAGE);
         setStreaming(false);
+        setTurnPhase("idle");
+        setDeferredTurn(null);
         setStreamingAssistantId(null);
         setUnread(0);
         setHistoryLimit(50);
@@ -192,6 +213,8 @@ export function useChatThread(params) {
         setUsage(EMPTY_USAGE);
         refs.usageResponseKeysRef.current = new Set();
         setStreaming(next.streaming);
+        setTurnPhase(next.turnPhase ?? (next.streaming ? "running" : "idle"));
+        setDeferredTurn(next.deferredTurn ?? null);
         setStreamingAssistantId(null);
         setUnread(0);
         setHistoryLimit(50);
@@ -213,6 +236,8 @@ export function useChatThread(params) {
             const activeTurnId = body.session.activeTurnId ?? null;
             refs.activeTurnIdRef.current = activeTurnId;
             refs.streamingRef.current = Boolean(activeTurnId);
+            setTurnPhase(body.session.turnPhase ?? (activeTurnId ? "running" : "idle"));
+            setDeferredTurn(body.session.deferredTurn ?? null);
             // Resume the events stream from the snapshot tail so the next
             // reconnect never immediately re-expires (AC-003). The refs below
             // are reset so any follow-up tail replay re-applies cleanly.
@@ -220,18 +245,9 @@ export function useChatThread(params) {
             refs.seenEventIdsRef.current = new Set();
             refs.turnAssistantIdsRef.current = new Map();
             refs.sealedAssistantIdsRef.current = new Set();
-            setMessages((body.session.messages ?? [])
-                .filter((message) => message.role === "user" || message.role === "assistant")
-                .map((message) => {
-                const content = parseAssistantContent(message.content);
-                return {
-                    id: message.id,
-                    role: message.role,
-                    text: message.text,
-                    createdAt: Date.parse(message.at) || Date.now(),
-                    ...(content && content.length > 0 ? { content } : {}),
-                };
-            }));
+            const hydrated = hydrateSessionThread(body.session.messages ?? []);
+            setMessages(hydrated.messages);
+            setToolCalls(hydrated.toolCalls);
             setStreamingAssistantId(null);
             return true;
         }
@@ -240,7 +256,15 @@ export function useChatThread(params) {
             // trigger another reconcile and retry (best-effort recovery).
             return false;
         }
-    }, [origin, refs, setMessages, setStreamingAssistantId]);
+    }, [
+        origin,
+        refs,
+        setMessages,
+        setToolCalls,
+        setStreamingAssistantId,
+        setTurnPhase,
+        setDeferredTurn,
+    ]);
     return {
         messages,
         setMessages,
@@ -259,6 +283,10 @@ export function useChatThread(params) {
         usage,
         streaming,
         setStreaming,
+        turnPhase,
+        setTurnPhase,
+        deferredTurn,
+        setDeferredTurn,
         streamingAssistantId,
         setStreamingAssistantId,
         visibleMessages,

package/dist/worker/console/static-src/operator-chat/useRepoBrowser.js

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { ACTIVE_CHAT_SESSION_STORAGE_KEY } from "../../chat/workspace-landing.js";
 /** Left-rail repo tree + file preview tabs state. */
 export function useRepoBrowser(params) {
@@ -9,6 +9,8 @@ export function useRepoBrowser(params) {
     const [previews, setPreviews] = useState([]);
     const [activePreviewPath, setActivePreviewPath] = useState(null);
     const [previewLoading, setPreviewLoading] = useState(false);
+    const expandedDirsRef = useRef(new Set());
+    expandedDirsRef.current = expandedDirs;
     const loadTree = useCallback(async (directory = "") => {
         try {
             setTreeError(null);
@@ -28,6 +30,28 @@ export function useRepoBrowser(params) {
     useEffect(() => {
         void loadTree();
     }, [loadTree]);
+    /** pi-web parity: re-fetch the root + every expanded directory. Bump
+     *  `refreshTick` to trigger; cached entries are NOT reused, so newly
+     *  created/deleted files appear without a manual refresh. */
+    const [refreshTick, setRefreshTick] = useState(0);
+    const refreshTree = useCallback(() => {
+        setRefreshTick((tick) => tick + 1);
+    }, []);
+    useEffect(() => {
+        const dirs = ["", ...expandedDirsRef.current];
+        for (const dir of dirs)
+            void loadTree(dir);
+    }, [loadTree, refreshTick]);
+    // Also refresh when the tab regains focus: external tools (editor, git,
+    // CLI) may have changed the tree while the console was hidden.
+    useEffect(() => {
+        const onVisibility = () => {
+            if (!document.hidden)
+                refreshTree();
+        };
+        document.addEventListener("visibilitychange", onVisibility);
+        return () => document.removeEventListener("visibilitychange", onVisibility);
+    }, [refreshTree]);
     const openPreview = useCallback(async (file) => {
         setPreviewLoading(true);
         try {
@@ -116,6 +140,7 @@ export function useRepoBrowser(params) {
         previewLoading,
         setPreviews,
         loadTree,
+        refreshTree,
         openPreview,
         closePreview,
         toggleDir,

package/dist/worker/loop-agent/loop-agent-client.js

@@ -292,9 +292,13 @@ function assertControllerIdentityUnchangedBeforeSpawn(identity) {
     }
 }
 function controllerIdentityDriftError(message, cause) {
-    return new Error(`controller identity changed before spawn: ${message}`, {
-        cause,
-    });
+    // Preserve the raw drift detail verbatim; the actionable suffix serves
+    // every consumer surface — operation errorMessage, SSE events, and agent/
+    // API callers that never reach the UI translation layer — with the exact
+    // recovery step: the running Console holds a stale controller fingerprint
+    // after rebuilds or commits touching fingerprint-scoped paths
+    // (package.json, bin/**, dist/**, skills/**).
+    return new Error(`controller identity changed before spawn: ${message}. Fix: restart the Console process so it re-resolves the current build, then retry the operation; avoid rebuilding or committing fingerprint-scoped files (package.json, bin/**, dist/**, skills/**) mid-session.`, { cause });
 }
 /**
  * Detect whether loopAgentBin is a Node-like executable and baseArgs