@tea-agent/loop-agent 0.33.7-beta.0 → 0.34.1

package/dist/worker/console/static-src/operator-chat/session-title-watcher.js

@@ -0,0 +1,128 @@
+/**
+ * Owns title-only SSE lifecycles. It is deliberately independent from the
+ * timeline SSE applier: title frames update the session index only.
+ */
+export class SessionTitleWatcher {
+    options;
+    eligible = new Set();
+    controllers = new Map();
+    fetchFn;
+    backoffMs;
+    deadlineMs;
+    constructor(options) {
+        this.options = options;
+        this.fetchFn = options.fetchFn ?? fetch;
+        this.backoffMs = options.backoffMs ?? 1_000;
+        this.deadlineMs = options.deadlineMs ?? 30_000;
+    }
+    markEligible(sessionId) {
+        this.eligible.add(sessionId);
+    }
+    startIfEligible(sessionId) {
+        if (!this.eligible.delete(sessionId) || this.controllers.has(sessionId))
+            return;
+        const controller = new AbortController();
+        this.controllers.set(sessionId, controller);
+        void this.run(sessionId, controller);
+    }
+    cancel(sessionId) {
+        this.eligible.delete(sessionId);
+        this.controllers.get(sessionId)?.abort();
+        this.controllers.delete(sessionId);
+    }
+    reconcile(sessionIds) {
+        const current = new Set(sessionIds);
+        for (const sessionId of this.controllers.keys()) {
+            if (!current.has(sessionId))
+                this.cancel(sessionId);
+        }
+    }
+    dispose() {
+        for (const controller of this.controllers.values())
+            controller.abort();
+        this.controllers.clear();
+        this.eligible.clear();
+    }
+    async run(sessionId, controller) {
+        let lastEventId;
+        const seen = new Set();
+        let deadlineReached = false;
+        const deadline = window.setTimeout(() => {
+            deadlineReached = true;
+            controller.abort();
+        }, this.deadlineMs);
+        try {
+            while (!controller.signal.aborted) {
+                try {
+                    const headers = { Accept: "text/event-stream" };
+                    if (lastEventId)
+                        headers["Last-Event-ID"] = lastEventId;
+                    const response = await this.fetchFn(`${this.options.origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/events`, { headers, credentials: "include", signal: controller.signal });
+                    if (response.status === 404 || !response.body)
+                        return;
+                    if (!response.ok)
+                        throw new Error(`HTTP ${response.status}`);
+                    const reader = response.body.getReader();
+                    const decoder = new TextDecoder();
+                    let buffer = "";
+                    for (;;) {
+                        const { done, value } = await reader.read();
+                        if (done || controller.signal.aborted)
+                            break;
+                        buffer += decoder.decode(value, { stream: true });
+                        const blocks = buffer.split("\n\n");
+                        buffer = blocks.pop() ?? "";
+                        for (const block of blocks) {
+                            const eventId = block.split("\n").find((line) => line.startsWith("id: "))?.slice(4);
+                            if (eventId)
+                                lastEventId = eventId;
+                            if (!eventId || seen.has(eventId) || !block.includes("event: session_title"))
+                                continue;
+                            const data = block.split("\n").find((line) => line.startsWith("data: "))?.slice(6);
+                            if (!data)
+                                continue;
+                            try {
+                                const parsed = JSON.parse(data);
+                                const title = parsed.data?.title?.trim();
+                                if (!title)
+                                    continue;
+                                seen.add(eventId);
+                                if (!this.options.hasSession(sessionId))
+                                    return;
+                                this.options.onTitle(sessionId, { title, automatic: Boolean(parsed.data?.automatic) });
+                                if (parsed.data?.automatic)
+                                    return;
+                            }
+                            catch { /* malformed title frames are ignored */ }
+                        }
+                    }
+                }
+                catch {
+                    if (controller.signal.aborted)
+                        return;
+                }
+                if (!controller.signal.aborted)
+                    await abortableSleep(this.backoffMs, controller.signal);
+            }
+        }
+        finally {
+            window.clearTimeout(deadline);
+            if (this.controllers.get(sessionId) === controller)
+                this.controllers.delete(sessionId);
+            if (deadlineReached || !this.options.hasSession(sessionId))
+                void this.options.refresh();
+        }
+    }
+}
+function abortableSleep(ms, signal) {
+    return new Promise((resolve) => {
+        const timer = window.setTimeout(done, ms);
+        const onAbort = () => done();
+        function done() {
+            window.clearTimeout(timer);
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}

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

@@ -0,0 +1,90 @@
+/** Session/repo vertical split percent with versioned localStorage. */
+export const SIDEBAR_SPLIT_STORAGE_KEY = "loop-console.operator-chat.sidebar-split.v1";
+export const SIDEBAR_SPLIT_DEFAULT = 45;
+export const SIDEBAR_SPLIT_MIN = 28;
+export const SIDEBAR_SPLIT_MAX = 70;
+export const SIDEBAR_SPLIT_STEP = 5;
+export const SIDEBAR_SPLIT_STEP_LARGE = 10;
+/** Clamp session share percent into the legal 28–70 band. */
+export function clampSplit(percent) {
+    if (!Number.isFinite(percent))
+        return SIDEBAR_SPLIT_DEFAULT;
+    return Math.min(SIDEBAR_SPLIT_MAX, Math.max(SIDEBAR_SPLIT_MIN, Math.round(percent)));
+}
+/** Parse a stored value; only integers in 28–70 are accepted. */
+export function parseStoredSplit(raw) {
+    if (raw == null || raw === "")
+        return null;
+    const n = Number(raw);
+    if (!Number.isFinite(n))
+        return null;
+    const rounded = Math.round(n);
+    if (rounded < SIDEBAR_SPLIT_MIN || rounded > SIDEBAR_SPLIT_MAX)
+        return null;
+    return rounded;
+}
+/** Load session percent or fall back to 45 on missing/corrupt storage. */
+export function loadSidebarSplit(storage = defaultStorage()) {
+    if (!storage)
+        return SIDEBAR_SPLIT_DEFAULT;
+    try {
+        const parsed = parseStoredSplit(storage.getItem(SIDEBAR_SPLIT_STORAGE_KEY));
+        return parsed ?? SIDEBAR_SPLIT_DEFAULT;
+    }
+    catch {
+        return SIDEBAR_SPLIT_DEFAULT;
+    }
+}
+/** Persist a clamped session percent; ignore storage failures. */
+export function saveSidebarSplit(percent, storage = defaultStorage()) {
+    const value = clampSplit(percent);
+    if (!storage)
+        return value;
+    try {
+        storage.setItem(SIDEBAR_SPLIT_STORAGE_KEY, String(value));
+    }
+    catch {
+        // localStorage may be unavailable; keep in-memory value.
+    }
+    return value;
+}
+/** Map keyboard keys on the separator to a next session percent. */
+export function adjustSplitByKey(current, key, shiftKey = false) {
+    const base = clampSplit(current);
+    switch (key) {
+        case "ArrowUp":
+            return clampSplit(base - (shiftKey ? SIDEBAR_SPLIT_STEP_LARGE : SIDEBAR_SPLIT_STEP));
+        case "ArrowDown":
+            return clampSplit(base + (shiftKey ? SIDEBAR_SPLIT_STEP_LARGE : SIDEBAR_SPLIT_STEP));
+        case "Home":
+            return SIDEBAR_SPLIT_MIN;
+        case "End":
+            return SIDEBAR_SPLIT_MAX;
+        case "Enter":
+            return SIDEBAR_SPLIT_DEFAULT;
+        default:
+            return null;
+    }
+}
+/**
+ * Compute session percent from a pointer Y within a split track rect.
+ * top of track → min session share; bottom → max session share.
+ */
+export function splitPercentFromPointer(clientY, trackTop, trackHeight) {
+    if (!Number.isFinite(trackHeight) || trackHeight <= 0) {
+        return SIDEBAR_SPLIT_DEFAULT;
+    }
+    const ratio = (clientY - trackTop) / trackHeight;
+    return clampSplit(ratio * 100);
+}
+function defaultStorage() {
+    try {
+        if (typeof globalThis === "undefined")
+            return null;
+        const storage = globalThis.localStorage;
+        return storage ?? null;
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Mutual-exclusion state for large spatial overlays in Operator Chat.
+ * At most one of: sidebar drawer, process, runtime context, tools.
+ * Small composer menus (model/thinking) are out of scope.
+ */
+export function createSpatialOverlayState(active = "none") {
+    return { active };
+}
+/** Open one overlay; closes any other spatial overlay. */
+export function openSpatialOverlay(_state, kind) {
+    return { active: kind };
+}
+/** Close the active overlay (or no-op when already none). */
+export function closeSpatialOverlay(_state = { active: "none" }) {
+    return { active: "none" };
+}
+/** Close only when the named overlay is active. */
+export function closeSpatialOverlayIf(state, kind) {
+    return state.active === kind ? { active: "none" } : state;
+}
+export function isSpatialOverlayOpen(state, kind) {
+    if (kind)
+        return state.active === kind;
+    return state.active !== "none";
+}
+/**
+ * Derive exclusive UI flags for the four large panels from a single source.
+ * Opening one forces the others closed.
+ */
+export function spatialOverlayFlags(state) {
+    return {
+        sidebarDrawerOpen: state.active === "sidebar-drawer",
+        processOpen: state.active === "process",
+        runtimeContextOpen: state.active === "runtime-context",
+        toolsOpen: state.active === "tools",
+    };
+}

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

@@ -4,6 +4,56 @@ import { hydrateSessionThread } from "../../chat/turn-process.js";
 import { ACTIVE_CHAT_SESSION_STORAGE_KEY } from "../../chat/workspace-landing.js";
 import { CHAT_SESSION_LIST_LIMIT } from "../chat-view-types.js";
 import { confirmationToken } from "./format.js";
+import { SessionTitleWatcher } from "./session-title-watcher.js";
+export async function createSessionAndPrimeTitleWatcher(input) {
+    if (input.creatingRef?.current) {
+        throw new Error("CREATE_SESSION_IN_FLIGHT");
+    }
+    if (input.creatingRef)
+        input.creatingRef.current = true;
+    // Synchronous busy feedback: callers set creatingSession in the same render
+    // turn via setCreatingSession before the network await below.
+    input.setCreatingSession?.(true);
+    try {
+        const res = await (input.fetchFn ?? fetch)(`${input.origin}/api/operator/v1/chat/sessions`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-loop-console-confirmation": confirmationToken(),
+            },
+            credentials: "include",
+            body: JSON.stringify(input.options ?? {}),
+        });
+        if (!res.ok) {
+            const body = (await res.json().catch(() => ({})));
+            throw new Error(body.error?.message ?? `HTTP ${res.status}`);
+        }
+        const body = (await res.json());
+        if (!body.session)
+            throw new Error("创建会话响应缺少 durable session");
+        const durable = body.session;
+        const created = {
+            sessionId: durable.sessionId,
+            ...runtimeSelectionFromRecord(durable),
+        };
+        const nextList = [
+            durable,
+            ...input.sessionListRef.current.filter((item) => item.sessionId !== durable.sessionId),
+        ].slice(0, CHAT_SESSION_LIST_LIMIT);
+        // Commit ref → state → eligibility → deferred refresh. The ref assignment
+        // makes the durable record observable before React's state commit.
+        input.sessionListRef.current = nextList;
+        input.setSessionList(nextList);
+        input.titleWatcher?.markEligible(durable.sessionId);
+        void input.refreshSessionList();
+        return created;
+    }
+    finally {
+        if (input.creatingRef)
+            input.creatingRef.current = false;
+        input.setCreatingSession?.(false);
+    }
+}
 /** Session lifecycle: list / activate / create / delete / rename-archive /
  *  compact, plus browser-refresh recovery from the durable session store. */
 export function useChatSessions(params) {
@@ -12,17 +62,34 @@ export function useChatSessions(params) {
     const { setInput, setPendingImages } = composer;
     const { setPreviews, setActivePreviewPath } = browser;
     const [sessionList, setSessionList] = useState([]);
+    const sessionListRef = useRef([]);
+    sessionListRef.current = sessionList;
+    const titleWatcherRef = useRef(null);
+    // Shared busy gate for sidebar + Landing create entries (one render feedback).
+    const [creatingSession, setCreatingSession] = useState(false);
+    const creatingSessionRef = useRef(false);
     // Only the latest activate/create/restore intent may commit active-session
     // 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.
+        refs.sessionGenerationRef.current += 1;
+        refs.abortRef.current?.abort();
+        refs.reconnectAbortRef.current?.abort();
+        for (const controller of refs.sessionAbortControllersRef.current.values())
+            controller.abort();
+        refs.sessionAbortControllersRef.current.clear();
+        refs.reconnectAbortRef.current = null;
+        refs.eventsStreamStateRef.current = null;
         refs.streamingRef.current = false;
         refs.abortRef.current = null;
         refs.assistantIdRef.current = null;
         refs.lastEventIdRef.current = null;
         refs.seenEventIdsRef.current = new Set();
         refs.turnAssistantIdsRef.current = new Map();
+        refs.settledTurnIdsRef.current = new Set();
         refs.activeTurnIdRef.current = null;
         resetForNewSession();
         setInput("");
@@ -91,6 +158,7 @@ export function useChatSessions(params) {
                 setError("删除会话失败");
                 return;
             }
+            titleWatcherRef.current?.cancel(sessionId);
             if (refs.sessionRef.current?.sessionId === sessionId) {
                 sessionSelectionVersionRef.current += 1;
                 refs.sessionRef.current = null;
@@ -124,11 +192,13 @@ export function useChatSessions(params) {
                 sessionId: body.session.sessionId,
                 ...runtimeSelectionFromRecord(body.session),
             };
+            resetActiveProjection();
             refs.sessionRef.current = next;
             refs.streamingRef.current = Boolean(body.session.activeTurnId);
             refs.activeTurnIdRef.current = body.session.activeTurnId ?? null;
             refs.seenEventIdsRef.current = new Set();
             refs.turnAssistantIdsRef.current = new Map();
+            refs.settledTurnIdsRef.current = new Set();
             refs.lastEventIdRef.current = null;
             setSession(next);
             refs.assistantIdRef.current = null;
@@ -159,12 +229,39 @@ export function useChatSessions(params) {
         setPreviews,
         setInput,
         applyActivatedSession,
+        resetActiveProjection,
         setActivePreviewPath,
         setError,
     ]);
     useEffect(() => {
         void refreshSessionList();
     }, [refreshSessionList]);
+    if (!titleWatcherRef.current) {
+        titleWatcherRef.current = new SessionTitleWatcher({
+            origin,
+            hasSession: (sessionId) => sessionListRef.current.some((item) => item.sessionId === sessionId),
+            onTitle: (sessionId, event) => {
+                setSessionList((current) => current.map((item) => {
+                    if (item.sessionId !== sessionId)
+                        return item;
+                    // A manually assigned title is authoritative over late automatic output.
+                    if (event.automatic && item.title)
+                        return item;
+                    return event.automatic
+                        ? { ...item, title: event.title }
+                        : { ...item, displayTitle: event.title };
+                }));
+            },
+            refresh: refreshSessionList,
+        });
+    }
+    const watchSessionTitle = useCallback((sessionId) => titleWatcherRef.current?.startIfEligible(sessionId), []);
+    useEffect(() => {
+        titleWatcherRef.current?.reconcile(sessionList
+            .filter((item) => item.state !== "archived" && !item.title)
+            .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.
     useEffect(() => {
@@ -189,6 +286,7 @@ export function useChatSessions(params) {
                     sessionId: body.session.sessionId,
                     ...runtimeSelectionFromRecord(body.session),
                 };
+                refs.sessionGenerationRef.current += 1;
                 refs.sessionRef.current = restored;
                 // Do not seed Last-Event-ID here: session messages are restored
                 // from the durable store, but tool/gate/operation projections live
@@ -197,6 +295,7 @@ export function useChatSessions(params) {
                 refs.activeTurnIdRef.current = body.session.activeTurnId ?? null;
                 refs.seenEventIdsRef.current = new Set();
                 refs.turnAssistantIdsRef.current = new Map();
+                refs.settledTurnIdsRef.current = new Set();
                 refs.lastEventIdRef.current = null;
                 setSession(restored);
                 setInput(body.session.composerDraft ?? "");
@@ -217,29 +316,26 @@ export function useChatSessions(params) {
             cancelled = true;
         };
     }, [origin, refs, setSession, setInput, setMessages]);
+    // 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]);
     const createSession = useCallback(async (options) => {
+        // Suppress concurrent create from any entry (sidebar / Landing / chip).
+        if (creatingSessionRef.current)
+            return null;
         const selectionVersion = ++sessionSelectionVersionRef.current;
         setError(null);
         try {
-            const res = await fetch(`${origin}/api/operator/v1/chat/sessions`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    "x-loop-console-confirmation": confirmationToken(),
-                },
-                credentials: "include",
-                body: JSON.stringify(options ?? {}),
-            });
-            if (!res.ok) {
-                const body = (await res.json().catch(() => ({})));
-                throw new Error(body.error?.message ?? `HTTP ${res.status}`);
-            }
-            const body = (await res.json());
-            const created = {
-                sessionId: body.sessionId,
-                ...(body.model ? { model: body.model } : {}),
-            };
-            void refreshSessionList();
+            const created = await createSessionAndPrimeTitleWatcherForHook(options);
             if (selectionVersion !== sessionSelectionVersionRef.current)
                 return null;
             resetActiveProjection();
@@ -254,16 +350,18 @@ export function useChatSessions(params) {
         catch (e) {
             if (selectionVersion !== sessionSelectionVersionRef.current)
                 return null;
-            setError(e instanceof Error ? e.message : String(e));
+            const message = e instanceof Error ? e.message : String(e);
+            if (message !== "CREATE_SESSION_IN_FLIGHT") {
+                setError(message);
+            }
             return null;
         }
     }, [
-        origin,
         refs,
         setSession,
         setError,
         resetActiveProjection,
-        refreshSessionList,
+        createSessionAndPrimeTitleWatcherForHook,
     ]);
     // Phase-1: fork / in-session branch / mainline switch UI deferred; API routes remain.
     const compactSession = useCallback(async () => {
@@ -302,6 +400,9 @@ export function useChatSessions(params) {
             return;
         }
         await refreshSessionList();
+        if (patch.state === "archived") {
+            titleWatcherRef.current?.cancel(sessionId);
+        }
         if (patch.state === "archived" &&
             refs.sessionRef.current?.sessionId === sessionId) {
             sessionSelectionVersionRef.current += 1;
@@ -313,11 +414,13 @@ export function useChatSessions(params) {
     };
     return {
         sessionList,
+        creatingSession,
         activateSession,
         refreshSessionList,
         deleteSession,
         createSession,
         updateSession,
+        watchSessionTitle,
         compactSession,
     };
 }