@bolt-foundry/gambit 0.8.6-rc.6 → 0.8.6

package/esm/simulator-ui/src/WorkspaceContext.js

@@ -1,1413 +0,0 @@
-// deno-lint-ignore-file gambit/no-useeffect-setstate gambit/no-useeffect-setstate no-console
-import * as dntShim from "../../_dnt.shims.js";
-import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from "react";
-import { WORKSPACE_API_BASE, WORKSPACES_API_BASE, } from "../../src/workspace_contract.js";
-import { buildChatProvider as defaultBuildChatProvider, buildDurableStreamUrl, deriveBuildDisplayMessages, getDurableStreamOffset, setDurableStreamOffset, summarizeToolCalls, WORKSPACE_STREAM_ID, } from "./utils.js";
-const WorkspaceContext = createContext(null);
-const BUILD_CHAT_PROVIDER_STORAGE_KEY = "gambit:build-chat-provider";
-function normalizeBuildChatProvider(value) {
-    if (value === "claude-code-cli")
-        return "claude-code-cli";
-    if (value === "codex-cli")
-        return "codex-cli";
-    return null;
-}
-function readStoredBuildChatProvider() {
-    if (typeof dntShim.dntGlobalThis === "undefined")
-        return null;
-    try {
-        return normalizeBuildChatProvider(globalThis.localStorage.getItem(BUILD_CHAT_PROVIDER_STORAGE_KEY));
-    }
-    catch {
-        return null;
-    }
-}
-function storeBuildChatProvider(provider) {
-    if (typeof dntShim.dntGlobalThis === "undefined")
-        return;
-    try {
-        globalThis.localStorage.setItem(BUILD_CHAT_PROVIDER_STORAGE_KEY, provider);
-    }
-    catch {
-        // ignore storage failures
-    }
-}
-function isGradeDebugEnabled() {
-    if (typeof dntShim.dntGlobalThis === "undefined")
-        return false;
-    const fromQuery = new URLSearchParams(globalThis.location.search).get("gradeDebug");
-    if (fromQuery === "1" || fromQuery === "true")
-        return true;
-    try {
-        const fromStorage = globalThis.localStorage.getItem("gambit.gradeDebug");
-        return fromStorage === "1" || fromStorage === "true";
-    }
-    catch {
-        return false;
-    }
-}
-function gradeDebugLog(event, payload) {
-    if (!isGradeDebugEnabled())
-        return;
-    const ts = new Date().toISOString();
-    if (payload && Object.keys(payload).length > 0) {
-        console.log(`[grade-debug] ${ts} ${event}`, payload);
-        return;
-    }
-    console.log(`[grade-debug] ${ts} ${event}`);
-}
-const normalizeTestRun = (run) => {
-    if (!run) {
-        return {
-            status: "idle",
-            messages: [],
-            traces: [],
-            toolInserts: [],
-        };
-    }
-    const workspaceId = typeof run.workspaceId === "string"
-        ? run.workspaceId
-        : typeof run.sessionId === "string"
-            ? run.sessionId
-            : undefined;
-    return {
-        ...run,
-        workspaceId,
-        sessionId: workspaceId,
-        messages: run.messages ?? [],
-        traces: run.traces ?? [],
-        toolInserts: run.toolInserts ?? [],
-    };
-};
-export function WorkspaceProvider(props) {
-    const { children, workspaceId, onWorkspaceChange, requestedTestRunId, requestedGradeRunId, onRoutingStateChange, } = props;
-    const [buildRun, setBuildRun] = useState({
-        id: "",
-        status: "idle",
-        messages: [],
-        traces: [],
-        toolInserts: [],
-    });
-    const buildRunRef = useRef({
-        id: "",
-        status: "idle",
-        messages: [],
-        traces: [],
-        toolInserts: [],
-    });
-    const buildRunIdRef = useRef("");
-    const buildIgnoredStreamRunIdsRef = useRef(new Set());
-    const [buildChatDraft, setBuildChatDraft] = useState("");
-    const [buildChatProvider, setBuildChatProvider] = useState(() => readStoredBuildChatProvider() ?? defaultBuildChatProvider);
-    const setAndPersistBuildChatProvider = useCallback((provider) => {
-        storeBuildChatProvider(provider);
-        setBuildChatProvider(provider);
-    }, []);
-    const [buildChatSending, setBuildChatSending] = useState(false);
-    const [buildChatError, setBuildChatError] = useState(null);
-    const [buildToolCallsOpen, setBuildToolCallsOpen] = useState({});
-    const [buildOptimisticUser, setBuildOptimisticUser] = useState(null);
-    const [buildStreamingAssistant, setBuildStreamingAssistant] = useState(null);
-    const pendingBuildTracesRef = useRef([]);
-    const pendingBuildTraceRunIdRef = useRef(null);
-    const buildTraceFlushHandleRef = useRef(null);
-    const buildTraceFlushModeRef = useRef(null);
-    const [testRun, setTestRun] = useState(() => normalizeTestRun());
-    const [activeTestRunId, setActiveTestRunId] = useState(null);
-    const [activeGradeRunId, setActiveGradeRunId] = useState(null);
-    const testRunIdRef = useRef("");
-    const testRunRef = useRef(normalizeTestRun());
-    const [testStreamingUser, setTestStreamingUser] = useState(null);
-    const [testStreamingAssistant, setTestStreamingAssistant] = useState(null);
-    const [testChatDraft, setTestChatDraft] = useState("");
-    const [testChatSending, setTestChatSending] = useState(false);
-    const [testChatError, setTestChatError] = useState(null);
-    const [testOptimisticUser, setTestOptimisticUser] = useState(null);
-    const [gradeLoading, setGradeLoading] = useState(false);
-    const [gradeError, setGradeError] = useState(null);
-    const [gradeRunning, setGradeRunning] = useState(false);
-    const [gradeGraders, setGradeGraders] = useState([]);
-    const [gradeSessions, setGradeSessions] = useState([]);
-    const [gradeSessionDetail, setGradeSessionDetail] = useState(null);
-    const buildDisplayMessages = useCallback((run) => {
-        return deriveBuildDisplayMessages(run.messages, run.traces ?? []);
-    }, []);
-    const normalizeBuildRun = useCallback((run) => {
-        return {
-            ...run,
-            messages: Array.isArray(run.messages) ? run.messages : [],
-            traces: Array.isArray(run.traces) ? run.traces : [],
-            toolInserts: Array.isArray(run.toolInserts) ? run.toolInserts : [],
-        };
-    }, []);
-    const mergeBuildRunSnapshot = useCallback((prev, incomingRun) => {
-        const incoming = normalizeBuildRun(incomingRun);
-        const sameRun = Boolean(prev.id) && prev.id === incoming.id;
-        const preserveStreamingArrays = sameRun &&
-            prev.status === "running" &&
-            incoming.status === "running";
-        const incomingMessages = incoming.messages ?? [];
-        const incomingTraces = incoming.traces ?? [];
-        const incomingToolInserts = incoming.toolInserts ?? [];
-        const nextRun = {
-            ...incoming,
-            messages: preserveStreamingArrays &&
-                incomingMessages.length < (prev.messages?.length ?? 0)
-                ? (prev.messages ?? [])
-                : incomingMessages,
-            traces: preserveStreamingArrays &&
-                incomingTraces.length < (prev.traces?.length ?? 0)
-                ? (prev.traces ?? [])
-                : incomingTraces,
-            toolInserts: preserveStreamingArrays &&
-                incomingToolInserts.length < (prev.toolInserts?.length ?? 0)
-                ? (prev.toolInserts ?? [])
-                : incomingToolInserts,
-        };
-        nextRun.displayMessages = buildDisplayMessages(nextRun);
-        return nextRun;
-    }, [buildDisplayMessages, normalizeBuildRun]);
-    const cancelBuildTraceFlush = useCallback(() => {
-        const handle = buildTraceFlushHandleRef.current;
-        const mode = buildTraceFlushModeRef.current;
-        if (handle === null || mode === null)
-            return;
-        if (mode === "raf" && typeof dntShim.dntGlobalThis !== "undefined" &&
-            typeof globalThis.cancelAnimationFrame === "function") {
-            globalThis.cancelAnimationFrame(handle);
-        }
-        else if (mode === "timeout") {
-            clearTimeout(handle);
-        }
-        buildTraceFlushHandleRef.current = null;
-        buildTraceFlushModeRef.current = null;
-    }, []);
-    const flushPendingBuildTraces = useCallback(() => {
-        const pending = pendingBuildTracesRef.current;
-        const pendingRunId = pendingBuildTraceRunIdRef.current;
-        if (pending.length === 0)
-            return;
-        pendingBuildTracesRef.current = [];
-        pendingBuildTraceRunIdRef.current = null;
-        setBuildRun((prev) => {
-            if (pendingRunId && prev.id && prev.id !== pendingRunId) {
-                return prev;
-            }
-            const traces = Array.isArray(prev.traces)
-                ? [...prev.traces, ...pending]
-                : [
-                    ...pending,
-                ];
-            const nextRun = { ...prev, traces };
-            nextRun.displayMessages = buildDisplayMessages(nextRun);
-            return nextRun;
-        });
-    }, [buildDisplayMessages]);
-    const scheduleBuildTraceFlush = useCallback(() => {
-        if (buildTraceFlushHandleRef.current !== null)
-            return;
-        const flush = () => {
-            buildTraceFlushHandleRef.current = null;
-            buildTraceFlushModeRef.current = null;
-            flushPendingBuildTraces();
-        };
-        if (typeof dntShim.dntGlobalThis !== "undefined" &&
-            typeof globalThis.requestAnimationFrame === "function") {
-            buildTraceFlushModeRef.current = "raf";
-            buildTraceFlushHandleRef.current = globalThis.requestAnimationFrame(flush);
-            return;
-        }
-        buildTraceFlushModeRef.current = "timeout";
-        buildTraceFlushHandleRef.current = setTimeout(flush, 16);
-    }, [flushPendingBuildTraces]);
-    const clearPendingBuildTraces = useCallback(() => {
-        cancelBuildTraceFlush();
-        pendingBuildTracesRef.current = [];
-        pendingBuildTraceRunIdRef.current = null;
-    }, [cancelBuildTraceFlush]);
-    const gradeLoadSeqRef = useRef(0);
-    const gradeDetailSeqRef = useRef(0);
-    const loadWorkspaceSnapshot = useCallback(async (targetWorkspaceId, opts) => {
-        const params = new URLSearchParams();
-        if (opts?.deckPath)
-            params.set("deckPath", opts.deckPath);
-        const query = params.toString() ? `?${params.toString()}` : "";
-        const endpoint = opts?.testRunId
-            ? `${WORKSPACES_API_BASE}/${encodeURIComponent(targetWorkspaceId)}/test/${encodeURIComponent(opts.testRunId)}${query}`
-            : opts?.gradeRunId
-                ? `${WORKSPACES_API_BASE}/${encodeURIComponent(targetWorkspaceId)}/grade/${encodeURIComponent(opts.gradeRunId)}${query}`
-                : `${WORKSPACES_API_BASE}/${encodeURIComponent(targetWorkspaceId)}${query}`;
-        const res = await fetch(endpoint);
-        if (!res.ok) {
-            const text = await res.text().catch(() => "");
-            throw new Error(text || res.statusText);
-        }
-        return await res.json();
-    }, []);
-    const resolvePersistedBuildChatProvider = useCallback((meta) => {
-        if (!meta)
-            return null;
-        const raw = meta.buildChatProvider;
-        return normalizeBuildChatProvider(raw);
-    }, []);
-    const refreshBuildStatus = useCallback(async (opts) => {
-        if (opts?.workspaceId) {
-            const data = await loadWorkspaceSnapshot(opts.workspaceId);
-            const persistedProvider = resolvePersistedBuildChatProvider(data.session?.meta);
-            setAndPersistBuildChatProvider(persistedProvider ?? readStoredBuildChatProvider() ??
-                defaultBuildChatProvider);
-            if (!data.build.run)
-                return;
-            setBuildRun((prev) => mergeBuildRunSnapshot(prev, data.build.run));
-            if (typeof data.build.run.id === "string" && data.build.run.id) {
-                buildRunIdRef.current = data.build.run.id;
-            }
-            return;
-        }
-        buildRunIdRef.current = "";
-        setBuildRun({
-            id: "",
-            status: "idle",
-            messages: [],
-            traces: [],
-            toolInserts: [],
-            displayMessages: [],
-        });
-    }, [
-        loadWorkspaceSnapshot,
-        mergeBuildRunSnapshot,
-        resolvePersistedBuildChatProvider,
-        setAndPersistBuildChatProvider,
-    ]);
-    useEffect(() => {
-        buildRunRef.current = buildRun;
-    }, [buildRun]);
-    useEffect(() => {
-        if (workspaceId) {
-            buildRunIdRef.current = workspaceId;
-            refreshBuildStatus({ workspaceId }).catch(() => { });
-            return;
-        }
-        refreshBuildStatus().catch(() => { });
-    }, [refreshBuildStatus, workspaceId]);
-    useEffect(() => {
-        if (!workspaceId)
-            return;
-        if (buildRunIdRef.current === workspaceId)
-            return;
-        buildRunIdRef.current = workspaceId;
-        setBuildRun((prev) => ({
-            ...prev,
-            id: workspaceId,
-        }));
-        setBuildChatError(null);
-        setBuildStreamingAssistant(null);
-        setBuildOptimisticUser(null);
-        setBuildToolCallsOpen({});
-        clearPendingBuildTraces();
-        refreshBuildStatus({ workspaceId }).catch(() => { });
-    }, [clearPendingBuildTraces, refreshBuildStatus, workspaceId]);
-    useEffect(() => {
-        testRunRef.current = testRun;
-        if (typeof testRun.id === "string" && testRun.id) {
-            testRunIdRef.current = testRun.id;
-            setActiveTestRunId(testRun.id);
-        }
-    }, [testRun]);
-    useEffect(() => {
-        if (requestedTestRunId === undefined)
-            return;
-        setActiveTestRunId(requestedTestRunId);
-    }, [requestedTestRunId]);
-    useEffect(() => {
-        if (requestedGradeRunId === undefined)
-            return;
-        setActiveGradeRunId(requestedGradeRunId);
-    }, [requestedGradeRunId]);
-    useEffect(() => {
-        onRoutingStateChange?.({
-            testRunId: activeTestRunId,
-            gradeRunId: activeGradeRunId,
-        });
-    }, [activeGradeRunId, activeTestRunId, onRoutingStateChange]);
-    useEffect(() => {
-        const streamId = WORKSPACE_STREAM_ID;
-        const handleMessage = (event) => {
-            let msg = null;
-            try {
-                const raw = JSON.parse(event.data);
-                if (raw.type === "next" &&
-                    raw.payload &&
-                    typeof raw.payload === "object") {
-                    const payload = raw.payload;
-                    const payloadType = typeof payload.type === "string"
-                        ? payload.type
-                        : "";
-                    if (payloadType === "gambit.build.status" && payload.run) {
-                        msg = {
-                            type: "buildBotStatus",
-                            run: payload.run,
-                        };
-                    }
-                    else if (payloadType === "gambit.build.trace" &&
-                        payload.event &&
-                        typeof payload.event === "object") {
-                        msg = {
-                            type: "buildBotTrace",
-                            runId: typeof payload.runId === "string"
-                                ? payload.runId
-                                : undefined,
-                            event: payload.event,
-                        };
-                    }
-                    else if ((payloadType === "gambit.build.stream" ||
-                        payloadType === "gambit.build.stream.delta") &&
-                        typeof payload.chunk === "string") {
-                        msg = {
-                            type: "buildBotStream",
-                            runId: typeof payload.runId === "string"
-                                ? payload.runId
-                                : undefined,
-                            role: payload.role === "user" ? "user" : "assistant",
-                            chunk: payload.chunk,
-                            turn: typeof payload.turn === "number" ? payload.turn : undefined,
-                            ts: typeof payload.ts === "number" ? payload.ts : undefined,
-                        };
-                    }
-                    else if (payloadType === "gambit.build.streamEnd" ||
-                        payloadType === "gambit.build.stream.done") {
-                        msg = {
-                            type: "buildBotStreamEnd",
-                            runId: typeof payload.runId === "string"
-                                ? payload.runId
-                                : undefined,
-                            role: payload.role === "user" ? "user" : "assistant",
-                            turn: typeof payload.turn === "number" ? payload.turn : undefined,
-                            ts: typeof payload.ts === "number" ? payload.ts : undefined,
-                        };
-                    }
-                    else if (payloadType === "gambit.test.status" && payload.run) {
-                        msg = {
-                            type: "testBotStatus",
-                            run: payload.run,
-                        };
-                    }
-                    else if ((payloadType === "gambit.test.stream" ||
-                        payloadType === "gambit.test.stream.delta") &&
-                        typeof payload.chunk === "string") {
-                        msg = {
-                            type: "testBotStream",
-                            runId: typeof payload.runId === "string"
-                                ? payload.runId
-                                : undefined,
-                            role: payload.role === "user" ? "user" : "assistant",
-                            chunk: payload.chunk,
-                            turn: typeof payload.turn === "number" ? payload.turn : undefined,
-                            ts: typeof payload.ts === "number" ? payload.ts : undefined,
-                        };
-                    }
-                    else if (payloadType === "gambit.test.streamEnd" ||
-                        payloadType === "gambit.test.stream.done") {
-                        msg = {
-                            type: "testBotStreamEnd",
-                            runId: typeof payload.runId === "string"
-                                ? payload.runId
-                                : undefined,
-                            role: payload.role === "user" ? "user" : "assistant",
-                            turn: typeof payload.turn === "number" ? payload.turn : undefined,
-                            ts: typeof payload.ts === "number" ? payload.ts : undefined,
-                        };
-                    }
-                }
-                else {
-                    msg = raw;
-                }
-            }
-            catch {
-                return;
-            }
-            const parsedOffset = Number(event.lastEventId);
-            if (Number.isFinite(parsedOffset)) {
-                setDurableStreamOffset(streamId, parsedOffset + 1);
-            }
-            if (!msg)
-                return;
-            if (msg.type === "buildBotStatus" && msg.run) {
-                const activeBuildRunId = buildRunIdRef.current;
-                if (activeBuildRunId && msg.run.id !== activeBuildRunId)
-                    return;
-                if (msg.run.id &&
-                    msg.run.status === "running" &&
-                    buildIgnoredStreamRunIdsRef.current.has(msg.run.id)) {
-                    return;
-                }
-                flushPendingBuildTraces();
-                setBuildRun((prev) => mergeBuildRunSnapshot(prev, msg.run));
-                if (msg.run.status !== "running") {
-                    setBuildStreamingAssistant(null);
-                }
-                return;
-            }
-            if (msg.type === "buildBotTrace") {
-                const activeBuildRunId = buildRunIdRef.current;
-                if (activeBuildRunId && msg.runId && msg.runId !== activeBuildRunId) {
-                    return;
-                }
-                if (!msg.event)
-                    return;
-                const traceRunId = typeof msg.runId === "string" && msg.runId.length > 0
-                    ? msg.runId
-                    : (buildRunIdRef.current || null);
-                const pendingRunId = pendingBuildTraceRunIdRef.current;
-                if (pendingRunId && traceRunId && pendingRunId !== traceRunId) {
-                    clearPendingBuildTraces();
-                }
-                if (!pendingBuildTraceRunIdRef.current && traceRunId) {
-                    pendingBuildTraceRunIdRef.current = traceRunId;
-                }
-                pendingBuildTracesRef.current.push(msg.event);
-                scheduleBuildTraceFlush();
-                return;
-            }
-            if (msg.type === "buildBotStream") {
-                const activeBuildRunId = buildRunIdRef.current;
-                if (!msg.runId ||
-                    (activeBuildRunId && msg.runId !== activeBuildRunId) ||
-                    buildIgnoredStreamRunIdsRef.current.has(msg.runId) ||
-                    msg.role !== "assistant") {
-                    return;
-                }
-                const streamRunId = msg.runId;
-                const turn = typeof msg.turn === "number" ? msg.turn : 0;
-                setBuildStreamingAssistant((prev) => prev && prev.runId === streamRunId && prev.turn === turn
-                    ? { ...prev, text: prev.text + msg.chunk }
-                    : { runId: streamRunId, turn, text: msg.chunk });
-                return;
-            }
-            if (msg.type === "buildBotStreamEnd") {
-                const activeBuildRunId = buildRunIdRef.current;
-                if (!msg.runId ||
-                    (activeBuildRunId && msg.runId !== activeBuildRunId) ||
-                    buildIgnoredStreamRunIdsRef.current.has(msg.runId)) {
-                    return;
-                }
-                const turn = typeof msg.turn === "number" ? msg.turn : 0;
-                setBuildStreamingAssistant((prev) => prev && prev.runId === msg.runId && prev.turn === turn ? null : prev);
-                return;
-            }
-            if (msg.type === "testBotStatus" && msg.run) {
-                const activeTestRunId = testRunIdRef.current;
-                if (activeTestRunId && msg.run.id !== activeTestRunId)
-                    return;
-                const normalized = normalizeTestRun(msg.run);
-                if (normalized.status !== "running") {
-                    setTestStreamingUser(null);
-                    setTestStreamingAssistant(null);
-                }
-                setTestStreamingUser((prev) => {
-                    if (!prev ||
-                        prev.runId !== normalized.id ||
-                        prev.expectedUserCount === undefined) {
-                        return prev;
-                    }
-                    const userCount = (normalized.messages ?? []).filter((entry) => entry.role === "user").length;
-                    return userCount >= prev.expectedUserCount ? null : prev;
-                });
-                setTestStreamingAssistant((prev) => {
-                    if (!prev ||
-                        prev.runId !== normalized.id ||
-                        !prev.text ||
-                        !Array.isArray(normalized.messages)) {
-                        return prev;
-                    }
-                    const hasAssistant = normalized.messages.some((entry) => entry.role === "assistant" &&
-                        typeof entry.content === "string" &&
-                        entry.content.includes(prev.text));
-                    return hasAssistant ? null : prev;
-                });
-                setTestRun(normalized);
-                if (typeof normalized.id === "string" && normalized.id) {
-                    testRunIdRef.current = normalized.id;
-                }
-                return;
-            }
-            if (msg.type === "testBotStream") {
-                const activeTestRunId = testRunIdRef.current;
-                if (!msg.runId || (activeTestRunId && msg.runId !== activeTestRunId)) {
-                    return;
-                }
-                const streamRunId = msg.runId;
-                const turn = typeof msg.turn === "number" ? msg.turn : 0;
-                if (msg.role === "assistant") {
-                    setTestStreamingAssistant((prev) => prev && prev.runId === streamRunId && prev.turn === turn
-                        ? { ...prev, text: prev.text + msg.chunk }
-                        : { runId: streamRunId, turn, text: msg.chunk });
-                    return;
-                }
-                if (msg.role === "user") {
-                    setTestStreamingUser((prev) => prev && prev.runId === streamRunId && prev.turn === turn
-                        ? { ...prev, text: prev.text + msg.chunk }
-                        : { runId: streamRunId, turn, text: msg.chunk });
-                }
-                return;
-            }
-            if (msg.type === "testBotStreamEnd") {
-                const activeTestRunId = testRunIdRef.current;
-                if (!msg.runId || (activeTestRunId && msg.runId !== activeTestRunId)) {
-                    return;
-                }
-                const turn = typeof msg.turn === "number" ? msg.turn : 0;
-                if (msg.role === "assistant") {
-                    setTestStreamingAssistant((prev) => prev && prev.runId === msg.runId && prev.turn === turn ? null : prev);
-                    return;
-                }
-                if (msg.role === "user") {
-                    const expectedUserCount = (testRunRef.current.messages ?? []).filter((entry) => entry.role === "user").length + 1;
-                    setTestStreamingUser((prev) => prev && prev.runId === msg.runId && prev.turn === turn
-                        ? { ...prev, expectedUserCount }
-                        : prev);
-                }
-                return;
-            }
-            const gradeMsg = msg;
-            if (gradeMsg.type !== "calibrateSession")
-                return;
-            gradeDebugLog("stream.calibrateSession", {
-                sessionId: gradeMsg.session.id,
-                runCount: gradeMsg.session.gradingRuns?.length ?? 0,
-            });
-            setGradeSessions((prev) => {
-                const next = [...prev];
-                const index = next.findIndex((sess) => sess.id === gradeMsg.session.id);
-                if (index >= 0) {
-                    next[index] = gradeMsg.session;
-                    return next;
-                }
-                return [gradeMsg.session, ...next];
-            });
-        };
-        const streamOrigin = globalThis.location?.origin ??
-            dntShim.dntGlobalThis.window?.location?.origin;
-        if (!streamOrigin || typeof globalThis.EventSource !== "function") {
-            let cancelled = false;
-            const poll = async () => {
-                try {
-                    const streamUrl = buildDurableStreamUrl(streamId, getDurableStreamOffset(streamId));
-                    const response = await fetch(streamUrl);
-                    if (!response.ok)
-                        return;
-                    const payload = await response.json();
-                    for (const item of payload.events ?? []) {
-                        if (!item || item.data === undefined)
-                            continue;
-                        handleMessage({
-                            data: JSON.stringify(item.data),
-                            lastEventId: String(item.offset ?? 0),
-                        });
-                    }
-                }
-                catch {
-                    // ignore polling errors; next loop retries.
-                }
-            };
-            const interval = globalThis.setInterval(() => {
-                if (cancelled)
-                    return;
-                void poll();
-            }, 500);
-            void poll();
-            return () => {
-                cancelled = true;
-                globalThis.clearInterval(interval);
-                clearPendingBuildTraces();
-            };
-        }
-        const streamUrl = buildDurableStreamUrl(streamId, getDurableStreamOffset(streamId));
-        const source = new EventSource(streamUrl);
-        const workspaceEventTypes = [
-            "next",
-            "buildBotStatus",
-            "buildBotTrace",
-            "buildBotStream",
-            "buildBotStreamEnd",
-            "testBotStatus",
-            "testBotStream",
-            "testBotStreamEnd",
-            "calibrateSession",
-        ];
-        for (const type of workspaceEventTypes) {
-            source.addEventListener(type, handleMessage);
-        }
-        return () => {
-            for (const type of workspaceEventTypes) {
-                source.removeEventListener(type, handleMessage);
-            }
-            source.close();
-            clearPendingBuildTraces();
-        };
-    }, [
-        clearPendingBuildTraces,
-        flushPendingBuildTraces,
-        mergeBuildRunSnapshot,
-        scheduleBuildTraceFlush,
-    ]);
-    useEffect(() => {
-        return () => {
-            clearPendingBuildTraces();
-        };
-    }, [clearPendingBuildTraces]);
-    const buildToolCalls = useMemo(() => summarizeToolCalls(buildRun.traces ?? []), [buildRun.traces]);
-    const ensureWorkspaceId = useCallback(async () => {
-        if (workspaceId)
-            return workspaceId;
-        if (buildRunIdRef.current)
-            return buildRunIdRef.current;
-        try {
-            const res = await fetch(`${WORKSPACE_API_BASE}/new`, {
-                method: "POST",
-            });
-            const data = await res.json().catch(() => ({}));
-            if (res.ok && typeof data.workspaceId === "string") {
-                const nextWorkspaceId = data.workspaceId;
-                buildRunIdRef.current = nextWorkspaceId;
-                setBuildRun((prev) => ({ ...prev, id: nextWorkspaceId }));
-                onWorkspaceChange?.(nextWorkspaceId);
-                return nextWorkspaceId;
-            }
-        }
-        catch {
-            // ignore
-        }
-        const fallback = `workspace-${crypto.randomUUID()}`;
-        buildRunIdRef.current = fallback;
-        setBuildRun((prev) => ({ ...prev, id: fallback }));
-        return fallback;
-    }, [onWorkspaceChange, workspaceId]);
-    const resetBuildChat = useCallback(async () => {
-        const res = await fetch(`${WORKSPACE_API_BASE}/new`, { method: "POST" })
-            .catch(() => null);
-        const data = res
-            ? await res.json().catch(() => ({}))
-            : {};
-        if (res && res.ok && typeof data.workspaceId === "string") {
-            buildRunIdRef.current = data.workspaceId;
-            buildIgnoredStreamRunIdsRef.current.clear();
-            setBuildRun({
-                id: data.workspaceId,
-                status: "idle",
-                messages: [],
-                traces: [],
-                toolInserts: [],
-                displayMessages: [],
-            });
-            onWorkspaceChange?.(data.workspaceId);
-        }
-        else {
-            buildRunIdRef.current = "";
-            buildIgnoredStreamRunIdsRef.current.clear();
-            setBuildRun({
-                id: "",
-                status: "idle",
-                messages: [],
-                traces: [],
-                toolInserts: [],
-                displayMessages: [],
-            });
-        }
-        setBuildChatDraft("");
-        setBuildChatError(null);
-        setBuildStreamingAssistant(null);
-        setBuildOptimisticUser(null);
-        setBuildToolCallsOpen({});
-        clearPendingBuildTraces();
-    }, [clearPendingBuildTraces, onWorkspaceChange]);
-    const stopBuildChat = useCallback(async () => {
-        const runId = buildRunRef.current.id || buildRunIdRef.current;
-        if (!runId)
-            return;
-        const runSnapshotAtStop = buildRunRef.current;
-        buildIgnoredStreamRunIdsRef.current.add(runId);
-        setBuildStreamingAssistant(null);
-        setBuildRun((prev) => prev.id === runId && prev.status === "running"
-            ? {
-                ...prev,
-                status: "canceled",
-                finishedAt: prev.finishedAt ?? new Date().toISOString(),
-                error: undefined,
-            }
-            : prev);
-        try {
-            const res = await fetch("/api/build/stop", {
-                method: "POST",
-                headers: { "content-type": "application/json" },
-                body: JSON.stringify({ workspaceId: runId }),
-            });
-            const data = await res.json().catch(() => ({}));
-            if (!res.ok) {
-                throw new Error(typeof data.error === "string" ? data.error : res.statusText);
-            }
-            if (data.stopped === false) {
-                buildIgnoredStreamRunIdsRef.current.delete(runId);
-                await refreshBuildStatus({ workspaceId: runId }).catch(() => { });
-                return;
-            }
-            if (data.run && data.run.id !== runId) {
-                buildIgnoredStreamRunIdsRef.current.delete(runId);
-                await refreshBuildStatus({ workspaceId: runId }).catch(() => { });
-                return;
-            }
-            if (data.run) {
-                setBuildRun((prev) => {
-                    if (prev.id !== runId)
-                        return prev;
-                    const next = mergeBuildRunSnapshot(prev, data.run);
-                    if (runSnapshotAtStop.id === runId &&
-                        runSnapshotAtStop.status === "running") {
-                        next.status = "canceled";
-                        next.finishedAt = next.finishedAt ?? new Date().toISOString();
-                        next.error = undefined;
-                        if (Array.isArray(next.messages) &&
-                            Array.isArray(runSnapshotAtStop.messages) &&
-                            next.messages.length < runSnapshotAtStop.messages.length) {
-                            next.messages = runSnapshotAtStop.messages;
-                        }
-                        if (Array.isArray(next.traces) &&
-                            Array.isArray(runSnapshotAtStop.traces) &&
-                            next.traces.length < runSnapshotAtStop.traces.length) {
-                            next.traces = runSnapshotAtStop.traces;
-                        }
-                        if (Array.isArray(next.toolInserts) &&
-                            Array.isArray(runSnapshotAtStop.toolInserts) &&
-                            next.toolInserts.length < runSnapshotAtStop.toolInserts.length) {
-                            next.toolInserts = runSnapshotAtStop.toolInserts;
-                        }
-                        next.displayMessages = buildDisplayMessages(next);
-                    }
-                    return next;
-                });
-            }
-        }
-        catch (err) {
-            buildIgnoredStreamRunIdsRef.current.delete(runId);
-            const isStillActiveRun = buildRunIdRef.current === runId &&
-                buildRunRef.current.id === runId;
-            if (isStillActiveRun) {
-                await refreshBuildStatus({ workspaceId: runId }).catch(() => { });
-            }
-            throw err;
-        }
-    }, [buildDisplayMessages, mergeBuildRunSnapshot, refreshBuildStatus]);
-    const sendBuildMessage = useCallback(async (message) => {
-        const runId = await ensureWorkspaceId();
-        buildIgnoredStreamRunIdsRef.current.delete(runId);
-        setBuildChatSending(true);
-        setBuildChatError(null);
-        try {
-            const res = await fetch("/api/build/message", {
-                method: "POST",
-                headers: { "content-type": "application/json" },
-                body: JSON.stringify({
-                    workspaceId: runId,
-                    message,
-                    buildChatProvider,
-                }),
-            });
-            const data = await res.json().catch(() => ({}));
-            if (!res.ok) {
-                throw new Error(typeof data.error === "string" ? data.error : res.statusText);
-            }
-            if (!data.run)
-                return;
-            setBuildRun((prev) => mergeBuildRunSnapshot(prev, data.run));
-            if (typeof data.run.id === "string" && data.run.id) {
-                buildRunIdRef.current = data.run.id;
-            }
-        }
-        finally {
-            setBuildChatSending(false);
-        }
-    }, [buildChatProvider, ensureWorkspaceId, mergeBuildRunSnapshot]);
-    const persistBuildChatProvider = useCallback(async (targetWorkspaceId, provider) => {
-        const res = await fetch("/api/build/provider", {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({
-                workspaceId: targetWorkspaceId,
-                buildChatProvider: provider,
-            }),
-        });
-        if (!res.ok) {
-            const text = await res.text().catch(() => "");
-            throw new Error(text || res.statusText);
-        }
-    }, []);
-    const updateBuildChatProvider = useCallback((provider) => {
-        setAndPersistBuildChatProvider(provider);
-        const targetWorkspaceId = buildRunIdRef.current || workspaceId || "";
-        if (!targetWorkspaceId)
-            return;
-        void persistBuildChatProvider(targetWorkspaceId, provider).catch(() => { });
-    }, [persistBuildChatProvider, setAndPersistBuildChatProvider, workspaceId]);
-    const loadBuildChat = useCallback(async (runId) => {
-        setBuildChatSending(true);
-        setBuildChatError(null);
-        try {
-            const snapshot = await loadWorkspaceSnapshot(runId);
-            const persistedProvider = resolvePersistedBuildChatProvider(snapshot.session?.meta);
-            setAndPersistBuildChatProvider(persistedProvider ?? readStoredBuildChatProvider() ??
-                defaultBuildChatProvider);
-            const data = snapshot.build;
-            if (!data.run)
-                return;
-            buildIgnoredStreamRunIdsRef.current.delete(runId);
-            setBuildRun((prev) => mergeBuildRunSnapshot(prev, data.run));
-            if (typeof data.run.id === "string" && data.run.id) {
-                buildRunIdRef.current = data.run.id;
-                onWorkspaceChange?.(data.run.id);
-            }
-            setBuildChatDraft("");
-            setBuildOptimisticUser(null);
-            setBuildStreamingAssistant(null);
-            setBuildToolCallsOpen({});
-        }
-        finally {
-            setBuildChatSending(false);
-        }
-    }, [
-        loadWorkspaceSnapshot,
-        mergeBuildRunSnapshot,
-        onWorkspaceChange,
-        resolvePersistedBuildChatProvider,
-        setAndPersistBuildChatProvider,
-    ]);
-    const refreshTestStatus = useCallback(async (opts) => {
-        const resolvedWorkspaceId = opts?.workspaceId ??
-            testRunRef.current.workspaceId ??
-            testRunRef.current.sessionId ??
-            workspaceId ??
-            undefined;
-        const resolvedRunId = opts?.runId ?? (testRunIdRef.current || undefined);
-        if (resolvedWorkspaceId) {
-            const snapshot = await loadWorkspaceSnapshot(resolvedWorkspaceId, {
-                deckPath: opts?.deckPath,
-                testRunId: resolvedRunId,
-            });
-            const data = snapshot.test;
-            const normalized = normalizeTestRun(data.run);
-            setTestRun(normalized);
-            if (normalized.status !== "running") {
-                setTestStreamingUser(null);
-                setTestStreamingAssistant(null);
-            }
-            if (typeof normalized.id === "string" && normalized.id) {
-                testRunIdRef.current = normalized.id;
-            }
-            return normalized;
-        }
-        const normalized = normalizeTestRun();
-        setTestRun(normalized);
-        testRunIdRef.current = resolvedRunId ?? "";
-        setTestStreamingUser(null);
-        setTestStreamingAssistant(null);
-        return normalized;
-    }, [loadWorkspaceSnapshot, workspaceId]);
-    const startTestRun = useCallback(async (payload) => {
-        const res = await fetch("/api/test/run", {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify(payload),
-        });
-        const data = await res.json().catch(() => ({}));
-        if (data.run) {
-            const normalized = normalizeTestRun(data.run);
-            setTestRun(normalized);
-            if (typeof normalized.id === "string" && normalized.id) {
-                testRunIdRef.current = normalized.id;
-            }
-        }
-        return data;
-    }, []);
-    const sendTestMessageRequest = useCallback(async (payload) => {
-        const res = await fetch("/api/test/message", {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify(payload),
-        });
-        const data = await res.json().catch(() => ({}));
-        if (data.run) {
-            const normalized = normalizeTestRun(data.run);
-            setTestRun(normalized);
-            if (typeof normalized.id === "string" && normalized.id) {
-                testRunIdRef.current = normalized.id;
-            }
-        }
-        return data;
-    }, []);
-    const startTestAssistant = useCallback(async (payload) => {
-        setTestChatSending(true);
-        setTestChatError(null);
-        let nextRunId = payload.runId;
-        if (!nextRunId) {
-            nextRunId = `testbot-ui-${crypto.randomUUID()}`;
-            setTestRun((prev) => ({
-                ...prev,
-                id: nextRunId,
-                status: "running",
-                error: undefined,
-                messages: prev.messages ?? [],
-                traces: prev.traces ?? [],
-                toolInserts: prev.toolInserts ?? [],
-            }));
-        }
-        const requestPayload = {
-            message: "",
-            runId: nextRunId,
-            workspaceId: payload.runWorkspaceId ?? payload.workspaceId ?? undefined,
-            botDeckPath: payload.botDeckPath ?? undefined,
-        };
-        if (!payload.runWorkspaceId && payload.context !== undefined) {
-            requestPayload.context = payload.context;
-        }
-        try {
-            const data = await sendTestMessageRequest(requestPayload);
-            if (!data.run) {
-                throw new Error(typeof data.error === "string"
-                    ? data.error
-                    : "Failed to start assistant");
-            }
-        }
-        catch (err) {
-            setTestChatError(err instanceof Error ? err.message : String(err));
-            throw err;
-        }
-        finally {
-            setTestChatSending(false);
-        }
-    }, [sendTestMessageRequest]);
-    const sendTestMessage = useCallback(async (message, payload) => {
-        const trimmed = message.trim();
-        if (!trimmed)
-            return;
-        setTestChatSending(true);
-        setTestChatError(null);
-        let nextRunId = payload.runId;
-        const optimisticId = crypto.randomUUID();
-        if (!nextRunId) {
-            nextRunId = `testbot-ui-${crypto.randomUUID()}`;
-            setTestRun((prev) => ({
-                ...prev,
-                id: nextRunId,
-                status: "running",
-                error: undefined,
-                messages: prev.messages ?? [],
-                traces: prev.traces ?? [],
-                toolInserts: prev.toolInserts ?? [],
-            }));
-        }
-        setTestOptimisticUser({ id: optimisticId, text: trimmed });
-        setTestChatDraft("");
-        const requestPayload = {
-            message: trimmed,
-            runId: nextRunId,
-            workspaceId: payload.runWorkspaceId ?? payload.workspaceId ?? undefined,
-            botDeckPath: payload.botDeckPath ?? undefined,
-        };
-        if (!payload.runWorkspaceId && payload.context !== undefined) {
-            requestPayload.context = payload.context;
-        }
-        try {
-            const data = await sendTestMessageRequest(requestPayload);
-            if (!data.run) {
-                throw new Error(typeof data.error === "string"
-                    ? data.error
-                    : "Failed to send message");
-            }
-        }
-        catch (err) {
-            setTestChatError(err instanceof Error ? err.message : String(err));
-            throw err;
-        }
-        finally {
-            setTestChatSending(false);
-        }
-    }, [sendTestMessageRequest]);
-    const stopTestRun = useCallback(async (runId) => {
-        await fetch("/api/test/stop", {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({ runId }),
-        });
-    }, []);
-    const resetTestRun = useCallback(() => {
-        testRunIdRef.current = "";
-        setTestRun(normalizeTestRun());
-        setTestStreamingUser(null);
-        setTestStreamingAssistant(null);
-        setTestChatDraft("");
-        setTestChatError(null);
-        setTestChatSending(false);
-        setTestOptimisticUser(null);
-    }, []);
-    useEffect(() => {
-        if (testOptimisticUser) {
-            const lastUser = [...(testRun.messages ?? [])].reverse().find((msg) => msg.role === "user");
-            if (lastUser?.content === testOptimisticUser.text) {
-                setTestOptimisticUser(null);
-            }
-        }
-        if (testRun.status !== "running" && testOptimisticUser) {
-            setTestOptimisticUser(null);
-        }
-    }, [testOptimisticUser, testRun.messages, testRun.status]);
-    const saveTestFeedback = useCallback(async (payload) => {
-        const res = await fetch(`${WORKSPACE_API_BASE}/feedback`, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify(payload),
-        });
-        if (!res.ok) {
-            const body = await res.json().catch(() => ({}));
-            throw new Error(body.error || res.statusText);
-        }
-        const data = await res.json();
-        setTestRun((prev) => {
-            if (!prev.messages.length)
-                return prev;
-            if (data.deleted) {
-                return {
-                    ...prev,
-                    messages: prev.messages.map((msg) => msg.messageRefId === payload.messageRefId
-                        ? { ...msg, feedback: undefined }
-                        : msg),
-                };
-            }
-            if (!data.feedback)
-                return prev;
-            return {
-                ...prev,
-                messages: prev.messages.map((msg) => msg.messageRefId === payload.messageRefId
-                    ? { ...msg, feedback: data.feedback }
-                    : msg),
-            };
-        });
-        return data;
-    }, []);
-    const loadGradeData = useCallback(async (opts) => {
-        const reqId = ++gradeLoadSeqRef.current;
-        gradeDebugLog("loadData.start", {
-            reqId,
-            workspaceId: opts?.workspaceId ?? null,
-        });
-        try {
-            setGradeLoading(true);
-            let data;
-            if (opts?.workspaceId) {
-                const snapshot = await loadWorkspaceSnapshot(opts.workspaceId, {
-                    gradeRunId: opts.gradeRunId ?? undefined,
-                });
-                data = snapshot.grade;
-                gradeDebugLog("loadData.response", {
-                    reqId,
-                    ok: true,
-                    status: 200,
-                    source: "workspace",
-                });
-            }
-            else {
-                data = { graderDecks: [], sessions: [] };
-                gradeDebugLog("loadData.response", {
-                    reqId,
-                    ok: true,
-                    status: 200,
-                    source: "empty",
-                });
-            }
-            setGradeGraders(Array.isArray(data.graderDecks) ? data.graderDecks : []);
-            setGradeSessions(Array.isArray(data.sessions) ? data.sessions : []);
-            gradeDebugLog("loadData.success", {
-                reqId,
-                graders: Array.isArray(data.graderDecks)
-                    ? data.graderDecks.length
-                    : 0,
-                sessions: Array.isArray(data.sessions) ? data.sessions.length : 0,
-            });
-            setGradeError(null);
-        }
-        catch (err) {
-            gradeDebugLog("loadData.error", {
-                reqId,
-                message: err instanceof Error ? err.message : String(err),
-            });
-            setGradeError(err instanceof Error
-                ? err.message
-                : "Failed to load calibration data");
-        }
-        finally {
-            setGradeLoading(false);
-            gradeDebugLog("loadData.end", {
-                reqId,
-                loading: false,
-            });
-        }
-    }, [loadWorkspaceSnapshot]);
-    const loadGradeSessionDetail = useCallback(async (targetWorkspaceId) => {
-        const reqId = ++gradeDetailSeqRef.current;
-        gradeDebugLog("loadSessionDetail.start", {
-            reqId,
-            workspaceId: targetWorkspaceId,
-        });
-        if (!targetWorkspaceId) {
-            setGradeSessionDetail(null);
-            gradeDebugLog("loadSessionDetail.skip", {
-                reqId,
-                reason: "missing-workspace-id",
-            });
-            return;
-        }
-        try {
-            const snapshot = await loadWorkspaceSnapshot(targetWorkspaceId);
-            gradeDebugLog("loadSessionDetail.response", {
-                reqId,
-                workspaceId: targetWorkspaceId,
-                ok: true,
-                status: 200,
-            });
-            const data = snapshot.session;
-            setGradeSessionDetail(data);
-            gradeDebugLog("loadSessionDetail.success", {
-                reqId,
-                workspaceId: targetWorkspaceId,
-                messageCount: Array.isArray(data.messages) ? data.messages.length : 0,
-            });
-        }
-        catch (err) {
-            setGradeSessionDetail(null);
-            gradeDebugLog("loadSessionDetail.error", {
-                reqId,
-                workspaceId: targetWorkspaceId,
-                message: err instanceof Error ? err.message : String(err),
-            });
-            setGradeError(err instanceof Error ? err.message : "Failed to load session details");
-        }
-    }, [loadWorkspaceSnapshot]);
-    const runGradeGrader = useCallback(async (payload) => {
-        try {
-            setGradeRunning(true);
-            const res = await fetch("/api/calibrate/run", {
-                method: "POST",
-                headers: { "content-type": "application/json" },
-                body: JSON.stringify(payload),
-            });
-            if (!res.ok) {
-                const text = await res.text().catch(() => "");
-                throw new Error(text || res.statusText);
-            }
-            const data = await res.json();
-            if (data.session) {
-                setGradeSessions((prev) => {
-                    const index = prev.findIndex((sess) => sess.id === data.session.id);
-                    if (index >= 0) {
-                        const next = [...prev];
-                        next[index] = data.session;
-                        return next;
-                    }
-                    return [data.session, ...prev];
-                });
-            }
-            if (!data.run) {
-                throw new Error(data.error ?? "Calibration response missing run payload");
-            }
-            if (data.run.status !== "completed") {
-                throw new Error(data.run.error ??
-                    `Calibration run ended with status ${data.run.status}`);
-            }
-            setGradeError(null);
-            return data;
-        }
-        catch (err) {
-            const message = err instanceof Error
-                ? err.message
-                : "Failed to run grader";
-            setGradeError(message);
-            throw new Error(message);
-        }
-        finally {
-            setGradeRunning(false);
-        }
-    }, []);
-    const toggleGradeFlag = useCallback(async (payload) => {
-        const res = await fetch("/api/calibrate/flag", {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify(payload),
-        });
-        if (!res.ok) {
-            const text = await res.text().catch(() => "");
-            throw new Error(text || res.statusText);
-        }
-        const data = await res.json();
-        if (data.flags) {
-            setGradeSessionDetail((prev) => {
-                if (!prev)
-                    return prev;
-                return {
-                    ...prev,
-                    meta: {
-                        ...(prev.meta ?? {}),
-                        gradingFlags: data.flags,
-                    },
-                };
-            });
-        }
-        return data;
-    }, []);
-    const updateGradeFlagReason = useCallback(async (payload) => {
-        const res = await fetch("/api/calibrate/flag/reason", {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify(payload),
-        });
-        if (!res.ok) {
-            const text = await res.text().catch(() => "");
-            throw new Error(text || res.statusText);
-        }
-        const data = await res.json();
-        if (data.flags) {
-            setGradeSessionDetail((prev) => {
-                if (!prev)
-                    return prev;
-                return {
-                    ...prev,
-                    meta: {
-                        ...(prev.meta ?? {}),
-                        gradingFlags: data.flags,
-                    },
-                };
-            });
-        }
-        return data;
-    }, []);
-    const value = useMemo(() => ({
-        build: {
-            run: buildRun,
-            toolCalls: buildToolCalls,
-            chatDraft: buildChatDraft,
-            setChatDraft: setBuildChatDraft,
-            chatSending: buildChatSending,
-            chatError: buildChatError,
-            setChatError: setBuildChatError,
-            toolCallsOpen: buildToolCallsOpen,
-            setToolCallsOpen: setBuildToolCallsOpen,
-            optimisticUser: buildOptimisticUser,
-            setOptimisticUser: setBuildOptimisticUser,
-            streamingAssistant: buildStreamingAssistant,
-            setStreamingAssistant: setBuildStreamingAssistant,
-            stopChat: stopBuildChat,
-            resetChat: resetBuildChat,
-            buildChatProvider,
-            setBuildChatProvider: updateBuildChatProvider,
-            sendMessage: sendBuildMessage,
-            loadChat: loadBuildChat,
-        },
-        test: {
-            run: testRun,
-            setRun: setTestRun,
-            streamingUser: testStreamingUser,
-            streamingAssistant: testStreamingAssistant,
-            chatDraft: testChatDraft,
-            setChatDraft: setTestChatDraft,
-            chatSending: testChatSending,
-            chatError: testChatError,
-            setChatError: setTestChatError,
-            optimisticUser: testOptimisticUser,
-            refreshStatus: refreshTestStatus,
-            startRun: startTestRun,
-            startAssistant: startTestAssistant,
-            sendMessage: sendTestMessage,
-            stopRun: stopTestRun,
-            resetRun: resetTestRun,
-            saveFeedback: saveTestFeedback,
-        },
-        grade: {
-            loading: gradeLoading,
-            error: gradeError,
-            running: gradeRunning,
-            graders: gradeGraders,
-            sessions: gradeSessions,
-            sessionDetail: gradeSessionDetail,
-            loadData: loadGradeData,
-            loadSessionDetail: loadGradeSessionDetail,
-            runGrader: runGradeGrader,
-            toggleFlag: toggleGradeFlag,
-            updateFlagReason: updateGradeFlagReason,
-        },
-        routing: {
-            testRunId: activeTestRunId,
-            gradeRunId: activeGradeRunId,
-            setTestRunId: setActiveTestRunId,
-            setGradeRunId: setActiveGradeRunId,
-        },
-    }), [
-        buildRun,
-        buildToolCalls,
-        buildChatDraft,
-        buildChatSending,
-        buildChatError,
-        buildToolCallsOpen,
-        buildOptimisticUser,
-        buildStreamingAssistant,
-        resetBuildChat,
-        buildChatProvider,
-        updateBuildChatProvider,
-        stopBuildChat,
-        sendBuildMessage,
-        loadBuildChat,
-        testRun,
-        testStreamingUser,
-        testStreamingAssistant,
-        testChatDraft,
-        testChatSending,
-        testChatError,
-        testOptimisticUser,
-        refreshTestStatus,
-        startTestRun,
-        startTestAssistant,
-        sendTestMessage,
-        stopTestRun,
-        resetTestRun,
-        saveTestFeedback,
-        gradeLoading,
-        gradeError,
-        gradeRunning,
-        gradeGraders,
-        gradeSessions,
-        gradeSessionDetail,
-        loadGradeData,
-        loadGradeSessionDetail,
-        runGradeGrader,
-        toggleGradeFlag,
-        updateGradeFlagReason,
-        activeTestRunId,
-        activeGradeRunId,
-    ]);
-    return (React.createElement(WorkspaceContext.Provider, { value: value }, children));
-}
-function useWorkspaceContext() {
-    const context = useContext(WorkspaceContext);
-    if (!context) {
-        throw new Error("Workspace hooks must be used within WorkspaceProvider");
-    }
-    return context;
-}
-export function useWorkspaceBuild() {
-    return useWorkspaceContext().build;
-}
-export function useWorkspaceTest() {
-    return useWorkspaceContext().test;
-}
-export function useWorkspaceGrade() {
-    return useWorkspaceContext().grade;
-}
-export function useWorkspaceRouting() {
-    return useWorkspaceContext().routing;
-}