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

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

@@ -1,716 +0,0 @@
-import { useCallback, useEffect, useMemo, useReducer, useRef, useState, } from "react";
-import { WORKSPACES_API_BASE } from "../../src/workspace_contract.js";
-import Button from "./gds/Button.js";
-import Badge from "./gds/Badge.js";
-import Icon from "./gds/Icon.js";
-import ScrollingText from "./gds/ScrollingText.js";
-import Callout from "./gds/Callout.js";
-import Chat from "./Chat.js";
-import Accordion from "./gds/Accordion.js";
-import Listbox from "./gds/Listbox.js";
-import CodexLoginRequiredOverlay from "./CodexLoginRequiredOverlay.js";
-import { useBuildChat } from "./BuildChatContext.js";
-import List from "./gds/List.js";
-import ListItem from "./gds/ListItem.js";
-import ProviderLoginPanel from "./ProviderLoginPanel.js";
-import { chatAccordionEnabled, extractGradingFlags, extractScoreAndReason, extractTurnContext, formatSnippet, formatTimestampShort, getScoreClass, } from "./utils.js";
-const initialCodexOverlayState = {
-    copiedCodexLoginCommand: false,
-    codexLoginRecheckPending: false,
-    showCodexLoginRecheck: false,
-    codexAutoRecheckActive: false,
-    codexWorkspaceLoggedIn: null,
-    codexLoginError: null,
-    codexLoginStatusText: null,
-    codexLoginOverlayDismissed: false,
-};
-function codexOverlayReducer(state, action) {
-    switch (action.type) {
-        case "reset_for_session":
-            return initialCodexOverlayState;
-        case "status_fetch_start":
-            return {
-                ...state,
-                codexLoginError: null,
-            };
-        case "status_fetch_success":
-            return {
-                ...state,
-                codexWorkspaceLoggedIn: action.loggedIn,
-                codexLoginStatusText: action.statusText,
-                showCodexLoginRecheck: action.loggedIn
-                    ? false
-                    : state.showCodexLoginRecheck,
-                codexAutoRecheckActive: action.loggedIn
-                    ? false
-                    : state.codexAutoRecheckActive,
-            };
-        case "status_fetch_error":
-            return {
-                ...state,
-                codexWorkspaceLoggedIn: null,
-                codexLoginStatusText: null,
-                codexLoginError: action.error,
-            };
-        case "copy_login_command":
-            return {
-                ...state,
-                copiedCodexLoginCommand: true,
-                showCodexLoginRecheck: true,
-                codexAutoRecheckActive: true,
-            };
-        case "clear_copied_login_command":
-            return {
-                ...state,
-                copiedCodexLoginCommand: false,
-            };
-        case "start_recheck":
-            return {
-                ...state,
-                codexLoginRecheckPending: true,
-                codexLoginError: null,
-            };
-        case "finish_recheck":
-            return {
-                ...state,
-                codexLoginRecheckPending: false,
-            };
-        case "show_recheck":
-            return {
-                ...state,
-                showCodexLoginRecheck: true,
-            };
-        case "dismiss_overlay":
-            return {
-                ...state,
-                codexLoginOverlayDismissed: true,
-                codexAutoRecheckActive: false,
-            };
-        default:
-            return state;
-    }
-}
-export default function WorkbenchDrawer(props) {
-    const { run, chatSending, resetChat, loadChat, buildChatProvider, setBuildChatProvider, } = useBuildChat();
-    const { open = true, onClose, statePath, loading = false, error = null, sessionId, messages, sessionDetail, feedbackItems, gradingFlags, runLabelById = new Map(), runItemByRefId = new Map(), composerChips = [], onComposerChipsChange, } = props;
-    const [chatHistoryOpen, setChatHistoryOpen] = useState(false);
-    const [chatHistory, setChatHistory] = useState([]);
-    const [chatHistoryLoading, setChatHistoryLoading] = useState(false);
-    const [chatHistoryError, setChatHistoryError] = useState(null);
-    const [copiedStatePath, setCopiedStatePath] = useState(false);
-    const [codexOverlayState, dispatchCodexOverlay] = useReducer(codexOverlayReducer, initialCodexOverlayState);
-    const { copiedCodexLoginCommand, codexLoginRecheckPending, showCodexLoginRecheck, codexAutoRecheckActive, codexWorkspaceLoggedIn, codexLoginError, codexLoginStatusText, codexLoginOverlayDismissed, } = codexOverlayState;
-    const initializedChipTrackingRef = useRef(false);
-    const seenRatingChipIdsRef = useRef(new Set());
-    const seenFlagChipIdsRef = useRef(new Set());
-    const buildProviderOptions = useMemo(() => [
-        { value: "codex-cli", label: "Codex" },
-        { value: "claude-code-cli", label: "Claude Code" },
-    ], []);
-    const codexLoginCommand = "codex login";
-    const codexWorkspaceId = sessionId ?? run.id;
-    const codexStatusEndpoint = codexWorkspaceId
-        ? `/api/codex/trust-workspace?workspaceId=${encodeURIComponent(codexWorkspaceId)}`
-        : "/api/codex/trust-workspace";
-    const showCodexLoginOverlay = (codexWorkspaceLoggedIn === false &&
-        !codexLoginOverlayDismissed) || Boolean(codexLoginError);
-    const resolvedStatePath = useMemo(() => {
-        if (statePath)
-            return statePath;
-        const meta = sessionDetail?.meta;
-        if (meta && typeof meta === "object") {
-            const sessionStatePath = meta
-                .sessionStatePath;
-            if (typeof sessionStatePath === "string") {
-                return sessionStatePath;
-            }
-        }
-        return null;
-    }, [sessionDetail?.meta, statePath]);
-    const resolvedFeedbackItems = useMemo(() => {
-        if (sessionDetail) {
-            const feedback = sessionDetail.feedback ?? [];
-            const refs = sessionDetail.messageRefs ?? [];
-            const messages = sessionDetail.messages ?? [];
-            const messageByRefId = new Map();
-            const roleByRefId = new Map();
-            refs.forEach((ref, index) => {
-                if (!ref?.id)
-                    return;
-                const message = messages[index];
-                if (message) {
-                    messageByRefId.set(ref.id, message);
-                }
-                if (ref.role)
-                    roleByRefId.set(ref.id, ref.role);
-            });
-            const items = feedback.map((entry) => {
-                const message = messageByRefId.get(entry.messageRefId);
-                const role = message?.role ?? roleByRefId.get(entry.messageRefId);
-                return { entry, message, role };
-            });
-            return items.sort((a, b) => {
-                const aKey = a.entry.createdAt ?? "";
-                const bKey = b.entry.createdAt ?? "";
-                return bKey.localeCompare(aKey);
-            });
-        }
-        if (feedbackItems !== undefined)
-            return feedbackItems;
-        if (!messages?.length)
-            return [];
-        const items = [];
-        messages.forEach((message, index) => {
-            if (!message?.feedback)
-                return;
-            items.push({
-                entry: message.feedback,
-                message: { content: message.content },
-                role: message.role,
-                _sortIndex: index,
-            });
-        });
-        return items.sort((a, b) => {
-            const aKey = a.entry.createdAt ?? "";
-            const bKey = b.entry.createdAt ?? "";
-            if (aKey && bKey && aKey !== bKey) {
-                return bKey.localeCompare(aKey);
-            }
-            return (b._sortIndex ?? 0) - (a._sortIndex ?? 0);
-        });
-    }, [feedbackItems, messages, sessionDetail]);
-    const resolvedGradingFlags = useMemo(() => {
-        if (sessionDetail) {
-            return extractGradingFlags(sessionDetail.meta);
-        }
-        return gradingFlags ?? [];
-    }, [gradingFlags, sessionDetail]);
-    const resolvedRunLabelById = useMemo(() => {
-        if (runLabelById.size > 0)
-            return runLabelById;
-        const meta = sessionDetail?.meta;
-        const runs = meta && typeof meta === "object"
-            ? meta.gradingRuns
-            : undefined;
-        if (!Array.isArray(runs))
-            return runLabelById;
-        const map = new Map();
-        runs.forEach((run) => {
-            if (!run || typeof run !== "object")
-                return;
-            const record = run;
-            if (typeof record.id !== "string")
-                return;
-            const label = typeof record.graderLabel === "string"
-                ? record.graderLabel
-                : typeof record.graderId === "string"
-                    ? record.graderId
-                    : record.id;
-            map.set(record.id, label);
-        });
-        return map;
-    }, [runLabelById, sessionDetail]);
-    const resolvedRunItemByRefId = useMemo(() => {
-        if (runItemByRefId.size > 0)
-            return runItemByRefId;
-        const meta = sessionDetail?.meta;
-        const runs = meta && typeof meta === "object"
-            ? meta.gradingRuns
-            : undefined;
-        if (!Array.isArray(runs))
-            return runItemByRefId;
-        const map = new Map();
-        runs.forEach((run) => {
-            if (!run || typeof run !== "object")
-                return;
-            const record = run;
-            if (typeof record.id !== "string")
-                return;
-            const result = record.result;
-            if (result &&
-                typeof result === "object" &&
-                result.mode === "turns" &&
-                Array.isArray(result.turns)) {
-                const turns = result
-                    .turns;
-                turns.forEach((turn, idx) => {
-                    const index = typeof turn.index === "number" ? turn.index : idx;
-                    map.set(`gradingRun:${record.id}#turn:${index}`, {
-                        turnNumber: index + 1,
-                        input: turn.input,
-                        result: turn.result,
-                    });
-                });
-            }
-            else {
-                map.set(`gradingRun:${record.id}`, {
-                    input: record.input,
-                    result: record.result,
-                });
-            }
-        });
-        return map;
-    }, [runItemByRefId, sessionDetail]);
-    const mergeComposerChip = useCallback((base, chip) => {
-        const next = [...base];
-        const existingIndex = next.findIndex((entry) => entry.chipId === chip.chipId);
-        if (existingIndex >= 0) {
-            next[existingIndex] = {
-                ...next[existingIndex],
-                ...chip,
-                enabled: true,
-            };
-            return next;
-        }
-        next.push(chip);
-        return next;
-    }, []);
-    const addComposerChip = useCallback((chip) => {
-        if (!onComposerChipsChange)
-            return;
-        onComposerChipsChange(mergeComposerChip(composerChips, chip));
-    }, [composerChips, mergeComposerChip, onComposerChipsChange]);
-    const removeComposerChip = useCallback((chipId) => {
-        if (!onComposerChipsChange)
-            return;
-        onComposerChipsChange(composerChips.filter((chip) => chip.chipId !== chipId));
-    }, [composerChips, onComposerChipsChange]);
-    const composerChipIds = useMemo(() => new Set(composerChips.map((chip) => chip.chipId)), [composerChips]);
-    const buildRatingChip = useCallback((entry) => {
-        const capturedAt = entry.createdAt ?? new Date().toISOString();
-        return {
-            chipId: `rating:${entry.messageRefId}:${entry.id}`,
-            source: "message_rating",
-            workspaceId: sessionId ?? undefined,
-            runId: entry.runId,
-            capturedAt,
-            messageRefId: entry.messageRefId,
-            statePath: resolvedStatePath ?? undefined,
-            statePointer: `messageRef:${entry.messageRefId}`,
-            score: entry.score,
-            reason: entry.reason,
-            enabled: true,
-        };
-    }, [resolvedStatePath, sessionId]);
-    const resolveFlagMessage = useCallback((flag) => {
-        if (flag.reason?.trim())
-            return flag.reason;
-        const flaggedItem = resolvedRunItemByRefId.get(flag.refId);
-        const gradedAssistant = extractTurnContext(flaggedItem?.input).gradedAssistant;
-        if (gradedAssistant?.trim())
-            return formatSnippet(gradedAssistant);
-        return "Flagged by grader";
-    }, [resolvedRunItemByRefId]);
-    const buildFlagChip = useCallback((flag) => {
-        const capturedAt = flag.createdAt ?? new Date().toISOString();
-        return {
-            // Use refId so optimistic and persisted updates collapse to one chip.
-            chipId: `flag:${flag.refId}`,
-            source: "grading_flag",
-            workspaceId: sessionId ?? undefined,
-            runId: flag.runId,
-            capturedAt,
-            flagId: flag.id,
-            refId: flag.refId,
-            score: extractScoreAndReason(resolvedRunItemByRefId.get(flag.refId)?.result)
-                .score,
-            message: resolveFlagMessage(flag),
-            enabled: true,
-        };
-    }, [resolveFlagMessage, resolvedRunItemByRefId, sessionId]);
-    useEffect(() => {
-        initializedChipTrackingRef.current = false;
-        seenRatingChipIdsRef.current.clear();
-        seenFlagChipIdsRef.current.clear();
-        dispatchCodexOverlay({ type: "reset_for_session" });
-    }, [sessionId]);
-    useEffect(() => {
-        if (!open)
-            return;
-        let canceled = false;
-        dispatchCodexOverlay({ type: "status_fetch_start" });
-        fetch(codexStatusEndpoint)
-            .then(async (response) => {
-            const payload = await response.json();
-            if (!response.ok || payload.ok === false) {
-                throw new Error(payload.error || response.statusText);
-            }
-            if (canceled)
-                return;
-            dispatchCodexOverlay({
-                type: "status_fetch_success",
-                loggedIn: payload.codexLoggedIn === true,
-                statusText: typeof payload.codexLoginStatus === "string"
-                    ? payload.codexLoginStatus
-                    : null,
-            });
-        })
-            .catch((err) => {
-            if (canceled)
-                return;
-            dispatchCodexOverlay({
-                type: "status_fetch_error",
-                error: err instanceof Error ? err.message : String(err),
-            });
-        })
-            .finally(() => {
-            if (canceled)
-                return;
-        });
-        return () => {
-            canceled = true;
-        };
-    }, [codexStatusEndpoint, open]);
-    useEffect(() => {
-        if (!showCodexLoginOverlay)
-            return;
-        if (codexWorkspaceLoggedIn !== false)
-            return;
-        if (showCodexLoginRecheck)
-            return;
-        const timeout = globalThis.setTimeout(() => {
-            dispatchCodexOverlay({ type: "show_recheck" });
-        }, 5000);
-        return () => globalThis.clearTimeout(timeout);
-    }, [codexWorkspaceLoggedIn, showCodexLoginOverlay, showCodexLoginRecheck]);
-    useEffect(() => {
-        if (loading)
-            return;
-        const currentRatingChipIds = new Set(resolvedFeedbackItems.map(({ entry }) => `rating:${entry.messageRefId}:${entry.id}`));
-        const currentFlagChipIds = new Set(resolvedGradingFlags.map((flag) => `flag:${flag.refId}`));
-        if (!initializedChipTrackingRef.current) {
-            seenRatingChipIdsRef.current = currentRatingChipIds;
-            seenFlagChipIdsRef.current = currentFlagChipIds;
-            initializedChipTrackingRef.current = true;
-            return;
-        }
-        const newRatingEntries = resolvedFeedbackItems.filter(({ entry }) => !seenRatingChipIdsRef.current.has(`rating:${entry.messageRefId}:${entry.id}`));
-        const newFlagEntries = resolvedGradingFlags.filter((flag) => !seenFlagChipIdsRef.current.has(`flag:${flag.refId}`));
-        if ((newRatingEntries.length > 0 || newFlagEntries.length > 0) &&
-            onComposerChipsChange) {
-            let nextChips = [...composerChips];
-            newRatingEntries.forEach(({ entry }) => {
-                nextChips = mergeComposerChip(nextChips, buildRatingChip(entry));
-            });
-            newFlagEntries.forEach((flag) => {
-                nextChips = mergeComposerChip(nextChips, buildFlagChip(flag));
-            });
-            onComposerChipsChange(nextChips);
-        }
-        if (onComposerChipsChange) {
-            const ratingByChipId = new Map(resolvedFeedbackItems.map(({ entry }) => [
-                `rating:${entry.messageRefId}:${entry.id}`,
-                buildRatingChip(entry),
-            ]));
-            const flagByChipId = new Map(resolvedGradingFlags.map((flag) => [
-                `flag:${flag.refId}`,
-                buildFlagChip(flag),
-            ]));
-            let didChange = false;
-            const syncedChips = composerChips.filter((chip) => {
-                if (chip.source === "message_rating") {
-                    if (!chip.chipId.startsWith("rating:"))
-                        return true;
-                    const stillExists = ratingByChipId.has(chip.chipId);
-                    if (!stillExists)
-                        didChange = true;
-                    return stillExists;
-                }
-                if (chip.source === "grading_flag") {
-                    if (!chip.chipId.startsWith("flag:"))
-                        return true;
-                    const stillExists = flagByChipId.has(chip.chipId);
-                    if (!stillExists)
-                        didChange = true;
-                    return stillExists;
-                }
-                return true;
-            }).map((chip) => {
-                const latest = chip.source === "message_rating" &&
-                    chip.chipId.startsWith("rating:")
-                    ? ratingByChipId.get(chip.chipId)
-                    : chip.source === "grading_flag" && chip.chipId.startsWith("flag:")
-                        ? flagByChipId.get(chip.chipId)
-                        : undefined;
-                if (!latest)
-                    return chip;
-                const next = { ...chip, ...latest, enabled: chip.enabled };
-                const changed = JSON.stringify(next) !== JSON.stringify(chip);
-                if (changed)
-                    didChange = true;
-                return next;
-            });
-            if (didChange) {
-                onComposerChipsChange(syncedChips);
-            }
-        }
-        seenRatingChipIdsRef.current = currentRatingChipIds;
-        seenFlagChipIdsRef.current = currentFlagChipIds;
-    }, [
-        buildFlagChip,
-        buildRatingChip,
-        composerChips,
-        loading,
-        mergeComposerChip,
-        onComposerChipsChange,
-        resolvedFeedbackItems,
-        resolvedGradingFlags,
-    ]);
-    const loadChatHistory = useCallback(async () => {
-        if (!chatAccordionEnabled)
-            return;
-        setChatHistoryLoading(true);
-        setChatHistoryError(null);
-        try {
-            const res = await fetch(WORKSPACES_API_BASE);
-            if (!res.ok)
-                throw new Error(res.statusText);
-            const data = await res.json();
-            const runs = Array.isArray(data.workspaces)
-                ? data.workspaces.filter((entry) => typeof entry?.id === "string").map((entry) => ({
-                    id: entry.id,
-                    updatedAt: entry.createdAt,
-                    startedAt: entry.createdAt,
-                }))
-                : [];
-            setChatHistory(runs);
-        }
-        catch (err) {
-            setChatHistoryError(err instanceof Error ? err.message : "Failed to load chat history");
-        }
-        finally {
-            setChatHistoryLoading(false);
-        }
-    }, []);
-    useEffect(() => {
-        if (!open)
-            return;
-        if (!chatAccordionEnabled)
-            return;
-        loadChatHistory().catch(() => { });
-    }, [loadChatHistory, open]);
-    const runStatusLabel = run.status === "running"
-        ? "Running…"
-        : run.status === "completed"
-            ? "Completed"
-            : run.status === "error"
-                ? "Failed"
-                : run.status === "canceled"
-                    ? "Stopped"
-                    : "Idle";
-    const showCopyStatePath = Boolean(resolvedStatePath);
-    const handleCopyStatePath = useMemo(() => {
-        if (!resolvedStatePath)
-            return null;
-        return () => {
-            navigator.clipboard?.writeText(resolvedStatePath);
-            setCopiedStatePath(true);
-            globalThis.setTimeout(() => setCopiedStatePath(false), 1200);
-        };
-    }, [resolvedStatePath]);
-    const handleCopyCodexLoginCommand = useCallback(() => {
-        navigator.clipboard?.writeText(codexLoginCommand);
-        dispatchCodexOverlay({ type: "copy_login_command" });
-        globalThis.setTimeout(() => {
-            dispatchCodexOverlay({ type: "clear_copied_login_command" });
-        }, 1200);
-    }, [codexLoginCommand]);
-    const handleRecheckCodexLogin = useCallback(async () => {
-        dispatchCodexOverlay({ type: "start_recheck" });
-        try {
-            const response = await fetch(codexStatusEndpoint);
-            const payload = await response.json();
-            if (!response.ok || payload.ok === false) {
-                throw new Error(payload.error || response.statusText);
-            }
-            dispatchCodexOverlay({
-                type: "status_fetch_success",
-                loggedIn: payload.codexLoggedIn === true,
-                statusText: typeof payload.codexLoginStatus === "string"
-                    ? payload.codexLoginStatus
-                    : null,
-            });
-        }
-        catch (err) {
-            dispatchCodexOverlay({
-                type: "status_fetch_error",
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-        finally {
-            dispatchCodexOverlay({ type: "finish_recheck" });
-        }
-    }, [codexStatusEndpoint]);
-    useEffect(() => {
-        if (!codexAutoRecheckActive)
-            return;
-        if (!showCodexLoginOverlay)
-            return;
-        if (codexWorkspaceLoggedIn !== false)
-            return;
-        const interval = globalThis.setInterval(() => {
-            if (codexLoginRecheckPending)
-                return;
-            void handleRecheckCodexLogin();
-        }, 2000);
-        return () => globalThis.clearInterval(interval);
-    }, [
-        codexAutoRecheckActive,
-        codexLoginRecheckPending,
-        codexWorkspaceLoggedIn,
-        handleRecheckCodexLogin,
-        showCodexLoginOverlay,
-    ]);
-    useEffect(() => {
-        if (!open)
-            return;
-        if (!onClose)
-            return;
-        const handler = (event) => {
-            if (event.key === "Escape") {
-                onClose();
-            }
-        };
-        globalThis.addEventListener("keydown", handler);
-        return () => globalThis.removeEventListener("keydown", handler);
-    }, [onClose, open]);
-    if (!open)
-        return null;
-    return (React.createElement("aside", { className: "workbench-drawer-docked", role: "dialog" },
-        React.createElement(Accordion, { allowMultiple: true, className: "workbench-accordion equal-open", items: [
-                ...(chatAccordionEnabled
-                    ? [{
-                            id: "workbench-chat",
-                            title: (React.createElement("div", { className: "workbench-accordion-title" },
-                                chatHistory.length > 0 && (React.createElement("span", { role: "button", tabIndex: 0, className: "workbench-chat-history-toggle", onClick: (event) => {
-                                        event.preventDefault();
-                                        event.stopPropagation();
-                                        setChatHistoryOpen((prev) => !prev);
-                                    }, onKeyDown: (event) => {
-                                        if (event.key !== "Enter" && event.key !== " ")
-                                            return;
-                                        event.preventDefault();
-                                        event.stopPropagation();
-                                        setChatHistoryOpen((prev) => !prev);
-                                    }, "aria-label": chatHistoryOpen
-                                        ? "Hide chat history"
-                                        : "Show chat history" },
-                                    React.createElement(Icon, { name: "chevronDown", size: 12, className: "workbench-chat-history-arrow" }))),
-                                React.createElement("span", null, "Chat"),
-                                React.createElement(Badge, { status: run.status }, runStatusLabel))),
-                            defaultOpen: true,
-                            contentClassName: "workbench-chat-content",
-                            headerActions: (React.createElement("div", { className: "workbench-chat-header-actions gds-accordion-open-only" },
-                                React.createElement("label", { className: "workbench-provider-select-label" },
-                                    React.createElement("div", { className: "workbench-provider-select", onClick: (event) => event.stopPropagation(), onMouseDown: (event) => event.stopPropagation(), onKeyDown: (event) => event.stopPropagation() },
-                                        React.createElement(Listbox, { value: buildChatProvider, onChange: (value) => setBuildChatProvider(value), options: buildProviderOptions, disabled: chatSending || run.status === "running", size: "small", popoverMatchTriggerWidth: false, popoverMinWidth: 200, popoverAlign: "right" }))),
-                                React.createElement(Button, { variant: "secondary", size: "small", onClick: (event) => {
-                                        event.stopPropagation();
-                                        resetChat().then(() => {
-                                            loadChatHistory().catch(() => { });
-                                        });
-                                    }, disabled: chatSending || run.status === "running" }, "New chat"))),
-                            content: (React.createElement("div", { className: "workbench-chat-panel" },
-                                React.createElement("div", { className: "workbench-chat-overlay" },
-                                    React.createElement("div", { className: "workbench-chat-history" },
-                                        chatHistoryLoading && (React.createElement(Callout, null, "Loading chat history\u2026")),
-                                        chatHistoryError && (React.createElement("div", { className: "error" }, chatHistoryError)),
-                                        !chatHistoryLoading &&
-                                            !chatHistoryError &&
-                                            chatHistory.length === 0 && (React.createElement(Callout, null, "No previous chats yet.")),
-                                        !chatHistoryLoading &&
-                                            !chatHistoryError &&
-                                            chatHistory.length > 0 && (React.createElement(List, { className: "workbench-chat-history-list" }, chatHistory.map((entry) => {
-                                            const timestamp = entry.updatedAt ??
-                                                entry.startedAt;
-                                            const label = timestamp
-                                                ? formatTimestampShort(timestamp)
-                                                : "Unknown date";
-                                            return (React.createElement("button", { key: entry.id, type: "button", className: "workbench-chat-history-row gds-list-item-button", onClick: () => {
-                                                    setChatHistoryOpen(false);
-                                                    loadChat(entry.id).catch(() => { });
-                                                } },
-                                                React.createElement(ListItem, { title: `Chat - ${label}` })));
-                                        })))),
-                                    React.createElement("div", { className: `workbench-chat-current${chatHistoryOpen ? " is-history" : ""}` },
-                                        React.createElement(ProviderLoginPanel, { key: `${sessionId ?? "sessionless"}:${buildChatProvider}`, open: open, buildChatProvider: buildChatProvider, workspaceId: (sessionId ?? run.id) || undefined }),
-                                        showCodexLoginOverlay && (React.createElement(CodexLoginRequiredOverlay, { codexWorkspaceLoggedIn: codexWorkspaceLoggedIn, codexLoginCommand: codexLoginCommand, copiedCodexLoginCommand: copiedCodexLoginCommand, showCodexLoginRecheck: showCodexLoginRecheck, codexLoginRecheckPending: codexLoginRecheckPending, codexLoginStatusText: codexLoginStatusText, codexLoginError: codexLoginError, onCopyCodexLoginCommand: handleCopyCodexLoginCommand, onRecheckCodexLogin: () => {
-                                                void handleRecheckCodexLogin();
-                                            }, onDismiss: () => {
-                                                dispatchCodexOverlay({ type: "dismiss_overlay" });
-                                            } })),
-                                        React.createElement(Chat, { composerChips: composerChips, onComposerChipsChange: onComposerChipsChange }))))),
-                        }]
-                    : []),
-                {
-                    id: "workbench-ratings",
-                    title: "Ratings & flags",
-                    defaultOpen: false,
-                    content: (React.createElement("div", { className: "workbench-ratings" },
-                        showCopyStatePath && handleCopyStatePath && (React.createElement(React.Fragment, null,
-                            React.createElement(Button, { variant: "secondary", onClick: handleCopyStatePath },
-                                React.createElement(Icon, { name: copiedStatePath ? "copied" : "copy", size: 14 }),
-                                copiedStatePath ? "Copied" : "Copy state path"),
-                            React.createElement("p", { className: "workbench-button-meta" }, "Paste this in your coding assistant to debug the agent."))),
-                        loading && React.createElement(Callout, null, "Loading ratings and flags\u2026"),
-                        error && React.createElement("div", { className: "error" }, error),
-                        !loading &&
-                            !error &&
-                            resolvedFeedbackItems.length === 0 &&
-                            resolvedGradingFlags.length === 0 && (React.createElement(Callout, null, "No ratings or flags yet.")),
-                        resolvedFeedbackItems.length > 0 && (React.createElement("div", { className: "workbench-summary-list" }, resolvedFeedbackItems.map(({ entry, message, role }) => {
-                            const ratingChip = buildRatingChip(entry);
-                            const inChat = composerChipIds.has(ratingChip.chipId);
-                            const roleLabel = role === "assistant"
-                                ? "Assistant message"
-                                : "Scenario message";
-                            const displayScore = entry.score;
-                            const scoreLabel = displayScore > 0
-                                ? `+${displayScore}`
-                                : displayScore;
-                            const scoreClass = getScoreClass(displayScore);
-                            return (React.createElement("div", { key: `${entry.id}-${entry.messageRefId}`, className: "workbench-summary-card" },
-                                React.createElement("div", { className: "workbench-summary-title", title: entry.createdAt &&
-                                        formatTimestampShort(entry.createdAt) }, roleLabel),
-                                React.createElement("div", { className: "workbench-summary-score-row" },
-                                    React.createElement("div", { className: `workbench-score-badge workbench-score-badge--small ${scoreClass}` }, scoreLabel),
-                                    entry.reason && (React.createElement(ScrollingText, { as: "div", text: entry.reason, className: "workbench-summary-reason" }))),
-                                message?.content && (React.createElement(ScrollingText, { as: "div", text: formatSnippet(message.content), className: "workbench-summary-meta" })),
-                                React.createElement("div", { className: "workbench-summary-actions" },
-                                    React.createElement(Button, { variant: "secondary", size: "small", onClick: () => inChat
-                                            ? removeComposerChip(ratingChip.chipId)
-                                            : addComposerChip(ratingChip), disabled: !onComposerChipsChange }, inChat ? "Remove from chat" : "Add to chat"))));
-                        }))),
-                        resolvedGradingFlags.length > 0 && (React.createElement("div", { className: "workbench-summary-list" }, resolvedGradingFlags.map((flag) => {
-                            const flagChip = buildFlagChip(flag);
-                            const inChat = composerChipIds.has(flagChip.chipId);
-                            const runLabel = flag.runId
-                                ? resolvedRunLabelById.get(flag.runId)
-                                : undefined;
-                            const flaggedItem = resolvedRunItemByRefId.get(flag.refId);
-                            const turnLabel = flaggedItem?.turnNumber
-                                ? `Assistant turn ${flaggedItem.turnNumber}`
-                                : undefined;
-                            const gradedAssistant = extractTurnContext(flaggedItem?.input).gradedAssistant;
-                            return (React.createElement("div", { key: flag.id, className: "workbench-summary-card workbench-flag-card" },
-                                React.createElement("div", { className: "workbench-summary-title" }, "Grader flag"),
-                                (runLabel || turnLabel)
-                                    ? (React.createElement("div", { className: "workbench-summary-subtitle", title: flag.createdAt &&
-                                            formatTimestampShort(flag.createdAt) },
-                                        runLabel,
-                                        runLabel && turnLabel && " • ",
-                                        turnLabel))
-                                    : "Flagged grader",
-                                React.createElement("div", { className: "workbench-summary-score-row" },
-                                    React.createElement("div", { className: "workbench-score-badge workbench-score-badge--small" },
-                                        React.createElement(Icon, { name: "flag", size: 10 })),
-                                    flag.reason && (React.createElement(ScrollingText, { as: "div", text: flag.reason, className: "workbench-summary-reason" }))),
-                                gradedAssistant && (React.createElement(ScrollingText, { as: "div", text: formatSnippet(gradedAssistant), className: "workbench-summary-meta" })),
-                                React.createElement("div", { className: "workbench-summary-actions" },
-                                    React.createElement(Button, { variant: "secondary", size: "small", onClick: () => inChat
-                                            ? removeComposerChip(flagChip.chipId)
-                                            : addComposerChip(flagChip), disabled: !onComposerChipsChange }, inChat ? "Remove from chat" : "Add to chat"))));
-                        }))))),
-                },
-            ] })));
-}