@tea-agent/loop-agent 0.42.0-next.9 → 0.42.1

package/dist/worker/console/static-src/operator-chat/pending-user-message.js

@@ -0,0 +1,44 @@
+/** Insert the optimistic user bubble and assistant slot exactly once.
+ *
+ * The optimistic user row is the ONLY row carrying `pending: true`. Every
+ * rollback path deletes pending rows by clientRequestId; a durable row that
+ * already replaced it must survive (2026-09-08). */
+export function appendPendingSubmission(messages, pending) {
+    if (messages.some((message) => message.clientRequestId === pending.clientRequestId))
+        return [...messages];
+    return [...messages, { ...pending.user, pending: true }, pending.assistant];
+}
+/** Merge a durable user message into its optimistic or snapshot row in place.
+ *
+ * The replacement drops the `pending` marker: the row is server truth from now
+ * on, so a later adopt/rejected/connect rollback for the same clientRequestId
+ * must not delete it. Matching the durable id also dedupes retained SSE replay
+ * against a session snapshot whose stored row predates clientRequestId. */
+export function replacePendingUserMessage(messages, clientRequestId, durable) {
+    let replaced = false;
+    const next = [];
+    for (const message of messages) {
+        const matches = message.clientRequestId === clientRequestId || message.id === durable.id;
+        if (!matches) {
+            next.push(message);
+            continue;
+        }
+        if (replaced)
+            continue;
+        replaced = true;
+        const { pending: _pending, ...rest } = message;
+        next.push({ ...rest, ...durable, clientRequestId });
+    }
+    return replaced ? next : [...next, durable];
+}
+/** Keep an unconfirmed optimistic bubble when a recovery snapshot lacks it. */
+export function mergePendingSubmissionOnHydration(canonical, pending) {
+    if (!pending || canonical.some((message) => message.clientRequestId === pending.clientRequestId))
+        return [...canonical];
+    return appendPendingSubmission(canonical, pending);
+}
+/** Drop only the unconfirmed optimistic rows for a submission. A durable row
+ *  that already replaced the optimistic one is left untouched. */
+export function removePendingSubmission(messages, clientRequestId) {
+    return messages.filter((message) => message.clientRequestId !== clientRequestId || message.pending !== true);
+}

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

@@ -0,0 +1,41 @@
+import { isSubagentTool } from "../../chat/tool-preview.js";
+/**
+ * Count the collapsed-turn disclosure buckets exactly like DSH
+ * `TurnProcessNodeView`: tool calls, process messages and subagents, in that
+ * order. Built-in subagent delegations (`Agent` tool) count as subagents, not
+ * as ordinary tool calls (2026-09-08 alignment).
+ *
+ * @param items - ordered process nodes of one turn.
+ * @returns the three bucket counts.
+ */
+export function countTurnProcessItems(items) {
+    let toolCalls = 0;
+    let messages = 0;
+    let subagents = 0;
+    for (const item of items) {
+        if (item.kind === "tool") {
+            if (isSubagentTool(item.tool.toolName))
+                subagents += 1;
+            else
+                toolCalls += 1;
+            continue;
+        }
+        messages += 1;
+    }
+    return { toolCalls, messages, subagents };
+}
+/**
+ * Summary label for a completed turn's process disclosure.
+ *
+ * @param counts - bucket counts from {@link countTurnProcessItems}.
+ * @returns `N 次工具调用 · M 条消息 · K 个 subagent`, or「已思考」when empty.
+ */
+export function buildTurnProcessLabel(counts) {
+    return ([
+        counts.toolCalls > 0 ? `${counts.toolCalls} 次工具调用` : "",
+        counts.messages > 0 ? `${counts.messages} 条消息` : "",
+        counts.subagents > 0 ? `${counts.subagents} 个 subagent` : "",
+    ]
+        .filter(Boolean)
+        .join(" · ") || "已思考");
+}

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

@@ -1,7 +1,10 @@
 /**
  * ADR 0011: full Pi tools + optional safe-* explore surface.
+ * The `Agent` (Explore) entry is injected from capabilities.builtinSubagents
+ * (ADR 0022 server truth); the static entry below is only a fallback for
+ * older backends that do not send the field yet.
  */
-const EXPLORE_TOOLS = [
+const STATIC_EXPLORE_TOOLS = [
     {
         toolId: "read",
         kind: "explore",
@@ -58,6 +61,12 @@ const EXPLORE_TOOLS = [
         description: "固定参数查看 git diff；敏感路径不可查看且结果自动脱敏。",
     },
 ];
+/** Fallback when the backend does not advertise builtinSubagents yet. */
+const FALLBACK_AGENT_ENTRY = {
+    toolId: "Agent",
+    kind: "explore",
+    description: "启动内置只读 Explore 子 Agent，执行代码库搜索、符号查找和调用链追踪。",
+};
 export function buildToolCatalog(capabilities) {
     if (!capabilities)
         return null;
@@ -68,7 +77,17 @@ export function buildToolCatalog(capabilities) {
         kind: t.kind ?? "read",
         cli: t.cli,
     }));
-    const explore = [...EXPLORE_TOOLS];
+    // ADR 0022: subagents come from the server's builtinSubagents field;
+    // static entries never duplicate a server-advertised toolId.
+    const subagentTools = (capabilities.builtinSubagents ?? []).map((s) => ({
+        toolId: s.toolId,
+        description: s.description,
+        kind: "explore",
+    }));
+    const staticTools = subagentTools.length > 0
+        ? STATIC_EXPLORE_TOOLS
+        : [...STATIC_EXPLORE_TOOLS, FALLBACK_AGENT_ENTRY];
+    const explore = [...staticTools, ...subagentTools];
     return {
         explore,
         operator: operatorTools,

package/dist/worker/console/static-src/operator-chat/turn-group-equality.js

@@ -0,0 +1,13 @@
+function sameReferences(previous, next) {
+    return (previous.length === next.length &&
+        previous.every((value, index) => value === next[index]));
+}
+/** A completed group's rendered projection is reusable only while every source
+ * object that feeds grouping and process-item derivation remains unchanged. */
+export function sameTurnGroupInputs(previous, next) {
+    return (previous.key === next.key &&
+        previous.user === next.user &&
+        previous.live === next.live &&
+        sameReferences(previous.assistants, next.assistants) &&
+        sameReferences(previous.tools, next.tools));
+}

package/dist/worker/console/static-src/operator-chat/turn-stream-controller.js

@@ -224,6 +224,7 @@ export function applyAdoptActiveOwnership(bag, input) {
     releaseSubmitOwnership(bag, input.pending.clientRequestId);
     if (!input.current)
         return;
+    input.ui?.removePendingMessage?.(input.pending.clientRequestId);
     input.ui?.clearEmptyAssistant(input.assistantId);
     input.ui?.setInput(input.text);
     input.ui?.setPendingImages(input.images);
@@ -253,6 +254,7 @@ export function applyRejectedOwnership(bag, input) {
     input.ui?.setStreaming(false);
     input.ui?.setStreamingAssistantId(null);
     input.ui?.clearEmptyAssistant(input.assistantId);
+    input.ui?.removePendingMessage?.(input.pending.clientRequestId);
     input.ui?.setInput(input.text);
     input.ui?.setPendingImages(input.images);
 }

package/dist/worker/console/static-src/operator-chat/use-searchable-hidden.js

@@ -0,0 +1,51 @@
+import { useEffect, useLayoutEffect, useRef } from "react";
+/** Whether this browser can reveal `hidden="until-found"` content through
+ *  `beforematch` (Chrome 102+, Firefox 148+, Safari: not supported at all).
+ *  `content-visibility` support does NOT imply this — Safari 18+ and
+ *  Firefox 125–147 have the former without the latter. */
+function supportsUntilFound() {
+    return typeof document !== "undefined" && "onbeforematch" in document.body;
+}
+/**
+ * Collapse content without removing it from the document: the element gets
+ * `hidden="until-found"` so browser find-in-page can still reach the text, and
+ * a match fires `beforematch`, which reveals (expands) the disclosure again.
+ *
+ * Mirrors DSH `useSearchableHidden` (2026-09-08 alignment). Browsers without
+ * `until-found` support get a plain `hidden=""` element, which keeps the
+ * pre-alignment behavior (collapsed and not searchable).
+ *
+ * @param hidden - whether the content is collapsed.
+ * @param reveal - expand callback invoked on `beforematch` and when the
+ *   collapsed subtree already owns focus.
+ * @returns ref for the collapsible container.
+ */
+export function useSearchableHidden(hidden, reveal) {
+    const ref = useRef(null);
+    useLayoutEffect(() => {
+        const element = ref.current;
+        if (element === null)
+            return;
+        // Focus would otherwise be lost inside a hidden subtree.
+        if (hidden && element.contains(element.ownerDocument.activeElement)) {
+            reveal();
+            return;
+        }
+        if (hidden) {
+            element.setAttribute("hidden", supportsUntilFound() ? "until-found" : "");
+        }
+        else {
+            element.removeAttribute("hidden");
+        }
+    }, [hidden, reveal]);
+    useEffect(() => {
+        const element = ref.current;
+        if (element === null)
+            return;
+        element.addEventListener("beforematch", reveal);
+        return () => {
+            element.removeEventListener("beforematch", reveal);
+        };
+    }, [reveal]);
+    return ref;
+}

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

@@ -2,6 +2,7 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import { runtimeSelectionFromRecord } from "../../chat/runtime-selection.js";
 import { hydrateSessionThread } from "../../chat/turn-process.js";
 import { forgetActiveChatSession, readActiveChatSessionId, rememberActiveChatSession, } from "../../chat/workspace-landing.js";
+import { DEFAULT_CONSOLE_CHAT_SESSION_MODE } from "../../chat/session-mode-view.js";
 import { confirmationToken } from "./format.js";
 import { isLostChatSessionError } from "./runtime-snapshot-store.js";
 import { upsertCompactionMessage } from "./compaction-message.js";
@@ -67,6 +68,8 @@ function sameSessionSummary(a, b) {
         a.model?.modelId === b.model?.modelId &&
         a.thinkingLevel === b.thinkingLevel &&
         a.isBlank === b.isBlank &&
+        (a.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE) ===
+            (b.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE) &&
         a.optimisticState === b.optimisticState &&
         sameQueueSummary(a, b));
 }
@@ -83,8 +86,18 @@ export function stabilizeSessionList(previous, next) {
     });
     return changed ? stabilized : previous;
 }
+/** Project a session detail/list record into the active ChatSessionInfo. */
+export function projectActiveChatSession(session, fallbackWorkspaceId) {
+    const workspaceId = session.workspaceId?.trim() || fallbackWorkspaceId?.trim() || "";
+    return {
+        sessionId: session.sessionId,
+        ...(workspaceId ? { workspaceId } : {}),
+        sessionMode: session.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE,
+        ...runtimeSelectionFromRecord(session),
+    };
+}
 /** Select a server-confirmed blank session owned by the requested workspace. */
-export function findReusableBlankSession(list, workspaceId) {
+export function findReusableBlankSession(list, workspaceId, sessionMode = DEFAULT_CONSOLE_CHAT_SESSION_MODE) {
     const scope = workspaceId.trim();
     if (!scope)
         return undefined;
@@ -93,7 +106,8 @@ export function findReusableBlankSession(list, workspaceId) {
         item.isBlank === true &&
         item.turnPhase === "idle" &&
         !item.activeTurnId &&
-        !item.optimisticState);
+        !item.optimisticState &&
+        (item.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE) === sessionMode);
 }
 export async function createSessionAndPrimeTitleWatcher(input) {
     if (input.creatingRef?.current) {
@@ -127,7 +141,13 @@ export async function createSessionAndPrimeTitleWatcher(input) {
         const body = (await res.json());
         if (!body.session)
             throw new Error("创建会话响应缺少 durable session");
-        const durable = { ...body.session, isBlank: true };
+        const durable = {
+            ...body.session,
+            isBlank: true,
+            sessionMode: body.session.sessionMode ??
+                input.options?.sessionMode ??
+                DEFAULT_CONSOLE_CHAT_SESSION_MODE,
+        };
         const created = {
             sessionId: durable.sessionId,
             ...(durable.workspaceId || input.options?.workspaceId
@@ -135,6 +155,7 @@ export async function createSessionAndPrimeTitleWatcher(input) {
                     workspaceId: durable.workspaceId ?? input.options?.workspaceId,
                 }
                 : {}),
+            sessionMode: durable.sessionMode,
             ...runtimeSelectionFromRecord(durable),
         };
         const nextList = replaceOptimisticSession(input.sessionListRef.current, input.options?.optimisticSessionId, durable);
@@ -402,11 +423,7 @@ export function useChatSessions(params) {
             }
             if (selectionVersion !== sessionSelectionVersionRef.current)
                 return false;
-            const next = {
-                sessionId: body.session.sessionId,
-                ...(body.session.workspaceId ? { workspaceId: body.session.workspaceId } : {}),
-                ...runtimeSelectionFromRecord(body.session),
-            };
+            const next = projectActiveChatSession(body.session);
             // AC-002: session switch (same or cross workspace) never aborts other
             // sessions' background request controllers; the single /events owner is
             // re-bound by useChatStream's session effect.
@@ -449,6 +466,7 @@ export function useChatSessions(params) {
                 pendingQuestion: body.session.pendingQuestion ?? null,
                 todos: body.session.todos ?? [],
                 goal: body.session.goal ?? null,
+                history: body.history,
             });
             rememberActiveChatSession(window.localStorage, body.session.workspaceId ?? ownerWorkspaceId ?? workspaceId, sessionId);
             setActivePreviewPath(null);
@@ -537,15 +555,7 @@ export function useChatSessions(params) {
                     selectionVersion !== sessionSelectionVersionRef.current ||
                     !body.session)
                     return;
-                const restored = {
-                    sessionId: body.session.sessionId,
-                    ...(body.session.workspaceId
-                        ? { workspaceId: body.session.workspaceId }
-                        : workspaceId
-                            ? { workspaceId }
-                            : {}),
-                    ...runtimeSelectionFromRecord(body.session),
-                };
+                const restored = projectActiveChatSession(body.session, workspaceId);
                 refs.sessionGenerationRef.current += 1;
                 refs.sessionRef.current = restored;
                 // Do not seed Last-Event-ID here: session messages are restored
@@ -585,6 +595,7 @@ export function useChatSessions(params) {
                     pendingQuestion: body.session.pendingQuestion ?? null,
                     todos: body.session.todos ?? [],
                     goal: body.session.goal ?? null,
+                    history: body.history,
                 });
             }
             catch {
@@ -617,6 +628,7 @@ export function useChatSessions(params) {
             setError("创建会话需要选择一个有效的工作区（不会回退默认工作区）");
             return Promise.reject(new Error("WORKSPACE_REQUIRED"));
         }
+        const sessionMode = options?.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE;
         const optimisticSessionId = `optimistic-chat-${Date.now()}-${Math.random().toString(16).slice(2)}`;
         const now = new Date().toISOString();
         const optimisticRow = {
@@ -625,6 +637,7 @@ export function useChatSessions(params) {
             state: "active",
             updatedAt: now,
             turnPhase: "idle",
+            sessionMode,
             optimisticState: "creating",
         };
         pendingCreatedRowsRef.current.set(optimisticSessionId, optimisticRow);
@@ -667,9 +680,10 @@ export function useChatSessions(params) {
         }
         // A caller-provided snapshot is an explicit new-session boundary; reusing
         // an existing shell would silently drop that context suffix.
+        const sessionMode = options?.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE;
         const reusable = options?.snapshot
             ? undefined
-            : findReusableBlankSession(sessionListRef.current, scope);
+            : findReusableBlankSession(sessionListRef.current, scope, sessionMode);
         if (reusable) {
             if (previousSession?.sessionId === reusable.sessionId)
                 return previousSession;
@@ -679,6 +693,7 @@ export function useChatSessions(params) {
             return {
                 sessionId: reusable.sessionId,
                 ...(reusable.workspaceId ? { workspaceId: reusable.workspaceId } : {}),
+                sessionMode: reusable.sessionMode ?? sessionMode,
                 ...runtimeSelectionFromRecord(reusable),
             };
         }

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

@@ -3,6 +3,7 @@ import { formatOperatorUserError } from "../../operator-user-error.js";
 import { confirmationToken, requestId, sleep } from "./format.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, visualTurnPhaseFromOwnership, } from "./turn-stream-controller.js";
+import { appendPendingSubmission, removePendingSubmission } from "./pending-user-message.js";
 /** Project ChatRefs into the executable ownership bag used by the controller. */
 function ownershipBagFromRefs(refs) {
     return {
@@ -52,7 +53,11 @@ function clearEmptyAssistant(setMessages, assistantId) {
         return;
     setMessages((messages) => messages.filter((message) => !(message.id === assistantId &&
         message.role === "assistant" &&
-        !message.text.trim())));
+        !message.text.trim() &&
+        // A row carrying only thinking/tool blocks is real content. Deleting
+        // it here dropped the turn's process nodes while the settled path in
+        // chat-sse-events deliberately keeps them (2026-09-08).
+        !(message.content && message.content.length > 0))));
 }
 /** One GET /events stream owns all Chat events. Sending a prompt creates a
  * detached Turn resource only; it never opens a second inline SSE consumer. */
@@ -139,7 +144,10 @@ export function useChatStream(params) {
                                 current.generation === generation)
                                 current.ready = true;
                             replay = false;
-                            continue;
+                            // Fall through: the applier owns the buffered-replay flush and
+                            // returns immediately for this event. `continue` here silently
+                            // dropped that flush, so a reconnect that landed after the
+                            // turn settled never restored the answer (2026-09-08).
                         }
                         const assistantId = refs.assistantIdRef.current ?? fallbackAssistantId;
                         const eventId = applySseBlock(block, assistantId, {
@@ -364,6 +372,7 @@ export function useChatStream(params) {
                 setPendingImages: setPendingImagesUi,
                 setStreaming,
                 setStreamingAssistantId,
+                removePendingMessage: (requestId) => setMessages((messages) => removePendingSubmission(messages, requestId)),
             },
             rejectedUi: {
                 setError,
@@ -373,6 +382,7 @@ export function useChatStream(params) {
                 setInput,
                 setPendingImages: setPendingImagesUi,
                 formatError: formatOperatorUserError,
+                removePendingMessage: (requestId) => setMessages((messages) => removePendingSubmission(messages, requestId)),
             },
             // AC-R5-001: durable stopRequested + accepted/adopt yields one abort.
             onAutoAbort: (turnId) => {
@@ -669,6 +679,29 @@ export function useChatStream(params) {
             userMessageId,
         });
         refs.pendingSubmissionRef.current = pending;
+        const userMsg = {
+            id: userMessageId,
+            role: "user",
+            text: draftText,
+            createdAt: Date.now(),
+            clientRequestId,
+        };
+        const assistantMsg = {
+            id: assistantId,
+            role: "assistant",
+            text: "",
+            createdAt: Date.now(),
+        };
+        // React must receive the optimistic projection before the first await so
+        // SSE readiness latency cannot hide the user's submitted message.
+        setMessages((messages) => appendPendingSubmission(messages, {
+            clientRequestId,
+            user: userMsg,
+            assistant: assistantMsg,
+        }));
+        setInput("");
+        setAutoScroll(true);
+        setError(null);
         try {
             await ensureEventsConnected(activeSession.sessionId, generation);
         }
@@ -678,28 +711,27 @@ export function useChatStream(params) {
                 setError(formatOperatorUserError(error instanceof Error ? error.message : String(error)));
             }
             releaseSubmitOwnership(clientRequestId);
+            setMessages((messages) => removePendingSubmission(messages, clientRequestId));
+            clearEmptyAssistant(setMessages, assistantId);
+            setInput(draftText);
+            setPendingImages(draftImages);
             return;
         }
         if (refs.sessionRef.current?.sessionId !== activeSession.sessionId ||
             refs.sessionGenerationRef.current !== generation) {
             releaseSubmitOwnership(clientRequestId);
+            if (refs.sessionRef.current?.sessionId === activeSession.sessionId) {
+                // Same session, newer generation: the activation snapshot replaced
+                // the thread, so the optimistic row is gone. Restore the draft
+                // instead of losing the user's text silently (2026-09-08).
+                setMessages((messages) => removePendingSubmission(messages, clientRequestId));
+                clearEmptyAssistant(setMessages, assistantId);
+                setInput(draftText);
+                setPendingImages(draftImages);
+            }
             return;
         }
-        const userMsg = {
-            id: userMessageId,
-            role: "user",
-            text: draftText,
-            createdAt: Date.now(),
-        };
-        setMessages((messages) => [
-            ...messages,
-            userMsg,
-            { id: assistantId, role: "assistant", text: "", createdAt: Date.now() },
-        ]);
-        setInput("");
         // Attachments stay until accepted (AC/UIS-accepted).
-        setAutoScroll(true);
-        setError(null);
         refs.streamingRef.current = true;
         setTurnPhase("running");
         refs.assistantIdRef.current = assistantId;