@bolt-foundry/gambit 0.8.5 → 0.8.6-rc.1

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

@@ -0,0 +1,1377 @@
+// 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);
+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(defaultBuildChatProvider);
+    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;
+        if (raw === "claude-code-cli")
+            return "claude-code-cli";
+        if (raw === "codex-cli")
+            return "codex-cli";
+        return null;
+    }, []);
+    const refreshBuildStatus = useCallback(async (opts) => {
+        if (opts?.workspaceId) {
+            const data = await loadWorkspaceSnapshot(opts.workspaceId);
+            const persistedProvider = resolvePersistedBuildChatProvider(data.session?.meta);
+            setBuildChatProvider(persistedProvider ?? 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,
+    ]);
+    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" &&
+                        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") {
+                        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" &&
+                        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") {
+                        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) => {
+        setBuildChatProvider(provider);
+        const targetWorkspaceId = buildRunIdRef.current || workspaceId || "";
+        if (!targetWorkspaceId)
+            return;
+        void persistBuildChatProvider(targetWorkspaceId, provider).catch(() => { });
+    }, [persistBuildChatProvider, workspaceId]);
+    const loadBuildChat = useCallback(async (runId) => {
+        setBuildChatSending(true);
+        setBuildChatError(null);
+        try {
+            const snapshot = await loadWorkspaceSnapshot(runId);
+            const persistedProvider = resolvePersistedBuildChatProvider(snapshot.session?.meta);
+            setBuildChatProvider(persistedProvider ?? 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,
+    ]);
+    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;
+}