@tea-agent/loop-agent 0.43.0-next.9 → 0.44.0-next.1

package/dist/worker/console/static-src/operator-chat/composer-session-ledger.js

@@ -0,0 +1,192 @@
+import { createInputHistoryState, navigateInputHistory, recordInputHistoryEntry, resetInputHistoryBrowsing, } from "./input-history.js";
+export const DUPLICATE_SUBMISSION_GESTURE_MS = 350;
+export function composerSessionKey(identity) {
+    return `${identity.workspaceId ?? ""}\u0000${identity.sessionId}`;
+}
+function cloneHistory(history) {
+    return { ...history, entries: [...history.entries] };
+}
+function cloneImages(images) {
+    return [...images];
+}
+function createRecord() {
+    return {
+        draft: "",
+        images: [],
+        history: createInputHistoryState(),
+        revision: 0,
+        sequence: 0,
+        initialized: false,
+        attempts: new Map(),
+        failedSubmissionCount: 0,
+    };
+}
+function sameImages(left, right) {
+    return (left.length === right.length &&
+        left.every((image, index) => {
+            const other = right[index];
+            return (other !== undefined &&
+                image.name === other.name &&
+                image.type === other.type &&
+                image.mimeType === other.mimeType &&
+                image.data === other.data);
+        }));
+}
+/**
+ * Browser-local composer state addressed by durable session identity.
+ *
+ * Network callbacks settle immutable attempts against their owning record;
+ * they never need to mutate whichever composer happens to be visible.
+ */
+export class ComposerSessionLedger {
+    now;
+    records = new Map();
+    constructor(now = Date.now) {
+        this.now = now;
+    }
+    has(identity) {
+        return this.records.has(composerSessionKey(identity));
+    }
+    snapshot(identity) {
+        const record = this.record(identity);
+        return {
+            draft: record.draft,
+            images: cloneImages(record.images),
+            history: cloneHistory(record.history),
+            revision: record.revision,
+            failedSubmissionCount: record.failedSubmissionCount,
+        };
+    }
+    seedDraft(identity, draft) {
+        const record = this.record(identity);
+        if (record.initialized || record.revision !== 0 || record.attempts.size > 0)
+            return false;
+        record.draft = draft;
+        record.initialized = true;
+        return true;
+    }
+    setDraft(identity, draft) {
+        const record = this.record(identity);
+        if (record.draft === draft)
+            return false;
+        record.draft = draft;
+        record.history = resetInputHistoryBrowsing(record.history);
+        record.revision += 1;
+        record.initialized = true;
+        return true;
+    }
+    setImages(identity, images) {
+        const record = this.record(identity);
+        record.images = cloneImages(images);
+        record.revision += 1;
+        record.initialized = true;
+        return true;
+    }
+    recordHistory(identity, text) {
+        const record = this.record(identity);
+        record.history = recordInputHistoryEntry(record.history, text);
+    }
+    navigateHistory(identity, direction, context) {
+        const record = this.record(identity);
+        const decision = navigateInputHistory(record.history, direction, context);
+        if (!decision.handled)
+            return decision;
+        record.history = decision.state;
+        if (record.draft !== decision.text) {
+            record.draft = decision.text;
+            record.revision += 1;
+            record.initialized = true;
+        }
+        return decision;
+    }
+    beginSubmission(identity, sessionGeneration, clientRequestId) {
+        const record = this.record(identity);
+        if (!record.draft.trim() && record.images.length === 0)
+            return null;
+        const now = this.now();
+        const sinceLastClaim = record.lastClaim
+            ? now - record.lastClaim.at
+            : Number.POSITIVE_INFINITY;
+        if (record.lastClaim &&
+            sinceLastClaim >= 0 &&
+            sinceLastClaim <= DUPLICATE_SUBMISSION_GESTURE_MS &&
+            record.lastClaim.draft === record.draft &&
+            sameImages(record.lastClaim.images, record.images))
+            return null;
+        record.sequence += 1;
+        const sequence = record.sequence;
+        const controller = new AbortController();
+        const draftSnapshot = record.draft;
+        const imageSnapshot = cloneImages(record.images);
+        record.lastClaim = {
+            draft: draftSnapshot,
+            images: cloneImages(imageSnapshot),
+            at: now,
+        };
+        record.history = recordInputHistoryEntry(record.history, draftSnapshot);
+        record.draft = "";
+        record.images = [];
+        record.revision += 1;
+        record.initialized = true;
+        const attempt = {
+            attemptId: `${composerSessionKey(identity)}:${sequence}:${clientRequestId}`,
+            identity: { ...identity },
+            sessionGeneration,
+            sequence,
+            clientRequestId,
+            draftSnapshot,
+            imageSnapshot,
+            committedRevision: record.revision,
+            signal: controller.signal,
+        };
+        record.attempts.set(attempt.attemptId, { attempt, controller });
+        return attempt;
+    }
+    settle(attempt, outcome) {
+        const key = composerSessionKey(attempt.identity);
+        const record = this.records.get(key);
+        const owned = record?.attempts.get(attempt.attemptId);
+        if (!record || !owned || owned.attempt !== attempt)
+            return "stale";
+        record.attempts.delete(attempt.attemptId);
+        owned.controller.abort();
+        if (outcome === "accepted")
+            return "accepted";
+        if (record.revision === attempt.committedRevision &&
+            record.draft === "" &&
+            record.images.length === 0) {
+            record.draft = attempt.draftSnapshot;
+            record.images = cloneImages(attempt.imageSnapshot);
+            record.revision += 1;
+            return "restored";
+        }
+        record.failedSubmissionCount = Math.min(Number.MAX_SAFE_INTEGER, record.failedSubmissionCount + 1);
+        return "retained";
+    }
+    settleByRequest(identity, clientRequestId, outcome) {
+        const record = this.records.get(composerSessionKey(identity));
+        const owned = record
+            ? [...record.attempts.values()].find((entry) => entry.attempt.clientRequestId === clientRequestId)
+            : undefined;
+        return owned ? this.settle(owned.attempt, outcome) : "stale";
+    }
+    release(identity) {
+        const key = composerSessionKey(identity);
+        const record = this.records.get(key);
+        if (!record)
+            return;
+        for (const owned of record.attempts.values())
+            owned.controller.abort();
+        record.attempts.clear();
+        this.records.delete(key);
+    }
+    record(identity) {
+        const key = composerSessionKey(identity);
+        let record = this.records.get(key);
+        if (!record) {
+            record = createRecord();
+            this.records.set(key, record);
+        }
+        return record;
+    }
+}

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

@@ -27,7 +27,15 @@ export function replacePendingUserMessage(messages, clientRequestId, durable) {
             continue;
         replaced = true;
         const { pending: _pending, ...rest } = message;
-        next.push({ ...rest, ...durable, clientRequestId });
+        next.push({
+            ...rest,
+            ...durable,
+            // Durable reconciliation replaces values in the established optimistic
+            // seat. A later server timestamp must not move the user below the empty
+            // active assistant cursor when turn groups sort by display time.
+            createdAt: Math.min(message.createdAt, durable.createdAt),
+            clientRequestId,
+        });
     }
     return replaced ? next : [...next, durable];
 }

package/dist/worker/console/static-src/operator-chat/slash-palette-nav.js

@@ -27,8 +27,11 @@ export function buildPaletteModel(entries) {
     for (const source of SLASH_GROUP_DISPLAY_ORDER) {
         const items = [];
         for (let i = 0; i < entries.length; i += 1) {
-            if (entries[i].source === source) {
-                items.push({ entry: entries[i], globalIndex: i });
+            const entry = entries[i];
+            if (!entry)
+                continue;
+            if (entry.source === source) {
+                items.push({ entry, globalIndex: i });
             }
         }
         if (items.length === 0)
@@ -69,6 +72,8 @@ export function movePaletteIndex(currentIndex, model, columns, direction) {
     if (groupPos < 0)
         return currentIndex;
     const group = model[groupPos];
+    if (!group)
+        return currentIndex;
     const offset = group.items.findIndex((card) => card.globalIndex === currentIndex);
     if (offset < 0)
         return currentIndex;
@@ -84,25 +89,30 @@ export function movePaletteIndex(currentIndex, model, columns, direction) {
         }
         if (Math.floor(targetOffset / columns) !== row)
             return currentIndex;
-        return group.items[targetOffset].globalIndex;
+        const targetCard = group.items[targetOffset];
+        return targetCard ? targetCard.globalIndex : currentIndex;
     }
     const delta = direction === "up" ? -1 : 1;
     const targetOffset = offset + delta * columns;
     if (targetOffset >= 0 && targetOffset < group.items.length) {
-        return group.items[targetOffset].globalIndex;
+        const targetCard = group.items[targetOffset];
+        return targetCard ? targetCard.globalIndex : currentIndex;
     }
     // Cross-group: walk to the previous/next non-empty group and target the
     // same column on its last (up) / first (down) row; stick when that column
     // does not exist in the partial edge row.
     for (let cursor = groupPos + delta; cursor >= 0 && cursor < model.length; cursor += delta) {
         const candidate = model[cursor];
+        if (!candidate)
+            continue;
         if (candidate.items.length === 0)
             continue;
         const lastRowStart = Math.floor((candidate.items.length - 1) / columns) * columns;
         const target = direction === "up" ? lastRowStart + col : col;
         if (target >= candidate.items.length)
             return currentIndex;
-        return candidate.items[target].globalIndex;
+        const targetCard = candidate.items[target];
+        return targetCard ? targetCard.globalIndex : currentIndex;
     }
     return currentIndex;
 }

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

@@ -0,0 +1,29 @@
+function anchorAt(group) {
+    return group.user?.createdAt ?? group.assistants[0]?.createdAt ?? 0;
+}
+function pendingAt(item) {
+    const at = Date.parse(item.updatedAt);
+    return Number.isFinite(at) ? at : Number.MAX_SAFE_INTEGER;
+}
+/**
+ * Merge pending (dispatching/queued) user steering into the message timeline
+ * by timestamp instead of always rendering at the very end. A pending message
+ * whose `updatedAt` precedes an already-rendered turn keeps its real slot; a
+ * stable sort preserves current group order for equal anchors (turns first).
+ */
+export function mergePendingIntoTimeline(input) {
+    const entries = [];
+    for (const group of input.turnGroups) {
+        entries.push({ kind: "group", group });
+    }
+    for (const item of input.pendingSteering) {
+        if (item.state !== "dispatching")
+            continue;
+        entries.push({ kind: "pending", item });
+    }
+    return entries.sort((a, b) => {
+        const atA = a.kind === "group" ? anchorAt(a.group) : pendingAt(a.item);
+        const atB = b.kind === "group" ? anchorAt(b.group) : pendingAt(b.item);
+        return atA - atB;
+    });
+}

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

@@ -180,7 +180,7 @@ function mergeCompactionMessages(messages, compactions) {
 export function useChatSessions(params) {
     const { origin, refs, setSession, thread, composer, browser, setError, setNotice, onCompactionChange, setProcessOpen, setAutoScroll, } = params;
     const { applyActivatedSession, resetForNewSession, setMessages } = thread;
-    const { setInput, setPendingImages } = composer;
+    const { seedSession, releaseSession } = composer;
     const { setPreviews, setActivePreviewPath } = browser;
     const { workspaceId, blocked } = params;
     const workspaceQuery = workspaceId
@@ -198,7 +198,11 @@ export function useChatSessions(params) {
         return owner ? `?workspaceId=${encodeURIComponent(owner)}` : "";
     }, [refs]);
     const [sessionList, setSessionList] = useState([]);
+    const [selectedSession, setSelectedSession] = useState(null);
+    const selectedSessionRef = useRef(null);
+    selectedSessionRef.current = selectedSession;
     const sessionListRef = useRef([]);
+    const sessionListRequestVersionRef = useRef(0);
     const pendingDeletedIdsRef = useRef(new Set());
     const pendingCreatedRowsRef = useRef(new Map());
     const sessionMutationVersionRef = useRef(0);
@@ -240,8 +244,6 @@ export function useChatSessions(params) {
         refs.settledTurnIdsRef.current = new Set();
         refs.activeTurnIdRef.current = null;
         resetForNewSession();
-        setInput("");
-        setPendingImages([]);
         setPreviews([]);
         setActivePreviewPath(null);
         setProcessOpen(false);
@@ -249,8 +251,6 @@ export function useChatSessions(params) {
     }, [
         refs,
         resetForNewSession,
-        setInput,
-        setPendingImages,
         setPreviews,
         setActivePreviewPath,
         setProcessOpen,
@@ -259,6 +259,7 @@ export function useChatSessions(params) {
     const refreshSessionList = useCallback(async () => {
         if (blocked)
             return; // AC-R5-002: fail-closed, zero session requests
+        const version = ++sessionListRequestVersionRef.current;
         try {
             // The sidebar is a multi-workspace index. Keep one unscoped summary
             // collection so expanding or switching a workspace never projects the
@@ -268,6 +269,8 @@ export function useChatSessions(params) {
                 credentials: "include",
             });
             const body = (await res.json().catch(() => ({})));
+            if (version !== sessionListRequestVersionRef.current)
+                return;
             if (!res.ok) {
                 setError(body.error?.message ?? `会话列表加载失败（HTTP ${res.status}）`);
                 return;
@@ -285,6 +288,8 @@ export function useChatSessions(params) {
             }
         }
         catch (error) {
+            if (version !== sessionListRequestVersionRef.current)
+                return;
             setError(`会话列表加载失败：${error instanceof Error ? error.message : String(error)}`);
         }
     }, [origin, blocked, setError]);
@@ -296,12 +301,22 @@ export function useChatSessions(params) {
         const { next: removedList, removed, index: removedIndex } = removeSessionById(currentList, sessionId);
         if (!removed || removedIndex < 0)
             return false;
+        // No pre-mutation snapshot may overwrite this deletion or its rollback.
+        sessionListRequestVersionRef.current += 1;
         pendingDeletedIdsRef.current.add(sessionId);
         deleteRequestVersionsRef.current.set(sessionId, requestId);
         const activeSession = refs.sessionRef.current?.sessionId === sessionId
             ? refs.sessionRef.current
             : null;
-        const activeWorkspaceId = activeSession?.workspaceId ?? workspaceId;
+        const selectedForDelete = selectedSessionRef.current?.sessionId === sessionId
+            ? selectedSessionRef.current
+            : null;
+        const deletingIdentity = selectedForDelete ??
+            activeSession ?? {
+            sessionId,
+            ...(removed.workspaceId ? { workspaceId: removed.workspaceId } : {}),
+        };
+        const activeWorkspaceId = deletingIdentity.workspaceId ?? workspaceId;
         const deletingRow = {
             ...removed,
             optimisticState: "deleting",
@@ -320,16 +335,17 @@ export function useChatSessions(params) {
         const restore = () => {
             if (deleteRequestVersionsRef.current.get(sessionId) !== requestId)
                 return;
+            sessionListRequestVersionRef.current += 1;
             pendingDeletedIdsRef.current.delete(sessionId);
             deleteRequestVersionsRef.current.delete(sessionId);
-            const restored = restoreSessionAt(sessionListRef.current, removed, removedIndex);
+            const restored = restoreSessionAt(sessionListRef.current.filter((item) => item.sessionId !== sessionId), removed, removedIndex);
             if (restored === sessionListRef.current)
                 return;
             sessionListRef.current = restored;
             setSessionList(restored);
         };
         let deletionSelectionVersion = null;
-        if (activeSession) {
+        if (activeSession || selectedForDelete) {
             deletionSelectionVersion = ++sessionSelectionVersionRef.current;
             refs.sessionRef.current = null;
             resetActiveProjection();
@@ -337,17 +353,16 @@ export function useChatSessions(params) {
             forgetActiveChatSession(window.localStorage, activeWorkspaceId, sessionId);
         }
         const restoreActiveSession = async () => {
-            if (activeSession &&
+            if ((activeSession || selectedForDelete) &&
                 deletionSelectionVersion === sessionSelectionVersionRef.current &&
                 !refs.sessionRef.current) {
-                await activateSessionRef.current?.(activeSession.sessionId, activeSession.workspaceId);
+                await activateSessionRef.current?.(deletingIdentity.sessionId, deletingIdentity.workspaceId);
             }
         };
         try {
             // 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 ownerQuery = sessionOwnerQuery(removed.workspaceId ?? null);
             const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}${ownerQuery}`, {
                 method: "DELETE",
                 credentials: "include",
@@ -362,6 +377,13 @@ export function useChatSessions(params) {
                 return false;
             }
             titleWatcherRef.current?.cancel(sessionId);
+            const next = sessionListRef.current.filter((item) => item.sessionId !== sessionId);
+            sessionListRef.current = next;
+            setSessionList(next);
+            if (deletionSelectionVersion === sessionSelectionVersionRef.current &&
+                selectedSessionRef.current?.sessionId === sessionId)
+                setSelectedSession(null);
+            releaseSession(deletingIdentity);
             void refreshSessionList().finally(() => {
                 pendingDeletedIdsRef.current.delete(sessionId);
                 deleteRequestVersionsRef.current.delete(sessionId);
@@ -379,6 +401,7 @@ export function useChatSessions(params) {
         refs,
         setSession,
         resetActiveProjection,
+        releaseSession,
         refreshSessionList,
         setError,
         sessionOwnerQuery,
@@ -388,25 +411,45 @@ export function useChatSessions(params) {
         const active = refs.sessionRef.current;
         const listed = sessionListRef.current.find((item) => item.sessionId === sessionId);
         const scope = ownerWorkspaceId ?? listed?.workspaceId ?? active?.workspaceId ?? workspaceId;
+        const identity = {
+            sessionId,
+            ...(scope ? { workspaceId: scope } : {}),
+        };
         forgetActiveChatSession(window.localStorage, scope, sessionId);
+        releaseSession(identity);
         pendingDeletedIdsRef.current.add(sessionId);
         const { next } = removeSessionById(sessionListRef.current, sessionId);
         sessionListRef.current = next;
         setSessionList(next);
-        if (active?.sessionId === sessionId) {
+        if (active?.sessionId === sessionId ||
+            selectedSessionRef.current?.sessionId === sessionId) {
             sessionSelectionVersionRef.current += 1;
             refs.sessionRef.current = null;
+            setSelectedSession(null);
             resetActiveProjection();
             setSession(null);
         }
         void refreshSessionList();
-    }, [refs, resetActiveProjection, setSession, workspaceId, refreshSessionList]);
+    }, [refs, releaseSession, resetActiveProjection, setSession, workspaceId, refreshSessionList]);
     const activateSession = useCallback(async (sessionId, ownerWorkspaceId) => {
         const selectionVersion = ++sessionSelectionVersionRef.current;
+        const listedOwner = sessionListRef.current.find((item) => item.sessionId === sessionId)?.workspaceId;
+        const requestedOwner = ownerWorkspaceId ?? listedOwner;
+        const requested = {
+            sessionId,
+            ...(requestedOwner ? { workspaceId: requestedOwner } : {}),
+        };
+        // DSH-style staging: selection identity changes synchronously; detail
+        // hydration follows. The previous session loses send authority now.
+        setSelectedSession(requested);
+        resetActiveProjection({ keepStreams: true });
+        refs.sessionRef.current = null;
+        setSession(null);
+        setError(null);
         // 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);
+        const ownerQuery = sessionOwnerQuery(requested.workspaceId);
         try {
             const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}${ownerQuery}`, { credentials: "include" });
             const body = (await res.json());
@@ -427,7 +470,7 @@ export function useChatSessions(params) {
             // 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 });
+            setSelectedSession(next);
             refs.sessionRef.current = next;
             refs.activeTurnIdRef.current = body.session.activeTurnId ?? null;
             const visuallyStopped = body.session.turnPhase === "stopping";
@@ -447,9 +490,8 @@ export function useChatSessions(params) {
             refs.assistantIdRef.current = null;
             refs.abortRef.current =
                 refs.sessionAbortControllersRef.current.get(sessionId) ?? null;
-            setPendingImages([]);
             setPreviews([]);
-            setInput(body.session.composerDraft ?? "");
+            seedSession(next, body.session.composerDraft ?? "");
             const hydrated = hydrateSessionThread(body.session.messages ?? []);
             hydrated.messages = mergeCompactionMessages(hydrated.messages, body.compactions);
             applyActivatedSession({
@@ -482,9 +524,8 @@ export function useChatSessions(params) {
         origin,
         refs,
         setSession,
-        setPendingImages,
         setPreviews,
-        setInput,
+        seedSession,
         applyActivatedSession,
         resetActiveProjection,
         setActivePreviewPath,
@@ -518,9 +559,7 @@ export function useChatSessions(params) {
     }
     const watchSessionTitle = useCallback((sessionId) => titleWatcherRef.current?.startIfEligible(sessionId), []);
     useEffect(() => {
-        titleWatcherRef.current?.reconcile(sessionList
-            .filter((item) => item.state !== "archived" && !item.title)
-            .map((item) => item.sessionId));
+        titleWatcherRef.current?.reconcile(sessionList.flatMap((item) => item.state !== "archived" && !item.title ? [item.sessionId] : []));
     }, [sessionList]);
     useEffect(() => () => titleWatcherRef.current?.dispose(), []);
     // Browser refresh/workspace-switch recovery: selection is client state keyed
@@ -537,15 +576,22 @@ export function useChatSessions(params) {
         setSession(null);
         const savedSessionId = readActiveChatSessionId(window.localStorage, workspaceId);
         if (!savedSessionId) {
+            setSelectedSession(null);
             // 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;
         }
+        setSelectedSession({
+            sessionId: savedSessionId,
+            ...(workspaceId ? { workspaceId } : {}),
+        });
         void (async () => {
             try {
                 const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(savedSessionId)}${workspaceQuery}`, { credentials: "include" });
                 if (!res.ok) {
+                    if (selectionVersion === sessionSelectionVersionRef.current)
+                        setSelectedSession(null);
                     forgetActiveChatSession(window.localStorage, workspaceId, savedSessionId);
                     return;
                 }
@@ -557,6 +603,7 @@ export function useChatSessions(params) {
                     return;
                 const restored = projectActiveChatSession(body.session, workspaceId);
                 refs.sessionGenerationRef.current += 1;
+                setSelectedSession(restored);
                 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
@@ -577,8 +624,8 @@ export function useChatSessions(params) {
                 refs.settledTurnIdsRef.current = new Set();
                 refs.lastEventIdRef.current = null;
                 setSession(restored);
+                seedSession(restored, body.session.composerDraft ?? "");
                 rememberActiveChatSession(window.localStorage, restored.workspaceId ?? workspaceId, restored.sessionId);
-                setInput(body.session.composerDraft ?? "");
                 const hydrated = hydrateSessionThread(body.session.messages ?? []);
                 hydrated.messages = mergeCompactionMessages(hydrated.messages, body.compactions);
                 applyActivatedSession({
@@ -610,7 +657,7 @@ export function useChatSessions(params) {
         workspaceQuery,
         refs,
         setSession,
-        setInput,
+        seedSession,
         applyActivatedSession,
         blocked,
         resetActiveProjection,
@@ -622,7 +669,7 @@ export function useChatSessions(params) {
     // 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 createSessionAndPrimeTitleWatcherForHook = useCallback(async (options) => {
         const scope = options?.workspaceId?.trim() ?? workspaceId?.trim();
         if (!scope) {
             setError("创建会话需要选择一个有效的工作区（不会回退默认工作区）");
@@ -644,25 +691,27 @@ export function useChatSessions(params) {
         const optimisticList = insertOptimisticSession(sessionListRef.current, optimisticRow);
         sessionListRef.current = optimisticList;
         setSessionList(optimisticList);
-        return createSessionAndPrimeTitleWatcher({
-            origin,
-            sessionListRef,
-            setSessionList,
-            titleWatcher: titleWatcherRef.current,
-            refreshSessionList,
-            options: { ...options, workspaceId: scope, optimisticSessionId },
-            setCreatingSession,
-            creatingRef: creatingSessionRef,
-        }).then((created) => {
+        try {
+            const created = await createSessionAndPrimeTitleWatcher({
+                origin,
+                sessionListRef,
+                setSessionList,
+                titleWatcher: titleWatcherRef.current,
+                refreshSessionList,
+                options: { ...options, workspaceId: scope, optimisticSessionId },
+                setCreatingSession,
+                creatingRef: creatingSessionRef,
+            });
             pendingCreatedRowsRef.current.delete(optimisticSessionId);
             return created;
-        }).catch((error) => {
+        }
+        catch (error) {
             pendingCreatedRowsRef.current.delete(optimisticSessionId);
             const cleaned = sessionListRef.current.filter((item) => item.sessionId !== optimisticSessionId);
             sessionListRef.current = cleaned;
             setSessionList(cleaned);
             throw error;
-        });
+        }
     }, [origin, refreshSessionList, workspaceId, setError]);
     const createSession = useCallback(async (options) => {
         // Suppress concurrent create from any entry (sidebar / Landing / chip).
@@ -708,6 +757,7 @@ export function useChatSessions(params) {
             // createSession().then(sendPrompt) reads the new session even
             // though sendPrompt's closure captured the stale (null) value.
             refs.sessionRef.current = created;
+            setSelectedSession(created);
             rememberActiveChatSession(window.localStorage, created.workspaceId ?? options?.workspaceId ?? workspaceId, created.sessionId);
             setSession(created);
             return created;
@@ -834,6 +884,7 @@ export function useChatSessions(params) {
             const activeSessionId = refs.sessionRef.current.sessionId;
             sessionSelectionVersionRef.current += 1;
             refs.sessionRef.current = null;
+            setSelectedSession(null);
             resetActiveProjection();
             setSession(null);
             forgetActiveChatSession(window.localStorage, activeWorkspaceId, activeSessionId);
@@ -841,6 +892,9 @@ export function useChatSessions(params) {
     };
     return {
         sessionList,
+        selectedSession,
+        sessionSwitching: Boolean(selectedSession &&
+            refs.sessionRef.current?.sessionId !== selectedSession.sessionId),
         creatingSession,
         activateSession,
         refreshSessionList,