@tea-agent/loop-agent 0.40.0-next.1 → 0.40.0-next.10

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

@@ -1,10 +1,10 @@
 import { useCallback, useEffect, useRef, useState } from "react";
-import { parseAssistantContent } from "../../chat/assistant-content.js";
 import { runtimeSelectionFromRecord } from "../../chat/runtime-selection.js";
 import { hydrateSessionThread } from "../../chat/turn-process.js";
-import { ACTIVE_CHAT_SESSION_STORAGE_KEY } from "../../chat/workspace-landing.js";
+import { forgetActiveChatSession, readActiveChatSessionId, rememberActiveChatSession, } from "../../chat/workspace-landing.js";
 import { CHAT_SESSION_LIST_LIMIT } from "../chat-view-types.js";
 import { confirmationToken } from "./format.js";
+import { upsertCompactionMessage } from "./compaction-message.js";
 import { describeMutationGateFailure, isMutationGateFailureCode, isStaleTokenFailure, } from "./mutation-gate.js";
 import { SessionTitleWatcher } from "./session-title-watcher.js";
 export async function createSessionAndPrimeTitleWatcher(input) {
@@ -28,6 +28,9 @@ export async function createSessionAndPrimeTitleWatcher(input) {
         });
         if (!res.ok) {
             const body = (await res.json().catch(() => ({})));
+            if (isMutationGateFailureCode(body.error?.code)) {
+                throw new Error(describeMutationGateFailure(body.error.code));
+            }
             throw new Error(body.error?.message ?? `HTTP ${res.status}`);
         }
         const body = (await res.json());
@@ -36,6 +39,11 @@ export async function createSessionAndPrimeTitleWatcher(input) {
         const durable = body.session;
         const created = {
             sessionId: durable.sessionId,
+            ...(durable.workspaceId || input.options?.workspaceId
+                ? {
+                    workspaceId: durable.workspaceId ?? input.options?.workspaceId,
+                }
+                : {}),
             ...runtimeSelectionFromRecord(durable),
         };
         const nextList = [
@@ -56,6 +64,9 @@ export async function createSessionAndPrimeTitleWatcher(input) {
         input.setCreatingSession?.(false);
     }
 }
+function mergeCompactionMessages(messages, compactions) {
+    return (compactions ?? []).reduce((result, item) => upsertCompactionMessage(result, item), messages);
+}
 /** Session lifecycle: list / activate / create / delete / rename-archive /
  *  compact, plus browser-refresh recovery from the durable session store. */
 export function useChatSessions(params) {
@@ -63,6 +74,21 @@ export function useChatSessions(params) {
     const { applyActivatedSession, resetForNewSession, setMessages } = thread;
     const { setInput, setPendingImages } = composer;
     const { setPreviews, setActivePreviewPath } = browser;
+    const { workspaceId, blocked } = params;
+    const workspaceQuery = workspaceId
+        ? `?workspaceId=${encodeURIComponent(workspaceId)}`
+        : "";
+    /** AC-002 (2026-08-26): session requests follow the session's DURABLE
+     *  owning workspace, not the global active workspace. The sidebar list
+     *  items carry workspaceId; once a session is activated its owner is kept
+     *  on the session record itself. Switching the Operate/Inspect active
+     *  workspace therefore never retargets an open session's requests. */
+    const sessionOwnerQuery = useCallback((ownerWorkspaceId) => {
+        const owner = ownerWorkspaceId?.trim() ||
+            refs.sessionRef.current?.workspaceId?.trim() ||
+            "";
+        return owner ? `?workspaceId=${encodeURIComponent(owner)}` : "";
+    }, [refs]);
     const [sessionList, setSessionList] = useState([]);
     const sessionListRef = useRef([]);
     sessionListRef.current = sessionList;
@@ -76,11 +102,15 @@ export function useChatSessions(params) {
     // state. This prevents slow responses from an older selection overwriting a
     // newer user choice.
     const sessionSelectionVersionRef = useRef(0);
-    const resetActiveProjection = useCallback(() => {
-        // M4.5/M5.2: selection is a hard ownership boundary. Abort every request
-        // owned by the old projection, then invalidate its async callbacks.
+    const resetActiveProjection = useCallback((options) => {
+        // M4.5/M5.2: selection is a hard ownership boundary for THIS projection.
+        // Multi-workspace (AC-002): keepStreams=true (workspace switch) aborts
+        // only projection-local requests and leaves background SSE streams of
+        // other sessions/workspaces running.
+        const keepStreams = options?.keepStreams === true;
         refs.sessionGenerationRef.current += 1;
-        refs.abortRef.current?.abort();
+        if (!keepStreams)
+            refs.abortRef.current?.abort();
         refs.reconnectAbortRef.current?.abort();
         for (const controller of refs.sessionAbortControllersRef.current.values())
             controller.abort();
@@ -114,43 +144,36 @@ export function useChatSessions(params) {
         setAutoScroll,
     ]);
     const refreshSessionList = useCallback(async () => {
+        if (blocked)
+            return; // AC-R5-002: fail-closed, zero session requests
         try {
-            const res = await fetch(`${origin}/api/operator/v1/chat/sessions`, {
+            const res = await fetch(`${origin}/api/operator/v1/chat/sessions${workspaceQuery}`, {
                 credentials: "include",
             });
             if (!res.ok)
                 return;
-            const sessions = (await res.json()).sessions ??
-                [];
+            const sessions = (await res.json())
+                .sessions ?? [];
+            // Multi-workspace (AC-002): list only this workspace's sessions when a
+            // scope is active; unscoped (legacy) keeps the full list.
+            const scoped = workspaceId
+                ? sessions.filter((item) => !item.workspaceId || item.workspaceId === workspaceId)
+                : sessions;
             // API returns newest-first; keep only the recent window in the sidebar.
-            const keep = sessions.slice(0, CHAT_SESSION_LIST_LIMIT);
-            const excess = sessions.slice(CHAT_SESSION_LIST_LIMIT);
+            const keep = scoped.slice(0, CHAT_SESSION_LIST_LIMIT);
             setSessionList(keep);
-            if (excess.length === 0)
-                return;
-            await Promise.all(excess.map((item) => fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(item.sessionId)}`, {
-                method: "DELETE",
-                credentials: "include",
-                headers: {
-                    "x-loop-console-confirmation": confirmationToken(),
-                },
-            }).catch(() => undefined)));
-            const activeId = refs.sessionRef.current?.sessionId;
-            if (activeId && excess.some((item) => item.sessionId === activeId)) {
-                sessionSelectionVersionRef.current += 1;
-                refs.sessionRef.current = null;
-                resetActiveProjection();
-                setSession(null);
-                window.localStorage.removeItem(ACTIVE_CHAT_SESSION_STORAGE_KEY);
-            }
         }
         catch {
             /* Chat remains usable without the sidebar index. */
         }
-    }, [origin, refs, resetActiveProjection, setSession]);
+    }, [origin, workspaceQuery, workspaceId, blocked]);
     const deleteSession = useCallback(async (sessionId) => {
         try {
-            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}`, {
+            // AC-002: delete follows the session's durable owner, not the
+            // global active workspace.
+            const ownerQuery = sessionOwnerQuery(sessionListRef.current.find((item) => item.sessionId === sessionId)
+                ?.workspaceId ?? null);
+            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}${ownerQuery}`, {
                 method: "DELETE",
                 credentials: "include",
                 headers: {
@@ -163,11 +186,12 @@ export function useChatSessions(params) {
             }
             titleWatcherRef.current?.cancel(sessionId);
             if (refs.sessionRef.current?.sessionId === sessionId) {
+                const activeWorkspaceId = refs.sessionRef.current.workspaceId ?? workspaceId;
                 sessionSelectionVersionRef.current += 1;
                 refs.sessionRef.current = null;
                 resetActiveProjection();
                 setSession(null);
-                window.localStorage.removeItem(ACTIVE_CHAT_SESSION_STORAGE_KEY);
+                forgetActiveChatSession(window.localStorage, activeWorkspaceId, sessionId);
             }
             await refreshSessionList();
             return true;
@@ -183,11 +207,17 @@ export function useChatSessions(params) {
         resetActiveProjection,
         refreshSessionList,
         setError,
+        sessionOwnerQuery,
+        workspaceId,
     ]);
-    const activateSession = useCallback(async (sessionId) => {
+    const activateSession = useCallback(async (sessionId, ownerWorkspaceId) => {
         const selectionVersion = ++sessionSelectionVersionRef.current;
+        // AC-002: activation targets the session's durable owning workspace —
+        // never the global active workspace (no cross-workspace leak when
+        // Operate/Inspect switch their scope while a session stays open).
+        const ownerQuery = sessionOwnerQuery(ownerWorkspaceId);
         try {
-            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}`, { credentials: "include" });
+            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}${ownerQuery}`, { credentials: "include" });
             const body = (await res.json());
             if (!res.ok || !body.session)
                 throw new Error(body.error?.message ?? "会话不可用");
@@ -195,12 +225,23 @@ export function useChatSessions(params) {
                 return;
             const next = {
                 sessionId: body.session.sessionId,
+                ...(body.session.workspaceId ? { workspaceId: body.session.workspaceId } : {}),
                 ...runtimeSelectionFromRecord(body.session),
             };
-            resetActiveProjection();
+            // 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.
+            resetActiveProjection({ keepStreams: true });
             refs.sessionRef.current = next;
-            refs.streamingRef.current = Boolean(body.session.activeTurnId);
             refs.activeTurnIdRef.current = body.session.activeTurnId ?? null;
+            const visuallyStopped = body.session.turnPhase === "stopping";
+            refs.streamingRef.current = visuallyStopped
+                ? false
+                : Boolean(body.session.activeTurnId);
+            refs.stoppingTurnIdRef.current = visuallyStopped
+                ? (body.session.activeTurnId ?? null)
+                : null;
+            refs.stopRequestedRef.current = visuallyStopped;
             refs.seenEventIdsRef.current = new Set();
             refs.turnAssistantIdsRef.current = new Map();
             refs.sealedAssistantIdsRef.current = new Set();
@@ -214,15 +255,21 @@ export function useChatSessions(params) {
             setPreviews([]);
             setInput(body.session.composerDraft ?? "");
             const hydrated = hydrateSessionThread(body.session.messages ?? []);
+            hydrated.messages = mergeCompactionMessages(hydrated.messages, body.compactions);
             applyActivatedSession({
                 messages: hydrated.messages,
                 toolCalls: hydrated.toolCalls,
-                streaming: Boolean(body.session.activeTurnId),
+                sessionStats: body.sessionStats,
+                usage: body.usage,
+                streaming: visuallyStopped ? false : Boolean(body.session.activeTurnId),
                 turnPhase: body.session.turnPhase ??
                     (body.session.activeTurnId ? "running" : "idle"),
                 deferredTurn: body.session.deferredTurn ?? null,
+                deferredTurns: body.session.deferredTurns ?? (body.session.deferredTurn ? [body.session.deferredTurn] : []),
+                pendingQuestion: body.session.pendingQuestion ?? null,
+                todos: body.session.todos ?? [],
             });
-            window.localStorage.setItem(ACTIVE_CHAT_SESSION_STORAGE_KEY, sessionId);
+            rememberActiveChatSession(window.localStorage, body.session.workspaceId ?? ownerWorkspaceId ?? workspaceId, sessionId);
             setActivePreviewPath(null);
         }
         catch (error) {
@@ -241,6 +288,8 @@ export function useChatSessions(params) {
         resetActiveProjection,
         setActivePreviewPath,
         setError,
+        sessionOwnerQuery,
+        workspaceId,
     ]);
     useEffect(() => {
         void refreshSessionList();
@@ -271,28 +320,45 @@ export function useChatSessions(params) {
             .map((item) => item.sessionId));
     }, [sessionList]);
     useEffect(() => () => titleWatcherRef.current?.dispose(), []);
-    // Browser refresh recovery: retain only the durable session id locally, then
-    // re-read messages and operation refs/facts from the server-owned stores.
+    // Browser refresh/workspace-switch recovery: selection is client state keyed
+    // by workspace; messages and operation refs/facts remain server-owned.
     useEffect(() => {
         let cancelled = false;
-        const savedSessionId = window.localStorage.getItem(ACTIVE_CHAT_SESSION_STORAGE_KEY);
-        if (!savedSessionId)
-            return;
+        if (blocked)
+            return; // AC-R5-002: unknown workspace — no restore GET
         const selectionVersion = ++sessionSelectionVersionRef.current;
+        // Remove the old workspace projection immediately. Background session
+        // streams remain alive; only the visible selection is rebound below.
+        resetActiveProjection({ keepStreams: true });
+        refs.sessionRef.current = null;
+        setSession(null);
+        const savedSessionId = readActiveChatSessionId(window.localStorage, workspaceId);
+        if (!savedSessionId) {
+            // Keep the per-workspace map intact, but clear the legacy global pointer
+            // so Operate/Models cannot link a session from another workspace.
+            forgetActiveChatSession(window.localStorage, workspaceId);
+            return;
+        }
         void (async () => {
             try {
-                const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(savedSessionId)}`, { credentials: "include" });
+                const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(savedSessionId)}${workspaceQuery}`, { credentials: "include" });
                 if (!res.ok) {
-                    window.localStorage.removeItem(ACTIVE_CHAT_SESSION_STORAGE_KEY);
+                    forgetActiveChatSession(window.localStorage, workspaceId, savedSessionId);
                     return;
                 }
                 const body = (await res.json());
                 if (cancelled ||
+                    blocked ||
                     selectionVersion !== sessionSelectionVersionRef.current ||
                     !body.session)
                     return;
                 const restored = {
                     sessionId: body.session.sessionId,
+                    ...(body.session.workspaceId
+                        ? { workspaceId: body.session.workspaceId }
+                        : workspaceId
+                            ? { workspaceId }
+                            : {}),
                     ...runtimeSelectionFromRecord(body.session),
                 };
                 refs.sessionGenerationRef.current += 1;
@@ -302,25 +368,37 @@ export function useChatSessions(params) {
                 // in the event ring and must replay once. applySseBlock dedups by
                 // eventId and marks replay so usage/unread/sound do not double-count.
                 refs.activeTurnIdRef.current = body.session.activeTurnId ?? null;
+                const visuallyStopped = body.session.turnPhase === "stopping";
+                refs.streamingRef.current = visuallyStopped
+                    ? false
+                    : Boolean(body.session.activeTurnId);
+                refs.stoppingTurnIdRef.current = visuallyStopped
+                    ? (body.session.activeTurnId ?? null)
+                    : null;
+                refs.stopRequestedRef.current = visuallyStopped;
                 refs.seenEventIdsRef.current = new Set();
                 refs.turnAssistantIdsRef.current = new Map();
                 refs.sealedAssistantIdsRef.current = new Set();
                 refs.settledTurnIdsRef.current = new Set();
                 refs.lastEventIdRef.current = null;
                 setSession(restored);
+                rememberActiveChatSession(window.localStorage, restored.workspaceId ?? workspaceId, restored.sessionId);
                 setInput(body.session.composerDraft ?? "");
-                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 ?? []);
+                hydrated.messages = mergeCompactionMessages(hydrated.messages, body.compactions);
+                applyActivatedSession({
+                    messages: hydrated.messages,
+                    toolCalls: hydrated.toolCalls,
+                    sessionStats: body.sessionStats,
+                    usage: body.usage,
+                    streaming: visuallyStopped ? false : Boolean(body.session.activeTurnId),
+                    turnPhase: body.session.turnPhase ??
+                        (body.session.activeTurnId ? "running" : "idle"),
+                    deferredTurn: body.session.deferredTurn ?? null,
+                    deferredTurns: body.session.deferredTurns ?? (body.session.deferredTurn ? [body.session.deferredTurn] : []),
+                    pendingQuestion: body.session.pendingQuestion ?? null,
+                    todos: body.session.todos ?? [],
+                });
             }
             catch {
                 // Recovery is best-effort; a new session remains available.
@@ -329,35 +407,58 @@ export function useChatSessions(params) {
         return () => {
             cancelled = true;
         };
-    }, [origin, refs, setSession, setInput, setMessages]);
+    }, [
+        origin,
+        workspaceQuery,
+        refs,
+        setSession,
+        setInput,
+        applyActivatedSession,
+        blocked,
+        resetActiveProjection,
+        workspaceId,
+    ]);
     // The sole production create path delegates to the exported orchestration
     // helper so its durable commit order is directly traceable and testable.
-    const createSessionAndPrimeTitleWatcherForHook = useCallback((options) => createSessionAndPrimeTitleWatcher({
-        origin,
-        sessionListRef,
-        setSessionList,
-        titleWatcher: titleWatcherRef.current,
-        refreshSessionList,
-        options,
-        setCreatingSession,
-        creatingRef: creatingSessionRef,
-    }), [origin, refreshSessionList]);
+    // AC-003 (2026-08-26): session creation REQUIRES a known workspaceId —
+    // either explicit (sidebar create-in-workspace) or the current valid
+    // selection. No scope → fail closed client-side (the server would reject
+    // with WORKSPACE_REQUIRED anyway); never a default-workspace fallback.
+    const createSessionAndPrimeTitleWatcherForHook = useCallback((options) => {
+        const scope = options?.workspaceId?.trim() ?? workspaceId?.trim();
+        if (!scope) {
+            setError("创建会话需要选择一个有效的工作区（不会回退默认工作区）");
+            return Promise.reject(new Error("WORKSPACE_REQUIRED"));
+        }
+        return createSessionAndPrimeTitleWatcher({
+            origin,
+            sessionListRef,
+            setSessionList,
+            titleWatcher: titleWatcherRef.current,
+            refreshSessionList,
+            options: { ...options, workspaceId: scope },
+            setCreatingSession,
+            creatingRef: creatingSessionRef,
+        });
+    }, [origin, refreshSessionList, workspaceId, setError]);
     const createSession = useCallback(async (options) => {
         // Suppress concurrent create from any entry (sidebar / Landing / chip).
         if (creatingSessionRef.current)
             return null;
+        if (blocked)
+            return null; // AC-R5-002: unknown workspace — no POST
         const selectionVersion = ++sessionSelectionVersionRef.current;
         setError(null);
         try {
             const created = await createSessionAndPrimeTitleWatcherForHook(options);
             if (selectionVersion !== sessionSelectionVersionRef.current)
                 return null;
-            resetActiveProjection();
+            resetActiveProjection({ keepStreams: true });
             // Set ref synchronously BEFORE setState so a chained
             // createSession().then(sendPrompt) reads the new session even
             // though sendPrompt's closure captured the stale (null) value.
             refs.sessionRef.current = created;
-            window.localStorage.setItem(ACTIVE_CHAT_SESSION_STORAGE_KEY, created.sessionId);
+            rememberActiveChatSession(window.localStorage, created.workspaceId ?? options?.workspaceId ?? workspaceId, created.sessionId);
             setSession(created);
             return created;
         }
@@ -376,6 +477,8 @@ export function useChatSessions(params) {
         setError,
         resetActiveProjection,
         createSessionAndPrimeTitleWatcherForHook,
+        blocked,
+        workspaceId,
     ]);
     // Phase-1: fork / in-session branch / mainline switch UI deferred; API routes remain.
     /** Single compact helper for toolbar + `/compact <instructions>` (AC-1). */
@@ -392,7 +495,8 @@ export function useChatSessions(params) {
             if (trimmed) {
                 headers["content-type"] = "application/json";
             }
-            const response = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(current.sessionId)}/compact`, {
+            // AC-002: compaction follows the session's durable owner.
+            const response = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(current.sessionId)}/compact${sessionOwnerQuery()}`, {
                 method: "POST",
                 credentials: "include",
                 headers,
@@ -421,22 +525,8 @@ export function useChatSessions(params) {
             // pi-web parity: reload the compacted session, then leave a distinct
             // compaction summary card in the timeline plus a transient toast.
             const summary = body.snapshot?.summary?.trim();
-            const tokensBefore = body.snapshot?.tokensBefore;
             const summaryText = summary || "历史上下文已精简，关键决策与当前任务已保留。";
             await activateSession(current.sessionId);
-            setMessages((messages) => [
-                ...messages,
-                {
-                    id: `compaction-${Date.now()}`,
-                    role: "assistant",
-                    kind: "compaction",
-                    text: summaryText,
-                    createdAt: Date.now(),
-                    ...(tokensBefore
-                        ? { compaction: { tokensBefore } }
-                        : {}),
-                },
-            ]);
             setNotice({
                 id: Date.now(),
                 message: `已压缩上下文：${summaryText.slice(0, 72)}${summaryText.length > 72 ? "…" : ""}`,
@@ -453,12 +543,14 @@ export function useChatSessions(params) {
         refs,
         setError,
         setNotice,
-        setMessages,
         onCompactionChange,
         activateSession,
+        sessionOwnerQuery,
     ]);
     const updateSession = async (sessionId, patch) => {
-        const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}`, {
+        // AC-002: rename/archive follows the session's durable owner.
+        const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}${sessionOwnerQuery(sessionListRef.current.find((item) => item.sessionId === sessionId)
+            ?.workspaceId ?? null)}`, {
             method: "PATCH",
             credentials: "include",
             headers: {
@@ -477,11 +569,13 @@ export function useChatSessions(params) {
         }
         if (patch.state === "archived" &&
             refs.sessionRef.current?.sessionId === sessionId) {
+            const activeWorkspaceId = refs.sessionRef.current.workspaceId ?? workspaceId;
+            const activeSessionId = refs.sessionRef.current.sessionId;
             sessionSelectionVersionRef.current += 1;
             refs.sessionRef.current = null;
             resetActiveProjection();
             setSession(null);
-            window.localStorage.removeItem(ACTIVE_CHAT_SESSION_STORAGE_KEY);
+            forgetActiveChatSession(window.localStorage, activeWorkspaceId, activeSessionId);
         }
     };
     return {