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

package/esm/src/simulator_graphql.js

@@ -1,3205 +0,0 @@
-import * as dntShim from "../_dnt.shims.js";
-import SchemaBuilder from "@pothos/core";
-import RelayPlugin, { resolveArrayConnection } from "@pothos/plugin-relay";
-import { createYoga } from "graphql-yoga";
-import { Kind } from "graphql";
-import { asGambitID, asGambitStreamID, } from "./gambit_id.js";
-import { asGambitWorkspaceRelativePath, } from "./gambit_path.js";
-import { asGambitISODateTime } from "./gambit_time.js";
-import { getDurableStreamNextOffset, readDurableStreamEvents, subscribeDurableStream, } from "./durable_streams.js";
-const BUILD_CHAT_DEBUG = (() => {
-    const value = (dntShim.Deno.env.get("GAMBIT_BUILD_CHAT_DEBUG") ?? "").toLowerCase()
-        .trim();
-    return value === "1" || value === "true" || value === "yes";
-})();
-function logBuildChatDebug(event, payload) {
-    if (!BUILD_CHAT_DEBUG)
-        return;
-    // deno-lint-ignore no-console -- debug logging is gated by env var.
-    console.log(`[gambit-build-chat-debug] ${event} ${JSON.stringify(payload)}`);
-}
-function toTranscriptMessageRole(value) {
-    return value === "user" ? "user" : "assistant";
-}
-function isTranscriptMessageFeedbackEligible(message) {
-    if (typeof message.feedbackEligible === "boolean") {
-        return message.feedbackEligible;
-    }
-    const role = toTranscriptMessageRole(message.role);
-    return role === "assistant" ||
-        (role === "user" && message.messageSource === "scenario");
-}
-function buildTranscriptMessages(parent) {
-    return parent.messages.map((message, index) => ({
-        __typename: "WorkspaceConversationTranscriptMessage",
-        id: message.messageRefId ?? `${parent.id}:transcript:${index}`,
-        role: toTranscriptMessageRole(message.role),
-        content: message.content,
-        messageRefId: message.messageRefId,
-        feedbackEligible: isTranscriptMessageFeedbackEligible(message),
-        feedback: message.feedback,
-    }));
-}
-function buildTranscriptEntries(args) {
-    const transcriptMessages = buildTranscriptMessages(args.parent);
-    if (args.outputItems.length === 0) {
-        return transcriptMessages;
-    }
-    const transcriptEntries = [];
-    const consumedCanonicalMessageIndexes = new Set();
-    let messageCursor = 0;
-    const markCanonicalMessageConsumed = (index) => {
-        consumedCanonicalMessageIndexes.add(index);
-        while (messageCursor < transcriptMessages.length &&
-            consumedCanonicalMessageIndexes.has(messageCursor)) {
-            messageCursor += 1;
-        }
-        return transcriptMessages[index];
-    };
-    const toTranscriptEntryFromOutputItem = (item) => {
-        switch (item.__typename) {
-            case "OutputReasoning":
-                return {
-                    __typename: "WorkspaceConversationTranscriptReasoning",
-                    id: item.id,
-                    summary: item.summary,
-                    reasoningType: item.reasoningType,
-                };
-            case "OutputToolCall":
-                return {
-                    __typename: "WorkspaceConversationTranscriptToolCall",
-                    id: item.id,
-                    toolCallId: item.toolCallId,
-                    toolName: item.toolName,
-                    status: item.status,
-                    argumentsText: item.argumentsText,
-                    resultText: item.resultText,
-                    error: item.error,
-                };
-            case "OutputMessage":
-                return {
-                    __typename: "WorkspaceConversationTranscriptMessage",
-                    id: item.messageRefId ?? item.id,
-                    role: toTranscriptMessageRole(item.role),
-                    content: item.content,
-                    messageRefId: item.messageRefId,
-                    feedbackEligible: item.feedbackEligible,
-                    feedback: item.feedback,
-                };
-        }
-    };
-    const takeCanonicalMessageForOutput = (item) => {
-        if (item.messageRefId) {
-            for (let index = messageCursor; index < transcriptMessages.length; index += 1) {
-                const message = transcriptMessages[index];
-                if (!consumedCanonicalMessageIndexes.has(index) &&
-                    message.messageRefId === item.messageRefId) {
-                    return markCanonicalMessageConsumed(index);
-                }
-            }
-        }
-        for (let index = messageCursor; index < transcriptMessages.length; index += 1) {
-            const message = transcriptMessages[index];
-            if (!consumedCanonicalMessageIndexes.has(index) &&
-                message.role === toTranscriptMessageRole(item.role) &&
-                message.content.trim() === item.content.trim()) {
-                return markCanonicalMessageConsumed(index);
-            }
-        }
-        return null;
-    };
-    for (const item of args.outputItems) {
-        if (item.__typename === "OutputMessage") {
-            transcriptEntries.push(takeCanonicalMessageForOutput(item) ??
-                toTranscriptEntryFromOutputItem(item));
-            continue;
-        }
-        const entry = toTranscriptEntryFromOutputItem(item);
-        if (entry) {
-            transcriptEntries.push(entry);
-        }
-    }
-    if (args.parent.conversationRunKind === "scenario") {
-        for (let index = 0; index < transcriptMessages.length; index += 1) {
-            if (consumedCanonicalMessageIndexes.has(index))
-                continue;
-            transcriptEntries.push(transcriptMessages[index]);
-        }
-    }
-    return transcriptEntries;
-}
-const builder = new SchemaBuilder({
-    plugins: [RelayPlugin],
-    relay: {},
-    defaultFieldNullability: false,
-});
-const WorkspaceRelativePathScalar = builder.scalarType("WorkspaceRelativePath", {
-    serialize: (value) => {
-        if (typeof value !== "string") {
-            throw new Error("WorkspaceRelativePath must serialize as string.");
-        }
-        return value;
-    },
-    parseValue: (value) => {
-        if (typeof value !== "string") {
-            throw new Error("WorkspaceRelativePath must be a string.");
-        }
-        return asGambitWorkspaceRelativePath(value);
-    },
-    parseLiteral: (ast) => {
-        if (ast.kind !== Kind.STRING) {
-            throw new Error("WorkspaceRelativePath must be a string literal.");
-        }
-        return asGambitWorkspaceRelativePath(ast.value);
-    },
-});
-function parseJsonLiteral(ast) {
-    switch (ast.kind) {
-        case Kind.NULL:
-            return null;
-        case Kind.STRING:
-        case Kind.BOOLEAN:
-            return ast.value;
-        case Kind.INT:
-        case Kind.FLOAT:
-            return Number(ast.value);
-        case Kind.LIST:
-            return ast.values.map(parseJsonLiteral);
-        case Kind.OBJECT: {
-            const result = {};
-            for (const field of ast.fields) {
-                result[field.name.value] = parseJsonLiteral(field.value);
-            }
-            return result;
-        }
-        default:
-            return null;
-    }
-}
-builder.scalarType("JSON", {
-    serialize: (value) => value,
-    parseValue: (value) => value,
-    parseLiteral: parseJsonLiteral,
-});
-const OpenResponseStatusEnum = builder.enumType("OpenResponseStatus", {
-    values: ["IDLE", "RUNNING", "COMPLETED", "FAILED", "CANCELED"],
-});
-function toOpenResponseStatus(value) {
-    switch (value) {
-        case "running":
-            return "RUNNING";
-        case "completed":
-            return "COMPLETED";
-        case "error":
-            return "FAILED";
-        case "canceled":
-            return "CANCELED";
-        default:
-            return "IDLE";
-    }
-}
-function parseWorkspaceConversationSessionKind(value) {
-    if (value === "build" || value === "scenario" || value === "grader" ||
-        value === "verify") {
-        return value;
-    }
-    throw new Error(`Unsupported conversation session kind: ${value}`);
-}
-function isWorkspaceConversationSessionRecord(value) {
-    return !!value && typeof value === "object" &&
-        typeof value.kind === "string";
-}
-function asRecord(value) {
-    return !!value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
-function asString(value) {
-    return typeof value === "string" ? value : "";
-}
-function toEventMessageText(value) {
-    if (typeof value === "string")
-        return value;
-    if (Array.isArray(value)) {
-        return value.map((entry) => {
-            const record = asRecord(entry);
-            if (!record)
-                return "";
-            const text = asString(record.text);
-            if (text.length > 0)
-                return text;
-            return toEventMessageText(record.content);
-        }).join("");
-    }
-    const record = asRecord(value);
-    if (!record)
-        return "";
-    const recordText = asString(record.text);
-    if (recordText.length > 0)
-        return recordText;
-    return toEventMessageText(record.content);
-}
-const WorkspaceSessionMetaType = builder.objectRef("WorkspaceSessionMeta");
-WorkspaceSessionMetaType.implement({
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        deck: t.string({
-            nullable: true,
-            resolve: (parent) => parent.deck ?? null,
-        }),
-        deckSlug: t.string({
-            nullable: true,
-            resolve: (parent) => parent.deckSlug ?? null,
-        }),
-        testBotName: t.string({
-            nullable: true,
-            resolve: (parent) => parent.testBotName ?? null,
-        }),
-        createdAt: t.string({
-            nullable: true,
-            resolve: (parent) => parent.createdAt ?? null,
-        }),
-        sessionDir: t.string({
-            nullable: true,
-            resolve: (parent) => parent.sessionDir ?? null,
-        }),
-        statePath: t.string({
-            nullable: true,
-            resolve: (parent) => parent.statePath ?? null,
-        }),
-    }),
-});
-const WorkspaceDeletePayloadType = builder.objectRef("WorkspaceDeletePayload");
-WorkspaceDeletePayloadType.implement({
-    fields: (t) => ({
-        workspaceId: t.id({ resolve: (parent) => parent.workspaceId }),
-        deleted: t.boolean({ resolve: (parent) => parent.deleted }),
-        error: t.string({
-            nullable: true,
-            resolve: (parent) => parent.error ?? null,
-        }),
-    }),
-});
-const StreamEventType = builder.objectRef("GambitDurableStreamEvent");
-StreamEventType.implement({
-    fields: (t) => ({
-        offset: t.int({ resolve: (parent) => parent.offset }),
-        createdAt: t.string({ resolve: (parent) => parent.createdAt }),
-        type: t.string({ resolve: (parent) => parent.type }),
-        data: t.field({ type: "JSON", resolve: (parent) => parent.data }),
-    }),
-});
-const StreamReplayType = builder.objectRef("GambitDurableStreamReplay");
-StreamReplayType.implement({
-    fields: (t) => ({
-        streamId: t.id({ resolve: (parent) => parent.streamId }),
-        fromOffset: t.int({ resolve: (parent) => parent.fromOffset }),
-        nextOffset: t.int({ resolve: (parent) => parent.nextOffset }),
-        events: t.field({
-            type: [StreamEventType],
-            resolve: (parent) => parent.events,
-        }),
-    }),
-});
-const WorkspaceFileType = builder.objectRef("WorkspaceFile");
-WorkspaceFileType.implement({
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        path: t.field({
-            type: WorkspaceRelativePathScalar,
-            resolve: (parent) => parent.path,
-        }),
-        size: t.int({
-            nullable: true,
-            resolve: (parent) => parent.size,
-        }),
-        modifiedAt: t.string({
-            nullable: true,
-            resolve: (parent) => parent.modifiedAt,
-        }),
-        content: t.string({
-            nullable: true,
-            resolve: (parent) => parent.content,
-        }),
-    }),
-});
-const WorkspaceScenarioDeckType = builder.objectRef("WorkspaceScenarioDeck");
-WorkspaceScenarioDeckType.implement({
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        label: t.string({ resolve: (parent) => parent.label }),
-        description: t.string({
-            nullable: true,
-            resolve: (parent) => parent.description ?? null,
-        }),
-        path: t.string({ resolve: (parent) => parent.path }),
-        maxTurns: t.int({
-            nullable: true,
-            resolve: (parent) => parent.maxTurns ?? null,
-        }),
-        inputSchema: t.field({
-            type: "String",
-            nullable: true,
-            resolve: (parent) => parent.inputSchema ? JSON.stringify(parent.inputSchema) : null,
-        }),
-        defaults: t.field({
-            type: "String",
-            nullable: true,
-            resolve: (parent) => parent.defaults !== undefined ? JSON.stringify(parent.defaults) : null,
-        }),
-        inputSchemaError: t.string({
-            nullable: true,
-            resolve: (parent) => parent.inputSchemaError ?? null,
-        }),
-    }),
-});
-const WorkspaceAssistantDeckType = builder.objectRef("WorkspaceAssistantDeck");
-WorkspaceAssistantDeckType.implement({
-    fields: (t) => ({
-        deck: t.string({
-            nullable: true,
-            resolve: (parent) => parent.deck ?? null,
-        }),
-        startMode: t.string({
-            nullable: true,
-            resolve: (parent) => parent.startMode ?? null,
-        }),
-        modelParams: t.field({
-            type: "String",
-            nullable: true,
-            resolve: (parent) => parent.modelParams ? JSON.stringify(parent.modelParams) : null,
-        }),
-        inputSchema: t.field({
-            type: "String",
-            nullable: true,
-            resolve: (parent) => parent.inputSchema ? JSON.stringify(parent.inputSchema) : null,
-        }),
-        defaults: t.field({
-            type: "String",
-            nullable: true,
-            resolve: (parent) => parent.defaults !== undefined ? JSON.stringify(parent.defaults) : null,
-        }),
-        tools: t.field({
-            type: "String",
-            nullable: true,
-            resolve: (parent) => parent.tools ? JSON.stringify(parent.tools) : null,
-        }),
-        inputSchemaError: t.string({
-            nullable: true,
-            resolve: (parent) => parent.inputSchemaError ?? null,
-        }),
-    }),
-});
-const WorkspaceRunInterface = builder.interfaceRef("WorkspaceRun");
-WorkspaceRunInterface.implement({
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        workspaceId: t.id({
-            resolve: (parent) => asGambitID(typeof parent.workspaceId === "string" &&
-                parent.workspaceId.length > 0
-                ? parent.workspaceId
-                : parent.id),
-        }),
-        status: t.field({
-            type: OpenResponseStatusEnum,
-            resolve: (parent) => toOpenResponseStatus(parent.status),
-        }),
-    }),
-});
-const TranscriptMessageType = builder.objectRef("WorkspaceConversationTranscriptMessage");
-const TranscriptReasoningType = builder.objectRef("WorkspaceConversationTranscriptReasoning");
-const TranscriptToolCallType = builder.objectRef("WorkspaceConversationTranscriptToolCall");
-const WorkspaceConversationTranscriptEntryType = builder.unionType("WorkspaceConversationTranscriptEntry", {
-    types: [
-        TranscriptMessageType,
-        TranscriptReasoningType,
-        TranscriptToolCallType,
-    ],
-    resolveType: (parent) => parent.__typename,
-});
-const WorkspaceConversationRunInterface = builder.interfaceRef("WorkspaceConversationRun");
-WorkspaceConversationRunInterface.implement({
-    resolveType: (parent) => parent.conversationRunKind === "scenario"
-        ? "WorkspaceScenarioRun"
-        : "WorkspaceBuildRun",
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        workspaceId: t.id({
-            resolve: (parent) => asGambitID("workspaceId" in parent && typeof parent.workspaceId === "string"
-                ? parent.workspaceId
-                : parent.id),
-        }),
-        status: t.field({
-            type: OpenResponseStatusEnum,
-            resolve: (parent) => toOpenResponseStatus(parent.status),
-        }),
-        error: t.string({
-            nullable: true,
-            resolve: (parent) => parent.error ?? null,
-        }),
-        startedAt: t.string({
-            nullable: true,
-            resolve: (parent) => parent.startedAt ?? null,
-        }),
-        finishedAt: t.string({
-            nullable: true,
-            resolve: (parent) => parent.finishedAt ?? null,
-        }),
-        transcriptEntries: t.field({
-            type: [WorkspaceConversationTranscriptEntryType],
-            resolve: async (parent, _args, ctx) => {
-                const workspaceId = typeof parent.workspaceId === "string" &&
-                    parent.workspaceId.trim().length > 0
-                    ? parent.workspaceId
-                    : null;
-                if (!workspaceId || !ctx.readWorkspaceOpenResponseOutputItems) {
-                    return buildTranscriptMessages(parent);
-                }
-                const outputItems = await ctx.readWorkspaceOpenResponseOutputItems({
-                    workspaceId,
-                    runId: parent.id,
-                });
-                return buildTranscriptEntries({ parent, outputItems });
-            },
-        }),
-        openResponses: t.connection({
-            type: OpenResponseType,
-            args: {
-                first: t.arg.int(),
-                after: t.arg.string(),
-            },
-            resolve: (parent, args) => resolveArrayConnection({ args }, [parent]),
-        }),
-    }),
-});
-const WorkspaceScenarioRunType = builder.objectRef("WorkspaceScenarioRun");
-WorkspaceScenarioRunType.implement({
-    interfaces: [WorkspaceConversationRunInterface],
-    fields: () => ({}),
-});
-const ToolCallStatusEnum = builder.enumType("ToolCallStatus", {
-    values: ["RUNNING", "COMPLETED", "ERROR"],
-});
-const FeedbackType = builder.objectRef("Feedback");
-FeedbackType.implement({
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        runId: t.id({ resolve: (parent) => parent.runId }),
-        messageRefId: t.id({ resolve: (parent) => parent.messageRefId }),
-        score: t.int({ resolve: (parent) => parent.score }),
-        reason: t.string({
-            nullable: true,
-            resolve: (parent) => parent.reason ?? null,
-        }),
-        createdAt: t.string({
-            nullable: true,
-            resolve: (parent) => parent.createdAt ?? null,
-        }),
-    }),
-});
-TranscriptMessageType.implement({
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        role: t.string({ resolve: (parent) => parent.role }),
-        content: t.string({ resolve: (parent) => parent.content }),
-        messageRefId: t.id({
-            nullable: true,
-            resolve: (parent) => parent.messageRefId ?? null,
-        }),
-        feedbackEligible: t.boolean({
-            resolve: (parent) => parent.feedbackEligible,
-        }),
-        feedback: t.field({
-            type: FeedbackType,
-            nullable: true,
-            resolve: (parent) => parent.feedback ?? null,
-        }),
-    }),
-});
-TranscriptReasoningType.implement({
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        summary: t.string({ resolve: (parent) => parent.summary }),
-        reasoningType: t.string({
-            nullable: true,
-            resolve: (parent) => parent.reasoningType ?? null,
-        }),
-    }),
-});
-TranscriptToolCallType.implement({
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        toolCallId: t.id({ resolve: (parent) => parent.toolCallId }),
-        toolName: t.string({ resolve: (parent) => parent.toolName }),
-        status: t.field({
-            type: ToolCallStatusEnum,
-            resolve: (parent) => parent.status,
-        }),
-        argumentsText: t.string({
-            nullable: true,
-            resolve: (parent) => parent.argumentsText ?? null,
-        }),
-        resultText: t.string({
-            nullable: true,
-            resolve: (parent) => parent.resultText ?? null,
-        }),
-        error: t.string({
-            nullable: true,
-            resolve: (parent) => parent.error ?? null,
-        }),
-    }),
-});
-const OutputMessageType = builder.objectRef("OutputMessage");
-OutputMessageType.implement({
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        role: t.string({ resolve: (parent) => parent.role }),
-        content: t.string({ resolve: (parent) => parent.content }),
-        messageRefId: t.id({
-            nullable: true,
-            resolve: (parent) => parent.messageRefId ?? null,
-        }),
-        feedbackEligible: t.boolean({
-            resolve: (parent) => parent.feedbackEligible,
-        }),
-        feedback: t.field({
-            type: FeedbackType,
-            nullable: true,
-            resolve: (parent) => parent.feedback ?? null,
-        }),
-    }),
-});
-const OutputReasoningType = builder.objectRef("OutputReasoning");
-OutputReasoningType.implement({
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        summary: t.string({ resolve: (parent) => parent.summary }),
-        reasoningType: t.string({
-            nullable: true,
-            resolve: (parent) => parent.reasoningType ?? null,
-        }),
-    }),
-});
-const OutputToolCallType = builder.objectRef("OutputToolCall");
-OutputToolCallType.implement({
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        toolCallId: t.id({ resolve: (parent) => parent.toolCallId }),
-        toolName: t.string({ resolve: (parent) => parent.toolName }),
-        status: t.field({
-            type: ToolCallStatusEnum,
-            resolve: (parent) => parent.status,
-        }),
-        argumentsText: t.string({
-            nullable: true,
-            resolve: (parent) => parent.argumentsText ?? null,
-        }),
-        resultText: t.string({
-            nullable: true,
-            resolve: (parent) => parent.resultText ?? null,
-        }),
-        error: t.string({
-            nullable: true,
-            resolve: (parent) => parent.error ?? null,
-        }),
-    }),
-});
-const OpenResponseOutputItemType = builder.unionType("OpenResponseOutputItem", {
-    types: [
-        OutputMessageType,
-        OutputReasoningType,
-        OutputToolCallType,
-    ],
-    resolveType: (parent) => parent.__typename,
-});
-const OpenResponseEventType = builder.objectRef("OpenResponseEvent");
-OpenResponseEventType.implement({
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        type: t.string({ resolve: (parent) => parent.type }),
-        data: t.field({ type: "JSON", resolve: (parent) => parent.data }),
-    }),
-});
-const WorkspaceOpenResponseEventsLiveEdgeType = builder.objectRef("WorkspaceOpenResponseEventsLiveEdge");
-WorkspaceOpenResponseEventsLiveEdgeType.implement({
-    fields: (t) => ({
-        workspaceId: t.id({ resolve: (parent) => asGambitID(parent.workspaceId) }),
-        runId: t.id({ resolve: (parent) => parent.runId }),
-        sourceSequence: t.int({ resolve: (parent) => parent.sourceSequence }),
-        occurredAt: t.string({ resolve: (parent) => parent.occurredAt }),
-        event: t.field({
-            type: OpenResponseEventType,
-            resolve: (parent) => parent.event,
-        }),
-    }),
-});
-const OpenResponseType = builder.objectRef("OpenResponse");
-OpenResponseType.implement({
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => `${parent.id}:open-response` }),
-        runId: t.id({ resolve: (parent) => parent.id }),
-        status: t.field({
-            type: OpenResponseStatusEnum,
-            resolve: (parent) => toOpenResponseStatus(parent.status),
-        }),
-        outputItems: t.connection({
-            type: OpenResponseOutputItemType,
-            args: {
-                first: t.arg.int(),
-                after: t.arg.string(),
-            },
-            resolve: async (parent, args, ctx) => {
-                const workspaceId = typeof parent.workspaceId === "string" &&
-                    parent.workspaceId.trim().length > 0
-                    ? parent.workspaceId
-                    : null;
-                if (!workspaceId || !ctx.readWorkspaceOpenResponseOutputItems) {
-                    return resolveArrayConnection({ args }, []);
-                }
-                const items = await ctx.readWorkspaceOpenResponseOutputItems({
-                    workspaceId,
-                    runId: parent.id,
-                });
-                logBuildChatDebug("resolver.openResponse.outputItems", {
-                    runId: parent.id,
-                    itemCount: items.length,
-                });
-                return resolveArrayConnection({ args }, items);
-            },
-        }),
-        events: t.connection({
-            type: OpenResponseEventType,
-            args: {
-                first: t.arg.int(),
-                after: t.arg.string(),
-            },
-            resolve: async (parent, args, ctx) => {
-                const workspaceId = typeof parent.workspaceId === "string" &&
-                    parent.workspaceId.trim().length > 0
-                    ? parent.workspaceId
-                    : null;
-                if (!workspaceId || !ctx.readWorkspaceOpenResponseEvents) {
-                    return resolveArrayConnection({ args }, []);
-                }
-                const records = await ctx.readWorkspaceOpenResponseEvents({
-                    workspaceId,
-                    runId: parent.id,
-                    fromSequence: 0,
-                });
-                const events = records.map((event) => ({
-                    id: `${parent.id}:event:${event.sequence}`,
-                    type: event.event_type,
-                    data: event.payload,
-                }));
-                logBuildChatDebug("resolver.openResponse.events", {
-                    runId: parent.id,
-                    eventCount: events.length,
-                });
-                return resolveArrayConnection({ args }, events);
-            },
-        }),
-    }),
-});
-const WorkspaceBuildRunType = builder.objectRef("WorkspaceBuildRun");
-WorkspaceBuildRunType.implement({
-    interfaces: [WorkspaceRunInterface, WorkspaceConversationRunInterface],
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        workspaceId: t.id({
-            resolve: (parent) => asGambitID(typeof parent.workspaceId === "string" &&
-                parent.workspaceId.length > 0
-                ? parent.workspaceId
-                : parent.id),
-        }),
-        status: t.field({
-            type: OpenResponseStatusEnum,
-            resolve: (parent) => toOpenResponseStatus(parent.status),
-        }),
-    }),
-});
-const BuildStateType = builder.objectRef("BuildState");
-BuildStateType.implement({
-    fields: (t) => ({
-        workspaceId: t.id({ resolve: (parent) => asGambitID(parent.workspaceId) }),
-        runStatus: t.field({
-            type: OpenResponseStatusEnum,
-            resolve: (parent) => toOpenResponseStatus(parent.run.status),
-        }),
-        canSend: t.boolean({
-            resolve: (parent) => parent.run.status !== "running",
-        }),
-        canStop: t.boolean({
-            resolve: (parent) => parent.run.status === "running",
-        }),
-    }),
-});
-const WorkspaceModelStatusType = builder.objectRef("WorkspaceModelStatus");
-WorkspaceModelStatusType.implement({
-    fields: (t) => ({
-        model: t.string({ resolve: (parent) => parent.model }),
-        workspaceId: t.id({ resolve: (parent) => asGambitID(parent.workspaceId) }),
-        available: t.boolean({ resolve: (parent) => parent.available }),
-        requiresLogin: t.boolean({ resolve: (parent) => parent.requiresLogin }),
-        loggedIn: t.boolean({ resolve: (parent) => parent.loggedIn }),
-        statusText: t.string({ resolve: (parent) => parent.statusText }),
-        trustedPath: t.string({
-            nullable: true,
-            resolve: (parent) => parent.trustedPath ?? null,
-        }),
-        writeEnabled: t.boolean({ resolve: (parent) => parent.writeEnabled }),
-    }),
-});
-const WorkspaceModelsType = builder.objectRef("WorkspaceModels");
-WorkspaceModelsType.implement({
-    fields: (t) => ({
-        codex: t.field({
-            type: WorkspaceModelStatusType,
-            args: {
-                checkOnline: t.arg.boolean(),
-            },
-            resolve: async (parent, args, context) => {
-                if (!context.readWorkspaceModelStatus) {
-                    return {
-                        model: "codex",
-                        workspaceId: parent.workspaceId,
-                        available: false,
-                        requiresLogin: true,
-                        loggedIn: false,
-                        statusText: "Model status resolver is unavailable.",
-                        writeEnabled: false,
-                    };
-                }
-                return await context.readWorkspaceModelStatus({
-                    workspaceId: parent.workspaceId,
-                    model: "codex",
-                    checkOnline: args.checkOnline ?? false,
-                });
-            },
-        }),
-    }),
-});
-const WorkspaceGradeRunStatusEnum = builder.enumType("WorkspaceGradeRunStatus", {
-    values: ["RUNNING", "COMPLETED", "ERROR"],
-});
-function toWorkspaceGradeRunStatus(value) {
-    if (value === "running")
-        return "RUNNING";
-    if (value === "completed")
-        return "COMPLETED";
-    return "ERROR";
-}
-function round2(value) {
-    return Math.round(value * 100) / 100;
-}
-function median(values) {
-    if (values.length === 0)
-        return null;
-    const sorted = [...values].sort((left, right) => left - right);
-    const mid = Math.floor(sorted.length / 2);
-    if (sorted.length % 2 === 1)
-        return sorted[mid];
-    return (sorted[mid - 1] + sorted[mid]) / 2;
-}
-function extractRepresentativeScore(run) {
-    const summaryScore = run.summary?.score;
-    if (typeof summaryScore === "number" && Number.isFinite(summaryScore)) {
-        return summaryScore;
-    }
-    const turnScores = run.turns
-        .map((turn) => turn.score)
-        .filter((score) => typeof score === "number" && Number.isFinite(score));
-    if (turnScores.length === 0)
-        return null;
-    return median(turnScores);
-}
-function extractRepresentativeReason(run) {
-    if (typeof run.summary?.reason === "string" &&
-        run.summary.reason.trim().length > 0) {
-        return run.summary.reason.trim();
-    }
-    const turnReason = run.turns.find((turn) => typeof turn.reason === "string" && turn.reason.trim().length > 0)?.reason;
-    return typeof turnReason === "string" ? turnReason.trim() : null;
-}
-function buildVerifyMetrics(args) {
-    const runById = new Map(args.runs.map((run) => [run.id, run]));
-    const reasonCounter = new Map();
-    const scoreValues = [];
-    let passCount = 0;
-    let scoreCount = 0;
-    let gradingFailureCount = 0;
-    const scenarioGroups = new Map();
-    const addReason = (kind, reason) => {
-        const normalized = typeof reason === "string" ? reason.trim() : "";
-        if (!normalized)
-            return;
-        const key = `${kind}:${normalized}`;
-        const existing = reasonCounter.get(key);
-        if (existing) {
-            existing.count += 1;
-            return;
-        }
-        reasonCounter.set(key, { key, kind, reason: normalized, count: 1 });
-    };
-    for (const request of args.batch.requests) {
-        if (!request.scenarioRunId)
-            continue;
-        const existing = scenarioGroups.get(request.scenarioRunId);
-        if (existing) {
-            existing.requests.push(request);
-            continue;
-        }
-        scenarioGroups.set(request.scenarioRunId, {
-            scenarioRunId: request.scenarioRunId,
-            requests: [request],
-            scores: [],
-            executionFailureCount: 0,
-            gradingFailureCount: 0,
-            completedSampleCount: 0,
-        });
-    }
-    for (const request of args.batch.requests) {
-        if (request.status === "error") {
-            addReason("execution", request.error);
-            if (request.scenarioRunId) {
-                const group = scenarioGroups.get(request.scenarioRunId);
-                if (group)
-                    group.executionFailureCount += 1;
-            }
-            continue;
-        }
-        if (request.status !== "completed" || !request.runId)
-            continue;
-        const run = runById.get(request.runId);
-        if (!run || run.status !== "completed")
-            continue;
-        const score = extractRepresentativeScore(run);
-        if (request.scenarioRunId) {
-            const group = scenarioGroups.get(request.scenarioRunId);
-            if (group) {
-                group.completedSampleCount += 1;
-            }
-        }
-        if (score === null)
-            continue;
-        const rounded = round2(score);
-        scoreValues.push(rounded);
-        scoreCount += 1;
-        if (rounded >= 0) {
-            passCount += 1;
-        }
-        else {
-            gradingFailureCount += 1;
-            addReason("grading", extractRepresentativeReason(run));
-            if (request.scenarioRunId) {
-                const group = scenarioGroups.get(request.scenarioRunId);
-                if (group)
-                    group.gradingFailureCount += 1;
-            }
-        }
-        if (request.scenarioRunId) {
-            const group = scenarioGroups.get(request.scenarioRunId);
-            if (group) {
-                const messageRefId = run.turns.find((turn) => typeof turn.refId === "string" && turn.refId.trim().length > 0)?.refId;
-                group.scores.push({
-                    runId: run.id,
-                    value: rounded,
-                    messageRefId,
-                });
-            }
-        }
-    }
-    const outlierScenarioRuns = [
-        ...scenarioGroups.values(),
-    ].map((group) => {
-        const sortedScores = [...group.scores].sort((left, right) => left.value - right.value);
-        const numericScores = sortedScores.map((entry) => entry.value);
-        const min = numericScores.length > 0 ? numericScores[0] : null;
-        const max = numericScores.length > 0
-            ? numericScores[numericScores.length - 1]
-            : null;
-        const avg = numericScores.length > 0
-            ? round2(numericScores.reduce((sum, value) => sum + value, 0) /
-                numericScores.length)
-            : null;
-        return {
-            key: group.scenarioRunId,
-            scenarioRunId: group.scenarioRunId,
-            gradeSampleCount: group.requests.length,
-            completedSampleCount: group.completedSampleCount,
-            executionFailureCount: group.executionFailureCount,
-            gradingFailureCount: group.gradingFailureCount,
-            averageScore: avg,
-            minScore: min === null ? null : round2(min),
-            maxScore: max === null ? null : round2(max),
-            failed: group.executionFailureCount > 0,
-            minRunId: sortedScores[0]?.runId,
-            maxRunId: sortedScores[sortedScores.length - 1]?.runId,
-            messageRefId: sortedScores[0]?.messageRefId ??
-                sortedScores[sortedScores.length - 1]?.messageRefId,
-        };
-    }).sort((left, right) => {
-        if (left.failed !== right.failed)
-            return left.failed ? -1 : 1;
-        const leftScore = left.averageScore ?? Number.POSITIVE_INFINITY;
-        const rightScore = right.averageScore ?? Number.POSITIVE_INFINITY;
-        if (leftScore !== rightScore)
-            return leftScore - rightScore;
-        return left.scenarioRunId.localeCompare(right.scenarioRunId);
-    });
-    const scoreMin = scoreValues.length > 0 ? Math.min(...scoreValues) : null;
-    const scoreMax = scoreValues.length > 0 ? Math.max(...scoreValues) : null;
-    const scoreMedian = median(scoreValues);
-    const scoreMean = scoreValues.length > 0
-        ? round2(scoreValues.reduce((sum, value) => sum + value, 0) / scoreValues.length)
-        : null;
-    const passRate = scoreCount > 0 ? round2(passCount / scoreCount) : null;
-    return {
-        scenarioRunCountRequested: args.batch.scenarioRuns,
-        scenarioRunCountCompleted: args.batch.scenarioRunsCompleted,
-        scenarioRunCountFailed: args.batch.scenarioRunsFailed,
-        gradeSampleCountRequested: args.batch.requested,
-        gradeSampleCountCompleted: args.batch.completed,
-        gradeSampleCountFailed: args.batch.failed,
-        executionFailureCount: args.batch.failed,
-        gradingFailureCount,
-        passRate,
-        scoreMin: scoreMin === null ? null : round2(scoreMin),
-        scoreMedian: scoreMedian === null ? null : round2(scoreMedian),
-        scoreMax: scoreMax === null ? null : round2(scoreMax),
-        scoreMean,
-        outlierScenarioRuns,
-        failureReasons: [...reasonCounter.values()].sort((left, right) => {
-            if (left.count !== right.count)
-                return right.count - left.count;
-            return left.reason.localeCompare(right.reason);
-        }),
-    };
-}
-function toWorkspaceVerifyBatchStatus(value) {
-    if (value === "running")
-        return "RUNNING";
-    if (value === "completed")
-        return "COMPLETED";
-    if (value === "error")
-        return "ERROR";
-    return "IDLE";
-}
-function toWorkspaceVerifyBatchRequestStatus(value) {
-    if (value === "running")
-        return "RUNNING";
-    if (value === "completed")
-        return "COMPLETED";
-    if (value === "error")
-        return "ERROR";
-    return "QUEUED";
-}
-const WorkspaceVerifyBatchStatusEnum = builder.enumType("WorkspaceVerifyBatchStatus", {
-    values: ["IDLE", "RUNNING", "COMPLETED", "ERROR"],
-});
-const WorkspaceVerifyBatchRequestStatusEnum = builder.enumType("WorkspaceVerifyBatchRequestStatus", {
-    values: ["QUEUED", "RUNNING", "COMPLETED", "ERROR"],
-});
-const WorkspaceVerifyFailureReasonKindEnum = builder.enumType("WorkspaceVerifyFailureReasonKind", {
-    values: ["EXECUTION", "GRADING"],
-});
-const WorkspaceGradeTurnType = builder.objectRef("WorkspaceGradeTurn");
-WorkspaceGradeTurnType.implement({
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        runId: t.id({ resolve: (parent) => parent.runId }),
-        turnIndex: t.int({ resolve: (parent) => parent.turnIndex }),
-        turnNumber: t.int({ resolve: (parent) => parent.turnNumber }),
-        refId: t.id({ resolve: (parent) => parent.refId }),
-        score: t.float({
-            nullable: true,
-            resolve: (parent) => parent.score ?? null,
-        }),
-        reason: t.string({
-            nullable: true,
-            resolve: (parent) => parent.reason ?? null,
-        }),
-        priorUser: t.string({
-            nullable: true,
-            resolve: (parent) => parent.priorUser ?? null,
-        }),
-        gradedAssistant: t.string({
-            nullable: true,
-            resolve: (parent) => parent.gradedAssistant ?? null,
-        }),
-    }),
-});
-const WorkspaceGradeRunSummaryType = builder.objectRef("WorkspaceGradeRunSummary");
-WorkspaceGradeRunSummaryType.implement({
-    fields: (t) => ({
-        score: t.float({
-            nullable: true,
-            resolve: (parent) => parent.score ?? null,
-        }),
-        reason: t.string({
-            nullable: true,
-            resolve: (parent) => parent.reason ?? null,
-        }),
-    }),
-});
-const WorkspaceGradeRunType = builder.objectRef("WorkspaceGradeRun");
-WorkspaceGradeRunType.implement({
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        workspaceId: t.id({ resolve: (parent) => parent.workspaceId }),
-        scenarioRunId: t.id({
-            nullable: true,
-            resolve: (parent) => parent.scenarioRunId ?? null,
-        }),
-        graderId: t.id({ resolve: (parent) => parent.graderId }),
-        graderPath: t.string({ resolve: (parent) => parent.graderPath }),
-        graderLabel: t.string({
-            nullable: true,
-            resolve: (parent) => parent.graderLabel ?? null,
-        }),
-        status: t.field({
-            type: WorkspaceGradeRunStatusEnum,
-            resolve: (parent) => toWorkspaceGradeRunStatus(parent.status),
-        }),
-        runAt: t.string({
-            nullable: true,
-            resolve: (parent) => parent.runAt ?? null,
-        }),
-        error: t.string({
-            nullable: true,
-            resolve: (parent) => parent.error ?? null,
-        }),
-        summary: t.field({
-            type: WorkspaceGradeRunSummaryType,
-            nullable: true,
-            resolve: (parent) => parent.summary
-                ? {
-                    score: parent.summary.score,
-                    reason: parent.summary.reason,
-                }
-                : null,
-        }),
-        turns: t.field({
-            type: [WorkspaceGradeTurnType],
-            resolve: (parent) => parent.turns,
-        }),
-    }),
-});
-const WorkspaceGraderDeckType = builder.objectRef("WorkspaceGraderDeck");
-WorkspaceGraderDeckType.implement({
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        label: t.string({ resolve: (parent) => parent.label }),
-        description: t.string({
-            nullable: true,
-            resolve: (parent) => parent.description ?? null,
-        }),
-        path: t.string({ resolve: (parent) => parent.path }),
-    }),
-});
-const WorkspaceGradeFlagType = builder.objectRef("WorkspaceGradeFlag");
-WorkspaceGradeFlagType.implement({
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        refId: t.id({ resolve: (parent) => parent.refId }),
-        runId: t.id({
-            nullable: true,
-            resolve: (parent) => parent.runId ?? null,
-        }),
-        turnIndex: t.int({
-            nullable: true,
-            resolve: (parent) => parent.turnIndex ?? null,
-        }),
-        reason: t.string({
-            nullable: true,
-            resolve: (parent) => parent.reason ?? null,
-        }),
-        createdAt: t.string({ resolve: (parent) => parent.createdAt }),
-    }),
-});
-const WorkspaceGradeTabType = builder.objectRef("WorkspaceGradeTab");
-WorkspaceGradeTabType.implement({
-    fields: (t) => ({
-        graderDecks: t.field({
-            type: [WorkspaceGraderDeckType],
-            resolve: async (parent, _args, context) => context.listWorkspaceGraderDecks
-                ? await context.listWorkspaceGraderDecks(parent.workspaceId)
-                : [],
-        }),
-        runs: t.field({
-            type: [WorkspaceGradeRunType],
-            resolve: async (parent, _args, context) => context.readWorkspaceGradeRuns
-                ? await context.readWorkspaceGradeRuns(parent.workspaceId)
-                : [],
-        }),
-        flags: t.field({
-            type: [WorkspaceGradeFlagType],
-            resolve: async (parent, _args, context) => context.readWorkspaceGradingFlags
-                ? await context.readWorkspaceGradingFlags(parent.workspaceId)
-                : [],
-        }),
-    }),
-});
-const WorkspaceVerifyBatchRequestType = builder.objectRef("WorkspaceVerifyBatchRequest");
-WorkspaceVerifyBatchRequestType.implement({
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        status: t.field({
-            type: WorkspaceVerifyBatchRequestStatusEnum,
-            resolve: (parent) => toWorkspaceVerifyBatchRequestStatus(parent.status),
-        }),
-        runId: t.id({
-            nullable: true,
-            resolve: (parent) => parent.runId ?? null,
-        }),
-        scenarioRunId: t.id({
-            nullable: true,
-            resolve: (parent) => parent.scenarioRunId ?? null,
-        }),
-        error: t.string({
-            nullable: true,
-            resolve: (parent) => parent.error ?? null,
-        }),
-    }),
-});
-const WorkspaceVerifyScenarioOutlierType = builder.objectRef("WorkspaceVerifyScenarioOutlier");
-WorkspaceVerifyScenarioOutlierType.implement({
-    fields: (t) => ({
-        key: t.id({ resolve: (parent) => parent.key }),
-        scenarioRunId: t.id({ resolve: (parent) => parent.scenarioRunId }),
-        gradeSampleCount: t.int({ resolve: (parent) => parent.gradeSampleCount }),
-        completedSampleCount: t.int({
-            resolve: (parent) => parent.completedSampleCount,
-        }),
-        executionFailureCount: t.int({
-            resolve: (parent) => parent.executionFailureCount,
-        }),
-        gradingFailureCount: t.int({
-            resolve: (parent) => parent.gradingFailureCount,
-        }),
-        averageScore: t.float({
-            nullable: true,
-            resolve: (parent) => parent.averageScore,
-        }),
-        minScore: t.float({
-            nullable: true,
-            resolve: (parent) => parent.minScore,
-        }),
-        maxScore: t.float({
-            nullable: true,
-            resolve: (parent) => parent.maxScore,
-        }),
-        failed: t.boolean({ resolve: (parent) => parent.failed }),
-        minRunId: t.id({
-            nullable: true,
-            resolve: (parent) => parent.minRunId ?? null,
-        }),
-        maxRunId: t.id({
-            nullable: true,
-            resolve: (parent) => parent.maxRunId ?? null,
-        }),
-        messageRefId: t.id({
-            nullable: true,
-            resolve: (parent) => parent.messageRefId ?? null,
-        }),
-    }),
-});
-const WorkspaceVerifyFailureReasonGroupType = builder.objectRef("WorkspaceVerifyFailureReasonGroup");
-WorkspaceVerifyFailureReasonGroupType.implement({
-    fields: (t) => ({
-        key: t.id({ resolve: (parent) => parent.key }),
-        kind: t.field({
-            type: WorkspaceVerifyFailureReasonKindEnum,
-            resolve: (parent) => parent.kind === "execution" ? "EXECUTION" : "GRADING",
-        }),
-        reason: t.string({ resolve: (parent) => parent.reason }),
-        count: t.int({ resolve: (parent) => parent.count }),
-    }),
-});
-const WorkspaceVerifyMetricsType = builder.objectRef("WorkspaceVerifyMetrics");
-WorkspaceVerifyMetricsType.implement({
-    fields: (t) => ({
-        scenarioRunCountRequested: t.int({
-            resolve: (parent) => parent.scenarioRunCountRequested,
-        }),
-        scenarioRunCountCompleted: t.int({
-            resolve: (parent) => parent.scenarioRunCountCompleted,
-        }),
-        scenarioRunCountFailed: t.int({
-            resolve: (parent) => parent.scenarioRunCountFailed,
-        }),
-        gradeSampleCountRequested: t.int({
-            resolve: (parent) => parent.gradeSampleCountRequested,
-        }),
-        gradeSampleCountCompleted: t.int({
-            resolve: (parent) => parent.gradeSampleCountCompleted,
-        }),
-        gradeSampleCountFailed: t.int({
-            resolve: (parent) => parent.gradeSampleCountFailed,
-        }),
-        executionFailureCount: t.int({
-            resolve: (parent) => parent.executionFailureCount,
-        }),
-        gradingFailureCount: t.int({
-            resolve: (parent) => parent.gradingFailureCount,
-        }),
-        passRate: t.float({
-            nullable: true,
-            resolve: (parent) => parent.passRate,
-        }),
-        scoreMin: t.float({
-            nullable: true,
-            resolve: (parent) => parent.scoreMin,
-        }),
-        scoreMedian: t.float({
-            nullable: true,
-            resolve: (parent) => parent.scoreMedian,
-        }),
-        scoreMax: t.float({
-            nullable: true,
-            resolve: (parent) => parent.scoreMax,
-        }),
-        scoreMean: t.float({
-            nullable: true,
-            resolve: (parent) => parent.scoreMean,
-        }),
-        outlierScenarioRuns: t.connection({
-            type: WorkspaceVerifyScenarioOutlierType,
-            args: {
-                first: t.arg.int(),
-                after: t.arg.string(),
-            },
-            resolve: (parent, args) => resolveArrayConnection({ args }, parent.outlierScenarioRuns),
-        }),
-        failureReasons: t.connection({
-            type: WorkspaceVerifyFailureReasonGroupType,
-            args: {
-                first: t.arg.int(),
-                after: t.arg.string(),
-            },
-            resolve: (parent, args) => resolveArrayConnection({ args }, parent.failureReasons),
-        }),
-    }),
-});
-const WorkspaceVerifyBatchType = builder.objectRef("WorkspaceVerifyBatch");
-WorkspaceVerifyBatchType.implement({
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        workspaceId: t.id({ resolve: (parent) => parent.workspaceId }),
-        scenarioDeckId: t.id({
-            nullable: true,
-            resolve: (parent) => parent.scenarioDeckId ?? null,
-        }),
-        graderId: t.id({ resolve: (parent) => parent.graderId }),
-        scenarioRuns: t.int({
-            resolve: (parent) => parent.scenarioRuns,
-        }),
-        graderRepeatsPerScenario: t.int({
-            resolve: (parent) => parent.graderRepeatsPerScenario,
-        }),
-        scenarioRunsCompleted: t.int({
-            resolve: (parent) => parent.scenarioRunsCompleted,
-        }),
-        scenarioRunsFailed: t.int({
-            resolve: (parent) => parent.scenarioRunsFailed,
-        }),
-        status: t.field({
-            type: WorkspaceVerifyBatchStatusEnum,
-            resolve: (parent) => toWorkspaceVerifyBatchStatus(parent.status),
-        }),
-        startedAt: t.string({
-            nullable: true,
-            resolve: (parent) => parent.startedAt ?? null,
-        }),
-        finishedAt: t.string({
-            nullable: true,
-            resolve: (parent) => parent.finishedAt ?? null,
-        }),
-        requested: t.int({ resolve: (parent) => parent.requested }),
-        active: t.int({ resolve: (parent) => parent.active }),
-        completed: t.int({ resolve: (parent) => parent.completed }),
-        failed: t.int({ resolve: (parent) => parent.failed }),
-        requests: t.connection({
-            type: WorkspaceVerifyBatchRequestType,
-            args: {
-                first: t.arg.int(),
-                after: t.arg.string(),
-            },
-            resolve: (parent, args) => resolveArrayConnection({ args }, parent.requests),
-        }),
-        metrics: t.field({
-            type: WorkspaceVerifyMetricsType,
-            nullable: true,
-            resolve: async (parent, _args, context) => {
-                if (!context.readWorkspaceGradeRuns)
-                    return null;
-                const runIds = parent.requests
-                    .filter((request) => typeof request.runId === "string" &&
-                    request.runId.trim().length > 0)
-                    .map((request) => request.runId);
-                const runIdSet = new Set(runIds);
-                const allRuns = await context.readWorkspaceGradeRuns(parent.workspaceId);
-                const selectedRuns = allRuns.filter((run) => runIdSet.has(run.id));
-                return buildVerifyMetrics({
-                    batch: parent,
-                    runs: selectedRuns,
-                });
-            },
-        }),
-    }),
-});
-const WorkspaceConversationSessionInterface = builder.interfaceRef("WorkspaceConversationSession");
-WorkspaceConversationSessionInterface.implement({
-    resolveType: (parent) => {
-        if (parent.kind === "build")
-            return "WorkspaceBuildConversationSession";
-        if (parent.kind === "scenario") {
-            return "WorkspaceScenarioConversationSession";
-        }
-        if (parent.kind === "grader")
-            return "WorkspaceGraderConversationSession";
-        return "WorkspaceVerifyConversationSession";
-    },
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => `${parent.kind}:${parent.sessionId}` }),
-        sessionId: t.id({ resolve: (parent) => parent.sessionId }),
-        workspaceId: t.id({
-            resolve: (parent) => asGambitID(parent.workspaceId),
-        }),
-        status: t.field({
-            type: OpenResponseStatusEnum,
-            resolve: (parent) => toOpenResponseStatus(parent.status),
-        }),
-        error: t.string({
-            nullable: true,
-            resolve: (parent) => parent.error ?? null,
-        }),
-        startedAt: t.string({
-            nullable: true,
-            resolve: (parent) => parent.startedAt ?? null,
-        }),
-        finishedAt: t.string({
-            nullable: true,
-            resolve: (parent) => parent.finishedAt ?? null,
-        }),
-    }),
-});
-const WorkspaceBuildConversationSessionType = builder.objectRef("WorkspaceBuildConversationSession");
-WorkspaceBuildConversationSessionType.implement({
-    interfaces: [WorkspaceConversationSessionInterface],
-    isTypeOf: (parent) => isWorkspaceConversationSessionRecord(parent) && parent.kind === "build",
-    fields: (t) => ({
-        run: t.field({
-            type: WorkspaceConversationRunInterface,
-            resolve: (parent) => {
-                if (!parent.buildRun) {
-                    throw new Error("WorkspaceBuildConversationSession missing build run");
-                }
-                return {
-                    ...parent.buildRun,
-                    workspaceId: parent.workspaceId,
-                    conversationRunKind: "build",
-                };
-            },
-        }),
-    }),
-});
-const WorkspaceScenarioConversationSessionType = builder.objectRef("WorkspaceScenarioConversationSession");
-WorkspaceScenarioConversationSessionType.implement({
-    interfaces: [WorkspaceConversationSessionInterface],
-    isTypeOf: (parent) => isWorkspaceConversationSessionRecord(parent) && parent.kind === "scenario",
-    fields: (t) => ({
-        run: t.field({
-            type: WorkspaceConversationRunInterface,
-            resolve: (parent) => {
-                if (!parent.scenarioRun) {
-                    throw new Error("WorkspaceScenarioConversationSession missing scenario run");
-                }
-                return {
-                    ...parent.scenarioRun,
-                    workspaceId: parent.workspaceId,
-                    conversationRunKind: "scenario",
-                };
-            },
-        }),
-    }),
-});
-const WorkspaceGraderConversationSessionType = builder.objectRef("WorkspaceGraderConversationSession");
-WorkspaceGraderConversationSessionType.implement({
-    interfaces: [WorkspaceConversationSessionInterface],
-    isTypeOf: (parent) => isWorkspaceConversationSessionRecord(parent) && parent.kind === "grader",
-    fields: (t) => ({
-        gradeRun: t.field({
-            type: WorkspaceGradeRunType,
-            resolve: (parent) => {
-                if (!parent.gradeRun) {
-                    throw new Error("WorkspaceGraderConversationSession missing grade run");
-                }
-                return parent.gradeRun;
-            },
-        }),
-    }),
-});
-const WorkspaceVerifyConversationSessionType = builder.objectRef("WorkspaceVerifyConversationSession");
-WorkspaceVerifyConversationSessionType.implement({
-    interfaces: [WorkspaceConversationSessionInterface],
-    isTypeOf: (parent) => isWorkspaceConversationSessionRecord(parent) && parent.kind === "verify",
-    fields: (t) => ({
-        verifyBatch: t.field({
-            type: WorkspaceVerifyBatchType,
-            resolve: (parent) => {
-                if (!parent.verifyBatch) {
-                    throw new Error("WorkspaceVerifyConversationSession missing verify batch");
-                }
-                return parent.verifyBatch;
-            },
-        }),
-    }),
-});
-const WorkspaceVerificationType = builder.objectRef("WorkspaceVerification");
-WorkspaceVerificationType.implement({
-    fields: (t) => ({
-        graderDecks: t.connection({
-            type: WorkspaceGraderDeckType,
-            args: {
-                first: t.arg.int(),
-                after: t.arg.string(),
-            },
-            resolve: async (parent, args, context) => {
-                const graderDecks = context.listWorkspaceGraderDecks
-                    ? await context.listWorkspaceGraderDecks(parent.workspaceId)
-                    : [];
-                return resolveArrayConnection({ args }, graderDecks);
-            },
-        }),
-        batches: t.connection({
-            type: WorkspaceVerifyBatchType,
-            args: {
-                first: t.arg.int(),
-                after: t.arg.string(),
-            },
-            resolve: async (parent, args, context) => {
-                const batches = context.readWorkspaceVerifyBatches
-                    ? await context.readWorkspaceVerifyBatches(parent.workspaceId)
-                    : [];
-                const sorted = [...batches].sort((left, right) => {
-                    const leftKey = left.startedAt ?? left.finishedAt ?? left.id;
-                    const rightKey = right.startedAt ?? right.finishedAt ?? right.id;
-                    return rightKey.localeCompare(leftKey);
-                });
-                return resolveArrayConnection({ args }, sorted);
-            },
-        }),
-    }),
-});
-const WorkspaceType = builder.objectRef("Workspace");
-WorkspaceType.implement({
-    fields: (t) => ({
-        id: t.id({ resolve: (parent) => parent.id }),
-        scenarioDecks: t.field({
-            type: [WorkspaceScenarioDeckType],
-            resolve: async (parent, _args, context) => context.listWorkspaceScenarioDecks
-                ? await context.listWorkspaceScenarioDecks(parent.id)
-                : [],
-        }),
-        assistantDeck: t.field({
-            type: WorkspaceAssistantDeckType,
-            nullable: true,
-            resolve: async (parent, _args, context) => context.readWorkspaceAssistantDeck
-                ? await context.readWorkspaceAssistantDeck(parent.id)
-                : null,
-        }),
-        scenarioRuns: t.connection({
-            type: WorkspaceConversationRunInterface,
-            args: {
-                first: t.arg.int(),
-                after: t.arg.string(),
-            },
-            resolve: async (parent, args, context) => {
-                const runs = context.readWorkspaceScenarioRuns
-                    ? await context.readWorkspaceScenarioRuns(parent.id)
-                    : [];
-                return resolveArrayConnection({ args }, runs.map((run) => ({
-                    ...run,
-                    conversationRunKind: "scenario",
-                })));
-            },
-        }),
-        files: t.connection({
-            type: WorkspaceFileType,
-            args: {
-                id: t.arg.id(),
-                pathPrefix: t.arg({
-                    type: WorkspaceRelativePathScalar,
-                }),
-            },
-            resolve: async (parent, args, context) => {
-                const files = await context.readWorkspaceFiles({
-                    workspaceId: parent.id,
-                    id: args.id ? asGambitID(args.id) : null,
-                    pathPrefix: args.pathPrefix ?? null,
-                });
-                return resolveArrayConnection({ args }, files);
-            },
-        }),
-        build: t.field({
-            type: BuildStateType,
-            resolve: async (parent, _args, context) => {
-                const run = context.readWorkspaceBuildRun
-                    ? await context.readWorkspaceBuildRun(parent.id)
-                    : {
-                        id: parent.id,
-                        status: "idle",
-                        messages: [],
-                        traces: [],
-                        toolInserts: [],
-                    };
-                return {
-                    workspaceId: parent.id,
-                    run,
-                };
-            },
-        }),
-        buildRuns: t.connection({
-            type: WorkspaceConversationRunInterface,
-            args: {
-                first: t.arg.int(),
-                after: t.arg.string(),
-            },
-            resolve: async (parent, args, context) => {
-                const run = context.readWorkspaceBuildRun
-                    ? await context.readWorkspaceBuildRun(parent.id)
-                    : {
-                        id: parent.id,
-                        status: "idle",
-                        messages: [],
-                        traces: [],
-                        toolInserts: [],
-                    };
-                return resolveArrayConnection({ args }, [{
-                        ...run,
-                        workspaceId: parent.id,
-                        conversationRunKind: "build",
-                    }]);
-            },
-        }),
-        conversationSessions: t.connection({
-            type: WorkspaceConversationSessionInterface,
-            args: {
-                first: t.arg.int(),
-                after: t.arg.string(),
-            },
-            resolve: async (parent, args, context) => {
-                const sessions = context.listWorkspaceConversationSessions
-                    ? await context.listWorkspaceConversationSessions({
-                        workspaceId: parent.id,
-                        kind: null,
-                    })
-                    : [];
-                return resolveArrayConnection({ args }, sessions);
-            },
-        }),
-        conversationSession: t.field({
-            type: WorkspaceConversationSessionInterface,
-            nullable: true,
-            args: {
-                sessionId: t.arg.id({ required: true }),
-            },
-            resolve: async (parent, args, context) => {
-                if (context.listWorkspaceConversationSessions) {
-                    const sessions = await context.listWorkspaceConversationSessions({
-                        workspaceId: parent.id,
-                        kind: null,
-                    });
-                    return sessions.find((session) => session.sessionId === args.sessionId) ??
-                        null;
-                }
-                if (!context.readWorkspaceConversationSession)
-                    return null;
-                for (const kind of ["build", "scenario", "grader", "verify"]) {
-                    const session = await context.readWorkspaceConversationSession({
-                        workspaceId: parent.id,
-                        kind,
-                        sessionId: args.sessionId,
-                    });
-                    if (session)
-                        return session;
-                }
-                return null;
-            },
-        }),
-        gradeTab: t.field({
-            type: WorkspaceGradeTabType,
-            resolve: (parent) => ({ workspaceId: parent.id }),
-        }),
-        verification: t.field({
-            type: WorkspaceVerificationType,
-            resolve: (parent) => ({ workspaceId: parent.id }),
-        }),
-        workbenchSelectedContextChips: t.field({
-            description: "Client-exclusive ephemeral workbench chip selection. This field exists for Isograph-owned simulator state until durable persistence is needed.",
-            type: "JSON",
-            resolve: () => [],
-        }),
-        models: t.field({
-            type: WorkspaceModelsType,
-            resolve: (parent) => ({ workspaceId: parent.id }),
-        }),
-    }),
-});
-const WorkspaceCreatePayloadType = builder.objectRef("WorkspaceCreatePayload");
-WorkspaceCreatePayloadType.implement({
-    fields: (t) => ({
-        workspace: t.field({
-            type: WorkspaceType,
-            resolve: (parent) => parent.workspace,
-        }),
-        workspaces: t.connection({
-            type: WorkspaceSessionMetaType,
-            args: {
-                first: t.arg.int(),
-                after: t.arg.string(),
-            },
-            resolve: async (parent, args, context) => {
-                const workspaces = parent.workspaces ??
-                    (context.listWorkspaces ? await context.listWorkspaces() : []);
-                return resolveArrayConnection({ args }, workspaces);
-            },
-        }),
-    }),
-});
-const WorkspaceBuildRunCreatePayloadType = builder.objectRef("WorkspaceBuildRunCreatePayload");
-WorkspaceBuildRunCreatePayloadType.implement({
-    fields: (t) => ({
-        workspace: t.field({
-            type: WorkspaceType,
-            resolve: (parent) => parent.workspace,
-        }),
-        run: t.field({
-            type: WorkspaceBuildRunType,
-            resolve: (parent) => parent.run,
-        }),
-    }),
-});
-const WorkspaceScenarioRunStartPayloadType = builder.objectRef("WorkspaceScenarioRunStartPayload");
-WorkspaceScenarioRunStartPayloadType.implement({
-    fields: (t) => ({
-        workspace: t.field({
-            type: WorkspaceType,
-            resolve: (parent) => parent.workspace,
-        }),
-        run: t.field({
-            type: WorkspaceScenarioRunType,
-            resolve: (parent) => parent.run,
-        }),
-    }),
-});
-const WorkspaceScenarioRunSendPayloadType = builder.objectRef("WorkspaceScenarioRunSendPayload");
-WorkspaceScenarioRunSendPayloadType.implement({
-    fields: (t) => ({
-        workspace: t.field({
-            type: WorkspaceType,
-            resolve: (parent) => parent.workspace,
-        }),
-        run: t.field({
-            type: WorkspaceScenarioRunType,
-            resolve: (parent) => parent.run,
-        }),
-    }),
-});
-const WorkspaceScenarioRunStopPayloadType = builder.objectRef("WorkspaceScenarioRunStopPayload");
-WorkspaceScenarioRunStopPayloadType.implement({
-    fields: (t) => ({
-        workspace: t.field({
-            type: WorkspaceType,
-            resolve: (parent) => parent.workspace,
-        }),
-        run: t.field({
-            type: WorkspaceScenarioRunType,
-            resolve: (parent) => parent.run,
-        }),
-    }),
-});
-const WorkspaceFeedbackSavePayloadType = builder.objectRef("WorkspaceFeedbackSavePayload");
-WorkspaceFeedbackSavePayloadType.implement({
-    fields: (t) => ({
-        workspace: t.field({
-            type: WorkspaceType,
-            resolve: (parent) => parent.workspace,
-        }),
-        run: t.field({
-            type: WorkspaceScenarioRunType,
-            resolve: (parent) => parent.run,
-        }),
-        feedback: t.field({
-            type: FeedbackType,
-            nullable: true,
-            resolve: (parent) => parent.feedback ?? null,
-        }),
-        deleted: t.boolean({ resolve: (parent) => parent.deleted }),
-    }),
-});
-const WorkspaceConversationSessionPayloadType = builder.objectRef("WorkspaceConversationSessionPayload");
-WorkspaceConversationSessionPayloadType.implement({
-    fields: (t) => ({
-        workspace: t.field({
-            type: WorkspaceType,
-            resolve: (parent) => parent.workspace,
-        }),
-        session: t.field({
-            type: WorkspaceConversationSessionInterface,
-            resolve: (parent) => parent.session,
-        }),
-    }),
-});
-const WorkspaceGradeRunCreatePayloadType = builder.objectRef("WorkspaceGradeRunCreatePayload");
-WorkspaceGradeRunCreatePayloadType.implement({
-    fields: (t) => ({
-        workspace: t.field({
-            type: WorkspaceType,
-            resolve: (parent) => parent.workspace,
-        }),
-        run: t.field({
-            type: WorkspaceGradeRunType,
-            resolve: (parent) => parent.run,
-        }),
-    }),
-});
-const WorkspaceVerifyBatchRunCreatePayloadType = builder.objectRef("WorkspaceVerifyBatchRunCreatePayload");
-WorkspaceVerifyBatchRunCreatePayloadType.implement({
-    fields: (t) => ({
-        workspace: t.field({
-            type: WorkspaceType,
-            resolve: (parent) => parent.workspace,
-        }),
-        batch: t.field({
-            type: WorkspaceVerifyBatchType,
-            resolve: (parent) => parent.batch,
-        }),
-    }),
-});
-const WorkspaceGradeFlagTogglePayloadType = builder.objectRef("WorkspaceGradeFlagTogglePayload");
-WorkspaceGradeFlagTogglePayloadType.implement({
-    fields: (t) => ({
-        workspace: t.field({
-            type: WorkspaceType,
-            resolve: (parent) => parent.workspace,
-        }),
-        flags: t.field({
-            type: [WorkspaceGradeFlagType],
-            resolve: (parent) => parent.flags,
-        }),
-    }),
-});
-const WorkspaceGradeFlagReasonUpdatePayloadType = builder.objectRef("WorkspaceGradeFlagReasonUpdatePayload");
-WorkspaceGradeFlagReasonUpdatePayloadType.implement({
-    fields: (t) => ({
-        workspace: t.field({
-            type: WorkspaceType,
-            resolve: (parent) => parent.workspace,
-        }),
-        flags: t.field({
-            type: [WorkspaceGradeFlagType],
-            resolve: (parent) => parent.flags,
-        }),
-    }),
-});
-const SimulatorStopRunPayloadType = builder.objectRef("SimulatorStopRunPayload");
-SimulatorStopRunPayloadType.implement({
-    fields: (t) => ({
-        workspace: t.field({
-            type: WorkspaceType,
-            resolve: (parent) => parent.workspace,
-        }),
-        run: t.field({
-            type: WorkspaceBuildRunType,
-            resolve: (parent) => parent.run,
-        }),
-    }),
-});
-const SimulatorResetWorkspacePayloadType = builder.objectRef("SimulatorResetWorkspacePayload");
-SimulatorResetWorkspacePayloadType.implement({
-    fields: (t) => ({
-        workspace: t.field({
-            type: WorkspaceType,
-            resolve: (parent) => parent.workspace,
-        }),
-        build: t.field({ type: BuildStateType, resolve: (parent) => parent.build }),
-    }),
-});
-const WorkspaceSnapshotUpdateType = builder.objectRef("WorkspaceSnapshotUpdate");
-WorkspaceSnapshotUpdateType.implement({
-    fields: (t) => ({
-        workspaceId: t.id({ resolve: (parent) => parent.workspaceId }),
-    }),
-});
-const WorkspaceRunLifecycleUpdateType = builder.objectRef("WorkspaceRunLifecycleUpdate");
-WorkspaceRunLifecycleUpdateType.implement({
-    fields: (t) => ({
-        workspaceId: t.id({ resolve: (parent) => parent.workspaceId }),
-        runId: t.id({
-            nullable: true,
-            resolve: (parent) => parent.runId ?? null,
-        }),
-        status: t.string({
-            nullable: true,
-            resolve: (parent) => parent.status ?? null,
-        }),
-    }),
-});
-const OpenResponseEventUpdateType = builder.objectRef("OpenResponseEventUpdate");
-OpenResponseEventUpdateType.implement({
-    fields: (t) => ({
-        workspaceId: t.id({ resolve: (parent) => parent.workspaceId }),
-        runId: t.id({ nullable: true, resolve: (parent) => parent.runId ?? null }),
-        eventType: t.string({
-            nullable: true,
-            resolve: (parent) => parent.eventType ?? null,
-        }),
-    }),
-});
-const WorkspaceUpdatePayloadUnion = builder.unionType("WorkspaceUpdatePayload", {
-    types: [
-        WorkspaceSnapshotUpdateType,
-        WorkspaceRunLifecycleUpdateType,
-        OpenResponseEventUpdateType,
-    ],
-    resolveType: (value) => {
-        if (!value || typeof value !== "object")
-            return WorkspaceSnapshotUpdateType;
-        const record = value;
-        if (typeof record.eventType === "string")
-            return OpenResponseEventUpdateType;
-        if (typeof record.runId === "string")
-            return WorkspaceRunLifecycleUpdateType;
-        return WorkspaceSnapshotUpdateType;
-    },
-});
-const WorkspaceUpdateType = builder.objectRef("WorkspaceUpdate");
-WorkspaceUpdateType.implement({
-    fields: (t) => ({
-        workspaceId: t.id({ resolve: (parent) => asGambitID(parent.workspaceId) }),
-        offset: t.int({ resolve: (parent) => parent.offset }),
-        occurredAt: t.string({ resolve: (parent) => parent.occurredAt }),
-        payload: t.field({
-            type: WorkspaceUpdatePayloadUnion,
-            resolve: (parent) => parent.payload,
-        }),
-    }),
-});
-const WorkspaceBuildLiveEdgeType = builder.objectRef("WorkspaceBuildLiveEdge");
-WorkspaceBuildLiveEdgeType.implement({
-    fields: (t) => ({
-        cursor: t.string({
-            resolve: (parent) => String(parent.sourceOffset),
-        }),
-        sourceOffset: t.int({ resolve: (parent) => parent.sourceOffset }),
-        occurredAt: t.string({ resolve: (parent) => parent.occurredAt }),
-        node: t.field({
-            type: WorkspaceType,
-            resolve: (parent) => ({ id: asGambitID(parent.workspaceId) }),
-        }),
-    }),
-});
-const WORKSPACE_STREAM_ID = "gambit-workspace";
-function normalizeStreamEventType(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return "gambit.event";
-    }
-    const rawType = value.type;
-    if (typeof rawType !== "string" || rawType.trim().length === 0) {
-        return "gambit.event";
-    }
-    return rawType;
-}
-function normalizeWorkspaceId(value) {
-    if (typeof value !== "string")
-        return null;
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : null;
-}
-function payloadAsRecord(payload) {
-    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-        return null;
-    }
-    return payload;
-}
-function toCanonicalBuildEventType(type) {
-    if (type === "buildBotStatus")
-        return "gambit.build.status";
-    if (type === "buildBotTrace")
-        return "gambit.build.trace";
-    if (type === "buildBotStream")
-        return "gambit.build.stream.delta";
-    if (type === "buildBotStreamEnd")
-        return "gambit.build.stream.done";
-    if (type === "testBotStatus")
-        return "gambit.test.status";
-    if (type === "testBotTrace")
-        return "gambit.test.trace";
-    if (type === "testBotStream")
-        return "gambit.test.stream.delta";
-    if (type === "testBotStreamEnd")
-        return "gambit.test.stream.done";
-    if (type === "gambit.grade.status")
-        return "gambit.grade.status";
-    if (type === "gambit.grade.flag")
-        return "gambit.grade.flag";
-    if (type === "gambit.verify.batch")
-        return "gambit.verify.batch";
-    if (type === "workspaceGraphRefresh") {
-        return "gambit.workspace.graph.refresh";
-    }
-    return type;
-}
-function toRunId(payload) {
-    if (typeof payload.runId === "string" && payload.runId.trim().length > 0) {
-        return payload.runId;
-    }
-    const run = payloadAsRecord(payload.run);
-    if (run && typeof run.id === "string" && run.id.trim().length > 0) {
-        return run.id;
-    }
-    return undefined;
-}
-function toWorkspaceRunStatus(payload) {
-    const run = payloadAsRecord(payload.run);
-    if (!run || typeof run.status !== "string")
-        return undefined;
-    const trimmed = run.status.trim();
-    if (!trimmed)
-        return undefined;
-    return trimmed.toUpperCase();
-}
-function deriveWorkspaceId(payload) {
-    if (typeof payload.workspaceId === "string" &&
-        payload.workspaceId.trim().length > 0) {
-        return payload.workspaceId.trim();
-    }
-    const run = payloadAsRecord(payload.run);
-    if (run) {
-        if (typeof run.workspaceId === "string" && run.workspaceId.trim().length > 0) {
-            return run.workspaceId.trim();
-        }
-        if (typeof run.sessionId === "string" && run.sessionId.trim().length > 0) {
-            return run.sessionId.trim();
-        }
-    }
-    if (typeof payload.runId === "string" && payload.runId.trim().length > 0) {
-        return payload.runId.trim();
-    }
-    return null;
-}
-function projectWorkspaceUpdateFromStreamEvent(event, expectedWorkspaceId) {
-    const data = payloadAsRecord(event.data);
-    if (!data || typeof data.type !== "string")
-        return null;
-    const workspaceId = deriveWorkspaceId(data);
-    if (!workspaceId || workspaceId !== expectedWorkspaceId)
-        return null;
-    const canonicalType = toCanonicalBuildEventType(data.type);
-    if (canonicalType === "gambit.build.status") {
-        return {
-            workspaceId,
-            offset: event.offset,
-            occurredAt: event.createdAt,
-            payload: {
-                workspaceId,
-                runId: toRunId(data),
-                status: toWorkspaceRunStatus(data),
-            },
-        };
-    }
-    if (canonicalType === "gambit.build.trace" ||
-        canonicalType === "gambit.build.stream.delta" ||
-        canonicalType === "gambit.build.stream.done" ||
-        canonicalType === "gambit.grade.flag" ||
-        canonicalType === "gambit.verify.batch") {
-        return {
-            workspaceId,
-            offset: event.offset,
-            occurredAt: event.createdAt,
-            payload: {
-                workspaceId,
-                runId: toRunId(data),
-                eventType: canonicalType,
-            },
-        };
-    }
-    if (canonicalType === "gambit.grade.status") {
-        return {
-            workspaceId,
-            offset: event.offset,
-            occurredAt: event.createdAt,
-            payload: {
-                workspaceId,
-                runId: toRunId(data),
-                status: toWorkspaceRunStatus(data),
-            },
-        };
-    }
-    return {
-        workspaceId,
-        offset: event.offset,
-        occurredAt: event.createdAt,
-        payload: { workspaceId },
-    };
-}
-function projectWorkspaceBuildLiveFromStreamEvent(event, expectedWorkspaceId, family = "build") {
-    const data = payloadAsRecord(event.data);
-    if (!data || typeof data.type !== "string") {
-        logBuildChatDebug("buildLive.drop.invalid", {
-            expectedWorkspaceId,
-            sourceOffset: event.offset,
-        });
-        return null;
-    }
-    const canonicalType = toCanonicalBuildEventType(data.type);
-    const refreshReason = typeof data.reason === "string" ? data.reason : null;
-    const refreshPathCount = Array.isArray(data.paths) ? data.paths.length : null;
-    if (canonicalType === "gambit.workspace.graph.refresh") {
-        logBuildChatDebug("buildLive.graphRefresh.seen", {
-            family,
-            expectedWorkspaceId,
-            sourceOffset: event.offset,
-            type: data.type,
-            canonicalType,
-            refreshReason,
-            refreshPathCount,
-        });
-    }
-    const isBuildFamily = family === "build";
-    const isTestFamily = family === "test";
-    const isGradeFamily = family === "grade";
-    const isAllowedFamilyType = isBuildFamily
-        ? (canonicalType === "gambit.build.status" ||
-            canonicalType === "gambit.build.stream.delta" ||
-            canonicalType === "gambit.build.stream.done" ||
-            canonicalType === "gambit.build.trace")
-        : isTestFamily
-            ? (canonicalType === "gambit.test.status" ||
-                canonicalType === "gambit.test.stream.delta" ||
-                canonicalType === "gambit.test.stream.done" ||
-                canonicalType === "gambit.test.trace")
-            : isGradeFamily
-                ? (canonicalType === "gambit.grade.status" ||
-                    canonicalType === "gambit.grade.flag")
-                : (canonicalType === "gambit.verify.batch");
-    if (!isAllowedFamilyType &&
-        canonicalType !== "gambit.workspace.graph.refresh") {
-        logBuildChatDebug("buildLive.drop.type", {
-            family,
-            expectedWorkspaceId,
-            sourceOffset: event.offset,
-            type: data.type,
-            canonicalType,
-            refreshReason,
-            refreshPathCount,
-        });
-        return null;
-    }
-    const workspaceId = deriveWorkspaceId(data);
-    if (!workspaceId || workspaceId !== expectedWorkspaceId) {
-        logBuildChatDebug("buildLive.drop.workspace", {
-            family,
-            expectedWorkspaceId,
-            sourceOffset: event.offset,
-            type: data.type,
-            canonicalType,
-            workspaceId,
-            refreshReason,
-            refreshPathCount,
-        });
-        return null;
-    }
-    logBuildChatDebug("buildLive.accept", {
-        family,
-        expectedWorkspaceId,
-        workspaceId,
-        sourceOffset: event.offset,
-        type: data.type,
-        canonicalType,
-        refreshReason,
-        refreshPathCount,
-    });
-    return {
-        workspaceId,
-        sourceOffset: event.offset,
-        occurredAt: event.createdAt,
-    };
-}
-function resolveRequestedFromOffset(fromOffset) {
-    const requested = typeof fromOffset === "number" && Number.isFinite(fromOffset)
-        ? Math.max(0, Math.floor(fromOffset))
-        : 0;
-    const streamHead = Math.max(0, getDurableStreamNextOffset(WORKSPACE_STREAM_ID));
-    const effective = Math.min(requested, streamHead);
-    if (effective !== requested) {
-        logBuildChatDebug("buildLive.offset.clamped", {
-            requestedFromOffset: requested,
-            effectiveFromOffset: effective,
-            streamHead,
-        });
-    }
-    return { requested, effective };
-}
-const OpenResponseInputItemInput = builder.inputType("OpenResponseInputItemInput", {
-    fields: (t) => ({
-        role: t.string(),
-        content: t.string({ required: true }),
-    }),
-});
-const WorkspaceBuildRunCreateInput = builder.inputType("WorkspaceBuildRunCreateInput", {
-    fields: (t) => ({
-        workspaceId: t.id({ required: true }),
-        inputItems: t.field({
-            required: true,
-            type: [OpenResponseInputItemInput],
-        }),
-    }),
-});
-const WorkspaceScenarioRunStartInput = builder.inputType("WorkspaceScenarioRunStartInput", {
-    fields: (t) => ({
-        workspaceId: t.id({ required: true }),
-        scenarioDeckId: t.id(),
-        scenarioInput: t.field({ type: "JSON" }),
-        assistantInit: t.field({ type: "JSON" }),
-    }),
-});
-const WorkspaceScenarioRunSendInput = builder.inputType("WorkspaceScenarioRunSendInput", {
-    fields: (t) => ({
-        workspaceId: t.id({ required: true }),
-        runId: t.id({ required: true }),
-        inputItems: t.field({
-            required: true,
-            type: [OpenResponseInputItemInput],
-        }),
-    }),
-});
-const WorkspaceScenarioRunStopInput = builder.inputType("WorkspaceScenarioRunStopInput", {
-    fields: (t) => ({
-        workspaceId: t.id({ required: true }),
-        runId: t.id({ required: true }),
-    }),
-});
-const WorkspaceFeedbackSaveInput = builder.inputType("WorkspaceFeedbackSaveInput", {
-    fields: (t) => ({
-        workspaceId: t.id({ required: true }),
-        runId: t.id(),
-        messageRefId: t.id({ required: true }),
-        score: t.int(),
-        reason: t.string(),
-    }),
-});
-const WorkspaceConversationSessionStartInput = builder.inputType("WorkspaceConversationSessionStartInput", {
-    fields: (t) => ({
-        workspaceId: t.id({ required: true }),
-        kind: t.string({ required: true }),
-        sessionId: t.id(),
-        inputItems: t.field({ type: [OpenResponseInputItemInput] }),
-        scenarioDeckId: t.id(),
-        scenarioInput: t.field({ type: "JSON" }),
-        assistantInit: t.field({ type: "JSON" }),
-        graderId: t.id(),
-        scenarioRunId: t.id(),
-        scenarioRuns: t.int(),
-        graderRepeatsPerScenario: t.int(),
-        concurrency: t.int(),
-    }),
-});
-const WorkspaceConversationSessionSendInput = builder.inputType("WorkspaceConversationSessionSendInput", {
-    fields: (t) => ({
-        workspaceId: t.id({ required: true }),
-        kind: t.string({ required: true }),
-        sessionId: t.id({ required: true }),
-        inputItems: t.field({
-            required: true,
-            type: [OpenResponseInputItemInput],
-        }),
-    }),
-});
-const WorkspaceConversationSessionStopInput = builder.inputType("WorkspaceConversationSessionStopInput", {
-    fields: (t) => ({
-        workspaceId: t.id({ required: true }),
-        kind: t.string({ required: true }),
-        sessionId: t.id({ required: true }),
-    }),
-});
-const WorkspaceGradeRunCreateInput = builder.inputType("WorkspaceGradeRunCreateInput", {
-    fields: (t) => ({
-        workspaceId: t.id({ required: true }),
-        graderId: t.id({ required: true }),
-        scenarioRunId: t.id(),
-    }),
-});
-const WorkspaceVerifyBatchRunCreateInput = builder.inputType("WorkspaceVerifyBatchRunCreateInput", {
-    fields: (t) => ({
-        workspaceId: t.id({ required: true }),
-        scenarioDeckId: t.id(),
-        graderId: t.id({ required: true }),
-        scenarioRuns: t.int({ required: true }),
-        graderRepeatsPerScenario: t.int({ required: true }),
-        concurrency: t.int({ required: true }),
-    }),
-});
-const WorkspaceGradeFlagToggleInput = builder.inputType("WorkspaceGradeFlagToggleInput", {
-    fields: (t) => ({
-        workspaceId: t.id({ required: true }),
-        refId: t.id({ required: true }),
-        runId: t.id({ required: true }),
-        turnIndex: t.int(),
-    }),
-});
-const WorkspaceGradeFlagReasonUpdateInput = builder.inputType("WorkspaceGradeFlagReasonUpdateInput", {
-    fields: (t) => ({
-        workspaceId: t.id({ required: true }),
-        refId: t.id({ required: true }),
-        reason: t.string({ required: true }),
-    }),
-});
-const SimulatorStopRunInput = builder.inputType("SimulatorStopRunInput", {
-    fields: (t) => ({
-        workspaceId: t.id({ required: true }),
-        runId: t.id({ required: true }),
-    }),
-});
-const SimulatorResetWorkspaceInput = builder.inputType("SimulatorResetWorkspaceInput", {
-    fields: (t) => ({
-        workspaceId: t.id({ required: true }),
-    }),
-});
-builder.queryType({
-    fields: (t) => ({
-        workspace: t.field({
-            type: WorkspaceType,
-            args: {
-                id: t.arg.id({ required: true }),
-            },
-            resolve: (_parent, args) => ({ id: asGambitID(args.id) }),
-        }),
-        gambitWorkspaces: t.connection({
-            type: WorkspaceSessionMetaType,
-            args: {
-                first: t.arg.int(),
-                after: t.arg.string(),
-            },
-            resolve: async (_parent, args, context) => {
-                const workspaces = context.listWorkspaces
-                    ? await context.listWorkspaces()
-                    : [];
-                return resolveArrayConnection({ args }, workspaces);
-            },
-        }),
-        gambitDurableStreamReplay: t.field({
-            type: StreamReplayType,
-            args: {
-                streamId: t.arg.id({ required: true }),
-                fromOffset: t.arg.int(),
-            },
-            resolve: (_parent, args) => {
-                const streamId = asGambitStreamID(args.streamId);
-                const fromOffset = typeof args.fromOffset === "number"
-                    ? Math.max(0, args.fromOffset)
-                    : 0;
-                const events = readDurableStreamEvents(streamId, fromOffset).map((event) => ({
-                    offset: event.offset,
-                    createdAt: asGambitISODateTime(event.createdAt),
-                    type: normalizeStreamEventType(event.data),
-                    data: event.data,
-                }));
-                return {
-                    streamId,
-                    fromOffset,
-                    nextOffset: getDurableStreamNextOffset(streamId),
-                    events,
-                };
-            },
-        }),
-    }),
-});
-builder.mutationType({
-    fields: (t) => ({
-        gambitWorkspaceCreate: t.field({
-            type: WorkspaceCreatePayloadType,
-            resolve: async (_parent, _args, context) => {
-                const created = context.createWorkspace
-                    ? await context.createWorkspace()
-                    : { workspaceId: "" };
-                return {
-                    workspace: { id: asGambitID(created.workspaceId) },
-                };
-            },
-        }),
-        gambitWorkspaceDelete: t.field({
-            type: WorkspaceDeletePayloadType,
-            args: {
-                workspaceId: t.arg.id({ required: true }),
-            },
-            resolve: async (_parent, args, context) => {
-                const result = context.deleteWorkspace
-                    ? await context.deleteWorkspace(args.workspaceId)
-                    : { ok: false, error: "workspace_delete_unavailable" };
-                return result.ok ? { workspaceId: args.workspaceId, deleted: true } : {
-                    workspaceId: args.workspaceId,
-                    deleted: false,
-                    error: result.error ?? "Workspace delete failed",
-                };
-            },
-        }),
-        workspaceBuildRunCreate: t.field({
-            type: WorkspaceBuildRunCreatePayloadType,
-            args: {
-                input: t.arg({ type: WorkspaceBuildRunCreateInput, required: true }),
-            },
-            resolve: async (_parent, args, context) => {
-                if (!context.createWorkspaceBuildRun) {
-                    throw new Error("workspace build run create is unavailable");
-                }
-                const message = (args.input.inputItems ?? [])
-                    .map((item) => item.content.trim())
-                    .filter((value) => value.length > 0)
-                    .join("\n")
-                    .trim();
-                const run = await context.createWorkspaceBuildRun(args.input.workspaceId, message);
-                return {
-                    workspace: { id: asGambitID(args.input.workspaceId) },
-                    run,
-                };
-            },
-        }),
-        workspaceScenarioRunStart: t.field({
-            type: WorkspaceScenarioRunStartPayloadType,
-            args: {
-                input: t.arg({
-                    type: WorkspaceScenarioRunStartInput,
-                    required: true,
-                }),
-            },
-            resolve: async (_parent, args, context) => {
-                if (!context.createWorkspaceScenarioRun) {
-                    throw new Error("workspace scenario run start is unavailable");
-                }
-                const run = await context.createWorkspaceScenarioRun({
-                    workspaceId: args.input.workspaceId,
-                    scenarioDeckId: args.input.scenarioDeckId ?? null,
-                    scenarioInput: args.input.scenarioInput,
-                    assistantInit: args.input.assistantInit,
-                });
-                return {
-                    workspace: { id: asGambitID(args.input.workspaceId) },
-                    run,
-                };
-            },
-        }),
-        workspaceScenarioRunSend: t.field({
-            type: WorkspaceScenarioRunSendPayloadType,
-            args: {
-                input: t.arg({
-                    type: WorkspaceScenarioRunSendInput,
-                    required: true,
-                }),
-            },
-            resolve: async (_parent, args, context) => {
-                if (!context.sendWorkspaceScenarioRun) {
-                    throw new Error("workspace scenario run send is unavailable");
-                }
-                const message = (args.input.inputItems ?? [])
-                    .map((item) => item.content.trim())
-                    .filter((value) => value.length > 0)
-                    .join("\n")
-                    .trim();
-                const run = await context.sendWorkspaceScenarioRun({
-                    workspaceId: args.input.workspaceId,
-                    runId: args.input.runId,
-                    message,
-                });
-                return {
-                    workspace: { id: asGambitID(args.input.workspaceId) },
-                    run,
-                };
-            },
-        }),
-        workspaceFeedbackSave: t.field({
-            type: WorkspaceFeedbackSavePayloadType,
-            args: {
-                input: t.arg({
-                    type: WorkspaceFeedbackSaveInput,
-                    required: true,
-                }),
-            },
-            resolve: async (_parent, args, context) => {
-                if (!context.saveWorkspaceFeedback) {
-                    throw new Error("workspace feedback save is unavailable");
-                }
-                const result = await context.saveWorkspaceFeedback({
-                    workspaceId: args.input.workspaceId,
-                    runId: args.input.runId ?? null,
-                    messageRefId: args.input.messageRefId,
-                    score: args.input.score ?? null,
-                    reason: args.input.reason ?? null,
-                });
-                return {
-                    workspace: { id: asGambitID(args.input.workspaceId) },
-                    run: result.run,
-                    feedback: result.feedback,
-                    deleted: result.deleted,
-                };
-            },
-        }),
-        workspaceConversationSessionStart: t.field({
-            type: WorkspaceConversationSessionPayloadType,
-            args: {
-                input: t.arg({
-                    type: WorkspaceConversationSessionStartInput,
-                    required: true,
-                }),
-            },
-            resolve: async (_parent, args, context) => {
-                if (!context.startWorkspaceConversationSession) {
-                    throw new Error("workspace conversation session start is unavailable");
-                }
-                const message = (args.input.inputItems ?? [])
-                    .map((item) => item.content.trim())
-                    .filter((value) => value.length > 0)
-                    .join("\n")
-                    .trim();
-                const session = await context.startWorkspaceConversationSession({
-                    workspaceId: args.input.workspaceId,
-                    kind: parseWorkspaceConversationSessionKind(args.input.kind),
-                    sessionId: args.input.sessionId ?? null,
-                    message,
-                    scenarioDeckId: args.input.scenarioDeckId ?? null,
-                    scenarioInput: args.input.scenarioInput,
-                    assistantInit: args.input.assistantInit,
-                    graderId: args.input.graderId ?? null,
-                    scenarioRunId: args.input.scenarioRunId ?? null,
-                    scenarioRuns: args.input.scenarioRuns ?? null,
-                    graderRepeatsPerScenario: args.input.graderRepeatsPerScenario ?? null,
-                    concurrency: args.input.concurrency ?? null,
-                });
-                return {
-                    workspace: { id: asGambitID(args.input.workspaceId) },
-                    session,
-                };
-            },
-        }),
-        workspaceConversationSessionSend: t.field({
-            type: WorkspaceConversationSessionPayloadType,
-            args: {
-                input: t.arg({
-                    type: WorkspaceConversationSessionSendInput,
-                    required: true,
-                }),
-            },
-            resolve: async (_parent, args, context) => {
-                if (!context.sendWorkspaceConversationSession) {
-                    throw new Error("workspace conversation session send is unavailable");
-                }
-                const message = (args.input.inputItems ?? [])
-                    .map((item) => item.content.trim())
-                    .filter((value) => value.length > 0)
-                    .join("\n")
-                    .trim();
-                const session = await context.sendWorkspaceConversationSession({
-                    workspaceId: args.input.workspaceId,
-                    kind: parseWorkspaceConversationSessionKind(args.input.kind),
-                    sessionId: args.input.sessionId,
-                    message,
-                });
-                return {
-                    workspace: { id: asGambitID(args.input.workspaceId) },
-                    session,
-                };
-            },
-        }),
-        workspaceScenarioRunStop: t.field({
-            type: WorkspaceScenarioRunStopPayloadType,
-            args: {
-                input: t.arg({
-                    type: WorkspaceScenarioRunStopInput,
-                    required: true,
-                }),
-            },
-            resolve: async (_parent, args, context) => {
-                if (!context.stopWorkspaceScenarioRun) {
-                    throw new Error("workspace scenario run stop is unavailable");
-                }
-                const run = await context.stopWorkspaceScenarioRun({
-                    workspaceId: args.input.workspaceId,
-                    runId: args.input.runId,
-                });
-                return {
-                    workspace: { id: asGambitID(args.input.workspaceId) },
-                    run,
-                };
-            },
-        }),
-        workspaceConversationSessionStop: t.field({
-            type: WorkspaceConversationSessionPayloadType,
-            args: {
-                input: t.arg({
-                    type: WorkspaceConversationSessionStopInput,
-                    required: true,
-                }),
-            },
-            resolve: async (_parent, args, context) => {
-                if (!context.stopWorkspaceConversationSession) {
-                    throw new Error("workspace conversation session stop is unavailable");
-                }
-                const session = await context.stopWorkspaceConversationSession({
-                    workspaceId: args.input.workspaceId,
-                    kind: parseWorkspaceConversationSessionKind(args.input.kind),
-                    sessionId: args.input.sessionId,
-                });
-                return {
-                    workspace: { id: asGambitID(args.input.workspaceId) },
-                    session,
-                };
-            },
-        }),
-        workspaceGradeRunCreate: t.field({
-            type: WorkspaceGradeRunCreatePayloadType,
-            args: {
-                input: t.arg({
-                    type: WorkspaceGradeRunCreateInput,
-                    required: true,
-                }),
-            },
-            resolve: async (_parent, args, context) => {
-                if (!context.createWorkspaceGradeRun) {
-                    throw new Error("workspace grade run create is unavailable");
-                }
-                const run = await context.createWorkspaceGradeRun({
-                    workspaceId: args.input.workspaceId,
-                    graderId: args.input.graderId,
-                    scenarioRunId: args.input.scenarioRunId ?? null,
-                });
-                return {
-                    workspace: { id: asGambitID(args.input.workspaceId) },
-                    run,
-                };
-            },
-        }),
-        workspaceVerifyBatchRunCreate: t.field({
-            type: WorkspaceVerifyBatchRunCreatePayloadType,
-            args: {
-                input: t.arg({
-                    type: WorkspaceVerifyBatchRunCreateInput,
-                    required: true,
-                }),
-            },
-            resolve: async (_parent, args, context) => {
-                if (!context.createWorkspaceVerifyBatchRun) {
-                    throw new Error("workspace verify batch run create is unavailable");
-                }
-                const batch = await context.createWorkspaceVerifyBatchRun({
-                    workspaceId: args.input.workspaceId,
-                    scenarioDeckId: args.input.scenarioDeckId ?? null,
-                    graderId: args.input.graderId,
-                    scenarioRuns: args.input.scenarioRuns,
-                    graderRepeatsPerScenario: args.input.graderRepeatsPerScenario,
-                    concurrency: args.input.concurrency,
-                });
-                return {
-                    workspace: { id: asGambitID(args.input.workspaceId) },
-                    batch,
-                };
-            },
-        }),
-        workspaceGradeFlagToggle: t.field({
-            type: WorkspaceGradeFlagTogglePayloadType,
-            args: {
-                input: t.arg({
-                    type: WorkspaceGradeFlagToggleInput,
-                    required: true,
-                }),
-            },
-            resolve: async (_parent, args, context) => {
-                if (!context.toggleWorkspaceGradeFlag) {
-                    throw new Error("workspace grade flag toggle is unavailable");
-                }
-                const flags = await context.toggleWorkspaceGradeFlag({
-                    workspaceId: args.input.workspaceId,
-                    refId: args.input.refId,
-                    runId: args.input.runId,
-                    turnIndex: args.input.turnIndex ?? null,
-                });
-                return {
-                    workspace: { id: asGambitID(args.input.workspaceId) },
-                    flags,
-                };
-            },
-        }),
-        workspaceGradeFlagReasonUpdate: t.field({
-            type: WorkspaceGradeFlagReasonUpdatePayloadType,
-            args: {
-                input: t.arg({
-                    type: WorkspaceGradeFlagReasonUpdateInput,
-                    required: true,
-                }),
-            },
-            resolve: async (_parent, args, context) => {
-                if (!context.updateWorkspaceGradeFlagReason) {
-                    throw new Error("workspace grade flag reason update is unavailable");
-                }
-                const flags = await context.updateWorkspaceGradeFlagReason({
-                    workspaceId: args.input.workspaceId,
-                    refId: args.input.refId,
-                    reason: args.input.reason,
-                });
-                return {
-                    workspace: { id: asGambitID(args.input.workspaceId) },
-                    flags,
-                };
-            },
-        }),
-        simulatorStopRun: t.field({
-            type: SimulatorStopRunPayloadType,
-            args: {
-                input: t.arg({ type: SimulatorStopRunInput, required: true }),
-            },
-            resolve: async (_parent, args, context) => {
-                if (!context.stopWorkspaceBuildRun) {
-                    throw new Error("workspace build run stop is unavailable");
-                }
-                const run = await context.stopWorkspaceBuildRun(args.input.workspaceId, args.input.runId);
-                return {
-                    workspace: { id: asGambitID(args.input.workspaceId) },
-                    run,
-                };
-            },
-        }),
-        simulatorResetWorkspace: t.field({
-            type: SimulatorResetWorkspacePayloadType,
-            args: {
-                input: t.arg({
-                    type: SimulatorResetWorkspaceInput,
-                    required: true,
-                }),
-            },
-            resolve: async (_parent, args, context) => {
-                if (!context.resetWorkspaceBuild) {
-                    throw new Error("workspace build reset is unavailable");
-                }
-                const run = await context.resetWorkspaceBuild(args.input.workspaceId);
-                return {
-                    workspace: { id: asGambitID(args.input.workspaceId) },
-                    build: {
-                        workspaceId: args.input.workspaceId,
-                        run,
-                    },
-                };
-            },
-        }),
-    }),
-});
-builder.subscriptionType({
-    fields: (t) => ({
-        workspaceOpenResponseEventsLive: t.field({
-            type: WorkspaceOpenResponseEventsLiveEdgeType,
-            args: {
-                workspaceId: t.arg.id({ required: true }),
-                runId: t.arg.id({ required: true }),
-                fromSequence: t.arg.int(),
-            },
-            subscribe: async function* (_parent, args, context) {
-                const workspaceId = normalizeWorkspaceId(args.workspaceId);
-                const runId = typeof args.runId === "string" ? args.runId.trim() : "";
-                if (!workspaceId || !runId)
-                    return;
-                const fromSequence = typeof args.fromSequence === "number" &&
-                    Number.isFinite(args.fromSequence)
-                    ? Math.max(0, Math.floor(args.fromSequence))
-                    : 0;
-                if (context.subscribeWorkspaceOpenResponseEvents) {
-                    const abortController = new AbortController();
-                    try {
-                        for await (const event of context.subscribeWorkspaceOpenResponseEvents({
-                            workspaceId,
-                            runId,
-                            fromSequence,
-                            signal: abortController.signal,
-                        })) {
-                            yield {
-                                workspaceId,
-                                runId,
-                                sourceSequence: event.sequence,
-                                occurredAt: event.created_at,
-                                event: {
-                                    id: `${runId}:event:${event.sequence}`,
-                                    type: event.event_type,
-                                    data: event.payload,
-                                },
-                            };
-                        }
-                    }
-                    finally {
-                        abortController.abort();
-                    }
-                    return;
-                }
-                if (!context.readWorkspaceOpenResponseEvents)
-                    return;
-                const replay = await context.readWorkspaceOpenResponseEvents({
-                    workspaceId,
-                    runId,
-                    fromSequence,
-                });
-                for (const event of replay) {
-                    yield {
-                        workspaceId,
-                        runId,
-                        sourceSequence: event.sequence,
-                        occurredAt: event.created_at,
-                        event: {
-                            id: `${runId}:event:${event.sequence}`,
-                            type: event.event_type,
-                            data: event.payload,
-                        },
-                    };
-                }
-            },
-            resolve: (parent) => parent,
-        }),
-        workspaceUpdates: t.field({
-            type: WorkspaceUpdateType,
-            args: {
-                workspaceId: t.arg.id({ required: true }),
-                fromOffset: t.arg.int(),
-            },
-            subscribe: async function* (_parent, args) {
-                const workspaceId = normalizeWorkspaceId(args.workspaceId);
-                if (!workspaceId)
-                    return;
-                const { effective: requestedFromOffset } = resolveRequestedFromOffset(args.fromOffset ?? null);
-                const pending = [];
-                let resolveNext = null;
-                let closed = false;
-                let nextSourceOffset = requestedFromOffset;
-                let replaying = true;
-                const buffered = [];
-                const push = (value) => {
-                    if (closed)
-                        return;
-                    if (resolveNext) {
-                        const resolve = resolveNext;
-                        resolveNext = null;
-                        resolve(value);
-                        return;
-                    }
-                    pending.push(value);
-                };
-                const pull = async () => {
-                    const next = pending.shift();
-                    if (next)
-                        return next;
-                    return await new Promise((resolve) => {
-                        resolveNext = resolve;
-                    });
-                };
-                const processStreamEvent = (streamEvent) => {
-                    if (streamEvent.offset < nextSourceOffset)
-                        return;
-                    nextSourceOffset = streamEvent.offset + 1;
-                    const projected = projectWorkspaceUpdateFromStreamEvent(streamEvent, workspaceId);
-                    if (!projected)
-                        return;
-                    push(projected);
-                };
-                const unsubscribe = subscribeDurableStream(WORKSPACE_STREAM_ID, (event) => {
-                    const streamEvent = event;
-                    if (replaying) {
-                        buffered.push(streamEvent);
-                        return;
-                    }
-                    processStreamEvent(streamEvent);
-                });
-                try {
-                    const replay = readDurableStreamEvents(WORKSPACE_STREAM_ID, requestedFromOffset);
-                    for (const streamEvent of replay) {
-                        processStreamEvent(streamEvent);
-                    }
-                    replaying = false;
-                    if (buffered.length > 0) {
-                        const sorted = [...buffered].sort((a, b) => a.offset - b.offset);
-                        buffered.length = 0;
-                        for (const streamEvent of sorted) {
-                            processStreamEvent(streamEvent);
-                        }
-                    }
-                    while (true) {
-                        const next = await pull();
-                        if (next === null)
-                            return;
-                        yield next;
-                    }
-                }
-                finally {
-                    closed = true;
-                    replaying = false;
-                    buffered.length = 0;
-                    unsubscribe();
-                    if (resolveNext) {
-                        const resolve = resolveNext;
-                        resolveNext = null;
-                        resolve(null);
-                    }
-                }
-            },
-            resolve: (parent) => parent,
-        }),
-        workspaceBuildLive: t.field({
-            type: WorkspaceBuildLiveEdgeType,
-            args: {
-                workspaceId: t.arg.id({ required: true }),
-                fromOffset: t.arg.int(),
-            },
-            subscribe: async function* (_parent, args) {
-                const workspaceId = normalizeWorkspaceId(args.workspaceId);
-                if (!workspaceId)
-                    return;
-                const { effective: requestedFromOffset } = resolveRequestedFromOffset(args.fromOffset ?? null);
-                const pending = [];
-                let resolveNext = null;
-                let closed = false;
-                let nextSourceOffset = requestedFromOffset;
-                let replaying = true;
-                const buffered = [];
-                const push = (value) => {
-                    if (closed)
-                        return;
-                    if (resolveNext) {
-                        const resolve = resolveNext;
-                        resolveNext = null;
-                        resolve(value);
-                        return;
-                    }
-                    pending.push(value);
-                };
-                const pull = async () => {
-                    const next = pending.shift();
-                    if (next)
-                        return next;
-                    return await new Promise((resolve) => {
-                        resolveNext = resolve;
-                    });
-                };
-                const processStreamEvent = (streamEvent) => {
-                    if (streamEvent.offset < nextSourceOffset)
-                        return;
-                    nextSourceOffset = streamEvent.offset + 1;
-                    const projected = projectWorkspaceBuildLiveFromStreamEvent(streamEvent, workspaceId, "build");
-                    if (!projected)
-                        return;
-                    push(projected);
-                };
-                const unsubscribe = subscribeDurableStream(WORKSPACE_STREAM_ID, (event) => {
-                    const streamEvent = event;
-                    if (replaying) {
-                        buffered.push(streamEvent);
-                        return;
-                    }
-                    processStreamEvent(streamEvent);
-                });
-                try {
-                    const replay = readDurableStreamEvents(WORKSPACE_STREAM_ID, requestedFromOffset);
-                    for (const streamEvent of replay) {
-                        processStreamEvent(streamEvent);
-                    }
-                    replaying = false;
-                    if (buffered.length > 0) {
-                        const sorted = [...buffered].sort((a, b) => a.offset - b.offset);
-                        buffered.length = 0;
-                        for (const streamEvent of sorted) {
-                            processStreamEvent(streamEvent);
-                        }
-                    }
-                    while (true) {
-                        const next = await pull();
-                        if (next === null)
-                            return;
-                        yield next;
-                    }
-                }
-                finally {
-                    closed = true;
-                    replaying = false;
-                    buffered.length = 0;
-                    unsubscribe();
-                    if (resolveNext) {
-                        const resolve = resolveNext;
-                        resolveNext = null;
-                        resolve(null);
-                    }
-                }
-            },
-            resolve: (parent) => parent,
-        }),
-        workspaceTestLive: t.field({
-            type: WorkspaceBuildLiveEdgeType,
-            args: {
-                workspaceId: t.arg.id({ required: true }),
-                fromOffset: t.arg.int(),
-            },
-            subscribe: async function* (_parent, args) {
-                const workspaceId = normalizeWorkspaceId(args.workspaceId);
-                if (!workspaceId)
-                    return;
-                const { effective: requestedFromOffset } = resolveRequestedFromOffset(args.fromOffset ?? null);
-                const pending = [];
-                let resolveNext = null;
-                let closed = false;
-                let nextSourceOffset = requestedFromOffset;
-                let replaying = true;
-                const buffered = [];
-                const push = (value) => {
-                    if (closed)
-                        return;
-                    if (resolveNext) {
-                        const resolve = resolveNext;
-                        resolveNext = null;
-                        resolve(value);
-                        return;
-                    }
-                    pending.push(value);
-                };
-                const pull = async () => {
-                    const next = pending.shift();
-                    if (next)
-                        return next;
-                    return await new Promise((resolve) => {
-                        resolveNext = resolve;
-                    });
-                };
-                const processStreamEvent = (streamEvent) => {
-                    if (streamEvent.offset < nextSourceOffset)
-                        return;
-                    nextSourceOffset = streamEvent.offset + 1;
-                    const projected = projectWorkspaceBuildLiveFromStreamEvent(streamEvent, workspaceId, "test");
-                    if (!projected)
-                        return;
-                    push(projected);
-                };
-                const unsubscribe = subscribeDurableStream(WORKSPACE_STREAM_ID, (event) => {
-                    const streamEvent = event;
-                    if (replaying) {
-                        buffered.push(streamEvent);
-                        return;
-                    }
-                    processStreamEvent(streamEvent);
-                });
-                try {
-                    const replay = readDurableStreamEvents(WORKSPACE_STREAM_ID, requestedFromOffset);
-                    for (const streamEvent of replay) {
-                        processStreamEvent(streamEvent);
-                    }
-                    replaying = false;
-                    if (buffered.length > 0) {
-                        const sorted = [...buffered].sort((a, b) => a.offset - b.offset);
-                        buffered.length = 0;
-                        for (const streamEvent of sorted) {
-                            processStreamEvent(streamEvent);
-                        }
-                    }
-                    while (true) {
-                        const next = await pull();
-                        if (next === null)
-                            return;
-                        yield next;
-                    }
-                }
-                finally {
-                    closed = true;
-                    replaying = false;
-                    buffered.length = 0;
-                    unsubscribe();
-                    if (resolveNext) {
-                        const resolve = resolveNext;
-                        resolveNext = null;
-                        resolve(null);
-                    }
-                }
-            },
-            resolve: (parent) => parent,
-        }),
-        workspaceGradeLive: t.field({
-            type: WorkspaceBuildLiveEdgeType,
-            args: {
-                workspaceId: t.arg.id({ required: true }),
-                fromOffset: t.arg.int(),
-            },
-            subscribe: async function* (_parent, args) {
-                const workspaceId = normalizeWorkspaceId(args.workspaceId);
-                if (!workspaceId)
-                    return;
-                const { effective: requestedFromOffset } = resolveRequestedFromOffset(args.fromOffset ?? null);
-                const pending = [];
-                let resolveNext = null;
-                let closed = false;
-                let nextSourceOffset = requestedFromOffset;
-                let replaying = true;
-                const buffered = [];
-                const push = (value) => {
-                    if (closed)
-                        return;
-                    if (resolveNext) {
-                        const resolve = resolveNext;
-                        resolveNext = null;
-                        resolve(value);
-                        return;
-                    }
-                    pending.push(value);
-                };
-                const pull = async () => {
-                    const next = pending.shift();
-                    if (next)
-                        return next;
-                    return await new Promise((resolve) => {
-                        resolveNext = resolve;
-                    });
-                };
-                const processStreamEvent = (streamEvent) => {
-                    if (streamEvent.offset < nextSourceOffset)
-                        return;
-                    nextSourceOffset = streamEvent.offset + 1;
-                    const projected = projectWorkspaceBuildLiveFromStreamEvent(streamEvent, workspaceId, "grade");
-                    if (!projected)
-                        return;
-                    push(projected);
-                };
-                const unsubscribe = subscribeDurableStream(WORKSPACE_STREAM_ID, (event) => {
-                    const streamEvent = event;
-                    if (replaying) {
-                        buffered.push(streamEvent);
-                        return;
-                    }
-                    processStreamEvent(streamEvent);
-                });
-                try {
-                    const replay = readDurableStreamEvents(WORKSPACE_STREAM_ID, requestedFromOffset);
-                    for (const streamEvent of replay) {
-                        processStreamEvent(streamEvent);
-                    }
-                    replaying = false;
-                    if (buffered.length > 0) {
-                        const sorted = [...buffered].sort((a, b) => a.offset - b.offset);
-                        buffered.length = 0;
-                        for (const streamEvent of sorted) {
-                            processStreamEvent(streamEvent);
-                        }
-                    }
-                    while (true) {
-                        const next = await pull();
-                        if (next === null)
-                            return;
-                        yield next;
-                    }
-                }
-                finally {
-                    closed = true;
-                    replaying = false;
-                    buffered.length = 0;
-                    unsubscribe();
-                    if (resolveNext) {
-                        const resolve = resolveNext;
-                        resolveNext = null;
-                        resolve(null);
-                    }
-                }
-            },
-            resolve: (parent) => parent,
-        }),
-        workspaceVerifyLive: t.field({
-            type: WorkspaceBuildLiveEdgeType,
-            args: {
-                workspaceId: t.arg.id({ required: true }),
-                fromOffset: t.arg.int(),
-            },
-            subscribe: async function* (_parent, args) {
-                const workspaceId = normalizeWorkspaceId(args.workspaceId);
-                if (!workspaceId)
-                    return;
-                const { effective: requestedFromOffset } = resolveRequestedFromOffset(args.fromOffset ?? null);
-                const pending = [];
-                let resolveNext = null;
-                let closed = false;
-                let nextSourceOffset = requestedFromOffset;
-                let replaying = true;
-                const buffered = [];
-                const push = (value) => {
-                    if (closed)
-                        return;
-                    if (resolveNext) {
-                        const resolve = resolveNext;
-                        resolveNext = null;
-                        resolve(value);
-                        return;
-                    }
-                    pending.push(value);
-                };
-                const pull = async () => {
-                    const next = pending.shift();
-                    if (next)
-                        return next;
-                    return await new Promise((resolve) => {
-                        resolveNext = resolve;
-                    });
-                };
-                const processStreamEvent = (streamEvent) => {
-                    if (streamEvent.offset < nextSourceOffset)
-                        return;
-                    nextSourceOffset = streamEvent.offset + 1;
-                    const projected = projectWorkspaceBuildLiveFromStreamEvent(streamEvent, workspaceId, "verify");
-                    if (!projected)
-                        return;
-                    push(projected);
-                };
-                const unsubscribe = subscribeDurableStream(WORKSPACE_STREAM_ID, (event) => {
-                    const streamEvent = event;
-                    if (replaying) {
-                        buffered.push(streamEvent);
-                        return;
-                    }
-                    processStreamEvent(streamEvent);
-                });
-                try {
-                    const replay = readDurableStreamEvents(WORKSPACE_STREAM_ID, requestedFromOffset);
-                    for (const streamEvent of replay) {
-                        processStreamEvent(streamEvent);
-                    }
-                    replaying = false;
-                    if (buffered.length > 0) {
-                        const sorted = [...buffered].sort((a, b) => a.offset - b.offset);
-                        buffered.length = 0;
-                        for (const streamEvent of sorted) {
-                            processStreamEvent(streamEvent);
-                        }
-                    }
-                    while (true) {
-                        const next = await pull();
-                        if (next === null)
-                            return;
-                        yield next;
-                    }
-                }
-                finally {
-                    closed = true;
-                    replaying = false;
-                    buffered.length = 0;
-                    unsubscribe();
-                    if (resolveNext) {
-                        const resolve = resolveNext;
-                        resolveNext = null;
-                        resolve(null);
-                    }
-                }
-            },
-            resolve: (parent) => parent,
-        }),
-    }),
-});
-export const gambitSimulatorSchema = builder.toSchema();
-export const gambitYoga = createYoga({
-    schema: gambitSimulatorSchema,
-    graphqlEndpoint: "/graphql",
-    graphiql: true,
-});