@tea-agent/loop-agent 0.39.3 → 0.40.0-beta.1

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

@@ -1,7 +1,9 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { buildTurnProcessGroups, hydrateSessionThread, selectRecentTurnGroups, } from "../../chat/turn-process.js";
+import { mergeOperationCardState, } from "../../chat/operation-card.js";
 import { createChatSseEventApplier, } from "./chat-sse-events.js";
 import { taskContextUnchanged } from "./format.js";
+import { upsertCompactionMessage } from "./compaction-message.js";
 const EMPTY_USAGE = {
     inputTokens: 0,
     outputTokens: 0,
@@ -9,13 +11,105 @@ const EMPTY_USAGE = {
     cacheWriteTokens: 0,
     totalTokens: 0,
 };
+const EMPTY_SESSION_STATS = {
+    turns: 0,
+    steps: 0,
+    llmMs: 0,
+    toolMs: 0,
+    ttftMs: 0,
+    ttftSteps: 0,
+    decodeMs: 0,
+    decodeTokens: 0,
+};
+/** R8 AC-R8-003: project a raw GET /operations/:id fact (the same shape the
+ *  server persists) into a browser OperationCardState. Field-validated; any
+ *  malformed fact returns undefined (no fabricated cards). */
+function operationCardFromOperationFact(op) {
+    const str = (key) => {
+        const value = op[key];
+        return typeof value === "string" && value ? value : undefined;
+    };
+    const operationId = str("operationId");
+    const action = str("action");
+    const state = str("state");
+    const createdAt = str("createdAt");
+    if (!operationId || !action || !state || !createdAt)
+        return undefined;
+    const updatedAt = str("updatedAt") ?? str("finishedAt") ?? str("startedAt") ?? createdAt;
+    const dagRunId = str("dagRunId");
+    return {
+        schemaVersion: 1,
+        operationId,
+        action,
+        state,
+        createdAt,
+        updatedAt,
+        inspectHref: `/inspect/?operationId=${encodeURIComponent(operationId)}#/`,
+        ...(str("taskId") ? { taskId: str("taskId") } : {}),
+        ...(dagRunId ? { dagRunId } : {}),
+        ...(str("errorCode") ? { errorCode: str("errorCode") } : {}),
+        activityRef: `operation:${operationId}`,
+        previewHash: `${operationId}:${state}:${updatedAt}`,
+    };
+}
+/**
+ * Apply one settled operation-link mutation to the visible card projection.
+ *
+ * The mutation identity is captured before the request starts. Both the
+ * session and workspace are fenced before and after the follow-up read so a
+ * late response can never leak into a newly selected workspace/session.
+ */
+export async function applyOperationLinkMutationProjection(input) {
+    const { identity } = input;
+    const stillOwnsProjection = () => {
+        const current = input.currentOwner();
+        return (current.sessionId === identity.sessionId &&
+            current.workspaceId === identity.workspaceId);
+    };
+    if (!identity.workspaceId || !stillOwnsProjection())
+        return false;
+    if (identity.action === "remove") {
+        input.setOperationCards((current) => current.filter((card) => card.operationId !== identity.operationId));
+        return true;
+    }
+    try {
+        const workspaceQuery = new URLSearchParams({
+            workspaceId: identity.workspaceId,
+        });
+        const fetchImpl = input.fetchFn ?? fetch;
+        const res = await fetchImpl(`${input.origin}/api/operator/v1/operations/${encodeURIComponent(identity.operationId)}?${workspaceQuery.toString()}`, { credentials: "include" });
+        if (!res.ok || !stillOwnsProjection())
+            return false;
+        const body = (await res.json());
+        const operation = body.operation;
+        if (body.workspaceId !== identity.workspaceId ||
+            !operation ||
+            operation.workspaceId !== identity.workspaceId ||
+            operation.operationId !== identity.operationId ||
+            !stillOwnsProjection())
+            return false;
+        const card = operationCardFromOperationFact(operation);
+        if (!card)
+            return false;
+        input.setOperationCards((current) => stillOwnsProjection()
+            ? mergeOperationCardState(current, card)
+            : current);
+        return stillOwnsProjection();
+    }
+    catch {
+        return false;
+    }
+}
+function mergeCompactionMessages(messages, compactions) {
+    return (compactions ?? []).reduce((result, item) => upsertCompactionMessage(result, item), messages);
+}
 /**
  * Thread state + SSE block parsing. The event-application logic itself lives
  * in chat-sse-events.ts (createChatSseEventApplier); this hook owns the state
  * slices it patches and the derived timeline projections.
  */
 export function useChatThread(params) {
-    const { origin, refs, sessionId, setError, onReconcile } = params;
+    const { origin, refs, sessionId, workspaceId, setError, onReconcile } = params;
     // setProcessOpen remains on the hook API for session lifecycle close/reset
     // (UI-08); the SSE applier must not open the process panel.
     void params.setProcessOpen;
@@ -30,12 +124,36 @@ export function useChatThread(params) {
     const [taskContext, setTaskContext] = useState(null);
     const [contextLoading, setContextLoading] = useState(false);
     const [usage, setUsage] = useState(EMPTY_USAGE);
+    const [sessionStats, setSessionStats] = useState(EMPTY_SESSION_STATS);
     const [streaming, setStreaming] = useState(false);
     const [turnPhase, setTurnPhase] = useState("idle");
     const [deferredTurn, setDeferredTurn] = useState(null);
+    const [deferredTurns, setDeferredTurns] = useState([]);
+    const [pendingQuestion, setPendingQuestion] = useState(null);
+    const [todos, setTodos] = useState([]);
     /** Assistant bubble id for the in-flight turn; only this row shows the streaming cursor. */
     const [streamingAssistantId, setStreamingAssistantId] = useState(null);
     const [showSystemInMessages] = useState(false);
+    const refreshSessionTelemetry = useCallback(async () => {
+        const targetSessionId = refs.sessionRef.current?.sessionId;
+        if (!targetSessionId)
+            return;
+        try {
+            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(targetSessionId)}`, { credentials: "include" });
+            if (!res.ok)
+                return;
+            const body = (await res.json());
+            if (refs.sessionRef.current?.sessionId !== targetSessionId)
+                return;
+            if (body.sessionStats)
+                setSessionStats(body.sessionStats);
+            if (body.usage)
+                setUsage(body.usage);
+        }
+        catch {
+            // Telemetry is supplementary; the normal event stream remains authoritative.
+        }
+    }, [origin, refs]);
     // All inputs are stable (state setters + the memoized refs bag), so the
     // applier identity is stable across renders.
     const applyChatSseEvent = useMemo(() => createChatSseEventApplier({
@@ -48,13 +166,17 @@ export function useChatThread(params) {
         setStreaming,
         setTurnPhase,
         setDeferredTurn,
+        setDeferredTurns,
+        setPendingQuestion,
+        setTodos,
         setStreamingAssistantId,
         setUnread,
         setOperationCards,
         setUsage,
+        onTelemetryRefresh: () => void refreshSessionTelemetry(),
         setMessages,
         setToolCalls,
-    }), [refs, onReconcile, setError]);
+    }), [refs, onReconcile, setError, refreshSessionTelemetry]);
     /** Parse + apply one raw SSE block (frames separated by \n\n). Returns the
      *  eventId if the block carried an `id:` line (for Last-Event-ID tracking). */
     const applySseBlock = useCallback((block, assistantId, options) => {
@@ -124,6 +246,21 @@ export function useChatThread(params) {
         }, 350);
         return () => window.clearTimeout(timer);
     }, [sessionId, operationCards, humanGateCards, interview, loadTaskContext]);
+    /** R8 AC-R8-003: deterministic mutation-driven operationCards updates.
+     *  Binds to the identity captured when the real POST/DELETE was issued:
+     *  - add    → consume server truth for that operation (GET operation) and
+     *             upsert the card when the captured session still matches.
+     *  - remove → drop the captured operation's card immediately (the server
+     *             tombstone guarantees it never resurrects on replay). */
+    const applyOperationLinkMutation = useCallback((identity) => applyOperationLinkMutationProjection({
+        origin,
+        identity,
+        currentOwner: () => ({
+            sessionId: refs.sessionRef.current?.sessionId,
+            workspaceId,
+        }),
+        setOperationCards,
+    }), [origin, refs, workspaceId]);
     const timelineMessages = useMemo(() => messages.filter((m) => m.role !== "system" || showSystemInMessages), [messages, showSystemInMessages]);
     useEffect(() => {
         const onVisibility = () => {
@@ -193,9 +330,13 @@ export function useChatThread(params) {
         setInterview(null);
         setTaskContext(null);
         setUsage(EMPTY_USAGE);
+        setSessionStats(EMPTY_SESSION_STATS);
         setStreaming(false);
         setTurnPhase("idle");
         setDeferredTurn(null);
+        setDeferredTurns([]);
+        setPendingQuestion(null);
+        setTodos([]);
         setStreamingAssistantId(null);
         setUnread(0);
         setHistoryLimit(50);
@@ -203,6 +344,7 @@ export function useChatThread(params) {
     }, [refs]);
     /** Adopt a freshly activated session's hydrated thread + streaming flags. */
     const applyActivatedSession = useCallback((next) => {
+        const visuallyStopped = next.turnPhase === "stopping";
         setMessages(next.messages);
         setToolCalls(next.toolCalls);
         setOperationCards([]);
@@ -210,11 +352,17 @@ export function useChatThread(params) {
         setArtifactCards([]);
         setTaskContext(null);
         setInterview(null);
-        setUsage(EMPTY_USAGE);
+        setUsage(next.usage ?? EMPTY_USAGE);
+        setSessionStats(next.sessionStats ?? EMPTY_SESSION_STATS);
         refs.usageResponseKeysRef.current = new Set();
-        setStreaming(next.streaming);
-        setTurnPhase(next.turnPhase ?? (next.streaming ? "running" : "idle"));
+        setStreaming(visuallyStopped ? false : next.streaming);
+        setTurnPhase(visuallyStopped
+            ? "idle"
+            : (next.turnPhase ?? (next.streaming ? "running" : "idle")));
         setDeferredTurn(next.deferredTurn ?? null);
+        setDeferredTurns(next.deferredTurns ?? (next.deferredTurn ? [next.deferredTurn] : []));
+        setPendingQuestion(next.pendingQuestion ?? null);
+        setTodos(next.todos ?? []);
         setStreamingAssistantId(null);
         setUnread(0);
         setHistoryLimit(50);
@@ -234,10 +382,21 @@ export function useChatThread(params) {
                 refs.sessionRef.current?.sessionId !== targetSessionId)
                 return false;
             const activeTurnId = body.session.activeTurnId ?? null;
+            const visuallyStopped = body.session.turnPhase === "stopping";
             refs.activeTurnIdRef.current = activeTurnId;
-            refs.streamingRef.current = Boolean(activeTurnId);
-            setTurnPhase(body.session.turnPhase ?? (activeTurnId ? "running" : "idle"));
+            refs.streamingRef.current = visuallyStopped ? false : Boolean(activeTurnId);
+            setStreaming(visuallyStopped ? false : Boolean(activeTurnId));
+            setTurnPhase(visuallyStopped
+                ? "idle"
+                : (body.session.turnPhase ?? (activeTurnId ? "running" : "idle")));
             setDeferredTurn(body.session.deferredTurn ?? null);
+            setDeferredTurns(body.session.deferredTurns ?? (body.session.deferredTurn ? [body.session.deferredTurn] : []));
+            setPendingQuestion(body.session.pendingQuestion ?? null);
+            setTodos(body.session.todos ?? []);
+            if (body.sessionStats)
+                setSessionStats(body.sessionStats);
+            if (body.usage)
+                setUsage(body.usage);
             // 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.
@@ -246,7 +405,7 @@ export function useChatThread(params) {
             refs.turnAssistantIdsRef.current = new Map();
             refs.sealedAssistantIdsRef.current = new Set();
             const hydrated = hydrateSessionThread(body.session.messages ?? []);
-            setMessages(hydrated.messages);
+            setMessages(mergeCompactionMessages(hydrated.messages, body.compactions));
             setToolCalls(hydrated.toolCalls);
             setStreamingAssistantId(null);
             return true;
@@ -262,8 +421,11 @@ export function useChatThread(params) {
         setMessages,
         setToolCalls,
         setStreamingAssistantId,
+        setStreaming,
         setTurnPhase,
         setDeferredTurn,
+        setPendingQuestion,
+        setTodos,
     ]);
     return {
         messages,
@@ -281,12 +443,18 @@ export function useChatThread(params) {
         taskContext,
         contextLoading,
         usage,
+        sessionStats,
         streaming,
         setStreaming,
         turnPhase,
         setTurnPhase,
         deferredTurn,
         setDeferredTurn,
+        deferredTurns,
+        setDeferredTurns,
+        pendingQuestion,
+        setPendingQuestion,
+        todos,
         streamingAssistantId,
         setStreamingAssistantId,
         visibleMessages,
@@ -295,6 +463,7 @@ export function useChatThread(params) {
         applyChatSseEvent,
         applySseBlock,
         loadTaskContext,
+        applyOperationLinkMutation,
         resetForNewSession,
         applyActivatedSession,
         recoverSession,

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

@@ -1,21 +1,32 @@
 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. */
+/** Details-rail repo tree + file preview tabs state. */
 export function useRepoBrowser(params) {
-    const { origin, refs, sessionId, setError } = params;
+    const { origin, refs, sessionId, workspaceId, blocked, setError } = params;
     const [tree, setTree] = useState({});
     const [expandedDirs, setExpandedDirs] = useState(new Set());
     const [treeError, setTreeError] = useState(null);
     const [previews, setPreviews] = useState([]);
     const [activePreviewPath, setActivePreviewPath] = useState(null);
     const [previewLoading, setPreviewLoading] = useState(false);
+    const workspaceScopeRef = useRef(workspaceId ?? null);
+    workspaceScopeRef.current = workspaceId ?? null;
+    const autoPreviewedWorkspaceRef = useRef(new Set());
     const expandedDirsRef = useRef(new Set());
     expandedDirsRef.current = expandedDirs;
+    const workspaceQuery = workspaceId
+        ? `&workspaceId=${encodeURIComponent(workspaceId)}`
+        : "";
     const loadTree = useCallback(async (directory = "") => {
+        if (blocked)
+            return; // AC-R5-002: fail-closed, zero repo requests
+        const requestWorkspaceId = workspaceId ?? null;
         try {
             setTreeError(null);
-            const res = await fetch(`${origin}/api/operator/v1/chat/repo/tree?path=${encodeURIComponent(directory)}`, { credentials: "include" });
+            const res = await fetch(`${origin}/api/operator/v1/chat/repo/tree?path=${encodeURIComponent(directory)}${workspaceQuery}`, { credentials: "include" });
             const body = (await res.json());
+            if (workspaceScopeRef.current !== requestWorkspaceId)
+                return;
             if (!res.ok)
                 throw new Error(body.error?.message ?? "无法读取仓库目录");
             setTree((current) => ({
@@ -24,9 +35,11 @@ export function useRepoBrowser(params) {
             }));
         }
         catch (error) {
+            if (workspaceScopeRef.current !== requestWorkspaceId)
+                return;
             setTreeError(error instanceof Error ? error.message : String(error));
         }
-    }, [origin]);
+    }, [origin, workspaceQuery, workspaceId, blocked]);
     useEffect(() => {
         void loadTree();
     }, [loadTree]);
@@ -53,10 +66,15 @@ export function useRepoBrowser(params) {
         return () => document.removeEventListener("visibilitychange", onVisibility);
     }, [refreshTree]);
     const openPreview = useCallback(async (file) => {
+        if (blocked)
+            return; // AC-R5-002: fail-closed
+        const requestWorkspaceId = workspaceId ?? null;
         setPreviewLoading(true);
         try {
-            const res = await fetch(`${origin}/api/operator/v1/chat/repo/file?path=${encodeURIComponent(file)}`, { credentials: "include" });
+            const res = await fetch(`${origin}/api/operator/v1/chat/repo/file?path=${encodeURIComponent(file)}${workspaceQuery}`, { credentials: "include" });
             const body = (await res.json());
+            if (workspaceScopeRef.current !== requestWorkspaceId)
+                return;
             if (!res.ok || !body.data)
                 throw new Error(body.error?.message ?? "无法预览文件");
             setPreviews((current) => {
@@ -72,12 +90,48 @@ export function useRepoBrowser(params) {
             setActivePreviewPath(body.data.path);
         }
         catch (error) {
+            if (workspaceScopeRef.current !== requestWorkspaceId)
+                return;
             setError(error instanceof Error ? error.message : String(error));
         }
         finally {
-            setPreviewLoading(false);
+            if (workspaceScopeRef.current === requestWorkspaceId)
+                setPreviewLoading(false);
         }
-    }, [origin, refs, setError]);
+    }, [origin, workspaceQuery, workspaceId, refs, setError, blocked]);
+    // A workspace switch must immediately remove the previous workspace's tree
+    // and file contents while the newly scoped requests are in flight.
+    useEffect(() => {
+        setTree({});
+        setExpandedDirs(new Set());
+        setTreeError(null);
+        setPreviews([]);
+        setActivePreviewPath(null);
+        setPreviewLoading(false);
+    }, [workspaceId]);
+    // DSH parity: Details opens as a real tree + preview split. Select a real
+    // root file once per workspace (README first), never placeholder content.
+    useEffect(() => {
+        if (blocked || activePreviewPath || previews.length > 0)
+            return;
+        const workspaceKey = workspaceId ?? "__default__";
+        if (autoPreviewedWorkspaceRef.current.has(workspaceKey))
+            return;
+        const rootFiles = (tree[""] ?? []).filter((entry) => entry.kind === "file");
+        if (rootFiles.length === 0)
+            return;
+        const initial = rootFiles.find((entry) => /^readme(?:\.[^.]+)?$/i.test(entry.name)) ??
+            rootFiles[0];
+        autoPreviewedWorkspaceRef.current.add(workspaceKey);
+        void openPreview(initial.path);
+    }, [
+        activePreviewPath,
+        blocked,
+        openPreview,
+        previews.length,
+        tree,
+        workspaceId,
+    ]);
     useEffect(() => {
         if (!sessionId)
             return;
@@ -95,7 +149,7 @@ export function useRepoBrowser(params) {
         if (!paths.length)
             return;
         void Promise.all(paths.map(async (file) => {
-            const res = await fetch(`${origin}/api/operator/v1/chat/repo/file?path=${encodeURIComponent(file)}`, { credentials: "include" });
+            const res = await fetch(`${origin}/api/operator/v1/chat/repo/file?path=${encodeURIComponent(file)}${workspaceQuery}`, { credentials: "include" });
             if (!res.ok)
                 return undefined;
             return (await res.json()).data;
@@ -106,7 +160,7 @@ export function useRepoBrowser(params) {
             setPreviews(available);
             setActivePreviewPath(available.at(-1)?.path ?? null);
         });
-    }, [origin, sessionId, refs]);
+    }, [origin, workspaceQuery, sessionId, refs]);
     const toggleDir = useCallback((dir) => {
         setExpandedDirs((current) => {
             const next = new Set(current);

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

@@ -0,0 +1,4 @@
+export const WORKSPACE_BROWSER_OK = { status: "ok" };
+export function workspaceBrowserGateActive(gate) {
+    return gate.status !== "ok";
+}

package/dist/worker/console/static-src/operator-chat/workspace-layout-mode.js

@@ -1,12 +1,12 @@
 /** Workspace layout modes resolved from measured Chat container width. */
 /** Width thresholds in CSS px against `.oc-workspace` (not window/UA). */
 export const WORKSPACE_LAYOUT_THRESHOLDS = {
-    comfortableMin: 1450,
-    compactMin: 1100,
+    comfortableMin: 1200,
+    compactMin: 720,
 };
 /**
  * Resolve the three-band workspace mode from a measured container width.
- * Boundaries: comfortable >=1450, compact 1100-1449, narrow <1100.
+ * Boundaries: comfortable >=1200, compact 720-1199, narrow <720.
  */
 export function resolveWorkspaceLayoutMode(widthPx) {
     if (!Number.isFinite(widthPx) || widthPx < 0)