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

package/esm/simulator-ui/isograph/components/Query/SimulatorVerifyPage.d.ts

@@ -0,0 +1,3 @@
+export declare const SimulatorVerifyPage: (data: import("../../../__generated__/__isograph/Workspace/VerifyTab/param_type.js").Workspace__VerifyTab__param, componentProps: Record<PropertyKey, never>) => import("react").JSX.Element;
+export default SimulatorVerifyPage;
+//# sourceMappingURL=SimulatorVerifyPage.d.ts.map

package/esm/simulator-ui/isograph/components/Query/SimulatorVerifyPage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SimulatorVerifyPage.d.ts","sourceRoot":"","sources":["../../../../../src/simulator-ui/isograph/components/Query/SimulatorVerifyPage.tsx"],"names":[],"mappings":"AAgHA,eAAO,MAAM,mBAAmB,8LA6sB9B,CAAC;AAEH,eAAe,mBAAmB,CAAC"}

package/esm/simulator-ui/isograph/components/Query/SimulatorVerifyPage.js

@@ -0,0 +1,531 @@
+import { iso } from "../../../__generated__/__isograph/iso.js";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { buildWorkspacePath } from "../../../../src/workspace_routes.js";
+import gambitWorkspaceVerifyBatchRunCreateMutation from "../../../mutations/GambitWorkspaceVerifyBatchRunCreateMutation.js";
+import gambitWorkspaceVerifyLiveSubscription from "../../../subscriptions/GambitWorkspaceVerifyLiveSubscription.js";
+import { useGambitTypedMutation } from "../../../src/hooks/useGambitTypedMutation.js";
+import { useGambitTypedSubscription } from "../../../src/hooks/useGambitTypedSubscription.js";
+import { useRouter } from "../../../src/RouterContext.js";
+import Badge from "../../../src/gds/Badge.js";
+import Button from "../../../src/gds/Button.js";
+import Callout from "../../../src/gds/Callout.js";
+import Listbox from "../../../src/gds/Listbox.js";
+import PageGrid from "../../../src/gds/PageGrid.js";
+import PageShell from "../../../src/gds/PageShell.js";
+import Panel from "../../../src/gds/Panel.js";
+import { classNames, formatTimestampShort, scenarioNameFromValue, } from "../../../src/utils.js";
+import { VERIFY_CONSISTENCY_THRESHOLDS } from "../../../src/verify_metrics.js";
+const MAX_BATCH_SIZE = 24;
+const MAX_BATCH_CONCURRENCY = 6;
+const DEFAULT_BATCH_SIZE = 8;
+const DEFAULT_BATCH_CONCURRENCY = 3;
+const NO_SCENARIO_RUN_VALUE = "__workspace_context__";
+function getRoutePrefix(path) {
+    return path === "/isograph" || path.startsWith("/isograph/")
+        ? "/isograph"
+        : "";
+}
+function toBatchStatus(status) {
+    const normalized = (status ?? "").trim().toUpperCase();
+    if (normalized === "RUNNING")
+        return "running";
+    if (normalized === "COMPLETED")
+        return "completed";
+    if (normalized === "ERROR")
+        return "error";
+    return "idle";
+}
+function toBatchRequestStatus(status) {
+    const normalized = (status ?? "").trim().toUpperCase();
+    if (normalized === "RUNNING")
+        return "running";
+    if (normalized === "COMPLETED")
+        return "completed";
+    if (normalized === "ERROR")
+        return "error";
+    return "queued";
+}
+function clampInt(value, min, max) {
+    const rounded = Number.isFinite(value) ? Math.round(value) : min;
+    return Math.max(min, Math.min(max, rounded));
+}
+export const SimulatorVerifyPage = iso(`
+  field Workspace.VerifyTab @component {
+    id
+    scenarioRuns(first: 50) {
+      edges {
+        node {
+          id
+          status
+          startedAt
+          finishedAt
+          error
+        }
+      }
+    }
+    verification {
+      graderDecks(first: 50) {
+        edges {
+          node {
+            id
+            label
+            description
+            path
+          }
+        }
+      }
+      batches(first: 50) {
+        edges {
+          node {
+            id
+            workspaceId
+            graderId
+            scenarioRunId
+            status
+            startedAt
+            finishedAt
+            requested
+            active
+            completed
+            failed
+            requests(first: 50) {
+              edges {
+                node {
+                  id
+                  status
+                  runId
+                  error
+                }
+              }
+            }
+            metrics {
+              sampleSize
+              agreementRate
+              scoreSpreadMin
+              scoreSpreadMedian
+              scoreSpreadMax
+              instabilityCount
+              verdict
+              verdictReason
+              outliers(first: 25) {
+                edges {
+                  node {
+                    key
+                    label
+                    sampleSize
+                    agreementRate
+                    scoreDelta
+                    passFlip
+                    instability
+                    minRunId
+                    maxRunId
+                    turnIndex
+                    messageRefId
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`)(function SimulatorVerifyPage({ data }) {
+    const workspaceId = data.id ?? "";
+    const { currentRoutePath, navigate } = useRouter();
+    const routePrefix = useMemo(() => getRoutePrefix(currentRoutePath), [
+        currentRoutePath,
+    ]);
+    const toPrefixedPath = useCallback((path) => `${routePrefix}${path}`, [routePrefix]);
+    const runBatchMutation = useGambitTypedMutation(gambitWorkspaceVerifyBatchRunCreateMutation);
+    useGambitTypedSubscription(gambitWorkspaceVerifyLiveSubscription, workspaceId ? { workspaceId } : null);
+    const graders = useMemo(() => (data.verification?.graderDecks?.edges ?? []).flatMap((edge) => {
+        const grader = edge?.node;
+        if (!grader?.id || !grader.label)
+            return [];
+        return [{
+                id: grader.id,
+                label: grader.label,
+                description: grader.description ?? null,
+                path: grader.path ?? "",
+            }];
+    }), [data.verification?.graderDecks?.edges]);
+    const scenarioRuns = useMemo(() => (data.scenarioRuns?.edges ?? []).flatMap((edge) => {
+        const run = edge?.node;
+        if (!run?.id)
+            return [];
+        return [{
+                id: run.id,
+                status: toBatchStatus(run.status),
+                startedAt: run.startedAt ?? null,
+                finishedAt: run.finishedAt ?? null,
+                error: run.error ?? null,
+            }];
+    }).sort((left, right) => {
+        const leftKey = left.finishedAt ?? left.startedAt ?? left.id;
+        const rightKey = right.finishedAt ?? right.startedAt ?? right.id;
+        return rightKey.localeCompare(leftKey);
+    }), [data.scenarioRuns?.edges]);
+    const batches = useMemo(() => (data.verification?.batches?.edges ?? []).flatMap((edge) => {
+        const batch = edge?.node;
+        if (!batch?.id || !batch.graderId)
+            return [];
+        return [{
+                id: batch.id,
+                graderId: batch.graderId,
+                scenarioRunId: batch.scenarioRunId ?? null,
+                status: toBatchStatus(batch.status),
+                startedAt: batch.startedAt ?? null,
+                finishedAt: batch.finishedAt ?? null,
+                requested: batch.requested ?? 0,
+                active: batch.active ?? 0,
+                completed: batch.completed ?? 0,
+                failed: batch.failed ?? 0,
+                requests: (batch.requests?.edges ?? []).flatMap((requestEdge) => {
+                    const request = requestEdge?.node;
+                    if (!request?.id)
+                        return [];
+                    return [{
+                            id: request.id,
+                            status: toBatchRequestStatus(request.status),
+                            runId: request.runId ?? undefined,
+                            error: request.error ?? undefined,
+                        }];
+                }),
+                metrics: batch.metrics
+                    ? {
+                        sampleSize: batch.metrics.sampleSize ?? 0,
+                        agreementRate: typeof batch.metrics.agreementRate === "number"
+                            ? batch.metrics.agreementRate
+                            : null,
+                        scoreSpreadMin: typeof batch.metrics.scoreSpreadMin === "number"
+                            ? batch.metrics.scoreSpreadMin
+                            : null,
+                        scoreSpreadMedian: typeof batch.metrics.scoreSpreadMedian === "number"
+                            ? batch.metrics.scoreSpreadMedian
+                            : null,
+                        scoreSpreadMax: typeof batch.metrics.scoreSpreadMax === "number"
+                            ? batch.metrics.scoreSpreadMax
+                            : null,
+                        instabilityCount: batch.metrics.instabilityCount ?? 0,
+                        verdict: batch.metrics.verdict === "PASS" ||
+                            batch.metrics.verdict === "WARN" ||
+                            batch.metrics.verdict === "FAIL"
+                            ? batch.metrics.verdict
+                            : "WARN",
+                        verdictReason: batch.metrics.verdictReason ??
+                            "Verify batch completed.",
+                        outliers: (batch.metrics.outliers?.edges ?? []).flatMap((outlierEdge) => {
+                            const outlier = outlierEdge?.node;
+                            if (!outlier?.key || !outlier.label)
+                                return [];
+                            return [{
+                                    key: outlier.key,
+                                    label: outlier.label,
+                                    sampleSize: outlier.sampleSize ?? 0,
+                                    agreementRate: typeof outlier.agreementRate === "number"
+                                        ? outlier.agreementRate
+                                        : null,
+                                    scoreDelta: typeof outlier.scoreDelta === "number"
+                                        ? outlier.scoreDelta
+                                        : null,
+                                    passFlip: Boolean(outlier.passFlip),
+                                    instability: Boolean(outlier.instability),
+                                    minRunId: outlier.minRunId ?? undefined,
+                                    maxRunId: outlier.maxRunId ?? undefined,
+                                    turnIndex: typeof outlier.turnIndex === "number"
+                                        ? outlier.turnIndex
+                                        : undefined,
+                                    messageRefId: outlier.messageRefId ?? undefined,
+                                }];
+                        }),
+                    }
+                    : null,
+            }];
+    }), [data.verification?.batches?.edges]);
+    const [selectedScenarioRunId, setSelectedScenarioRunId] = useState(null);
+    const [selectedGraderId, setSelectedGraderId] = useState(null);
+    const [selectedBatchId, setSelectedBatchId] = useState(null);
+    const [batchSize, setBatchSize] = useState(DEFAULT_BATCH_SIZE);
+    const [batchConcurrency, setBatchConcurrency] = useState(DEFAULT_BATCH_CONCURRENCY);
+    const [mutationError, setMutationError] = useState(null);
+    useEffect(() => {
+        if (selectedGraderId &&
+            graders.some((grader) => grader.id === selectedGraderId)) {
+            return;
+        }
+        setSelectedGraderId(graders[0]?.id ?? null);
+    }, [graders, selectedGraderId]);
+    useEffect(() => {
+        if (selectedScenarioRunId &&
+            scenarioRuns.some((scenarioRun) => scenarioRun.id === selectedScenarioRunId)) {
+            return;
+        }
+        setSelectedScenarioRunId(scenarioRuns[0]?.id ?? null);
+    }, [scenarioRuns, selectedScenarioRunId]);
+    const filteredBatches = useMemo(() => {
+        return batches.filter((batch) => {
+            if (selectedGraderId && batch.graderId !== selectedGraderId)
+                return false;
+            if (selectedScenarioRunId && batch.scenarioRunId !== selectedScenarioRunId) {
+                return false;
+            }
+            return true;
+        });
+    }, [batches, selectedGraderId, selectedScenarioRunId]);
+    const visibleBatches = filteredBatches.length > 0 ? filteredBatches : batches;
+    useEffect(() => {
+        if (selectedBatchId &&
+            visibleBatches.some((batch) => batch.id === selectedBatchId)) {
+            return;
+        }
+        setSelectedBatchId(visibleBatches[0]?.id ?? null);
+    }, [selectedBatchId, visibleBatches]);
+    const selectedBatch = useMemo(() => {
+        if (selectedBatchId) {
+            const selected = visibleBatches.find((batch) => batch.id === selectedBatchId);
+            if (selected)
+                return selected;
+        }
+        return visibleBatches[0] ?? null;
+    }, [selectedBatchId, visibleBatches]);
+    const selectedGrader = useMemo(() => graders.find((grader) => grader.id === selectedGraderId) ?? null, [graders, selectedGraderId]);
+    const queuedCount = useMemo(() => (selectedBatch?.requests ?? []).filter((request) => request.status === "queued")
+        .length, [selectedBatch?.requests]);
+    const metrics = selectedBatch?.metrics ?? null;
+    const topOutliers = (metrics?.outliers ?? []).slice(0, 8);
+    const hasRunningBatch = visibleBatches.some((batch) => batch.status === "running");
+    const canRun = Boolean(workspaceId && selectedGraderId && !runBatchMutation.inFlight &&
+        !hasRunningBatch);
+    const runBatch = useCallback(() => {
+        if (!workspaceId || !selectedGraderId)
+            return;
+        setMutationError(null);
+        const nextBatchSize = clampInt(batchSize, 1, MAX_BATCH_SIZE);
+        const nextConcurrency = clampInt(batchConcurrency, 1, Math.min(MAX_BATCH_CONCURRENCY, nextBatchSize));
+        runBatchMutation.commit({
+            input: {
+                workspaceId,
+                graderId: selectedGraderId,
+                ...(selectedScenarioRunId
+                    ? { scenarioRunId: selectedScenarioRunId }
+                    : {}),
+                batchSize: nextBatchSize,
+                concurrency: nextConcurrency,
+            },
+        }, {
+            onComplete: (result) => {
+                const nextBatchId = result
+                    ?.batch?.id ?? null;
+                if (nextBatchId) {
+                    setSelectedBatchId(nextBatchId);
+                }
+            },
+            onError: () => {
+                setMutationError("Failed to run verify batch.");
+            },
+        });
+    }, [
+        batchConcurrency,
+        batchSize,
+        runBatchMutation,
+        selectedGraderId,
+        selectedScenarioRunId,
+        workspaceId,
+    ]);
+    const navigateToGradeRun = useCallback((runId) => {
+        const gradePath = buildWorkspacePath("grade", workspaceId, { runId });
+        navigate(toPrefixedPath(gradePath));
+    }, [navigate, toPrefixedPath, workspaceId]);
+    const scenarioOptions = useMemo(() => [
+        {
+            value: NO_SCENARIO_RUN_VALUE,
+            label: "Current workspace context",
+            meta: "Run without a prior scenario run binding",
+        },
+        ...scenarioRuns.map((run) => ({
+            value: run.id,
+            label: scenarioNameFromValue(run.id) ?? run.id,
+            meta: [
+                run.status,
+                run.finishedAt ?? run.startedAt,
+            ].filter(Boolean).join(" · "),
+        })),
+    ], [scenarioRuns]);
+    return (React.createElement(PageShell, { className: "verify-shell" },
+        React.createElement(PageGrid, { as: "main", className: "verify-layout" },
+            React.createElement(Panel, { className: "verify-controls", "data-testid": "verify-tab-scaffold" },
+                React.createElement("div", { className: "verify-controls-header" },
+                    React.createElement("strong", null, "Verify consistency"),
+                    React.createElement("span", { className: "secondary-note" }, "Run repeated grading checks against one grader and scenario.")),
+                scenarioRuns.length > 0 && (React.createElement(Listbox, { label: "Scenario run", value: selectedScenarioRunId ?? NO_SCENARIO_RUN_VALUE, onChange: (runId) => {
+                        setSelectedScenarioRunId(runId === NO_SCENARIO_RUN_VALUE ? null : runId);
+                    }, options: scenarioOptions, placeholder: "Select scenario run" })),
+                React.createElement(Listbox, { label: "Grader", value: selectedGraderId ?? "", onChange: (value) => setSelectedGraderId(value.length ? value : null), options: graders.map((grader) => ({
+                        value: grader.id,
+                        label: grader.label,
+                        meta: grader.path,
+                    })), placeholder: "Select grader", disabled: graders.length === 0 }),
+                React.createElement("div", { className: "verify-number-grid" },
+                    React.createElement("label", { className: "verify-number-field" },
+                        "Batch size",
+                        React.createElement("input", { type: "number", min: 1, max: MAX_BATCH_SIZE, value: batchSize, onChange: (event) => setBatchSize(clampInt(Number(event.target.value), 1, MAX_BATCH_SIZE)) })),
+                    React.createElement("label", { className: "verify-number-field" },
+                        "Concurrency",
+                        React.createElement("input", { type: "number", min: 1, max: MAX_BATCH_CONCURRENCY, value: batchConcurrency, onChange: (event) => setBatchConcurrency(clampInt(Number(event.target.value), 1, MAX_BATCH_CONCURRENCY)) }))),
+                React.createElement(Button, { "data-testid": "verify-run-batch", variant: "primary", onClick: runBatch, disabled: !canRun }, hasRunningBatch || runBatchMutation.inFlight
+                    ? "Running consistency batch…"
+                    : "Run consistency batch"),
+                graders.length === 0 && (React.createElement(Callout, null,
+                    "No graders are available. Add ",
+                    React.createElement("code", null, "[[graders]]"),
+                    " ",
+                    "entries to the active root deck.")),
+                selectedGrader?.description && (React.createElement(Callout, null, selectedGrader.description)),
+                React.createElement(Callout, { variant: "emphasis", title: "Build assistant stays available" }, "Use the chat drawer toggle in the top-right corner to investigate and iterate while this page remains open.")),
+            React.createElement(Panel, { className: "verify-results", "data-testid": "verify-results" },
+                mutationError && React.createElement("div", { className: "error" }, mutationError),
+                React.createElement("div", { className: "verify-status-row" },
+                    React.createElement("div", { className: "verify-status-main" },
+                        React.createElement("strong", null, "Batch status"),
+                        React.createElement("div", { className: "verify-status-meta" },
+                            React.createElement(Badge, { status: selectedBatch?.status ?? "idle" }, selectedBatch?.status ?? "idle"),
+                            selectedBatch?.startedAt
+                                ? ` · started ${formatTimestampShort(selectedBatch.startedAt)}`
+                                : "",
+                            selectedBatch?.finishedAt
+                                ? ` · finished ${formatTimestampShort(selectedBatch.finishedAt)}`
+                                : "")),
+                    metrics && metrics.sampleSize > 0 && (React.createElement("span", { className: classNames("verify-verdict-badge", `verify-verdict-badge--${metrics.verdict.toLowerCase()}`) }, metrics.verdict))),
+                selectedBatch && selectedBatch.requested > 0 && (React.createElement("div", { className: "verify-progress-row" },
+                    React.createElement("span", null,
+                        "Queued: ",
+                        queuedCount),
+                    React.createElement("span", null,
+                        "Running: ",
+                        selectedBatch.active),
+                    React.createElement("span", null,
+                        "Completed: ",
+                        selectedBatch.completed),
+                    React.createElement("span", null,
+                        "Failed: ",
+                        selectedBatch.failed))),
+                !selectedBatch && (React.createElement(Callout, null, "Run a consistency batch to compute agreement, spread, and instability for the selected grader.")),
+                metrics && metrics.sampleSize > 0 && (React.createElement(React.Fragment, null,
+                    React.createElement("div", { className: "verify-metric-grid" },
+                        React.createElement("div", { className: "verify-metric-card" },
+                            React.createElement("div", { className: "verify-metric-label" }, "Sample size"),
+                            React.createElement("div", { className: "verify-metric-value" }, metrics.sampleSize)),
+                        React.createElement("div", { className: "verify-metric-card" },
+                            React.createElement("div", { className: "verify-metric-label" }, "Agreement rate"),
+                            React.createElement("div", { className: "verify-metric-value" }, metrics.agreementRate === null
+                                ? "—"
+                                : `${Math.round(metrics.agreementRate * 100)}%`)),
+                        React.createElement("div", { className: "verify-metric-card" },
+                            React.createElement("div", { className: "verify-metric-label" }, "Score spread (min/median/max)"),
+                            React.createElement("div", { className: "verify-metric-value verify-metric-value--compact" }, metrics.scoreSpreadMin === null
+                                ? "—"
+                                : `${metrics.scoreSpreadMin} / ${metrics.scoreSpreadMedian ?? "—"} / ${metrics.scoreSpreadMax ?? "—"}`)),
+                        React.createElement("div", { className: "verify-metric-card" },
+                            React.createElement("div", { className: "verify-metric-label" }, "Instability count"),
+                            React.createElement("div", { className: "verify-metric-value" }, metrics.instabilityCount))),
+                    React.createElement(Callout, { variant: metrics.verdict === "FAIL"
+                            ? "danger"
+                            : metrics.verdict === "WARN"
+                                ? "emphasis"
+                                : "muted", title: `Verdict: ${metrics.verdict}` }, metrics.verdictReason))),
+                React.createElement(Callout, { title: "Thresholds in code" },
+                    "Min sample size: ",
+                    VERIFY_CONSISTENCY_THRESHOLDS.minSampleSize,
+                    " ",
+                    "\u00B7 PASS requires agreement \u2265 ",
+                    Math.round(VERIFY_CONSISTENCY_THRESHOLDS.pass.agreementMin * 100),
+                    "%, spread \u2264",
+                    " ",
+                    VERIFY_CONSISTENCY_THRESHOLDS.pass.maxSpread,
+                    ", instability \u2264",
+                    " ",
+                    VERIFY_CONSISTENCY_THRESHOLDS.pass.maxInstabilityCount,
+                    " ",
+                    "\u00B7 WARN allows agreement \u2265 ",
+                    Math.round(VERIFY_CONSISTENCY_THRESHOLDS.warn.agreementMin * 100),
+                    "%, spread \u2264",
+                    " ",
+                    VERIFY_CONSISTENCY_THRESHOLDS.warn.maxSpread,
+                    ", instability \u2264",
+                    " ",
+                    VERIFY_CONSISTENCY_THRESHOLDS.warn.maxInstabilityCount,
+                    "."),
+                React.createElement("div", { className: "verify-section" },
+                    React.createElement("strong", null, "Most inconsistent examples"),
+                    topOutliers.length === 0
+                        ? (React.createElement(Callout, null, "Inconsistent examples will appear here as soon as at least one completed run is available in this batch."))
+                        : (React.createElement("div", { className: "verify-outlier-list" }, topOutliers.map((outlier) => {
+                            const runLinks = [outlier.maxRunId, outlier.minRunId]
+                                .filter((value) => Boolean(value));
+                            const uniqueRunLinks = [...new Set(runLinks)];
+                            return (React.createElement("div", { key: outlier.key, className: "verify-outlier-card" },
+                                React.createElement("div", { className: "verify-outlier-header" },
+                                    React.createElement("strong", null, outlier.label),
+                                    React.createElement(Badge, { variant: outlier.instability
+                                            ? "error"
+                                            : "completed" }, outlier.instability ? "Unstable" : "Stable")),
+                                React.createElement("div", { className: "verify-outlier-meta" },
+                                    "agreement ",
+                                    outlier.agreementRate === null
+                                        ? "—"
+                                        : `${Math.round(outlier.agreementRate * 100)}%`,
+                                    " ",
+                                    "\u00B7 delta ",
+                                    outlier.scoreDelta ?? "—",
+                                    " \u00B7 samples",
+                                    " ",
+                                    outlier.sampleSize,
+                                    outlier.passFlip ? " · pass/fail flip" : "",
+                                    outlier.messageRefId
+                                        ? ` · ref ${outlier.messageRefId}`
+                                        : ""),
+                                uniqueRunLinks.length > 0 && (React.createElement("div", { className: "verify-outlier-links" }, uniqueRunLinks.map((runId) => (React.createElement("a", { key: runId, href: toPrefixedPath(buildWorkspacePath("grade", workspaceId, {
+                                        runId,
+                                    })), onClick: (event) => {
+                                        event.preventDefault();
+                                        navigateToGradeRun(runId);
+                                    } },
+                                    "Open grade run ",
+                                    runId)))))));
+                        })))),
+                visibleBatches.length > 0 && (React.createElement("div", { className: "verify-section" },
+                    React.createElement("strong", null, "Batch history"),
+                    React.createElement("ul", { className: "verify-request-list" }, visibleBatches.slice(0, 15).map((batch, index) => (React.createElement("li", { key: batch.id, className: "verify-request-row" },
+                        React.createElement("span", { className: "verify-request-index" },
+                            "#",
+                            index + 1),
+                        React.createElement(Badge, { status: batch.status }, batch.status),
+                        React.createElement("button", { type: "button", className: "link-button", onClick: () => setSelectedBatchId(batch.id) }, batch.id),
+                        React.createElement("span", { className: "secondary-note" },
+                            batch.completed,
+                            "/",
+                            batch.requested,
+                            " complete"))))))),
+                selectedBatch?.requests.length
+                    ? (React.createElement("div", { className: "verify-section" },
+                        React.createElement("strong", null, "Batch requests"),
+                        React.createElement("ul", { className: "verify-request-list" }, selectedBatch.requests.map((request, index) => (React.createElement("li", { key: request.id, className: "verify-request-row" },
+                            React.createElement("span", { className: "verify-request-index" },
+                                "#",
+                                index + 1),
+                            React.createElement(Badge, { status: request.status === "queued"
+                                    ? "idle"
+                                    : request.status }, request.status),
+                            request.runId
+                                ? (React.createElement("a", { href: toPrefixedPath(buildWorkspacePath("grade", workspaceId, {
+                                        runId: request.runId,
+                                    })), onClick: (event) => {
+                                        event.preventDefault();
+                                        navigateToGradeRun(request.runId);
+                                    } }, request.runId))
+                                : null,
+                            request.error && (React.createElement("span", { className: "verify-request-error" }, request.error))))))))
+                    : null))));
+});
+export default SimulatorVerifyPage;

package/esm/simulator-ui/isograph/components/Query/SimulatorWorkspacesPage.d.ts

@@ -0,0 +1,3 @@
+export declare const SimulatorWorkspacesPage: (data: import("../../../__generated__/__isograph/Query/SimulatorWorkspacesPage/param_type.js").Query__SimulatorWorkspacesPage__param, componentProps: Record<PropertyKey, never>) => import("react").JSX.Element;
+export default SimulatorWorkspacesPage;
+//# sourceMappingURL=SimulatorWorkspacesPage.d.ts.map

package/esm/simulator-ui/isograph/components/Query/SimulatorWorkspacesPage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SimulatorWorkspacesPage.d.ts","sourceRoot":"","sources":["../../../../../src/simulator-ui/isograph/components/Query/SimulatorWorkspacesPage.tsx"],"names":[],"mappings":"AAUA,eAAO,MAAM,uBAAuB,kNAqFlC,CAAC;AAEH,eAAe,uBAAuB,CAAC"}

package/esm/simulator-ui/isograph/components/Query/SimulatorWorkspacesPage.js

@@ -0,0 +1,64 @@
+import { iso } from "../../../__generated__/__isograph/iso.js";
+import { buildWorkspacePath } from "../../../../src/workspace_routes.js";
+import { GambitLogo } from "../../../src/GambitLogo.js";
+import { useRouter } from "../../../src/RouterContext.js";
+import List from "../../../src/gds/List.js";
+import ListItem from "../../../src/gds/ListItem.js";
+import Panel from "../../../src/gds/Panel.js";
+import { formatTimestamp } from "../../../src/utils.js";
+export const SimulatorWorkspacesPage = iso(`
+  field Query.SimulatorWorkspacesPage @component {
+    gambitWorkspaces(first: 200) {
+      edges {
+        node {
+          id
+          deck
+          deckSlug
+          testBotName
+          createdAt
+          sessionDir
+          statePath
+        }
+      }
+    }
+  }
+`)(function SimulatorWorkspacesPage({ data }) {
+    const { currentRoutePath, navigate } = useRouter();
+    const routePrefix = currentRoutePath === "/isograph" ||
+        currentRoutePath.startsWith("/isograph/")
+        ? "/isograph"
+        : "";
+    const workspaces = (data.gambitWorkspaces?.edges ?? [])
+        .flatMap((edge) => {
+        const node = edge?.node;
+        const id = node?.id;
+        if (!id || id.trim().length === 0)
+            return [];
+        return [{
+                id,
+                deck: node.deck ?? undefined,
+                deckSlug: node.deckSlug ?? undefined,
+                testBotName: node.testBotName ?? undefined,
+                createdAt: node.createdAt ?? undefined,
+                sessionDir: node.sessionDir ?? undefined,
+                statePath: node.statePath ?? undefined,
+            }];
+    });
+    return (React.createElement("div", { className: "docs-shell" },
+        React.createElement("section", { className: "docs-hero" },
+            React.createElement("p", { className: "docs-eyebrow" },
+                React.createElement("span", { className: "docs-eyebrow-logo", "aria-label": "Gambit" },
+                    React.createElement(GambitLogo, { height: 11 })),
+                " ",
+                "Simulator"),
+            React.createElement("h1", null, "Workspaces"),
+            React.createElement("p", { className: "docs-subtitle" }, "Open an existing workspace session.")),
+        React.createElement(Panel, { className: "docs-section-card" }, workspaces.length > 0
+            ? (React.createElement(List, null, workspaces.map((workspace) => (React.createElement("button", { key: workspace.id, type: "button", className: "gds-list-item-button", style: { width: "100%", display: "block" }, onClick: () => navigate(`${routePrefix}${buildWorkspacePath("build", workspace.id)}`) },
+                React.createElement(ListItem, { title: workspace.testBotName ??
+                        workspace.deckSlug ??
+                        workspace.deck ??
+                        "workspace", description: formatTimestamp(workspace.createdAt), meta: React.createElement("code", null, workspace.id) }))))))
+            : React.createElement("p", null, "No saved workspaces yet."))));
+});
+export default SimulatorWorkspacesPage;

package/esm/simulator-ui/isograph/components/Workspace/WorkbenchChatDrawer.d.ts

@@ -0,0 +1,5 @@
+export declare const WorkbenchChatDrawer: (data: import("../../../__generated__/__isograph/Workspace/WorkbenchChatDrawer/param_type.js").Workspace__WorkbenchChatDrawer__param, componentProps: {
+    open: boolean;
+}) => import("react").JSX.Element;
+export default WorkbenchChatDrawer;
+//# sourceMappingURL=WorkbenchChatDrawer.d.ts.map

package/esm/simulator-ui/isograph/components/Workspace/WorkbenchChatDrawer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkbenchChatDrawer.d.ts","sourceRoot":"","sources":["../../../../../src/simulator-ui/isograph/components/Workspace/WorkbenchChatDrawer.tsx"],"names":[],"mappings":"AAqBA,eAAO,MAAM,mBAAmB;UAwBkC,OAAO;iCAiQvE,CAAC;AAEH,eAAe,mBAAmB,CAAC"}