@bolt-foundry/gambit 0.8.6-rc.3 → 0.8.6-rc.4

package/esm/src/server/workspace/scenarios.js

@@ -0,0 +1,1052 @@
+import * as dntShim from "../../../_dnt.shims.js";
+import * as path from "../../../deps/jsr.io/@std/path/1.1.4/mod.js";
+import { isGambitEndSignal, isRunCanceledError, runDeck, } from "@bolt-foundry/gambit-core";
+import { sanitizeNumber } from "../../test_bot.js";
+import { cloneValue, deriveInitialFromSchema } from "./schema.js";
+import { applyUserMessageRefSource, buildTestBotSnapshot, stringifyContent, syncTestBotRunFromState, } from "./helpers.js";
+import { resolveWorkerSandboxForSignalAwareRun, runDeckWithFallback, stringifyOutput, } from "./run_deck.js";
+import { isFeedbackEligibleMessageRef, isFeedbackEligiblePersistedTestRunMessageRef, listPersistedTestRunStatuses, listScenarioRunStatusesFromStateMeta, readPersistedTestRunStatusById, } from "./scenario_history.js";
+const DEFAULT_TEST_BOT_SEED_PROMPT = "Start the conversation as the user. Do not wait for the assistant to speak first.";
+const traceCategory = (type) => {
+    switch (type) {
+        case "message.user":
+        case "model.result":
+            return "turn";
+        case "tool.call":
+        case "tool.result":
+            return "tool";
+        case "log":
+        case "monolog":
+            return "status";
+        case "run.start":
+        case "run.end":
+        case "deck.start":
+        case "deck.end":
+        case "action.start":
+        case "action.end":
+        case "model.call":
+            return "lifecycle";
+        default:
+            return "trace";
+    }
+};
+export const createWorkspaceScenarioService = (deps) => {
+    const testBotRuns = new Map();
+    const shouldPersistTestWorkspaceEvent = (payload) => {
+        if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+            return false;
+        }
+        const type = payload.type;
+        return type === "testBotStatus" || type === "gambit.test.status";
+    };
+    const broadcastTestBot = (payload, workspaceId) => {
+        if (workspaceId && shouldPersistTestWorkspaceEvent(payload)) {
+            const state = deps.readSessionState(workspaceId);
+            if (state) {
+                deps.appendWorkspaceEnvelope(state, "test", payload);
+            }
+        }
+        deps.appendDurableStreamEvent(deps.workspaceStreamId, payload);
+        deps.appendDurableStreamEvent(deps.testStreamId, payload);
+    };
+    const findTestRunByWorkspaceId = (workspaceId) => {
+        for (const candidate of testBotRuns.values()) {
+            if (candidate.run.workspaceId === workspaceId ||
+                candidate.run.sessionId === workspaceId) {
+                return candidate;
+            }
+        }
+        return undefined;
+    };
+    const startTestBotRun = (runOpts = {}) => {
+        const botDeckPath = typeof runOpts.botDeckPath === "string"
+            ? runOpts.botDeckPath
+            : undefined;
+        if (!botDeckPath) {
+            throw new Error("Missing scenario deck path");
+        }
+        const defaultMaxTurns = 12;
+        const maxTurns = Math.round(sanitizeNumber(runOpts.maxTurnsOverride ?? defaultMaxTurns, defaultMaxTurns, { min: 1, max: 200 }));
+        const deckInput = runOpts.deckInput;
+        const hasDeckInput = deckInput !== undefined;
+        const botInput = runOpts.botInput;
+        const initialUserMessage = typeof runOpts.initialUserMessage === "string"
+            ? runOpts.initialUserMessage.trim()
+            : "";
+        const botConfigPath = botDeckPath;
+        const testBotName = path.basename(botConfigPath).replace(/\.deck\.(md|ts)$/i, "");
+        const selectedScenarioDeckId = runOpts.botDeckId ?? testBotName;
+        const selectedScenarioDeckLabel = runOpts.botDeckLabel ?? testBotName;
+        const runId = typeof runOpts.runId === "string" &&
+            runOpts.runId.trim().length > 0
+            ? runOpts.runId.trim()
+            : deps.randomId("testbot");
+        const startedAt = new Date().toISOString();
+        const controller = new AbortController();
+        const entry = {
+            run: {
+                id: runId,
+                status: "running",
+                startedAt,
+                maxTurns,
+                messages: [],
+                traces: [],
+                toolInserts: [],
+            },
+            state: null,
+            promise: null,
+            abort: controller,
+        };
+        testBotRuns.set(runId, entry);
+        const run = entry.run;
+        if (runOpts.workspaceId) {
+            run.workspaceId = runOpts.workspaceId;
+            run.sessionId = runOpts.workspaceId;
+        }
+        const emitTestBot = (payload) => broadcastTestBot(payload, run.workspaceId ?? runOpts.workspaceId);
+        if (runOpts.initFill)
+            run.initFill = runOpts.initFill;
+        let savedState = undefined;
+        const openResponsesStartIndex = runOpts.workspaceId
+            ? (deps.readSessionState(runOpts.workspaceId)?.messages?.length ?? 0)
+            : 0;
+        const baseMeta = runOpts.baseMeta ?? {};
+        const workspaceMeta = runOpts.workspaceRecord
+            ? deps.buildWorkspaceMeta(runOpts.workspaceRecord, baseMeta)
+            : baseMeta;
+        let lastCount = 0;
+        const capturedTraces = [];
+        if (runOpts.initFillTrace) {
+            const actionCallId = deps.randomId("initfill");
+            capturedTraces.push({
+                type: "tool.call",
+                runId,
+                actionCallId,
+                name: "gambit_test_bot_init_fill",
+                args: runOpts.initFillTrace.args,
+                toolKind: "internal",
+            }, {
+                type: "tool.result",
+                runId,
+                actionCallId,
+                name: "gambit_test_bot_init_fill",
+                result: runOpts.initFillTrace.result,
+                toolKind: "internal",
+            });
+        }
+        const setWorkspaceId = (state) => {
+            const workspaceId = typeof state?.meta?.workspaceId === "string"
+                ? state.meta.workspaceId
+                : typeof state?.meta?.sessionId === "string"
+                    ? state.meta.sessionId
+                    : undefined;
+            if (workspaceId) {
+                run.workspaceId = workspaceId;
+                run.sessionId = workspaceId;
+            }
+        };
+        const appendFromState = (state) => {
+            const snapshot = buildTestBotSnapshot(state);
+            const rawLength = state.messages?.length ?? 0;
+            const toolCount = snapshot.toolInserts.length;
+            const shouldBroadcast = rawLength !== lastCount ||
+                (run.toolInserts?.length ?? 0) !== toolCount;
+            run.messages = snapshot.messages;
+            run.toolInserts = snapshot.toolInserts;
+            lastCount = rawLength;
+            setWorkspaceId(state);
+            run.traces = Array.isArray(state.traces) ? [...state.traces] : undefined;
+            if (shouldBroadcast) {
+                emitTestBot({ type: "testBotStatus", run });
+            }
+        };
+        const pendingTraceEvents = [];
+        const flushPendingTraceEvents = (state) => {
+            if (!pendingTraceEvents.length)
+                return;
+            for (const pending of pendingTraceEvents) {
+                deps.persistOpenResponsesTraceEvent(state, pending, runId);
+                deps.appendSessionEvent(state, {
+                    ...pending,
+                    kind: "trace",
+                    category: traceCategory(pending.type),
+                });
+            }
+            pendingTraceEvents.length = 0;
+        };
+        const tracer = (event) => {
+            const stamped = event.ts ? event : { ...event, ts: Date.now() };
+            capturedTraces.push(stamped);
+            deps.consoleTracer?.(stamped);
+            if (savedState?.meta?.sessionId) {
+                deps.persistOpenResponsesTraceEvent(savedState, stamped, runId);
+                deps.appendSessionEvent(savedState, {
+                    ...stamped,
+                    kind: "trace",
+                    category: traceCategory(stamped.type),
+                });
+            }
+            else {
+                pendingTraceEvents.push(stamped);
+            }
+        };
+        let deckBotState = undefined;
+        let sessionEnded = false;
+        const getLastAssistantMessage = (history) => {
+            for (let i = history.length - 1; i >= 0; i--) {
+                const msg = history[i];
+                if (msg?.role === "assistant") {
+                    return stringifyContent(msg.content);
+                }
+            }
+            return undefined;
+        };
+        const generateDeckBotUserMessage = async (history, streamOptions) => {
+            const assistantMessage = getLastAssistantMessage(history)?.trim() || "";
+            const seedPrompt = !assistantMessage && streamOptions?.allowEmptyAssistant
+                ? DEFAULT_TEST_BOT_SEED_PROMPT
+                : undefined;
+            if (!assistantMessage && !seedPrompt)
+                return "";
+            const result = await runDeckWithFallback({
+                path: botDeckPath,
+                input: botInput,
+                inputProvided: botInput !== undefined,
+                modelProvider: deps.modelProvider,
+                state: deckBotState,
+                allowRootStringInput: true,
+                initialUserMessage: assistantMessage || seedPrompt,
+                onStateUpdate: (state) => {
+                    deckBotState = state;
+                },
+                stream: Boolean(streamOptions?.onStreamText),
+                onStreamText: streamOptions?.onStreamText,
+                responsesMode: deps.responsesMode,
+                workerSandbox: deps.workerSandbox,
+                signal: controller.signal,
+            });
+            if (isGambitEndSignal(result)) {
+                sessionEnded = true;
+                return "";
+            }
+            const text = stringifyOutput(result);
+            return text.trim();
+        };
+        const loop = async () => {
+            try {
+                const effectiveStartMode = deps.getRootStartMode() ?? "assistant";
+                const shouldRunInitial = effectiveStartMode !== "user" ||
+                    Boolean(initialUserMessage);
+                if (!controller.signal.aborted && shouldRunInitial) {
+                    const initialResult = await runDeck({
+                        path: deps.getResolvedDeckPath(),
+                        input: deckInput,
+                        inputProvided: hasDeckInput,
+                        modelProvider: deps.modelProvider,
+                        defaultModel: deps.model,
+                        modelOverride: deps.modelForce,
+                        trace: tracer,
+                        stream: false,
+                        state: savedState,
+                        allowRootStringInput: true,
+                        initialUserMessage: initialUserMessage || undefined,
+                        responsesMode: deps.responsesMode,
+                        workerSandbox: resolveWorkerSandboxForSignalAwareRun({
+                            workerSandbox: deps.workerSandbox,
+                            signal: controller.signal,
+                        }),
+                        signal: controller.signal,
+                        onStateUpdate: (state) => {
+                            const nextStateWithSource = applyUserMessageRefSource(savedState, state, "scenario");
+                            const nextMeta = {
+                                ...workspaceMeta,
+                                ...(nextStateWithSource.meta ?? {}),
+                                testBot: true,
+                                testBotRunId: runId,
+                                testBotConfigPath: botConfigPath,
+                                testBotName,
+                                scenarioRunId: runId,
+                                selectedScenarioDeckId,
+                                selectedScenarioDeckLabel,
+                                scenarioConfigPath: botConfigPath,
+                                ...(run.initFill ? { testBotInitFill: run.initFill } : {}),
+                                ...(runOpts.workspaceId
+                                    ? { workspaceId: runOpts.workspaceId }
+                                    : {}),
+                            };
+                            const enriched = deps.persistSessionState({
+                                ...nextStateWithSource,
+                                meta: nextMeta,
+                                traces: capturedTraces,
+                            });
+                            savedState = enriched;
+                            entry.state = enriched;
+                            flushPendingTraceEvents(enriched);
+                            appendFromState(enriched);
+                        },
+                    });
+                    if (isGambitEndSignal(initialResult)) {
+                        sessionEnded = true;
+                    }
+                }
+                for (let turn = 0; turn < maxTurns; turn++) {
+                    if (sessionEnded)
+                        break;
+                    if (controller.signal.aborted)
+                        break;
+                    const history = savedState?.messages ?? [];
+                    const userMessage = await generateDeckBotUserMessage(history, {
+                        onStreamText: (chunk) => emitTestBot({
+                            type: "testBotStream",
+                            workspaceId: run.workspaceId ?? runOpts.workspaceId,
+                            runId,
+                            role: "user",
+                            chunk,
+                            turn,
+                            ts: Date.now(),
+                        }),
+                        allowEmptyAssistant: effectiveStartMode === "user" &&
+                            !getLastAssistantMessage(history),
+                    });
+                    emitTestBot({
+                        type: "testBotStreamEnd",
+                        workspaceId: run.workspaceId ?? runOpts.workspaceId,
+                        runId,
+                        role: "user",
+                        turn,
+                        ts: Date.now(),
+                    });
+                    if (!userMessage)
+                        break;
+                    const rootResult = await runDeck({
+                        path: deps.getResolvedDeckPath(),
+                        input: deckInput,
+                        inputProvided: hasDeckInput,
+                        modelProvider: deps.modelProvider,
+                        defaultModel: deps.model,
+                        modelOverride: deps.modelForce,
+                        trace: tracer,
+                        stream: true,
+                        state: savedState,
+                        allowRootStringInput: true,
+                        initialUserMessage: userMessage,
+                        responsesMode: deps.responsesMode,
+                        workerSandbox: resolveWorkerSandboxForSignalAwareRun({
+                            workerSandbox: deps.workerSandbox,
+                            signal: controller.signal,
+                        }),
+                        signal: controller.signal,
+                        onStateUpdate: (state) => {
+                            const nextStateWithSource = applyUserMessageRefSource(savedState, state, "scenario");
+                            const nextMeta = {
+                                ...workspaceMeta,
+                                ...(nextStateWithSource.meta ?? {}),
+                                testBot: true,
+                                testBotRunId: runId,
+                                testBotConfigPath: botConfigPath,
+                                testBotName,
+                                scenarioRunId: runId,
+                                selectedScenarioDeckId,
+                                selectedScenarioDeckLabel,
+                                scenarioConfigPath: botConfigPath,
+                                ...(run.initFill ? { testBotInitFill: run.initFill } : {}),
+                                ...(runOpts.workspaceId
+                                    ? { workspaceId: runOpts.workspaceId }
+                                    : {}),
+                            };
+                            const enriched = deps.persistSessionState({
+                                ...nextStateWithSource,
+                                meta: nextMeta,
+                                traces: capturedTraces,
+                            });
+                            savedState = enriched;
+                            entry.state = enriched;
+                            flushPendingTraceEvents(enriched);
+                            appendFromState(enriched);
+                        },
+                        onStreamText: (chunk) => emitTestBot({
+                            type: "testBotStream",
+                            workspaceId: run.workspaceId ?? runOpts.workspaceId,
+                            runId,
+                            role: "assistant",
+                            chunk,
+                            turn,
+                            ts: Date.now(),
+                        }),
+                    });
+                    if (isGambitEndSignal(rootResult)) {
+                        sessionEnded = true;
+                        break;
+                    }
+                    emitTestBot({
+                        type: "testBotStreamEnd",
+                        workspaceId: run.workspaceId ?? runOpts.workspaceId,
+                        runId,
+                        role: "assistant",
+                        turn,
+                        ts: Date.now(),
+                    });
+                }
+                run.status = controller.signal.aborted ? "canceled" : "completed";
+                emitTestBot({ type: "testBotStatus", run });
+            }
+            catch (err) {
+                if (controller.signal.aborted || isRunCanceledError(err)) {
+                    run.status = "canceled";
+                    run.error = undefined;
+                }
+                else {
+                    run.status = "error";
+                    run.error = err instanceof Error ? err.message : String(err);
+                    const stack = err instanceof Error ? err.stack : undefined;
+                    deps.logger.error(`[sim] scenario run failed runId=${runId} workspaceId=${run.workspaceId ?? runOpts.workspaceId ?? "unknown"} rootDeck=${deps.getResolvedDeckPath()} scenarioDeck=${botDeckPath} error=${run.error}${stack ? `\n${stack}` : ""}`);
+                }
+                emitTestBot({ type: "testBotStatus", run });
+            }
+            finally {
+                if (savedState?.messages) {
+                    const snapshot = buildTestBotSnapshot(savedState);
+                    run.messages = snapshot.messages;
+                    run.toolInserts = snapshot.toolInserts;
+                }
+                setWorkspaceId(savedState);
+                run.traces = Array.isArray(savedState?.traces)
+                    ? [...(savedState?.traces ?? [])]
+                    : undefined;
+                if (savedState) {
+                    deps.persistCanonicalStateMessages({
+                        state: savedState,
+                        runId,
+                        startIndex: openResponsesStartIndex,
+                        source: "scenario",
+                    });
+                    entry.state = savedState;
+                }
+                run.finishedAt = new Date().toISOString();
+                entry.abort = null;
+                entry.promise = null;
+                emitTestBot({ type: "testBotStatus", run });
+            }
+        };
+        entry.promise = loop();
+        emitTestBot({ type: "testBotStatus", run });
+        return run;
+    };
+    const startWorkspaceScenarioRunForGraphql = async (args) => {
+        await deps.activateWorkspaceDeck(args.workspaceId, { forceReload: true });
+        const workspaceRecord = deps.resolveWorkspaceRecord(args.workspaceId);
+        if (!workspaceRecord) {
+            throw new Error("Workspace not found");
+        }
+        const deckState = deps.readWorkspaceDeckStateStrict(args.workspaceId);
+        const requestedDeckId = typeof args.scenarioDeckId === "string" &&
+            args.scenarioDeckId.trim().length > 0
+            ? args.scenarioDeckId.trim()
+            : null;
+        const fallbackScenarioDeck = deps.buildRootScenarioFallback(deckState);
+        const scenarioDeck = requestedDeckId
+            ? deps.resolveScenarioDeckFromState(deckState, requestedDeckId) ??
+                (requestedDeckId === deckState.assistantDeck.deck
+                    ? fallbackScenarioDeck
+                    : null)
+            : fallbackScenarioDeck;
+        if (requestedDeckId && !scenarioDeck) {
+            throw new Error("Unknown scenario deck selection");
+        }
+        if (!scenarioDeck) {
+            throw new Error("No scenario deck configured for this workspace.");
+        }
+        try {
+            const stat = await dntShim.Deno.stat(scenarioDeck.path);
+            if (!stat.isFile) {
+                throw new Error(`Scenario deck path is not a file: ${scenarioDeck.path}`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            deps.logger.error(`[sim] workspaceScenarioRunStart deck preflight failed workspaceId=${args.workspaceId} deckId=${scenarioDeck.id} deckPath=${scenarioDeck.path} error=${message}`);
+            throw new Error(`Scenario deck is unavailable (${scenarioDeck.label}): ${message}`);
+        }
+        const parseOptionalJsonInput = (value, label) => {
+            if (value === null || value === undefined)
+                return undefined;
+            if (typeof value !== "string")
+                return value;
+            const text = value.trim();
+            if (text.length === 0)
+                return undefined;
+            try {
+                return JSON.parse(text);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "Invalid JSON";
+                throw new Error(`${label} must be valid JSON: ${message}`);
+            }
+        };
+        const parsedScenarioInput = parseOptionalJsonInput(args.scenarioInput, "scenarioInput");
+        const parsedAssistantInit = parseOptionalJsonInput(args.assistantInit, "assistantInit");
+        let assistantInit = parsedAssistantInit;
+        if (assistantInit === undefined) {
+            try {
+                const desc = await deps.getSchemaPromise();
+                assistantInit = desc.defaults !== undefined
+                    ? cloneValue(desc.defaults)
+                    : deriveInitialFromSchema(desc.schema);
+            }
+            catch {
+                // keep assistantInit undefined when schema introspection fails
+            }
+        }
+        if (!requestedDeckId) {
+            const startedAt = new Date().toISOString();
+            const manualRun = {
+                id: typeof args.runId === "string" && args.runId.trim().length > 0
+                    ? args.runId.trim()
+                    : deps.randomId("testbot"),
+                status: "idle",
+                workspaceId: args.workspaceId,
+                sessionId: args.workspaceId,
+                startedAt,
+                messages: [],
+                traces: [],
+                toolInserts: [],
+            };
+            const existing = deps.readSessionState(args.workspaceId);
+            const baseMeta = deps.buildWorkspaceMeta(workspaceRecord, existing?.meta);
+            const nextMeta = {
+                ...baseMeta,
+                testBot: true,
+                testBotRunId: manualRun.id,
+                testBotConfigPath: scenarioDeck.path,
+                testBotName: path.basename(scenarioDeck.path).replace(/\.deck\.(md|ts)$/i, ""),
+                scenarioRunId: manualRun.id,
+                selectedScenarioDeckId: scenarioDeck.id,
+                selectedScenarioDeckLabel: "Manual assistant chat",
+                scenarioConfigPath: scenarioDeck.path,
+                scenarioRunMode: "manual",
+                workspaceId: args.workspaceId,
+            };
+            const manualState = deps.persistSessionState({
+                ...(existing ?? {
+                    runId: args.workspaceId,
+                    messages: [],
+                }),
+                runId: manualRun.id,
+                messages: [],
+                messageRefs: [],
+                traces: [],
+                items: [],
+                meta: nextMeta,
+            });
+            testBotRuns.set(manualRun.id, {
+                run: manualRun,
+                state: manualState,
+                promise: null,
+                abort: null,
+            });
+            broadcastTestBot({ type: "testBotStatus", run: manualRun }, args.workspaceId);
+            return {
+                id: manualRun.id,
+                workspaceId: args.workspaceId,
+                status: manualRun.status,
+                error: manualRun.error,
+                startedAt: manualRun.startedAt,
+                finishedAt: manualRun.finishedAt,
+                messages: [],
+                traces: [],
+                toolInserts: [],
+            };
+        }
+        const run = startTestBotRun({
+            runId: args.runId,
+            workspaceId: args.workspaceId,
+            workspaceRecord,
+            botDeckPath: scenarioDeck.path,
+            botDeckId: scenarioDeck.id,
+            botDeckLabel: scenarioDeck.label,
+            maxTurnsOverride: scenarioDeck.maxTurns,
+            botInput: parsedScenarioInput,
+            deckInput: assistantInit,
+            baseMeta: {
+                scenarioRunMode: "scenario",
+            },
+        });
+        return {
+            id: run.id ?? deps.randomId("testbot"),
+            workspaceId: args.workspaceId,
+            status: run.status,
+            error: run.error,
+            startedAt: run.startedAt,
+            finishedAt: run.finishedAt,
+            messages: Array.isArray(run.messages) ? [...run.messages] : [],
+            traces: Array.isArray(run.traces) ? [...run.traces] : [],
+            toolInserts: Array.isArray(run.toolInserts) ? [...run.toolInserts] : [],
+        };
+    };
+    const sendWorkspaceScenarioRunForGraphql = async (args) => {
+        await deps.activateWorkspaceDeck(args.workspaceId, { forceReload: true });
+        const workspaceRecord = deps.resolveWorkspaceRecord(args.workspaceId);
+        if (!workspaceRecord) {
+            throw new Error("Workspace not found");
+        }
+        const active = testBotRuns.get(args.runId);
+        if (active &&
+            active.run.status === "running" &&
+            (active.run.workspaceId === args.workspaceId ||
+                active.run.sessionId === args.workspaceId)) {
+            throw new Error("Scenario run already in progress.");
+        }
+        const activeMatchesWorkspace = active
+            ? (active.run.workspaceId === args.workspaceId ||
+                active.run.sessionId === args.workspaceId)
+            : false;
+        let state = activeMatchesWorkspace
+            ? (active?.state ?? undefined)
+            : undefined;
+        if (!state) {
+            try {
+                state = deps.readSessionStateStrict(args.workspaceId, {
+                    withTraces: true,
+                });
+            }
+            catch {
+                state = undefined;
+            }
+        }
+        if (!state) {
+            throw new Error("Workspace state unavailable for scenario send.");
+        }
+        const stateMeta = state.meta && typeof state.meta === "object"
+            ? state.meta
+            : {};
+        const stateRunId = typeof stateMeta.scenarioRunId === "string"
+            ? stateMeta.scenarioRunId
+            : typeof stateMeta.testBotRunId === "string"
+                ? stateMeta.testBotRunId
+                : null;
+        if (stateRunId !== args.runId) {
+            throw new Error("Scenario run is not the active run state. Open latest run first.");
+        }
+        const scenarioDeckPath = typeof stateMeta.scenarioConfigPath === "string"
+            ? stateMeta.scenarioConfigPath
+            : typeof stateMeta.testBotConfigPath === "string"
+                ? stateMeta.testBotConfigPath
+                : null;
+        if (!scenarioDeckPath) {
+            throw new Error("Scenario deck path unavailable for this run.");
+        }
+        const scenarioDeckId = typeof stateMeta.selectedScenarioDeckId === "string"
+            ? stateMeta.selectedScenarioDeckId
+            : undefined;
+        const scenarioDeckLabel = typeof stateMeta.selectedScenarioDeckLabel === "string"
+            ? stateMeta.selectedScenarioDeckLabel
+            : undefined;
+        const userMessageSource = stateMeta.scenarioRunMode === "manual"
+            ? "manual"
+            : "scenario";
+        const runMaxTurns = typeof stateMeta.testBotMaxTurns === "number" &&
+            Number.isFinite(stateMeta.testBotMaxTurns)
+            ? Math.round(stateMeta.testBotMaxTurns)
+            : undefined;
+        const existingRun = active?.run;
+        const openResponsesStartIndex = state.messages?.length ?? 0;
+        const run = {
+            id: args.runId,
+            status: "running",
+            workspaceId: args.workspaceId,
+            sessionId: args.workspaceId,
+            startedAt: existingRun?.startedAt ??
+                (typeof stateMeta.startedAt === "string"
+                    ? stateMeta.startedAt
+                    : null) ??
+                new Date().toISOString(),
+            finishedAt: undefined,
+            error: undefined,
+            maxTurns: existingRun?.maxTurns ?? runMaxTurns,
+            messages: existingRun?.messages ? [...existingRun.messages] : [],
+            traces: existingRun?.traces
+                ? [...existingRun.traces]
+                : Array.isArray(state.traces)
+                    ? [...state.traces]
+                    : [],
+            toolInserts: existingRun?.toolInserts ? [...existingRun.toolInserts] : [],
+            initFill: stateMeta.testBotInitFill ??
+                existingRun?.initFill,
+        };
+        const controller = new AbortController();
+        const entry = {
+            run,
+            state,
+            promise: null,
+            abort: controller,
+        };
+        testBotRuns.set(args.runId, entry);
+        const emitTestBot = (payload) => broadcastTestBot(payload, args.workspaceId);
+        const baseMeta = deps.buildWorkspaceMeta(workspaceRecord, stateMeta);
+        let savedState = state;
+        const capturedTraces = Array.isArray(state.traces)
+            ? [...state.traces]
+            : [];
+        const appendFromState = (nextState) => {
+            const snapshot = buildTestBotSnapshot(nextState);
+            run.messages = snapshot.messages;
+            run.toolInserts = snapshot.toolInserts;
+            run.traces = Array.isArray(nextState.traces)
+                ? [...nextState.traces]
+                : undefined;
+            emitTestBot({ type: "testBotStatus", run });
+        };
+        const tracer = (event) => {
+            const stamped = event.ts ? event : { ...event, ts: Date.now() };
+            capturedTraces.push(stamped);
+            if (savedState) {
+                deps.persistOpenResponsesTraceEvent(savedState, stamped, args.runId);
+            }
+            emitTestBot({
+                type: "testBotTrace",
+                workspaceId: args.workspaceId,
+                runId: args.runId,
+                event: stamped,
+            });
+        };
+        const trimmedMessage = args.message.trim();
+        const turn = run.messages.filter((message) => message.role === "user")
+            .length;
+        if (trimmedMessage.length > 0) {
+            run.messages = [
+                ...run.messages,
+                { role: "user", content: trimmedMessage },
+            ];
+        }
+        let hasStartedAssistantStreamMessage = false;
+        entry.promise = (async () => {
+            try {
+                emitTestBot({ type: "testBotStatus", run });
+                const rootResult = await runDeck({
+                    path: scenarioDeckPath,
+                    input: undefined,
+                    inputProvided: false,
+                    modelProvider: deps.modelProvider,
+                    defaultModel: deps.model,
+                    modelOverride: deps.modelForce,
+                    trace: tracer,
+                    stream: true,
+                    state: savedState,
+                    allowRootStringInput: true,
+                    initialUserMessage: trimmedMessage,
+                    responsesMode: deps.responsesMode,
+                    workerSandbox: resolveWorkerSandboxForSignalAwareRun({
+                        workerSandbox: deps.workerSandbox,
+                        signal: controller.signal,
+                    }),
+                    signal: controller.signal,
+                    onStateUpdate: (nextState) => {
+                        const sourced = applyUserMessageRefSource(savedState, nextState, userMessageSource);
+                        const nextMeta = {
+                            ...baseMeta,
+                            ...(sourced.meta ?? {}),
+                            testBot: true,
+                            testBotRunId: args.runId,
+                            testBotConfigPath: scenarioDeckPath,
+                            testBotName: path.basename(scenarioDeckPath).replace(/\.deck\.(md|ts)$/i, ""),
+                            scenarioRunId: args.runId,
+                            ...(scenarioDeckId
+                                ? { selectedScenarioDeckId: scenarioDeckId }
+                                : {}),
+                            ...(scenarioDeckLabel
+                                ? { selectedScenarioDeckLabel: scenarioDeckLabel }
+                                : {}),
+                            scenarioConfigPath: scenarioDeckPath,
+                            scenarioRunMode: userMessageSource === "manual"
+                                ? "manual"
+                                : "scenario",
+                            ...(run.initFill ? { testBotInitFill: run.initFill } : {}),
+                            workspaceId: args.workspaceId,
+                            ...(run.maxTurns ? { testBotMaxTurns: run.maxTurns } : {}),
+                        };
+                        const enriched = deps.persistSessionState({
+                            ...sourced,
+                            meta: nextMeta,
+                            traces: capturedTraces,
+                        });
+                        savedState = enriched;
+                        entry.state = enriched;
+                        appendFromState(enriched);
+                    },
+                    onStreamText: (chunk) => {
+                        if (typeof chunk === "string" && chunk.length > 0) {
+                            if (!hasStartedAssistantStreamMessage) {
+                                run.messages = [
+                                    ...run.messages,
+                                    { role: "assistant", content: chunk },
+                                ];
+                                hasStartedAssistantStreamMessage = true;
+                            }
+                            else {
+                                const last = run.messages[run.messages.length - 1];
+                                if (last?.role === "assistant") {
+                                    last.content += chunk;
+                                }
+                            }
+                        }
+                        emitTestBot({
+                            type: "testBotStream",
+                            workspaceId: args.workspaceId,
+                            runId: args.runId,
+                            role: "assistant",
+                            chunk,
+                            turn,
+                            ts: Date.now(),
+                        });
+                    },
+                });
+                if (!isGambitEndSignal(rootResult)) {
+                    emitTestBot({
+                        type: "testBotStreamEnd",
+                        workspaceId: args.workspaceId,
+                        runId: args.runId,
+                        role: "assistant",
+                        turn,
+                        ts: Date.now(),
+                    });
+                }
+                run.status = controller.signal.aborted ? "canceled" : "completed";
+                run.error = undefined;
+            }
+            catch (err) {
+                if (controller.signal.aborted || isRunCanceledError(err)) {
+                    run.status = "canceled";
+                    run.error = undefined;
+                }
+                else {
+                    run.status = "error";
+                    run.error = err instanceof Error ? err.message : String(err);
+                }
+            }
+            finally {
+                if (savedState?.messages) {
+                    const snapshot = buildTestBotSnapshot(savedState);
+                    run.messages = snapshot.messages;
+                    run.toolInserts = snapshot.toolInserts;
+                    run.traces = Array.isArray(savedState.traces)
+                        ? [...savedState.traces]
+                        : run.traces;
+                }
+                if (savedState) {
+                    deps.persistCanonicalStateMessages({
+                        state: savedState,
+                        runId: args.runId,
+                        startIndex: openResponsesStartIndex,
+                        source: userMessageSource,
+                    });
+                    entry.state = savedState;
+                }
+                run.finishedAt = new Date().toISOString();
+                entry.abort = null;
+                entry.promise = null;
+                emitTestBot({ type: "testBotStatus", run });
+            }
+        })();
+        return {
+            id: run.id,
+            workspaceId: args.workspaceId,
+            status: run.status,
+            error: run.error,
+            startedAt: run.startedAt,
+            finishedAt: run.finishedAt,
+            messages: Array.isArray(run.messages) ? [...run.messages] : [],
+            traces: Array.isArray(run.traces) ? [...run.traces] : [],
+            toolInserts: Array.isArray(run.toolInserts) ? [...run.toolInserts] : [],
+        };
+    };
+    const readWorkspaceScenarioRunsForGraphql = (workspaceId) => {
+        const latestByRunId = new Map();
+        const persistedState = deps.readSessionState(workspaceId);
+        if (persistedState) {
+            const metaRuns = listScenarioRunStatusesFromStateMeta(persistedState, workspaceId);
+            if (metaRuns.length > 0) {
+                for (const run of metaRuns) {
+                    latestByRunId.set(run.id, run);
+                }
+            }
+            else {
+                for (const run of listPersistedTestRunStatuses(persistedState, workspaceId)) {
+                    latestByRunId.set(run.id, run);
+                }
+            }
+        }
+        for (const entry of testBotRuns.values()) {
+            const run = entry.run;
+            if (run.workspaceId !== workspaceId &&
+                run.sessionId !== workspaceId) {
+                continue;
+            }
+            if (!run.id || run.id.trim().length === 0)
+                continue;
+            latestByRunId.set(run.id, run);
+        }
+        const records = [...latestByRunId.values()].map((run) => ({
+            id: run.id,
+            workspaceId,
+            status: run.status,
+            error: run.error,
+            startedAt: run.startedAt,
+            finishedAt: run.finishedAt,
+            messages: Array.isArray(run.messages) ? [...run.messages] : [],
+            traces: Array.isArray(run.traces) ? [...run.traces] : [],
+            toolInserts: Array.isArray(run.toolInserts) ? [...run.toolInserts] : [],
+            maxTurns: run.maxTurns,
+            initFill: run.initFill,
+            sessionId: run.sessionId,
+        }));
+        records.sort((a, b) => {
+            const aKey = a.startedAt ?? a.finishedAt ?? a.id;
+            const bKey = b.startedAt ?? b.finishedAt ?? b.id;
+            return bKey.localeCompare(aKey);
+        });
+        return records;
+    };
+    const stopWorkspaceScenarioRunForGraphql = async (args) => {
+        const active = testBotRuns.get(args.runId);
+        if (active &&
+            (active.run.workspaceId === args.workspaceId ||
+                active.run.sessionId === args.workspaceId)) {
+            active.abort?.abort();
+            try {
+                await active.promise;
+            }
+            catch {
+                // Abort path can reject internally; run projection remains authoritative.
+            }
+        }
+        const latest = readWorkspaceScenarioRunsForGraphql(args.workspaceId).find((run) => run.id === args.runId);
+        if (latest)
+            return latest;
+        throw new Error(`Scenario run ${args.runId} not found`);
+    };
+    const readWorkspaceScenarioRunForGraphql = (workspaceId, runId) => {
+        return readWorkspaceScenarioRunsForGraphql(workspaceId).find((run) => run.id === runId);
+    };
+    const saveWorkspaceFeedbackForGraphql = (args) => {
+        const workspaceId = args.workspaceId.trim();
+        if (!workspaceId)
+            throw new Error("Missing workspaceId");
+        const messageRefId = args.messageRefId.trim();
+        if (!messageRefId)
+            throw new Error("Missing messageRefId");
+        if (args.score !== null &&
+            (typeof args.score !== "number" || Number.isNaN(args.score))) {
+            throw new Error("Invalid score");
+        }
+        const state = deps.readSessionState(workspaceId);
+        if (!state)
+            throw new Error("Workspace not found");
+        const requestedRunId = typeof args.runId === "string" &&
+            args.runId.trim().length > 0
+            ? args.runId.trim()
+            : undefined;
+        const feedbackEligible = isFeedbackEligibleMessageRef(state, messageRefId) ||
+            (requestedRunId
+                ? isFeedbackEligiblePersistedTestRunMessageRef(state, requestedRunId, messageRefId)
+                : false);
+        if (!feedbackEligible) {
+            throw new Error("Feedback target is not eligible");
+        }
+        const existing = state.feedback ?? [];
+        const idx = existing.findIndex((entry) => entry.messageRefId === messageRefId);
+        let feedback = existing;
+        let entry;
+        let deleted = false;
+        if (args.score === null) {
+            if (idx >= 0) {
+                feedback = existing.filter((_, index) => index !== idx);
+                deleted = true;
+            }
+        }
+        else {
+            const clamped = Math.max(-3, Math.min(3, Math.round(args.score)));
+            const reason = typeof args.reason === "string"
+                ? args.reason
+                : idx >= 0
+                    ? existing[idx]?.reason
+                    : undefined;
+            const runId = requestedRunId ??
+                (typeof state.runId === "string" ? state.runId : "session");
+            const scenarioRunId = requestedRunId ??
+                (typeof state.meta?.scenarioRunId === "string"
+                    ? state.meta.scenarioRunId
+                    : runId);
+            const now = new Date().toISOString();
+            entry = idx >= 0
+                ? {
+                    ...existing[idx],
+                    score: clamped,
+                    reason,
+                    runId: existing[idx]?.runId ?? runId,
+                }
+                : {
+                    id: deps.randomId("fb"),
+                    runId,
+                    messageRefId,
+                    score: clamped,
+                    reason,
+                    createdAt: now,
+                };
+            if (entry) {
+                entry.workspaceId = workspaceId;
+                entry.scenarioRunId = scenarioRunId;
+            }
+            feedback = idx >= 0
+                ? existing.map((item, index) => index === idx ? entry : item)
+                : [...existing, entry];
+        }
+        const nextState = deps.persistSessionState({ ...state, feedback });
+        deps.appendSessionEvent(nextState, {
+            type: "feedback.update",
+            kind: "artifact",
+            category: "feedback",
+            workspaceId,
+            scenarioRunId: typeof nextState.meta?.scenarioRunId === "string"
+                ? nextState.meta.scenarioRunId
+                : nextState.runId,
+            messageRefId,
+            feedback: entry,
+            deleted,
+        });
+        const liveRunId = typeof nextState.meta?.testBotRunId === "string"
+            ? nextState.meta.testBotRunId
+            : undefined;
+        if (liveRunId) {
+            const liveEntry = testBotRuns.get(liveRunId);
+            if (liveEntry) {
+                syncTestBotRunFromState(liveEntry.run, nextState);
+                broadcastTestBot({ type: "testBotStatus", run: liveEntry.run }, workspaceId);
+            }
+        }
+        const effectiveRunId = requestedRunId ??
+            (entry?.runId ??
+                (typeof nextState.meta?.scenarioRunId === "string"
+                    ? nextState.meta.scenarioRunId
+                    : nextState.runId));
+        const run = readWorkspaceScenarioRunForGraphql(workspaceId, effectiveRunId);
+        if (!run) {
+            throw new Error(`Scenario run ${effectiveRunId} not found`);
+        }
+        return { feedback: entry, deleted, run };
+    };
+    return {
+        broadcastTestBot,
+        startWorkspaceScenarioRunForGraphql,
+        sendWorkspaceScenarioRunForGraphql,
+        readWorkspaceScenarioRunsForGraphql,
+        readWorkspaceScenarioRunForGraphql,
+        saveWorkspaceFeedbackForGraphql,
+        stopWorkspaceScenarioRunForGraphql,
+        getLiveTestRunEntry: (runId) => testBotRuns.get(runId),
+        getLiveTestRunEntryByWorkspaceId: findTestRunByWorkspaceId,
+        readPersistedTestRunStatusById,
+        isFeedbackEligibleMessageRef,
+        isFeedbackEligiblePersistedTestRunMessageRef,
+        syncTestBotRunFromState,
+    };
+};