@tea-agent/loop-agent 0.43.0-next.8 → 0.43.0

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

@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, } from "react";
 import { buildTurnProcessGroups, hydrateSessionThread, selectRecentTurnGroups, } from "../../chat/turn-process.js";
 import { isToolFailure } from "../../chat/tool-preview.js";
+import { compareChatOrder } from "../../chat/turn-order.js";
 import { mergeOperationCardState, } from "../../chat/operation-card.js";
 import { createChatSseEventApplier, } from "./chat-sse-events.js";
 import { mergePendingSubmissionOnHydration } from "./pending-user-message.js";
@@ -130,7 +131,7 @@ export function useChatThread(params) {
     const [historyHasMore, setHistoryHasMore] = useState(false);
     const [historyNextCursor, setHistoryNextCursor] = useState(null);
     const [historyLoading, setHistoryLoading] = useState(false);
-    const historyLoadingRef = useRef(false);
+    const historyLoadingRef = useRef(null);
     const [unread, setUnread] = useState(0);
     const [humanGateCards, setHumanGateCards] = useState([]);
     const [interview, setInterview] = useState(null);
@@ -150,7 +151,6 @@ export function useChatThread(params) {
     const [streamingAssistantId, setStreamingAssistantId] = useState(null);
     const [showSystemInMessages] = useState(false);
     const completedGroupsRef = useRef([]);
-    const previousTimelineRef = useRef(null);
     const refreshSessionTelemetry = useCallback(async () => {
         const targetSessionId = refs.sessionRef.current?.sessionId;
         if (!targetSessionId)
@@ -317,42 +317,17 @@ export function useChatThread(params) {
         };
     }, [toolCalls]);
     const turnGroups = useMemo(() => {
-        const previousTimeline = previousTimelineRef.current;
-        let built;
-        const activeIndex = streamingAssistantId
-            ? timelineMessages.findIndex((message) => message.id === streamingAssistantId)
-            : -1;
-        const canBuildActiveTail = Boolean(previousTimeline && streaming && streamingAssistantId && activeIndex >= 0) &&
-            previousTimeline?.activeAssistantId === streamingAssistantId &&
-            (previousTimeline?.messages.every((message, index) => message.id === streamingAssistantId || timelineMessages[index]?.id === message.id) ?? false);
-        if (canBuildActiveTail && previousTimeline) {
-            let tailStart = activeIndex;
-            while (tailStart > 0 && timelineMessages[tailStart - 1]?.role !== "user")
-                tailStart -= 1;
-            const tailMessages = timelineMessages.slice(tailStart);
-            const tailIds = new Set(tailMessages.map((message) => message.id));
-            const tailTurnIds = new Set(tailMessages.map((message) => message.turnId).filter(Boolean));
-            const tailTools = toolCalls.filter((tool) => tailIds.has(tool.assistantMessageId ?? "") ||
-                (Boolean(tool.turnId) && tailTurnIds.has(tool.turnId)) ||
-                (tool.createdAt >= (tailMessages[0]?.createdAt ?? Number.POSITIVE_INFINITY)));
-            const activeTail = buildTurnProcessGroups({
-                messages: tailMessages,
-                toolCalls: tailTools,
-                streaming,
-                activeAssistantId: streamingAssistantId,
-            });
-            built = [...previousTimeline.groups.filter((group) => !group.live), ...activeTail];
-        }
-        else {
-            built = buildTurnProcessGroups({
-                messages: timelineMessages,
-                toolCalls,
-                streaming,
-                activeAssistantId: streamingAssistantId,
-            });
-        }
-        // Preserve completed group objects across streaming tokens. The active
-        // tail is rebuilt, while stable historical groups keep their references so
+        // Server confirmation can change ordering without changing message ids.
+        // Rebuild membership from canonical messages; cache only finished row
+        // objects below so rich historical content still avoids re-rendering.
+        const built = buildTurnProcessGroups({
+            messages: timelineMessages,
+            toolCalls,
+            streaming,
+            activeAssistantId: streamingAssistantId,
+        });
+        // Preserve completed group objects across streaming tokens. Stable
+        // historical groups keep their references so
         // memoized rows do not re-render or re-parse the full conversation.
         const previous = new Map(completedGroupsRef.current.map((group) => [group.key, group]));
         const all = built.map((group) => {
@@ -362,12 +337,6 @@ export function useChatThread(params) {
                 : group;
         });
         completedGroupsRef.current = all.filter((group) => !group.live);
-        previousTimelineRef.current = {
-            messages: timelineMessages,
-            toolCalls,
-            activeAssistantId: streamingAssistantId,
-            groups: all,
-        };
         return selectRecentTurnGroups(all, historyLimit);
     }, [
         timelineMessages,
@@ -376,12 +345,14 @@ export function useChatThread(params) {
         streamingAssistantId,
         historyLimit,
     ]);
-    const loadEarlierMessages = useCallback(async () => {
+    const loadEarlierMessages = useCallback(async (beforePrepend) => {
         const targetSessionId = refs.sessionRef.current?.sessionId;
         const beforeId = historyNextCursor;
         if (!targetSessionId || !historyHasMore || !beforeId || historyLoadingRef.current)
             return false;
-        historyLoadingRef.current = true;
+        const generation = refs.sessionGenerationRef.current;
+        const request = Symbol();
+        historyLoadingRef.current = request;
         setHistoryLoading(true);
         try {
             const query = new URLSearchParams({ limit: "50", beforeId });
@@ -389,7 +360,12 @@ export function useChatThread(params) {
             if (!res.ok || refs.sessionRef.current?.sessionId !== targetSessionId)
                 return false;
             const body = (await res.json());
+            if (refs.sessionRef.current?.sessionId !== targetSessionId ||
+                refs.sessionGenerationRef.current !== generation ||
+                historyLoadingRef.current !== request)
+                return false;
             const page = hydrateSessionThread(body.messages ?? []);
+            beforePrepend?.();
             setMessages((current) => {
                 const seen = new Set();
                 const merged = [...page.messages, ...current].filter((message) => {
@@ -398,11 +374,7 @@ export function useChatThread(params) {
                     seen.add(message.id);
                     return true;
                 });
-                return merged.sort((a, b) => {
-                    if (a.eventSeq !== undefined && b.eventSeq !== undefined && a.eventSeq !== b.eventSeq)
-                        return a.eventSeq - b.eventSeq;
-                    return a.createdAt - b.createdAt;
-                });
+                return merged.sort(compareChatOrder);
             });
             setToolCalls((current) => {
                 const byId = new Map(current.map((tool) => [tool.id, tool]));
@@ -415,11 +387,19 @@ export function useChatThread(params) {
             setHistoryLimit((value) => value + 50);
             return true;
         }
+        catch (error) {
+            if (refs.sessionRef.current?.sessionId === targetSessionId && refs.sessionGenerationRef.current === generation) {
+                setError(`加载历史消息失败：${error instanceof Error ? error.message : String(error)}`);
+            }
+            return false;
+        }
         finally {
-            historyLoadingRef.current = false;
-            setHistoryLoading(false);
+            if (historyLoadingRef.current === request) {
+                historyLoadingRef.current = null;
+                setHistoryLoading(false);
+            }
         }
-    }, [historyHasMore, historyNextCursor, origin, refs]);
+    }, [historyHasMore, historyNextCursor, origin, refs, setError]);
     const visibleMessages = useMemo(() => {
         const next = [];
         for (const group of turnGroups) {
@@ -453,13 +433,15 @@ export function useChatThread(params) {
         setHistoryLimit(50);
         setHistoryHasMore(false);
         setHistoryNextCursor(null);
-        historyLoadingRef.current = false;
+        historyLoadingRef.current = null;
+        setHistoryLoading(false);
         completedGroupsRef.current = [];
-        previousTimelineRef.current = null;
         refs.usageResponseKeysRef.current = new Set();
     }, [refs]);
     /** Adopt a freshly activated session's hydrated thread + streaming flags. */
     const applyActivatedSession = useCallback((next) => {
+        historyLoadingRef.current = null;
+        setHistoryLoading(false);
         const visuallyStopped = next.turnPhase === "stopping";
         // A submission still owned for THIS session keeps its optimistic bubble
         // across an activation snapshot (refresh / reopen); a lease owned by
@@ -511,7 +493,6 @@ export function useChatThread(params) {
         setHistoryHasMore(next.history?.hasMore === true);
         setHistoryNextCursor(next.history?.nextCursor ?? null);
         completedGroupsRef.current = [];
-        previousTimelineRef.current = null;
     }, [refs]);
     /** Reconcile recovery (AC-001/AC-002/AC-003): reload the canonical session
      *  facts (session-store messages + event-ring tail cursor) and REPLACE the

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

@@ -1,31 +1,70 @@
-import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, } from "react";
+import { useCallback, useEffect, useLayoutEffect, useMemo, useReducer, useRef, useState, } from "react";
 import { filterSlashCommands, mergeSlashCommands, } from "../../chat/shortcuts.js";
-import { confirmationToken } from "./format.js";
+import { ComposerSessionLedger, composerSessionKey, } from "./composer-session-ledger.js";
+import { confirmationToken, requestId } from "./format.js";
 import { clampShortcutIndex } from "./slash-palette-nav.js";
-import { createInputHistoryState, navigateInputHistory, recordInputHistoryEntry, resetInputHistoryBrowsing, } from "./input-history.js";
 import { attachRuntimeSnapshotController } from "./useRuntimeSnapshot.js";
+function sameComposerSession(left, right) {
+    if (!left || !right)
+        return left === right;
+    return composerSessionKey(left) === composerSessionKey(right);
+}
+function readPendingImage(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onerror = () => reject(reader.error ?? new Error("图片读取失败"));
+        reader.onload = () => {
+            const value = String(reader.result ?? "");
+            resolve({
+                name: file.name,
+                type: "image",
+                mimeType: file.type,
+                data: value.slice(value.indexOf(",") + 1),
+            });
+        };
+        reader.readAsDataURL(file);
+    });
+}
 /** Composer state: input text, @file palette, image attachments, /shortcuts,
  *  IME composition guards, auto-grow and server-side draft sync. */
 export function useComposer(params) {
-    const { origin, sessionId, sessionMode, refs, setError, onUnrecoverableSession, } = params;
-    const [input, setInputState] = useState("");
+    const { origin, sessionIdentity, sessionMode, sessionReady = true, refs, setError, onUnrecoverableSession, } = params;
+    const sessionId = sessionIdentity?.sessionId;
+    const ledgerRef = useRef(null);
+    if (!ledgerRef.current)
+        ledgerRef.current = new ComposerSessionLedger();
+    const ledger = ledgerRef.current;
+    const activeIdentityRef = useRef(sessionIdentity);
+    activeIdentityRef.current = sessionIdentity;
+    const [, forceRender] = useReducer((version) => version + 1, 0);
+    const activeSnapshot = sessionIdentity
+        ? ledger.snapshot(sessionIdentity)
+        : { draft: "", images: [] };
+    const input = activeSnapshot.draft;
+    const pendingImages = activeSnapshot.images;
     const [fileOptions, setFileOptions] = useState([]);
-    const [pendingImages, setPendingImages] = useState([]);
     const [shortcutOpen, setShortcutOpen] = useState(false);
     /** Any composer text that starts with `/` should reveal the palette,
      *  including draft restore. Escape can still close it without clearing. */
     const setInput = useCallback((value) => {
-        if (typeof value === "function") {
-            setInputState((prev) => {
-                const next = value(prev);
-                setShortcutOpen(next.startsWith("/"));
-                return next;
-            });
+        const identity = activeIdentityRef.current;
+        if (!identity)
             return;
-        }
-        setInputState(value);
-        setShortcutOpen(value.startsWith("/"));
-    }, []);
+        const previous = ledger.snapshot(identity).draft;
+        const next = typeof value === "function" ? value(previous) : value;
+        if (ledger.setDraft(identity, next))
+            forceRender();
+        setShortcutOpen(next.startsWith("/"));
+    }, [ledger]);
+    const setPendingImages = useCallback((value) => {
+        const identity = activeIdentityRef.current;
+        if (!identity)
+            return;
+        const previous = ledger.snapshot(identity).images;
+        const next = typeof value === "function" ? value(previous) : value;
+        ledger.setImages(identity, next);
+        forceRender();
+    }, [ledger]);
     const [shortcutIndex, setShortcutIndex] = useState(0);
     const [dynamicCommands, setDynamicCommands] = useState([]);
     const [commandCapabilities, setCommandCapabilities] = useState({
@@ -36,30 +75,29 @@ export function useComposer(params) {
     const [dynamicCommandsError, setDynamicCommandsError] = useState(null);
     const [commandsEpoch, setCommandsEpoch] = useState(0);
     const textareaRef = useRef(null);
-    /** Arrow-key input history; unsent drafts survive history browsing. */
-    const historyRef = useRef(createInputHistoryState());
     /** Active session generation for /commands; bumped immediately on switch (AC-2). */
     const commandsSessionRef = useRef(sessionId);
     const commandsGenerationRef = useRef(0);
     const handleInputChange = useCallback((value) => {
         setInput(value);
-        setShortcutOpen(value.startsWith("/"));
         setShortcutIndex(0);
-        // Manual typing edits a recalled entry in place → back to present draft.
-        historyRef.current = resetInputHistoryBrowsing(historyRef.current);
-    }, []);
+    }, [setInput]);
     /** Recall an earlier input via ↑/↓; returns true when the key was consumed. */
     const navigateHistory = useCallback((direction) => {
+        const identity = activeIdentityRef.current;
+        if (!identity)
+            return false;
+        const current = ledger.snapshot(identity).draft;
         const textarea = textareaRef.current;
-        const decision = navigateInputHistory(historyRef.current, direction, {
-            text: input,
-            caretStart: textarea?.selectionStart ?? input.length,
-            caretEnd: textarea?.selectionEnd ?? input.length,
+        const decision = ledger.navigateHistory(identity, direction, {
+            text: current,
+            caretStart: textarea?.selectionStart ?? current.length,
+            caretEnd: textarea?.selectionEnd ?? current.length,
         });
         if (!decision.handled)
             return false;
-        historyRef.current = decision.state;
-        setInput(decision.text);
+        forceRender();
+        setShortcutOpen(decision.text.startsWith("/"));
         const caret = decision.text.length;
         queueMicrotask(() => {
             const el = textareaRef.current;
@@ -68,22 +106,76 @@ export function useComposer(params) {
             }
         });
         return true;
-    }, [input, setInput]);
-    /** Record a submitted text into history (consecutive duplicates collapse). */
+    }, [ledger]);
+    /** Record a submitted text into the selected session's history. */
     const recordHistory = useCallback((text) => {
-        historyRef.current = recordInputHistoryEntry(historyRef.current, text);
-    }, []);
+        const identity = activeIdentityRef.current;
+        if (identity)
+            ledger.recordHistory(identity, text);
+    }, [ledger]);
+    const claimSubmission = useCallback(() => {
+        const identity = activeIdentityRef.current;
+        if (!identity)
+            return null;
+        const attempt = ledger.beginSubmission(identity, refs.sessionGenerationRef.current, requestId("chat-submit"));
+        if (!attempt)
+            return null;
+        forceRender();
+        setShortcutOpen(false);
+        setShortcutIndex(0);
+        return attempt;
+    }, [ledger, refs]);
+    const claimSessionSubmission = useCallback((identity, text, images = []) => {
+        ledger.setDraft(identity, text);
+        ledger.setImages(identity, images);
+        const attempt = ledger.beginSubmission(identity, refs.sessionGenerationRef.current, requestId("chat-submit"));
+        if (sameComposerSession(activeIdentityRef.current, identity))
+            forceRender();
+        return attempt;
+    }, [ledger, refs]);
+    const settleSubmission = useCallback((attempt, outcome) => {
+        const result = ledger.settle(attempt, outcome);
+        if (sameComposerSession(activeIdentityRef.current, attempt.identity))
+            forceRender();
+        return result;
+    }, [ledger]);
+    const settleSubmissionByRequest = useCallback((identity, clientRequestId, outcome) => {
+        const result = ledger.settleByRequest(identity, clientRequestId, outcome);
+        if (sameComposerSession(activeIdentityRef.current, identity))
+            forceRender();
+        return result;
+    }, [ledger]);
+    const seedSession = useCallback((identity, draft) => {
+        const seeded = ledger.seedDraft(identity, draft);
+        if (seeded && sameComposerSession(activeIdentityRef.current, identity))
+            forceRender();
+        return seeded;
+    }, [ledger]);
+    const replaceSessionDraft = useCallback((identity, draft, images) => {
+        ledger.setDraft(identity, draft);
+        ledger.setImages(identity, images);
+        if (sameComposerSession(activeIdentityRef.current, identity))
+            forceRender();
+    }, [ledger]);
+    const releaseSession = useCallback((identity) => {
+        ledger.release(identity);
+        if (sameComposerSession(activeIdentityRef.current, identity))
+            forceRender();
+    }, [ledger]);
     // Immediate invalidation on A→B even when B palette never opens (AC-2).
     useLayoutEffect(() => {
         commandsSessionRef.current = sessionId;
         commandsGenerationRef.current += 1;
+        refs.isComposingRef.current = false;
+        setFileOptions([]);
+        setShortcutOpen(input.startsWith("/"));
         setDynamicCommands([]);
         setCommandCapabilities({ sddBingo: false, sessionMode });
         setDynamicCommandsError(null);
         setDynamicCommandsLoading(false);
     }, [sessionId, sessionMode]);
     const loadDynamicCommands = useCallback(async () => {
-        if (!sessionId) {
+        if (!sessionId || !sessionReady) {
             setDynamicCommands([]);
             setDynamicCommandsError(null);
             setDynamicCommandsLoading(false);
@@ -147,21 +239,21 @@ export function useComposer(params) {
                 setDynamicCommandsLoading(false);
             }
         }
-    }, [origin, sessionId, sessionMode]);
+    }, [origin, sessionId, sessionMode, sessionReady]);
     // Lazy-load dynamic commands when slash palette opens or session changes.
     useEffect(() => {
-        if (!sessionId)
+        if (!sessionId || !sessionReady)
             return;
         if (!shortcutOpen && commandsEpoch === 0)
             return;
         void loadDynamicCommands();
-    }, [sessionId, shortcutOpen, commandsEpoch, loadDynamicCommands]);
+    }, [sessionId, sessionReady, shortcutOpen, commandsEpoch, loadDynamicCommands]);
     const retryDynamicCommands = useCallback(() => {
         setCommandsEpoch((n) => n + 1);
         void loadDynamicCommands();
     }, [loadDynamicCommands]);
     useEffect(() => {
-        if (!sessionId)
+        if (!sessionId || !sessionIdentity || !sessionReady)
             return;
         const match = input
             .slice(0, textareaRef.current?.selectionStart ?? input.length)
@@ -170,13 +262,29 @@ export function useComposer(params) {
             setFileOptions([]);
             return;
         }
+        const owner = { ...sessionIdentity };
+        const ownerKey = composerSessionKey(owner);
+        const generation = refs.sessionGenerationRef.current;
+        const controller = new AbortController();
         const timer = window.setTimeout(() => {
-            void fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/files?q=${encodeURIComponent(match[1] ?? "")}`)
+            void fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/files?q=${encodeURIComponent(match[1] ?? "")}`, { signal: controller.signal })
                 .then((r) => (r.ok ? r.json() : null))
-                .then((body) => setFileOptions((body?.files ?? []).map((item) => item.path)));
+                .then((body) => {
+                const active = activeIdentityRef.current;
+                if (controller.signal.aborted ||
+                    !active ||
+                    composerSessionKey(active) !== ownerKey ||
+                    refs.sessionGenerationRef.current !== generation)
+                    return;
+                setFileOptions((body?.files ?? []).map((item) => item.path));
+            })
+                .catch(() => undefined);
         }, 150);
-        return () => window.clearTimeout(timer);
-    }, [origin, sessionId, input]);
+        return () => {
+            window.clearTimeout(timer);
+            controller.abort();
+        };
+    }, [origin, sessionId, sessionIdentity, sessionReady, input, refs]);
     const insertFileReference = useCallback((file) => {
         const caret = textareaRef.current?.selectionStart ?? input.length;
         const before = input.slice(0, caret);
@@ -185,44 +293,51 @@ export function useComposer(params) {
             return;
         setInput(`${input.slice(0, start)}@${file} ${input.slice(caret)}`);
         setFileOptions([]);
-    }, [input]);
+    }, [input, setInput]);
     const addImagesFromFiles = useCallback((files) => {
-        for (const file of Array.from(files).slice(0, 4)) {
-            if (!file.type.startsWith("image/") || file.size > 5 * 1024 * 1024) {
-                setError("图片仅支持 PNG/JPEG/GIF/WebP，单张不超过 5 MiB");
-                continue;
-            }
-            const reader = new FileReader();
-            reader.onload = () => {
-                const value = String(reader.result ?? "");
-                const data = value.slice(value.indexOf(",") + 1);
-                setPendingImages((items) => [
-                    ...items,
-                    {
-                        name: file.name,
-                        type: "image",
-                        mimeType: file.type,
-                        data,
-                    },
-                ].slice(0, 4));
-            };
-            reader.readAsDataURL(file);
-        }
-    }, [setError]);
+        const owner = activeIdentityRef.current;
+        if (!owner)
+            return;
+        const ownerIdentity = { ...owner };
+        const selected = Array.from(files).slice(0, 4);
+        const valid = selected.filter((file) => file.type.startsWith("image/") && file.size <= 5 * 1024 * 1024);
+        if (valid.length !== selected.length)
+            setError("图片仅支持 PNG/JPEG/GIF/WebP，单张不超过 5 MiB");
+        void Promise.all(valid.map(readPendingImage)).then((loaded) => {
+            if (!ledger.has(ownerIdentity) || loaded.length === 0)
+                return;
+            const current = ledger.snapshot(ownerIdentity).images;
+            ledger.setImages(ownerIdentity, [...current, ...loaded].slice(0, 4));
+            if (sameComposerSession(activeIdentityRef.current, ownerIdentity))
+                forceRender();
+        }, (error) => {
+            if (sameComposerSession(activeIdentityRef.current, ownerIdentity))
+                setError(error instanceof Error ? error.message : "图片读取失败");
+        });
+    }, [ledger, setError]);
     const removeImage = useCallback((image) => {
         setPendingImages((items) => items.filter((item) => item !== image));
-    }, []);
-    // Auto-grow textarea height.
-    useLayoutEffect(() => {
+    }, [setPendingImages]);
+    // Chromium handles growth in CSS without forcing a layout read on every key.
+    // Keep a deferred fallback for browsers that do not support field-sizing.
+    useEffect(() => {
         const ta = textareaRef.current;
         if (!ta)
             return;
-        ta.style.height = "auto";
-        ta.style.height = `${Math.min(ta.scrollHeight, 280)}px`;
+        if (typeof CSS !== "undefined" &&
+            CSS.supports("field-sizing", "content")) {
+            ta.style.removeProperty("height");
+            return;
+        }
+        const frame = window.requestAnimationFrame(() => {
+            ta.style.height = "auto";
+            ta.style.height = `${Math.min(ta.scrollHeight, 280)}px`;
+        });
+        return () => window.cancelAnimationFrame(frame);
     }, [input]);
     // Debounced server-side composer draft sync.
     useEffect(() => {
-        if (!sessionId)
+        if (!sessionId || !sessionReady)
             return;
         const timer = window.setTimeout(() => {
             void fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/draft`, {
@@ -236,7 +351,7 @@ export function useComposer(params) {
             });
         }, 400);
         return () => window.clearTimeout(timer);
-    }, [origin, sessionId, input]);
+    }, [origin, sessionId, sessionReady, input]);
     const mergedCommands = useMemo(() => mergeSlashCommands(dynamicCommands, commandCapabilities), [dynamicCommands, commandCapabilities]);
     const filteredShortcuts = useMemo(() => input.startsWith("/")
         ? filterSlashCommands(mergedCommands, input)
@@ -270,17 +385,24 @@ export function useComposer(params) {
     useEffect(() => {
         attachRuntimeSnapshotController({
             origin,
-            sessionId,
+            sessionId: sessionReady ? sessionId : undefined,
             refs,
             onUnrecoverableSession,
         });
-    }, [origin, sessionId, refs, onUnrecoverableSession]);
+    }, [origin, sessionId, sessionReady, refs, onUnrecoverableSession]);
     return {
         input,
         setInput,
         handleInputChange,
         navigateHistory,
         recordHistory,
+        claimSubmission,
+        claimSessionSubmission,
+        settleSubmission,
+        settleSubmissionByRequest,
+        seedSession,
+        replaceSessionDraft,
+        releaseSession,
         fileOptions,
         pendingImages,
         setPendingImages,

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

@@ -149,6 +149,8 @@ export function useRepoBrowser(params) {
             return;
         const initial = rootFiles.find((entry) => /^readme(?:\.[^.]+)?$/i.test(entry.name)) ??
             rootFiles[0];
+        if (!initial)
+            return;
         autoPreviewedWorkspaceRef.current.add(workspaceKey);
         void openPreview(initial.path);
     }, [

package/dist/worker/console/static-src/prd-file-import.js

@@ -181,10 +181,12 @@ export function composePrdDocuments(docs, options) {
     if (docs.length === 0)
         return "";
     if (docs.length === 1) {
-        return docs[0].text;
+        return docs[0]?.text ?? "";
     }
     const primaryIndex = Math.min(Math.max(0, options?.primaryIndex ?? 0), docs.length - 1);
     const primary = docs[primaryIndex];
+    if (!primary)
+        return docs[0]?.text ?? "";
     const title = extractComposeTitle(primary.text, primary.fileName);
     const names = docs.map((d) => d.fileName).join(", ");
     const parts = [