@bolt-foundry/gambit 0.8.3 → 0.8.5-rc.5

package/esm/src/server.js

@@ -1,10 +1,19 @@
 import * as dntShim from "../_dnt.shims.js";
 import * as path from "../deps/jsr.io/@std/path/1.1.4/mod.js";
-import { isGambitEndSignal, runDeck } from "@bolt-foundry/gambit-core";
+import { copy, ensureDir, existsSync } from "../deps/jsr.io/@std/fs/1.0.22/mod.js";
+import { parse } from "../deps/jsr.io/@std/jsonc/1.0.2/mod.js";
+import { parse as parseToml } from "../deps/jsr.io/@std/toml/1.0.11/mod.js";
+import { isGambitEndSignal, isRunCanceledError, runDeck, } from "@bolt-foundry/gambit-core";
 import { sanitizeNumber } from "./test_bot.js";
 import { makeConsoleTracer } from "./trace.js";
 import { defaultSessionRoot } from "./cli_utils.js";
 import { loadDeck } from "@bolt-foundry/gambit-core";
+import { createWorkspaceScaffold } from "./workspace.js";
+import { assertSafeBuildBotRoot, randomId, resolveDefaultValue, } from "./server_helpers.js";
+import { createSessionStore } from "./server_session_store.js";
+import { handleFeedbackRoutes, handleGradingReferenceRoute, } from "./server_feedback_grading_routes.js";
+import { handleUiRoutes } from "./server_ui_routes.js";
+import { resolveWorkspaceIdFromRecord, resolveWorkspaceIdFromSearchParams, WORKSPACE_ROUTE_BASE, WORKSPACE_STATE_SCHEMA_VERSION, workspaceSchemaError, } from "./workspace_contract.js";
 import { appendDurableStreamEvent, handleDurableStreamRequest, } from "./durable_streams.js";
 const GAMBIT_TOOL_RESPOND = "gambit_respond";
 const logger = console;
@@ -51,34 +60,89 @@ const simulatorBundlePath = path.resolve(moduleDir, "..", "simulator-ui", "dist"
 const simulatorBundleSourceMapPath = path.resolve(moduleDir, "..", "simulator-ui", "dist", "bundle.js.map");
 const simulatorFaviconDistPath = path.resolve(moduleDir, "..", "simulator-ui", "dist", "favicon.ico");
 const simulatorFaviconSrcPath = path.resolve(moduleDir, "..", "simulator-ui", "src", "favicon.ico");
+const gambitVersion = (() => {
+    const envVersion = dntShim.Deno.env.get("GAMBIT_VERSION")?.trim();
+    if (envVersion)
+        return envVersion;
+    const readVersion = (configPath) => {
+        try {
+            const text = dntShim.Deno.readTextFileSync(configPath);
+            const data = parse(text);
+            const version = typeof data.version === "string"
+                ? data.version.trim()
+                : "";
+            return version || null;
+        }
+        catch (err) {
+            if (err instanceof dntShim.Deno.errors.NotFound)
+                return null;
+            throw err;
+        }
+    };
+    const candidates = [
+        path.resolve(moduleDir, "..", "deno.jsonc"),
+        path.resolve(moduleDir, "..", "deno.json"),
+    ];
+    for (const candidate of candidates) {
+        const version = readVersion(candidate);
+        if (version)
+            return version;
+    }
+    return "unknown";
+})();
 const SIMULATOR_STREAM_ID = "gambit-simulator";
+const WORKSPACE_STREAM_ID = "gambit-workspace";
 const GRADE_STREAM_ID = "gambit-grade";
 const TEST_STREAM_ID = "gambit-test";
+const BUILD_STREAM_ID = "gambit-build";
+const DEFAULT_TEST_BOT_SEED_PROMPT = "Start the conversation as the user. Do not wait for the assistant to speak first.";
+const isWorkspaceEventDomain = (value) => value === "build" || value === "test" || value === "grade" ||
+    value === "session";
+const extractPersistedWorkspacePayload = (record) => {
+    if (!isWorkspaceEventDomain(record.type))
+        return record;
+    const nested = record.data;
+    if (!nested || typeof nested !== "object" || Array.isArray(nested)) {
+        return record;
+    }
+    return nested;
+};
+const GAMBIT_BOT_SOURCE_DECK_URL = new URL("./decks/gambit-bot/PROMPT.md", globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url);
+const GAMBIT_BOT_SOURCE_DIR = GAMBIT_BOT_SOURCE_DECK_URL.protocol === "file:"
+    ? path.dirname(path.fromFileUrl(GAMBIT_BOT_SOURCE_DECK_URL))
+    : "";
+const GAMBIT_BOT_POLICY_DIR = GAMBIT_BOT_SOURCE_DIR
+    ? path.join(GAMBIT_BOT_SOURCE_DIR, "policy")
+    : "";
+async function ensureGambitPolicyInBotRoot(root) {
+    if (!GAMBIT_BOT_POLICY_DIR)
+        return;
+    try {
+        const info = await dntShim.Deno.stat(GAMBIT_BOT_POLICY_DIR);
+        if (!info.isDirectory)
+            return;
+    }
+    catch {
+        return;
+    }
+    const dest = path.join(root, ".gambit", "policy");
+    if (existsSync(dest))
+        return;
+    await ensureDir(path.dirname(dest));
+    await copy(GAMBIT_BOT_POLICY_DIR, dest, { overwrite: false });
+}
 let availableTestDecks = [];
 const testDeckByPath = new Map();
 const testDeckById = new Map();
 let availableGraderDecks = [];
 const graderDeckByPath = new Map();
 const graderDeckById = new Map();
-function randomId(prefix) {
-    const suffix = crypto.randomUUID().replace(/-/g, "").slice(0, 24);
-    return `${prefix}-${suffix}`;
-}
-function resolveDefaultValue(raw) {
-    if (typeof raw === "function") {
-        try {
-            return raw();
-        }
-        catch {
-            return undefined;
-        }
-    }
-    return raw;
-}
 async function describeDeckInputSchemaFromPath(deckPath) {
     try {
         const deck = await loadDeck(deckPath);
-        return describeZodSchema(deck.inputSchema);
+        const tools = mapDeckTools(deck.actionDecks);
+        const desc = describeZodSchema(deck.inputSchema);
+        return tools ? { ...desc, tools } : desc;
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -86,6 +150,22 @@ async function describeDeckInputSchemaFromPath(deckPath) {
         return { error: message };
     }
 }
+function mapDeckTools(actionDecks) {
+    if (!Array.isArray(actionDecks) || actionDecks.length === 0) {
+        return undefined;
+    }
+    const described = actionDecks
+        .filter((action) => Boolean(action?.name && typeof action.name === "string"))
+        .map((action) => ({
+        name: action.name,
+        label: typeof action.label === "string" ? action.label : undefined,
+        description: typeof action.description === "string"
+            ? action.description
+            : undefined,
+        path: action.path,
+    }));
+    return described.length > 0 ? described : undefined;
+}
 function describeZodSchema(schema) {
     try {
         const normalized = normalizeSchema(schema);
@@ -409,7 +489,7 @@ function buildInitFillPrompt(args) {
         schemaHints,
     };
     return [
-        "You are filling missing required init fields for a Gambit Test Bot run.",
+        "You are filling missing required init fields for a Gambit Scenario run.",
         "Return ONLY valid JSON that includes values for the missing fields.",
         "Do not include any fields that are not listed as missing.",
         "If the only missing path is '(root)', return the full init JSON value.",
@@ -465,6 +545,389 @@ function validateInitInput(schema, value) {
     }
     return result.data;
 }
+function jsonResponse(body, status = 200) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { "content-type": "application/json" },
+    });
+}
+function parseBodyObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Request body must be a JSON object");
+    }
+    return value;
+}
+function toTextPart(role, value) {
+    if (typeof value === "string") {
+        return {
+            type: role === "assistant" ? "output_text" : "input_text",
+            text: value,
+        };
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    const text = typeof record.text === "string" ? record.text : "";
+    if (!text)
+        return null;
+    const type = typeof record.type === "string" ? record.type : "";
+    if (type === "output_text")
+        return { type: "output_text", text };
+    if (type === "input_text")
+        return { type: "input_text", text };
+    return {
+        type: role === "assistant" ? "output_text" : "input_text",
+        text,
+    };
+}
+function normalizeMessageItem(item) {
+    const role = item.role;
+    if (role !== "system" && role !== "user" && role !== "assistant") {
+        throw new Error("message.role must be system, user, or assistant");
+    }
+    const rawContent = item.content;
+    const content = Array.isArray(rawContent)
+        ? rawContent.map((part) => toTextPart(role, part)).filter((part) => Boolean(part))
+        : [toTextPart(role, rawContent)].filter((part) => Boolean(part));
+    if (content.length === 0) {
+        throw new Error("message.content must include text");
+    }
+    return {
+        type: "message",
+        role,
+        content,
+        id: typeof item.id === "string" ? item.id : undefined,
+    };
+}
+function normalizeInputItems(input) {
+    if (typeof input === "string") {
+        return [{
+                type: "message",
+                role: "user",
+                content: [{ type: "input_text", text: input }],
+            }];
+    }
+    const arr = Array.isArray(input) ? input : [input];
+    const items = [];
+    for (const raw of arr) {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+            throw new Error("input items must be objects");
+        }
+        const item = raw;
+        const type = typeof item.type === "string" ? item.type : "";
+        if (type === "message") {
+            const normalized = normalizeMessageItem(item);
+            if (normalized)
+                items.push(normalized);
+            continue;
+        }
+        if (type === "function_call") {
+            const callId = item.call_id;
+            const name = item.name;
+            const args = item.arguments;
+            if (typeof callId !== "string" || typeof name !== "string" ||
+                typeof args !== "string") {
+                throw new Error("function_call requires call_id, name, and arguments strings");
+            }
+            items.push({
+                type: "function_call",
+                call_id: callId,
+                name,
+                arguments: args,
+                id: typeof item.id === "string" ? item.id : undefined,
+            });
+            continue;
+        }
+        if (type === "function_call_output") {
+            const callId = item.call_id;
+            const output = item.output;
+            if (typeof callId !== "string" || typeof output !== "string") {
+                throw new Error("function_call_output requires call_id and output strings");
+            }
+            items.push({
+                type: "function_call_output",
+                call_id: callId,
+                output,
+                id: typeof item.id === "string" ? item.id : undefined,
+            });
+            continue;
+        }
+        throw new Error(`Unsupported input item type: ${type || "(missing type)"}`);
+    }
+    return items;
+}
+function normalizeTools(tools) {
+    if (!Array.isArray(tools) || tools.length === 0)
+        return undefined;
+    const out = [];
+    for (const raw of tools) {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+            throw new Error("tools entries must be objects");
+        }
+        const item = raw;
+        const type = typeof item.type === "string" ? item.type : "";
+        if (type !== "function")
+            continue;
+        const nested = item.function;
+        if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+            const fn = nested;
+            const name = fn.name;
+            if (typeof name !== "string" || !name) {
+                throw new Error("tool.function.name is required");
+            }
+            out.push({
+                type: "function",
+                function: {
+                    name,
+                    description: typeof fn.description === "string"
+                        ? fn.description
+                        : undefined,
+                    parameters: (fn.parameters &&
+                        typeof fn.parameters === "object" &&
+                        !Array.isArray(fn.parameters))
+                        ? fn.parameters
+                        : {},
+                },
+            });
+            continue;
+        }
+        const name = item.name;
+        if (typeof name !== "string" || !name) {
+            throw new Error("tool.name is required");
+        }
+        out.push({
+            type: "function",
+            function: {
+                name,
+                description: typeof item.description === "string"
+                    ? item.description
+                    : undefined,
+                parameters: (item.parameters &&
+                    typeof item.parameters === "object" &&
+                    !Array.isArray(item.parameters))
+                    ? item.parameters
+                    : {},
+            },
+        });
+    }
+    return out.length ? out : undefined;
+}
+function normalizeToolChoice(choice) {
+    if (!choice)
+        return undefined;
+    if (choice === "none" || choice === "auto" || choice === "required") {
+        return choice;
+    }
+    if (!choice || typeof choice !== "object" || Array.isArray(choice)) {
+        return undefined;
+    }
+    const record = choice;
+    if (record.type === "allowed_tools" && Array.isArray(record.tools)) {
+        const tools = record.tools
+            .map((entry) => {
+            if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+                return null;
+            }
+            const tool = entry;
+            if (tool.type !== "function" || typeof tool.name !== "string") {
+                return null;
+            }
+            return { type: "function", name: tool.name };
+        })
+            .filter((entry) => Boolean(entry));
+        if (tools.length === 0)
+            return undefined;
+        const mode = record.mode === "none" || record.mode === "auto" ||
+            record.mode === "required"
+            ? record.mode
+            : undefined;
+        return { type: "allowed_tools", tools, mode };
+    }
+    if (record.type !== "function")
+        return undefined;
+    if (record.function && typeof record.function === "object") {
+        const fn = record.function;
+        if (typeof fn.name === "string" && fn.name.length > 0) {
+            return { type: "function", function: { name: fn.name } };
+        }
+    }
+    if (typeof record.name === "string" && record.name.length > 0) {
+        return { type: "function", function: { name: record.name } };
+    }
+    return undefined;
+}
+function sseFrame(event) {
+    const encoder = new TextEncoder();
+    const type = event && typeof event === "object" && !Array.isArray(event) &&
+        typeof event.type === "string"
+        ? event.type
+        : null;
+    if (type) {
+        return encoder.encode(`event: ${type}\ndata: ${JSON.stringify(event)}\n\n`);
+    }
+    return encoder.encode(`data: ${JSON.stringify(event)}\n\n`);
+}
+function asJsonValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "number" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => asJsonValue(entry));
+    }
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [key, entry] of Object.entries(value)) {
+            out[key] = asJsonValue(entry);
+        }
+        return out;
+    }
+    return String(value);
+}
+function toStrictContentPart(part) {
+    if (part.type === "output_text") {
+        return {
+            type: "output_text",
+            text: part.text,
+            annotations: [],
+            logprobs: [],
+        };
+    }
+    return {
+        type: part.type,
+        text: part.text,
+    };
+}
+function toStrictResponseItem(item, index) {
+    if (item.type === "message") {
+        return {
+            type: "message",
+            id: item.id ?? `msg_${index + 1}`,
+            status: "completed",
+            role: item.role,
+            content: item.content.map((part) => toStrictContentPart(part)),
+        };
+    }
+    if (item.type === "function_call") {
+        return {
+            type: "function_call",
+            id: item.id ?? item.call_id,
+            call_id: item.call_id,
+            name: item.name,
+            arguments: item.arguments,
+            status: "completed",
+        };
+    }
+    if (item.type === "function_call_output") {
+        return {
+            type: "function_call_output",
+            id: item.id ?? `${item.call_id}_out`,
+            call_id: item.call_id,
+            output: item.output,
+            status: "completed",
+        };
+    }
+    return {
+        type: "reasoning",
+        id: item.id ?? `rs_${index + 1}`,
+        content: (item.content ?? []).map((part) => toStrictContentPart(part)),
+        summary: item.summary.map((part) => toStrictContentPart(part)),
+        encrypted_content: item.encrypted_content ?? null,
+    };
+}
+function toStrictTools(tools) {
+    if (!tools || tools.length === 0)
+        return [];
+    return tools.map((tool) => ({
+        type: "function",
+        name: tool.function.name,
+        description: tool.function.description ?? null,
+        parameters: tool.function.parameters ?? null,
+        strict: false,
+    }));
+}
+function toStrictToolChoice(choice) {
+    if (!choice)
+        return "auto";
+    if (choice === "none" || choice === "auto" || choice === "required") {
+        return choice;
+    }
+    if (choice.type === "allowed_tools") {
+        return {
+            type: "allowed_tools",
+            tools: choice.tools,
+            mode: choice.mode ?? "auto",
+        };
+    }
+    return { type: "function", name: choice.function.name };
+}
+function toStrictResponseResource(args) {
+    const now = Math.floor(Date.now() / 1000);
+    const createdAt = args.response.created_at ?? args.response.created ?? now;
+    const status = args.statusOverride ?? args.response.status ?? "completed";
+    const usage = args.response.usage
+        ? {
+            input_tokens: args.response.usage.promptTokens ?? 0,
+            output_tokens: args.response.usage.completionTokens ?? 0,
+            total_tokens: args.response.usage.totalTokens ?? 0,
+            input_tokens_details: {
+                cached_tokens: 0,
+            },
+            output_tokens_details: {
+                reasoning_tokens: args.response.usage.reasoningTokens ?? 0,
+            },
+        }
+        : null;
+    return {
+        id: args.response.id,
+        object: "response",
+        created_at: createdAt,
+        completed_at: status === "completed" ? now : null,
+        status,
+        incomplete_details: null,
+        model: args.response.model ?? args.request.model,
+        previous_response_id: args.request.previous_response_id ?? null,
+        instructions: args.request.instructions ?? null,
+        output: (args.response.output ?? []).map((item, idx) => toStrictResponseItem(item, idx)),
+        error: args.response.error ?? null,
+        tools: toStrictTools(args.request.tools),
+        tool_choice: toStrictToolChoice(args.request.tool_choice),
+        truncation: args.response.truncation ?? args.request.truncation ??
+            "disabled",
+        parallel_tool_calls: args.response.parallel_tool_calls ??
+            args.request.parallel_tool_calls ?? false,
+        text: args.response.text
+            ? asJsonValue(args.response.text)
+            : args.request.text
+                ? asJsonValue(args.request.text)
+                : { format: { type: "text" } },
+        top_p: args.response.top_p ?? args.request.top_p ?? 1,
+        presence_penalty: args.response.presence_penalty ??
+            args.request.presence_penalty ?? 0,
+        frequency_penalty: args.response.frequency_penalty ??
+            args.request.frequency_penalty ?? 0,
+        top_logprobs: args.response.top_logprobs ?? args.request.top_logprobs ?? 0,
+        temperature: args.response.temperature ?? args.request.temperature ?? 1,
+        reasoning: args.request.reasoning
+            ? {
+                effort: args.request.reasoning.effort ?? null,
+                summary: args.request.reasoning.summary ?? null,
+            }
+            : null,
+        usage,
+        max_output_tokens: args.request.max_output_tokens ?? null,
+        max_tool_calls: args.request.max_tool_calls ?? null,
+        store: args.response.store ?? args.request.store ?? false,
+        background: args.response.background ?? args.request.background ?? false,
+        service_tier: args.response.service_tier ?? args.request.service_tier ??
+            "default",
+        metadata: args.request.metadata ? asJsonValue(args.request.metadata) : {},
+        safety_identifier: args.response.safety_identifier ??
+            args.request.safety_identifier ?? null,
+        prompt_cache_key: args.response.prompt_cache_key ??
+            args.request.prompt_cache_key ?? null,
+    };
+}
 /**
  * Start the WebSocket simulator server used by the Gambit debug UI.
  */
@@ -475,6 +938,13 @@ export function startWebSocketSimulator(opts) {
         (initialContext !== undefined);
     const consoleTracer = opts.verbose ? makeConsoleTracer() : undefined;
     let resolvedDeckPath = resolveDeckPath(opts.deckPath);
+    const buildBotRootCache = new Map();
+    const activeWorkspaceId = opts.workspace?.id ?? null;
+    const activeWorkspaceOnboarding = Boolean(opts.workspace?.onboarding);
+    const workspaceScaffoldEnabled = Boolean(opts.workspace?.scaffoldEnabled);
+    const workspaceScaffoldRoot = opts.workspace?.scaffoldRoot
+        ? path.resolve(opts.workspace.scaffoldRoot)
+        : null;
     const sessionsRoot = (() => {
         const base = opts.sessionDir
             ? path.resolve(opts.sessionDir)
@@ -483,10 +953,23 @@ export function startWebSocketSimulator(opts) {
             dntShim.Deno.mkdirSync(base, { recursive: true });
         }
         catch (err) {
-            logger.warn(`[sim] unable to ensure sessions directory ${base}: ${err instanceof Error ? err.message : err}`);
+            logger.warn(`[sim] unable to ensure workspace state directory ${base}: ${err instanceof Error ? err.message : err}`);
         }
         return base;
     })();
+    const workspaceRoot = (() => {
+        const dir = workspaceScaffoldRoot ?? sessionsRoot;
+        if (workspaceScaffoldEnabled) {
+            try {
+                dntShim.Deno.mkdirSync(dir, { recursive: true });
+            }
+            catch (err) {
+                logger.warn(`[sim] unable to ensure workspace directory ${dir}: ${err instanceof Error ? err.message : err}`);
+            }
+        }
+        return dir;
+    })();
+    const workspaceById = new Map();
     const ensureDir = (dir) => {
         try {
             dntShim.Deno.mkdirSync(dir, { recursive: true });
@@ -502,19 +985,270 @@ export function startWebSocketSimulator(opts) {
         return slug || "session";
     };
     const testBotRuns = new Map();
-    const broadcastTestBot = (payload) => {
+    const broadcastTestBot = (payload, workspaceId) => {
+        if (workspaceId) {
+            const state = readSessionState(workspaceId);
+            if (state) {
+                appendWorkspaceEnvelope(state, "test", payload);
+            }
+        }
+        appendDurableStreamEvent(WORKSPACE_STREAM_ID, payload);
         appendDurableStreamEvent(TEST_STREAM_ID, payload);
     };
+    const buildBotRuns = new Map();
+    const registerWorkspace = (record) => {
+        workspaceById.set(record.id, record);
+        return record;
+    };
+    const resolveWorkspaceRecord = (workspaceId) => {
+        if (!workspaceId)
+            return null;
+        const cached = workspaceById.get(workspaceId);
+        if (cached)
+            return cached;
+        const state = readSessionState(workspaceId);
+        const meta = state?.meta ?? {};
+        const deckPath = typeof meta
+            .workspaceRootDeckPath === "string"
+            ? meta.workspaceRootDeckPath
+            : typeof meta.deck === "string"
+                ? meta.deck
+                : undefined;
+        const rootDir = typeof meta.workspaceRootDir ===
+            "string"
+            ? meta.workspaceRootDir
+            : deckPath
+                ? path.dirname(deckPath)
+                : undefined;
+        if (!deckPath || !rootDir)
+            return null;
+        const createdAt = typeof meta.workspaceCreatedAt ===
+            "string"
+            ? meta.workspaceCreatedAt
+            : typeof meta.sessionCreatedAt === "string"
+                ? meta.sessionCreatedAt
+                : new Date().toISOString();
+        return registerWorkspace({
+            id: workspaceId,
+            rootDir,
+            rootDeckPath: deckPath,
+            createdAt,
+        });
+    };
+    const resolveBuildBotRoot = async (workspaceId) => {
+        const override = dntShim.Deno.env.get("GAMBIT_SIMULATOR_BUILD_BOT_ROOT")?.trim();
+        if (override) {
+            const root = await dntShim.Deno.realPath(override);
+            const info = await dntShim.Deno.stat(root);
+            if (!info.isDirectory) {
+                throw new Error(`Build bot root is not a directory: ${root}`);
+            }
+            assertSafeBuildBotRoot(root, GAMBIT_BOT_SOURCE_DIR);
+            await ensureGambitPolicyInBotRoot(root);
+            return root;
+        }
+        const cacheKey = workspaceId ?? "default";
+        const cached = buildBotRootCache.get(cacheKey);
+        if (cached)
+            return cached;
+        const record = resolveWorkspaceRecord(workspaceId);
+        const candidate = record?.rootDir ?? path.dirname(resolvedDeckPath);
+        const root = await dntShim.Deno.realPath(candidate);
+        const info = await dntShim.Deno.stat(root);
+        if (!info.isDirectory) {
+            throw new Error(`Build bot root is not a directory: ${root}`);
+        }
+        assertSafeBuildBotRoot(root, GAMBIT_BOT_SOURCE_DIR);
+        await ensureGambitPolicyInBotRoot(root);
+        buildBotRootCache.set(cacheKey, root);
+        return root;
+    };
+    const logWorkspaceBotRoot = async (endpoint, workspaceId) => {
+        try {
+            const root = await resolveBuildBotRoot(workspaceId);
+            logger.info(`[sim] ${endpoint}: workspaceId=${workspaceId ?? "(none)"} botRoot=${root}`);
+        }
+        catch (err) {
+            logger.warn(`[sim] ${endpoint}: workspaceId=${workspaceId ?? "(none)"} botRoot=<unresolved> ${err instanceof Error ? err.message : String(err)}`);
+        }
+    };
+    if (opts.workspace?.id && opts.workspace.rootDir && opts.workspace.rootDeckPath) {
+        registerWorkspace({
+            id: opts.workspace.id,
+            rootDir: opts.workspace.rootDir,
+            rootDeckPath: opts.workspace.rootDeckPath,
+            createdAt: new Date().toISOString(),
+        });
+    }
+    const MAX_FILE_PREVIEW_BYTES = 250_000;
+    const shouldReadBuildDeckLabel = (relativePath) => {
+        const lower = path.basename(relativePath).toLowerCase();
+        return lower === "prompt.md" || lower.endsWith(".deck.md");
+    };
+    const readBuildDeckLabel = async (fullPath) => {
+        try {
+            const text = await dntShim.Deno.readTextFile(fullPath);
+            const lines = text.split(/\r?\n/);
+            if (lines[0] !== "+++")
+                return undefined;
+            const endIndex = lines.indexOf("+++", 1);
+            if (endIndex === -1)
+                return undefined;
+            const frontmatter = lines.slice(1, endIndex).join("\n");
+            const parsed = parseToml(frontmatter);
+            const label = typeof parsed.label === "string" ? parsed.label.trim() : "";
+            return label.length > 0 ? label : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const listBuildBotFiles = async (root) => {
+        const entries = [];
+        const shouldSkipRelativePath = (relativePath) => {
+            const segments = relativePath.split(/\\|\//g).filter(Boolean);
+            return segments.includes(".gambit");
+        };
+        const walk = async (dir, relativePrefix) => {
+            for await (const entry of dntShim.Deno.readDir(dir)) {
+                if (entry.isSymlink)
+                    continue;
+                const fullPath = path.join(dir, entry.name);
+                const relPath = relativePrefix
+                    ? path.join(relativePrefix, entry.name)
+                    : entry.name;
+                if (shouldSkipRelativePath(relPath))
+                    continue;
+                if (entry.isDirectory) {
+                    entries.push({ path: relPath, type: "dir" });
+                    await walk(fullPath, relPath);
+                }
+                else if (entry.isFile) {
+                    const info = await dntShim.Deno.stat(fullPath);
+                    const label = shouldReadBuildDeckLabel(relPath)
+                        ? await readBuildDeckLabel(fullPath)
+                        : undefined;
+                    entries.push({
+                        path: relPath,
+                        type: "file",
+                        size: info.size,
+                        modifiedAt: info.mtime ? info.mtime.toISOString() : undefined,
+                        label,
+                    });
+                }
+            }
+        };
+        await walk(root, "");
+        return entries;
+    };
+    const resolveBuildBotPath = async (root, inputPath) => {
+        if (!inputPath || typeof inputPath !== "string") {
+            throw new Error("path is required");
+        }
+        const normalizedInput = path.normalize(inputPath);
+        const segments = normalizedInput.split(/\\|\//g);
+        if (segments.includes("..")) {
+            throw new Error("path traversal is not allowed");
+        }
+        const candidate = path.isAbsolute(normalizedInput)
+            ? normalizedInput
+            : path.resolve(root, normalizedInput);
+        const relativePath = path.relative(root, candidate);
+        if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+            throw new Error("path escapes bot root");
+        }
+        const stat = await dntShim.Deno.lstat(candidate);
+        if (stat.isSymlink) {
+            throw new Error("symlinks are not allowed");
+        }
+        const realCandidate = await dntShim.Deno.realPath(candidate);
+        const realRelative = path.relative(root, realCandidate);
+        if (realRelative.startsWith("..") || path.isAbsolute(realRelative)) {
+            throw new Error("path escapes bot root");
+        }
+        return { fullPath: candidate, relativePath, stat };
+    };
+    const readPreviewText = (bytes) => {
+        const limit = Math.min(bytes.length, 8192);
+        for (let i = 0; i < limit; i += 1) {
+            if (bytes[i] === 0)
+                return null;
+        }
+        const decoder = new TextDecoder("utf-8", { fatal: true });
+        try {
+            return decoder.decode(bytes);
+        }
+        catch {
+            return null;
+        }
+    };
+    const isBuildStreamDebugEnabled = (() => {
+        const raw = dntShim.Deno.env.get("GAMBIT_BUILD_STREAM_DEBUG")?.trim()
+            .toLowerCase();
+        return raw === "1" || raw === "true" || raw === "yes";
+    })();
+    const logBuildStreamDebug = (event, payload) => {
+        if (!isBuildStreamDebugEnabled)
+            return;
+        const ts = new Date().toISOString();
+        if (payload && Object.keys(payload).length > 0) {
+            logger.info(`[build-stream-debug] ${ts} ${event} ${JSON.stringify(payload)}`);
+            return;
+        }
+        logger.info(`[build-stream-debug] ${ts} ${event}`);
+    };
+    const broadcastBuildBot = (payload, workspaceId) => {
+        const record = payload && typeof payload === "object"
+            ? payload
+            : null;
+        const type = record && typeof record.type === "string"
+            ? record.type
+            : "(unknown)";
+        const runId = record && typeof record.runId === "string"
+            ? record.runId
+            : record && record.run && typeof record.run === "object" &&
+                typeof record.run.id === "string"
+                ? record.run.id
+                : undefined;
+        const traceType = type === "buildBotTrace" && record &&
+            record.event && typeof record.event === "object" &&
+            typeof record.event.type === "string"
+            ? record.event.type
+            : undefined;
+        logBuildStreamDebug("broadcastBuildBot", {
+            type,
+            runId,
+            traceType,
+        });
+        const eventWorkspaceId = workspaceId ??
+            (typeof runId === "string" ? runId : undefined);
+        if (eventWorkspaceId) {
+            const state = readSessionState(eventWorkspaceId);
+            if (state) {
+                appendWorkspaceEnvelope(state, "build", payload);
+            }
+        }
+        appendDurableStreamEvent(WORKSPACE_STREAM_ID, payload);
+        appendDurableStreamEvent(BUILD_STREAM_ID, payload);
+    };
     let deckSlug = deckSlugFromPath(resolvedDeckPath);
     let deckLabel = undefined;
+    let rootStartMode = undefined;
     const enrichStateWithSession = (state) => {
         const meta = { ...(state.meta ?? {}) };
         const now = new Date();
+        meta.sessionUpdatedAt = now.toISOString();
         if (typeof meta.sessionId !== "string") {
             const stamp = now.toISOString().replace(/[:.]/g, "-");
             meta.sessionId = `${deckSlug}-${stamp}`;
             meta.sessionCreatedAt = now.toISOString();
         }
+        if (typeof meta.workspaceId !== "string") {
+            meta.workspaceId = String(meta.sessionId);
+        }
+        if (typeof meta.workspaceSchemaVersion !== "string") {
+            meta.workspaceSchemaVersion = WORKSPACE_STATE_SCHEMA_VERSION;
+        }
         if (typeof meta.deck !== "string") {
             meta.deck = resolvedDeckPath;
         }
@@ -528,39 +1262,143 @@ export function startWebSocketSimulator(opts) {
             typeof meta.sessionDir === "string") {
             meta.sessionStatePath = path.join(meta.sessionDir, "state.json");
         }
+        if (typeof meta.sessionEventsPath !== "string" &&
+            typeof meta.sessionDir === "string") {
+            meta.sessionEventsPath = path.join(meta.sessionDir, "events.jsonl");
+        }
+        if (typeof meta.sessionBuildStatePath !== "string" &&
+            typeof meta.sessionDir === "string") {
+            meta.sessionBuildStatePath = path.join(meta.sessionDir, "build_state.json");
+        }
         const dir = typeof meta.sessionDir === "string"
             ? meta.sessionDir
             : undefined;
         return { state: { ...state, meta }, dir };
     };
-    const persistSessionState = (state) => {
-        const { state: enriched, dir } = enrichStateWithSession(state);
-        if (dir) {
-            try {
-                ensureDir(dir);
-                const filePath = path.join(dir, "state.json");
-                dntShim.Deno.writeTextFileSync(filePath, JSON.stringify(enriched, null, 2));
-            }
-            catch (err) {
-                logger.warn(`[sim] failed to persist session state: ${err instanceof Error ? err.message : err}`);
-            }
+    const { parseFiniteInteger, selectCanonicalScenarioRunSummary, appendWorkspaceEnvelope, appendSessionEvent, appendFeedbackLog, appendGradingLog, appendServerErrorLog, persistSessionState, readSessionStateStrict, readSessionState, readBuildState, } = createSessionStore({
+        sessionsRoot,
+        ensureDir,
+        randomId,
+        logger,
+        enrichStateWithSession,
+        workspaceStateSchemaVersion: WORKSPACE_STATE_SCHEMA_VERSION,
+        workspaceSchemaError,
+    });
+    const traceCategory = (type) => {
+        switch (type) {
+            case "message.user":
+            case "model.result":
+                return "turn";
+            case "tool.call":
+            case "tool.result":
+                return "tool";
+            case "log":
+            case "monolog":
+                return "status";
+            case "run.start":
+            case "run.end":
+            case "deck.start":
+            case "deck.end":
+            case "action.start":
+            case "action.end":
+            case "model.call":
+                return "lifecycle";
+            default:
+                return "trace";
         }
-        return enriched;
     };
-    const readSessionState = (sessionId) => {
-        const dir = path.join(sessionsRoot, sessionId);
-        const filePath = path.join(dir, "state.json");
-        try {
-            const text = dntShim.Deno.readTextFileSync(filePath);
-            const parsed = JSON.parse(text);
-            if (parsed && typeof parsed === "object") {
-                return parsed;
-            }
+    const buildWorkspaceMeta = (record, base) => {
+        const createdAt = typeof base?.sessionCreatedAt ===
+            "string"
+            ? base.sessionCreatedAt
+            : typeof base
+                ?.workspaceCreatedAt === "string"
+                ? base.workspaceCreatedAt
+                : new Date().toISOString();
+        return {
+            ...(base ?? {}),
+            workspaceSchemaVersion: WORKSPACE_STATE_SCHEMA_VERSION,
+            workspaceId: record.id,
+            workspaceRootDeckPath: record.rootDeckPath,
+            workspaceRootDir: record.rootDir,
+            workspaceCreatedAt: base
+                ?.workspaceCreatedAt ?? createdAt,
+            sessionCreatedAt: base
+                ?.sessionCreatedAt ?? createdAt,
+            deck: record.rootDeckPath,
+            deckSlug: deckSlugFromPath(record.rootDeckPath),
+            sessionId: record.id,
+        };
+    };
+    const createWorkspaceSession = async (opts) => {
+        const createdAt = new Date().toISOString();
+        if (workspaceScaffoldEnabled) {
+            const scaffold = await createWorkspaceScaffold({
+                baseDir: workspaceRoot,
+            });
+            const record = registerWorkspace(scaffold);
+            persistSessionState({
+                runId: record.id,
+                messages: [],
+                meta: buildWorkspaceMeta(record, {
+                    sessionCreatedAt: record.createdAt,
+                    workspaceCreatedAt: record.createdAt,
+                    workspaceOnboarding: opts?.onboarding ?? false,
+                }),
+            });
+            return record;
         }
-        catch {
-            // ignore
+        const workspaceId = randomId("workspace");
+        const rootDeckPath = resolvedDeckPath;
+        const rootDir = path.dirname(rootDeckPath);
+        const record = registerWorkspace({
+            id: workspaceId,
+            rootDir,
+            rootDeckPath,
+            createdAt,
+        });
+        persistSessionState({
+            runId: record.id,
+            messages: [],
+            meta: buildWorkspaceMeta(record, {
+                sessionCreatedAt: createdAt,
+                workspaceCreatedAt: createdAt,
+                workspaceOnboarding: opts?.onboarding ?? false,
+            }),
+        });
+        return record;
+    };
+    if (opts.workspace?.id && opts.workspace.rootDir && opts.workspace.rootDeckPath) {
+        const existing = readSessionState(opts.workspace.id);
+        if (!existing) {
+            persistSessionState({
+                runId: opts.workspace.id,
+                messages: [],
+                meta: buildWorkspaceMeta({
+                    id: opts.workspace.id,
+                    rootDir: opts.workspace.rootDir,
+                    rootDeckPath: opts.workspace.rootDeckPath,
+                }, {
+                    sessionCreatedAt: new Date().toISOString(),
+                    workspaceCreatedAt: new Date().toISOString(),
+                    workspaceOnboarding: activeWorkspaceOnboarding,
+                }),
+            });
         }
-        return undefined;
+    }
+    const activateWorkspaceDeck = async (workspaceId) => {
+        if (!workspaceId)
+            return;
+        const record = resolveWorkspaceRecord(workspaceId);
+        if (!record)
+            return;
+        const nextPath = resolveDeckPath(record.rootDeckPath);
+        if (nextPath === resolvedDeckPath)
+            return;
+        resolvedDeckPath = nextPath;
+        buildBotRootCache.delete("default");
+        reloadPrimaryDeck();
+        await deckLoadPromise.catch(() => null);
     };
     const deleteSessionState = (sessionId) => {
         if (!sessionId ||
@@ -628,22 +1466,137 @@ export function startWebSocketSimulator(opts) {
             return [];
         }
     };
-    const buildSessionMeta = (sessionId, state) => {
-        const meta = state?.meta ?? {};
-        const createdAt = typeof meta.sessionCreatedAt === "string"
-            ? meta.sessionCreatedAt
-            : undefined;
-        const deck = typeof meta.deck === "string" ? meta.deck : undefined;
-        const deckSlug = typeof meta.deckSlug === "string"
-            ? meta.deckSlug
+    const getWorkspaceIdFromQuery = (url) => resolveWorkspaceIdFromSearchParams(url.searchParams);
+    const getWorkspaceIdFromBody = (body) => {
+        if (!body || typeof body !== "object")
+            return undefined;
+        return resolveWorkspaceIdFromRecord(body);
+    };
+    const findTestRunByWorkspaceId = (workspaceId) => {
+        for (const candidate of testBotRuns.values()) {
+            if (candidate.run.workspaceId === workspaceId ||
+                candidate.run.sessionId === workspaceId) {
+                return candidate;
+            }
+        }
+        return undefined;
+    };
+    const buildWorkspaceReadModel = async (workspaceId, opts) => {
+        let state;
+        try {
+            state = readSessionStateStrict(workspaceId, { withTraces: true });
+        }
+        catch (err) {
+            return {
+                error: err instanceof Error ? err.message : String(err),
+                status: 400,
+            };
+        }
+        if (!state) {
+            return {
+                error: "Workspace not found",
+                status: 404,
+            };
+        }
+        const buildEntry = buildBotRuns.get(workspaceId);
+        const buildRun = buildEntry?.run ?? buildRunFromProjection(workspaceId);
+        const requestedTestRunId = typeof opts?.requestedTestRunId === "string" &&
+            opts.requestedTestRunId.trim().length > 0
+            ? opts.requestedTestRunId
+            : null;
+        const requestedTestEntry = requestedTestRunId
+            ? testBotRuns.get(requestedTestRunId)
             : undefined;
-        const testBotName = typeof meta.testBotName ===
-            "string"
-            ? meta.testBotName
+        const requestedLiveRun = requestedTestEntry?.run &&
+            (requestedTestEntry.run.workspaceId === workspaceId ||
+                requestedTestEntry.run.sessionId === workspaceId)
+            ? requestedTestEntry.run
             : undefined;
-        const gradingRuns = Array.isArray(meta.gradingRuns)
-            ? meta.gradingRuns.map((run) => ({
-                id: typeof run.id === "string" ? run.id : randomId("cal"),
+        const persistedRequestedRun = requestedTestRunId
+            ? readPersistedTestRunStatusById(state, workspaceId, requestedTestRunId)
+            : null;
+        const testEntry = requestedLiveRun
+            ? undefined
+            : findTestRunByWorkspaceId(workspaceId);
+        const testRun = requestedLiveRun ?? persistedRequestedRun ??
+            testEntry?.run ?? {
+            id: "",
+            status: "idle",
+            messages: [],
+            traces: [],
+            toolInserts: [],
+            workspaceId,
+            sessionId: workspaceId,
+        };
+        if (!requestedLiveRun && !persistedRequestedRun && !testEntry) {
+            syncTestBotRunFromState(testRun, state);
+            const meta = state.meta && typeof state.meta === "object"
+                ? state.meta
+                : null;
+            if (meta) {
+                const selectedScenarioSummary = selectCanonicalScenarioRunSummary(meta);
+                if (selectedScenarioSummary) {
+                    testRun.id = selectedScenarioSummary.scenarioRunId;
+                    if (testRun.status === "idle") {
+                        testRun.status = "completed";
+                    }
+                }
+            }
+        }
+        await deckLoadPromise.catch(() => null);
+        const requestedDeck = opts?.requestedTestDeckPath ?? null;
+        const testSelection = requestedDeck
+            ? resolveTestDeck(requestedDeck)
+            : availableTestDecks[0];
+        const testSchemaDesc = testSelection
+            ? await describeDeckInputSchemaFromPath(testSelection.path)
+            : undefined;
+        const session = {
+            workspaceId,
+            messages: state.messages,
+            messageRefs: state.messageRefs,
+            feedback: state.feedback,
+            traces: state.traces,
+            notes: state.notes,
+            meta: state.meta,
+        };
+        return {
+            workspaceId,
+            build: { run: buildRun },
+            test: {
+                run: testRun,
+                botPath: testSelection?.path ?? null,
+                botLabel: testSelection?.label ?? null,
+                botDescription: testSelection?.description ?? null,
+                selectedDeckId: testSelection?.id ?? null,
+                inputSchema: testSchemaDesc?.schema ?? null,
+                inputSchemaError: testSchemaDesc?.error ?? null,
+                defaults: { input: testSchemaDesc?.defaults },
+                testDecks: availableTestDecks,
+            },
+            grade: {
+                graderDecks: availableGraderDecks,
+                sessions: listSessions(),
+            },
+            session,
+        };
+    };
+    const buildSessionMeta = (sessionId, state) => {
+        const meta = state?.meta ?? {};
+        const createdAt = typeof meta.sessionCreatedAt === "string"
+            ? meta.sessionCreatedAt
+            : undefined;
+        const deck = typeof meta.deck === "string" ? meta.deck : undefined;
+        const deckSlug = typeof meta.deckSlug === "string"
+            ? meta.deckSlug
+            : undefined;
+        const testBotName = typeof meta.testBotName ===
+            "string"
+            ? meta.testBotName
+            : undefined;
+        const gradingRuns = Array.isArray(meta.gradingRuns)
+            ? meta.gradingRuns.map((run) => ({
+                id: typeof run.id === "string" ? run.id : randomId("cal"),
                 graderId: run.graderId,
                 graderPath: run.graderPath,
                 graderLabel: run.graderLabel,
@@ -812,6 +1765,11 @@ export function startWebSocketSimulator(opts) {
                     role: msg.role,
                     content,
                     messageRefId: refId,
+                    messageSource: refs[i]?.source === "scenario" ||
+                        refs[i]?.source === "manual" ||
+                        refs[i]?.source === "artifact"
+                        ? refs[i].source
+                        : undefined,
                     feedback: refId ? feedbackByRef.get(refId) : undefined,
                 });
                 continue;
@@ -822,6 +1780,11 @@ export function startWebSocketSimulator(opts) {
                     role: "assistant",
                     content: respondSummary.displayText,
                     messageRefId: refId,
+                    messageSource: refs[i]?.source === "scenario" ||
+                        refs[i]?.source === "manual" ||
+                        refs[i]?.source === "artifact"
+                        ? refs[i].source
+                        : undefined,
                     feedback: refId ? feedbackByRef.get(refId) : undefined,
                     respondStatus: respondSummary.status,
                     respondCode: respondSummary.code,
@@ -851,32 +1814,229 @@ export function startWebSocketSimulator(opts) {
                 : fallbackToolInserts,
         };
     };
-    const buildConversationMessages = (state) => {
+    const buildScenarioConversationArtifacts = (state) => {
         const rawMessages = state.messages ?? [];
+        const refs = state.messageRefs ?? [];
         const conversation = [];
-        for (const msg of rawMessages) {
+        const assistantTurns = [];
+        for (let i = 0; i < rawMessages.length; i++) {
+            const msg = rawMessages[i];
+            const messageRefId = typeof refs[i]?.id === "string"
+                ? refs[i].id
+                : undefined;
             if (msg?.role === "assistant" || msg?.role === "user") {
                 const content = stringifyContent(msg.content).trim();
                 if (!content)
                     continue;
-                conversation.push({
+                const nextMessage = {
                     role: msg.role,
                     content,
                     name: msg.name,
                     tool_calls: msg.tool_calls,
-                });
+                };
+                const conversationIndex = conversation.length;
+                conversation.push(nextMessage);
+                if (nextMessage.role === "assistant") {
+                    assistantTurns.push({
+                        conversationIndex,
+                        message: nextMessage,
+                        messageRefId,
+                    });
+                }
                 continue;
             }
             const respondSummary = summarizeRespondCall(msg);
             if (respondSummary) {
-                conversation.push({
+                const nextMessage = {
                     role: "assistant",
                     content: respondSummary.displayText,
                     name: GAMBIT_TOOL_RESPOND,
+                };
+                const conversationIndex = conversation.length;
+                conversation.push(nextMessage);
+                assistantTurns.push({
+                    conversationIndex,
+                    message: nextMessage,
+                    messageRefId,
+                });
+            }
+        }
+        return { messages: conversation, assistantTurns };
+    };
+    const buildScenarioConversationArtifactsFromRun = (run) => {
+        const conversation = [];
+        const assistantTurns = [];
+        const runMessages = Array.isArray(run.messages) ? run.messages : [];
+        for (const msg of runMessages) {
+            if (msg?.role !== "assistant" && msg?.role !== "user")
+                continue;
+            const content = typeof msg.content === "string" ? msg.content.trim() : "";
+            if (!content)
+                continue;
+            const nextMessage = {
+                role: msg.role,
+                content,
+            };
+            const conversationIndex = conversation.length;
+            conversation.push(nextMessage);
+            if (nextMessage.role === "assistant") {
+                assistantTurns.push({
+                    conversationIndex,
+                    message: nextMessage,
+                    messageRefId: msg.messageRefId,
+                });
+            }
+        }
+        return { messages: conversation, assistantTurns };
+    };
+    const normalizePersistedTestRunStatus = (value, workspaceId) => {
+        if (!value || typeof value !== "object")
+            return null;
+        const raw = value;
+        const id = typeof raw.id === "string" ? raw.id : "";
+        if (!id)
+            return null;
+        const rawStatus = raw.status;
+        const status = rawStatus === "running" || rawStatus === "completed" ||
+            rawStatus === "error" || rawStatus === "canceled"
+            ? rawStatus
+            : "idle";
+        return {
+            id,
+            status,
+            workspaceId: typeof raw.workspaceId === "string"
+                ? raw.workspaceId
+                : workspaceId,
+            sessionId: typeof raw.sessionId === "string"
+                ? raw.sessionId
+                : workspaceId,
+            error: typeof raw.error === "string" ? raw.error : undefined,
+            startedAt: typeof raw.startedAt === "string" ? raw.startedAt : undefined,
+            finishedAt: typeof raw.finishedAt === "string"
+                ? raw.finishedAt
+                : undefined,
+            maxTurns: typeof raw.maxTurns === "number" && Number.isFinite(raw.maxTurns)
+                ? raw.maxTurns
+                : undefined,
+            messages: Array.isArray(raw.messages)
+                ? raw.messages
+                : [],
+            traces: Array.isArray(raw.traces) ? raw.traces : [],
+            toolInserts: Array.isArray(raw.toolInserts)
+                ? raw.toolInserts
+                : [],
+        };
+    };
+    const readPersistedTestRunStatusById = (sessionState, workspaceId, requestedRunId) => {
+        const eventsPath = typeof sessionState.meta?.sessionEventsPath === "string"
+            ? sessionState.meta.sessionEventsPath
+            : undefined;
+        if (!eventsPath)
+            return null;
+        try {
+            const text = dntShim.Deno.readTextFileSync(eventsPath);
+            let latest = null;
+            for (const line of text.split("\n")) {
+                if (!line.trim())
+                    continue;
+                let parsed = null;
+                try {
+                    parsed = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (!parsed || typeof parsed !== "object")
+                    continue;
+                const payload = extractPersistedWorkspacePayload(parsed);
+                if (payload.type !== "testBotStatus" &&
+                    payload.type !== "gambit.test.status")
+                    continue;
+                const normalized = normalizePersistedTestRunStatus(payload.run, workspaceId);
+                if (!normalized || normalized.id !== requestedRunId)
+                    continue;
+                latest = normalized;
+            }
+            return latest;
+        }
+        catch {
+            return null;
+        }
+    };
+    const resolveMessageByRef = (state, messageRefId) => {
+        const refs = Array.isArray(state.messageRefs) ? state.messageRefs : [];
+        const messages = Array.isArray(state.messages) ? state.messages : [];
+        const idx = refs.findIndex((ref) => ref?.id === messageRefId);
+        if (idx < 0)
+            return {};
+        return {
+            message: messages[idx],
+            ref: refs[idx],
+        };
+    };
+    const isFeedbackEligibleMessageRef = (state, messageRefId) => {
+        const { message, ref } = resolveMessageByRef(state, messageRefId);
+        if (!message)
+            return false;
+        if (message.role === "assistant")
+            return true;
+        if (message.role === "user" && ref?.source === "scenario")
+            return true;
+        return summarizeRespondCall(message) !== null;
+    };
+    const isFeedbackEligiblePersistedTestRunMessageRef = (state, runId, messageRefId) => {
+        const eventsPath = typeof state.meta?.sessionEventsPath === "string"
+            ? state.meta.sessionEventsPath
+            : undefined;
+        if (!eventsPath)
+            return false;
+        try {
+            const text = dntShim.Deno.readTextFileSync(eventsPath);
+            for (const line of text.split("\n")) {
+                if (!line.trim())
+                    continue;
+                let parsed = null;
+                try {
+                    parsed = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (!parsed || typeof parsed !== "object")
+                    continue;
+                const payload = extractPersistedWorkspacePayload(parsed);
+                if (payload.type !== "testBotStatus" &&
+                    payload.type !== "gambit.test.status") {
+                    continue;
+                }
+                const run = payload.run;
+                if (!run || typeof run !== "object")
+                    continue;
+                const runRecord = run;
+                if (typeof runRecord.id !== "string" || runRecord.id !== runId) {
+                    continue;
+                }
+                if (!Array.isArray(runRecord.messages))
+                    continue;
+                const found = runRecord.messages.some((entry) => {
+                    if (!entry || typeof entry !== "object")
+                        return false;
+                    const message = entry;
+                    if (message.messageRefId !== messageRefId)
+                        return false;
+                    if (message.role === "assistant")
+                        return true;
+                    return message.role === "user" &&
+                        message.messageSource === "scenario";
                 });
+                if (found)
+                    return true;
             }
         }
-        return conversation;
+        catch {
+            return false;
+        }
+        return false;
     };
     const deriveToolInsertsFromTraces = (state, messageCount) => {
         const traces = Array.isArray(state.traces) ? state.traces : [];
@@ -913,27 +2073,84 @@ export function startWebSocketSimulator(opts) {
         }
         return inserts;
     };
+    const applyUserMessageRefSource = (previousState, nextState, source) => {
+        if (!Array.isArray(nextState.messages) ||
+            !Array.isArray(nextState.messageRefs)) {
+            return nextState;
+        }
+        const startIndex = Math.max(0, previousState?.messages?.length ?? 0);
+        const nextRefs = [...nextState.messageRefs];
+        let changed = false;
+        for (let idx = startIndex; idx < nextState.messages.length; idx++) {
+            const msg = nextState.messages[idx];
+            if (!msg || msg.role !== "user")
+                continue;
+            const ref = nextRefs[idx];
+            if (!ref || typeof ref.id !== "string")
+                continue;
+            if (ref.source === source)
+                continue;
+            nextRefs[idx] = { ...ref, source };
+            changed = true;
+        }
+        if (!changed)
+            return nextState;
+        return { ...nextState, messageRefs: nextRefs };
+    };
     const syncTestBotRunFromState = (run, state) => {
         const snapshot = buildTestBotSnapshot(state);
         run.messages = snapshot.messages;
         run.toolInserts = snapshot.toolInserts;
-        const sessionId = typeof state.meta?.sessionId === "string"
-            ? state.meta.sessionId
-            : undefined;
-        if (sessionId)
-            run.sessionId = sessionId;
+        const workspaceId = typeof state.meta?.workspaceId === "string"
+            ? state.meta.workspaceId
+            : typeof state.meta?.sessionId === "string"
+                ? state.meta.sessionId
+                : undefined;
+        if (workspaceId) {
+            run.workspaceId = workspaceId;
+            run.sessionId = workspaceId;
+        }
         const initFill = state.meta
             ?.testBotInitFill;
         if (initFill)
             run.initFill = initFill;
         run.traces = Array.isArray(state.traces) ? [...state.traces] : undefined;
     };
+    const syncBuildBotRunFromState = (run, state) => {
+        const snapshot = buildTestBotSnapshot(state);
+        run.messages = snapshot.messages;
+        run.toolInserts = snapshot.toolInserts;
+        run.traces = Array.isArray(state.traces) ? [...state.traces] : undefined;
+    };
+    const buildRunFromProjection = (workspaceId) => {
+        const projection = readBuildState(workspaceId);
+        const run = projection?.run;
+        if (!run) {
+            return {
+                id: workspaceId,
+                status: "idle",
+                messages: [],
+                traces: [],
+                toolInserts: [],
+            };
+        }
+        return {
+            id: run.id || workspaceId,
+            status: run.status,
+            error: run.error,
+            startedAt: run.startedAt,
+            finishedAt: run.finishedAt,
+            messages: Array.isArray(run.messages) ? run.messages : [],
+            traces: Array.isArray(run.traces) ? run.traces : [],
+            toolInserts: Array.isArray(run.toolInserts) ? run.toolInserts : [],
+        };
+    };
     const startTestBotRun = (runOpts = {}) => {
         const botDeckPath = typeof runOpts.botDeckPath === "string"
             ? runOpts.botDeckPath
             : undefined;
         if (!botDeckPath) {
-            throw new Error("Missing test bot deck path");
+            throw new Error("Missing scenario deck path");
         }
         const defaultMaxTurns = 12;
         const maxTurns = Math.round(sanitizeNumber(runOpts.maxTurnsOverride ?? defaultMaxTurns, defaultMaxTurns, { min: 1, max: 200 }));
@@ -945,6 +2162,8 @@ export function startWebSocketSimulator(opts) {
             : "";
         const botConfigPath = botDeckPath;
         const testBotName = path.basename(botConfigPath).replace(/\.deck\.(md|ts)$/i, "");
+        const selectedScenarioDeckId = runOpts.botDeckId ?? testBotName;
+        const selectedScenarioDeckLabel = runOpts.botDeckLabel ?? testBotName;
         const runId = randomId("testbot");
         const startedAt = new Date().toISOString();
         const controller = new AbortController();
@@ -963,9 +2182,14 @@ export function startWebSocketSimulator(opts) {
         };
         testBotRuns.set(runId, entry);
         const run = entry.run;
+        const emitTestBot = (payload) => broadcastTestBot(payload, run.workspaceId ?? runOpts.workspaceId);
         if (runOpts.initFill)
             run.initFill = runOpts.initFill;
         let savedState = undefined;
+        const baseMeta = runOpts.baseMeta ?? {};
+        const workspaceMeta = runOpts.workspaceRecord
+            ? buildWorkspaceMeta(runOpts.workspaceRecord, baseMeta)
+            : baseMeta;
         let lastCount = 0;
         const capturedTraces = [];
         if (runOpts.initFillTrace) {
@@ -976,20 +2200,26 @@ export function startWebSocketSimulator(opts) {
                 actionCallId,
                 name: "gambit_test_bot_init_fill",
                 args: runOpts.initFillTrace.args,
+                toolKind: "internal",
             }, {
                 type: "tool.result",
                 runId,
                 actionCallId,
                 name: "gambit_test_bot_init_fill",
                 result: runOpts.initFillTrace.result,
+                toolKind: "internal",
             });
         }
-        const setSessionId = (state) => {
-            const sessionId = typeof state?.meta?.sessionId === "string"
-                ? state.meta.sessionId
-                : undefined;
-            if (sessionId)
-                run.sessionId = sessionId;
+        const setWorkspaceId = (state) => {
+            const workspaceId = typeof state?.meta?.workspaceId === "string"
+                ? state.meta.workspaceId
+                : typeof state?.meta?.sessionId === "string"
+                    ? state.meta.sessionId
+                    : undefined;
+            if (workspaceId) {
+                run.workspaceId = workspaceId;
+                run.sessionId = workspaceId;
+            }
         };
         const appendFromState = (state) => {
             const snapshot = buildTestBotSnapshot(state);
@@ -1000,16 +2230,39 @@ export function startWebSocketSimulator(opts) {
             run.messages = snapshot.messages;
             run.toolInserts = snapshot.toolInserts;
             lastCount = rawLength;
-            setSessionId(state);
+            setWorkspaceId(state);
             run.traces = Array.isArray(state.traces) ? [...state.traces] : undefined;
             if (shouldBroadcast) {
-                broadcastTestBot({ type: "testBotStatus", run });
+                emitTestBot({ type: "testBotStatus", run });
+            }
+        };
+        const pendingTraceEvents = [];
+        const flushPendingTraceEvents = (state) => {
+            if (!pendingTraceEvents.length)
+                return;
+            for (const pending of pendingTraceEvents) {
+                appendSessionEvent(state, {
+                    ...pending,
+                    kind: "trace",
+                    category: traceCategory(pending.type),
+                });
             }
+            pendingTraceEvents.length = 0;
         };
         const tracer = (event) => {
             const stamped = event.ts ? event : { ...event, ts: Date.now() };
             capturedTraces.push(stamped);
             consoleTracer?.(stamped);
+            if (savedState?.meta?.sessionId) {
+                appendSessionEvent(savedState, {
+                    ...stamped,
+                    kind: "trace",
+                    category: traceCategory(stamped.type),
+                });
+            }
+            else {
+                pendingTraceEvents.push(stamped);
+            }
         };
         let deckBotState = undefined;
         let sessionEnded = false;
@@ -1023,8 +2276,11 @@ export function startWebSocketSimulator(opts) {
             return undefined;
         };
         const generateDeckBotUserMessage = async (history, streamOpts) => {
-            const assistantMessage = getLastAssistantMessage(history);
-            if (!assistantMessage)
+            const assistantMessage = getLastAssistantMessage(history)?.trim() || "";
+            const seedPrompt = !assistantMessage && streamOpts?.allowEmptyAssistant
+                ? DEFAULT_TEST_BOT_SEED_PROMPT
+                : undefined;
+            if (!assistantMessage && !seedPrompt)
                 return "";
             const result = await runDeckWithFallback({
                 path: botDeckPath,
@@ -1033,13 +2289,15 @@ export function startWebSocketSimulator(opts) {
                 modelProvider: opts.modelProvider,
                 state: deckBotState,
                 allowRootStringInput: true,
-                initialUserMessage: assistantMessage,
+                initialUserMessage: assistantMessage || seedPrompt,
                 onStateUpdate: (state) => {
                     deckBotState = state;
                 },
                 stream: Boolean(streamOpts?.onStreamText),
                 onStreamText: streamOpts?.onStreamText,
                 responsesMode: opts.responsesMode,
+                workerSandbox: opts.workerSandbox,
+                signal: controller.signal,
             });
             if (isGambitEndSignal(result)) {
                 sessionEnded = true;
@@ -1050,7 +2308,10 @@ export function startWebSocketSimulator(opts) {
         };
         const loop = async () => {
             try {
-                if (!controller.signal.aborted) {
+                const effectiveStartMode = rootStartMode ?? "assistant";
+                const shouldRunInitial = effectiveStartMode !== "user" ||
+                    Boolean(initialUserMessage);
+                if (!controller.signal.aborted && shouldRunInitial) {
                     const initialResult = await runDeck({
                         path: resolvedDeckPath,
                         input: deckInput,
@@ -1064,22 +2325,33 @@ export function startWebSocketSimulator(opts) {
                         allowRootStringInput: true,
                         initialUserMessage: initialUserMessage || undefined,
                         responsesMode: opts.responsesMode,
+                        workerSandbox: opts.workerSandbox,
+                        signal: controller.signal,
                         onStateUpdate: (state) => {
+                            const nextStateWithSource = applyUserMessageRefSource(savedState, state, "scenario");
                             const nextMeta = {
-                                ...(savedState?.meta ?? {}),
-                                ...(state.meta ?? {}),
+                                ...workspaceMeta,
+                                ...(nextStateWithSource.meta ?? {}),
                                 testBot: true,
                                 testBotRunId: runId,
                                 testBotConfigPath: botConfigPath,
                                 testBotName,
+                                scenarioRunId: runId,
+                                selectedScenarioDeckId,
+                                selectedScenarioDeckLabel,
+                                scenarioConfigPath: botConfigPath,
                                 ...(run.initFill ? { testBotInitFill: run.initFill } : {}),
+                                ...(runOpts.workspaceId
+                                    ? { workspaceId: runOpts.workspaceId }
+                                    : {}),
                             };
                             const enriched = persistSessionState({
-                                ...state,
+                                ...nextStateWithSource,
                                 meta: nextMeta,
                                 traces: capturedTraces,
                             });
                             savedState = enriched;
+                            flushPendingTraceEvents(enriched);
                             appendFromState(enriched);
                         },
                     });
@@ -1094,7 +2366,7 @@ export function startWebSocketSimulator(opts) {
                         break;
                     const history = savedState?.messages ?? [];
                     const userMessage = await generateDeckBotUserMessage(history, {
-                        onStreamText: (chunk) => broadcastTestBot({
+                        onStreamText: (chunk) => emitTestBot({
                             type: "testBotStream",
                             runId,
                             role: "user",
@@ -1102,8 +2374,10 @@ export function startWebSocketSimulator(opts) {
                             turn,
                             ts: Date.now(),
                         }),
+                        allowEmptyAssistant: effectiveStartMode === "user" &&
+                            !getLastAssistantMessage(history),
                     });
-                    broadcastTestBot({
+                    emitTestBot({
                         type: "testBotStreamEnd",
                         runId,
                         role: "user",
@@ -1125,25 +2399,36 @@ export function startWebSocketSimulator(opts) {
                         allowRootStringInput: true,
                         initialUserMessage: userMessage,
                         responsesMode: opts.responsesMode,
+                        workerSandbox: opts.workerSandbox,
+                        signal: controller.signal,
                         onStateUpdate: (state) => {
+                            const nextStateWithSource = applyUserMessageRefSource(savedState, state, "scenario");
                             const nextMeta = {
-                                ...(savedState?.meta ?? {}),
-                                ...(state.meta ?? {}),
+                                ...workspaceMeta,
+                                ...(nextStateWithSource.meta ?? {}),
                                 testBot: true,
                                 testBotRunId: runId,
                                 testBotConfigPath: botConfigPath,
                                 testBotName,
+                                scenarioRunId: runId,
+                                selectedScenarioDeckId,
+                                selectedScenarioDeckLabel,
+                                scenarioConfigPath: botConfigPath,
                                 ...(run.initFill ? { testBotInitFill: run.initFill } : {}),
+                                ...(runOpts.workspaceId
+                                    ? { workspaceId: runOpts.workspaceId }
+                                    : {}),
                             };
                             const enriched = persistSessionState({
-                                ...state,
+                                ...nextStateWithSource,
                                 meta: nextMeta,
                                 traces: capturedTraces,
                             });
                             savedState = enriched;
+                            flushPendingTraceEvents(enriched);
                             appendFromState(enriched);
                         },
-                        onStreamText: (chunk) => broadcastTestBot({
+                        onStreamText: (chunk) => emitTestBot({
                             type: "testBotStream",
                             runId,
                             role: "assistant",
@@ -1156,7 +2441,7 @@ export function startWebSocketSimulator(opts) {
                         sessionEnded = true;
                         break;
                     }
-                    broadcastTestBot({
+                    emitTestBot({
                         type: "testBotStreamEnd",
                         runId,
                         role: "assistant",
@@ -1165,12 +2450,18 @@ export function startWebSocketSimulator(opts) {
                     });
                 }
                 run.status = controller.signal.aborted ? "canceled" : "completed";
-                broadcastTestBot({ type: "testBotStatus", run });
+                emitTestBot({ type: "testBotStatus", run });
             }
             catch (err) {
-                run.status = "error";
-                run.error = err instanceof Error ? err.message : String(err);
-                broadcastTestBot({ type: "testBotStatus", run });
+                if (controller.signal.aborted || isRunCanceledError(err)) {
+                    run.status = "canceled";
+                    run.error = undefined;
+                }
+                else {
+                    run.status = "error";
+                    run.error = err instanceof Error ? err.message : String(err);
+                }
+                emitTestBot({ type: "testBotStatus", run });
             }
             finally {
                 if (savedState?.messages) {
@@ -1178,23 +2469,25 @@ export function startWebSocketSimulator(opts) {
                     run.messages = snapshot.messages;
                     run.toolInserts = snapshot.toolInserts;
                 }
-                setSessionId(savedState);
+                setWorkspaceId(savedState);
                 run.traces = Array.isArray(savedState?.traces)
                     ? [...(savedState?.traces ?? [])]
                     : undefined;
                 run.finishedAt = new Date().toISOString();
                 entry.abort = null;
                 entry.promise = null;
-                broadcastTestBot({ type: "testBotStatus", run });
+                emitTestBot({ type: "testBotStatus", run });
             }
         };
         entry.promise = loop();
-        broadcastTestBot({ type: "testBotStatus", run });
+        emitTestBot({ type: "testBotStatus", run });
         return run;
     };
     const persistFailedInitFill = (args) => {
         const failedRunId = randomId("testbot");
         const testBotName = path.basename(args.botDeckPath).replace(/\.deck\.(md|ts)$/i, "");
+        const selectedScenarioDeckId = args.botDeckId ?? testBotName;
+        const selectedScenarioDeckLabel = args.botDeckLabel ?? testBotName;
         const actionCallId = randomId("initfill");
         const traces = [
             {
@@ -1203,6 +2496,7 @@ export function startWebSocketSimulator(opts) {
                 actionCallId,
                 name: "gambit_test_bot_init_fill",
                 args: { missing: args.initFill?.requested ?? [] },
+                toolKind: "internal",
             },
             {
                 type: "tool.result",
@@ -1213,6 +2507,7 @@ export function startWebSocketSimulator(opts) {
                     error: args.error,
                     provided: args.initFill?.provided,
                 },
+                toolKind: "internal",
             },
         ];
         const failedState = persistSessionState({
@@ -1224,25 +2519,52 @@ export function startWebSocketSimulator(opts) {
                 testBotRunId: failedRunId,
                 testBotConfigPath: args.botDeckPath,
                 testBotName,
+                scenarioRunId: failedRunId,
+                selectedScenarioDeckId,
+                selectedScenarioDeckLabel,
+                scenarioConfigPath: args.botDeckPath,
                 testBotInitFill: args.initFill,
                 testBotInitFillError: args.error,
             },
         });
-        const sessionId = typeof failedState.meta?.sessionId === "string"
-            ? failedState.meta.sessionId
+        const workspaceId = typeof failedState.meta?.workspaceId === "string"
+            ? failedState.meta.workspaceId
             : undefined;
-        const sessionPath = typeof failedState.meta?.sessionStatePath === "string"
+        const workspacePath = typeof failedState.meta?.sessionStatePath === "string"
             ? failedState.meta.sessionStatePath
             : undefined;
-        if (sessionPath) {
-            logger.warn(`[sim] init fill failed; session saved to ${sessionPath}`);
+        if (workspacePath) {
+            logger.warn(`[sim] init fill failed; workspace state saved to ${workspacePath}`);
+        }
+        return { workspaceId, workspacePath };
+    };
+    const resolvePreferredDeckPath = async (candidate) => {
+        if (path.basename(candidate) === "PROMPT.md")
+            return candidate;
+        const promptPath = path.join(path.dirname(candidate), "PROMPT.md");
+        try {
+            const stat = await dntShim.Deno.stat(promptPath);
+            if (stat.isFile)
+                return promptPath;
         }
-        return { sessionId, sessionPath };
+        catch {
+            // ignore missing PROMPT.md
+        }
+        return candidate;
     };
-    const deckLoadPromise = loadDeck(resolvedDeckPath)
+    const createDeckLoadPromise = () => resolvePreferredDeckPath(resolvedDeckPath)
+        .then((preferredPath) => {
+        resolvedDeckPath = preferredPath;
+        return loadDeck(preferredPath);
+    })
         .then((deck) => {
         resolvedDeckPath = deck.path;
+        buildBotRootCache.clear();
         deckSlug = deckSlugFromPath(resolvedDeckPath);
+        rootStartMode = deck.startMode === "assistant" ||
+            deck.startMode === "user"
+            ? deck.startMode
+            : undefined;
         deckLabel = typeof deck.label === "string"
             ? deck.label
             : toDeckLabel(deck.path);
@@ -1264,7 +2586,8 @@ export function startWebSocketSimulator(opts) {
         });
         updateTestDeckRegistry(availableTestDecks);
         availableGraderDecks = (deck.graderDecks ?? []).map((graderDeck, index) => {
-            const label = graderDeck.label && typeof graderDeck.label === "string"
+            const label = graderDeck.label &&
+                typeof graderDeck.label === "string"
                 ? graderDeck.label
                 : toDeckLabel(graderDeck.path);
             const id = graderDeck.id && typeof graderDeck.id === "string"
@@ -1291,21 +2614,30 @@ export function startWebSocketSimulator(opts) {
         updateGraderDeckRegistry(availableGraderDecks);
         return null;
     });
-    const schemaPromise = deckLoadPromise
+    const createSchemaPromise = (loadPromise) => loadPromise
         .then((deck) => {
-        const desc = deck ? describeZodSchema(deck.inputSchema) : {
-            error: "Deck failed to load",
-        };
+        if (!deck) {
+            return { error: "Deck failed to load" };
+        }
+        const desc = describeZodSchema(deck.inputSchema);
+        const tools = mapDeckTools(deck.actionDecks);
+        const next = tools ? { ...desc, tools } : desc;
         if (hasInitialContext) {
-            return { ...desc, defaults: initialContext };
+            return { ...next, defaults: initialContext };
         }
-        return desc;
+        return next;
     })
         .catch((err) => {
         const message = err instanceof Error ? err.message : String(err);
         logger.warn(`[sim] failed to load deck schema: ${message}`);
         return { error: message };
     });
+    let deckLoadPromise = createDeckLoadPromise();
+    let schemaPromise = createSchemaPromise(deckLoadPromise);
+    const reloadPrimaryDeck = () => {
+        deckLoadPromise = createDeckLoadPromise();
+        schemaPromise = createSchemaPromise(deckLoadPromise);
+    };
     const wantsSourceMap = Boolean(opts.sourceMap);
     const bundlePlatform = opts.bundlePlatform ?? "deno";
     const autoBundle = opts.autoBundle ?? true;
@@ -1325,6 +2657,7 @@ export function startWebSocketSimulator(opts) {
         logger.log(`[sim] auto-bundle enabled; rebuilding simulator UI (${forceBundle ? "forced" : "stale"})...`);
         logger.log(`[sim] bundling simulator UI (${forceBundle ? "forced" : "stale"})...`);
         try {
+            const decode = new TextDecoder();
             const p = new dntShim.Deno.Command("deno", {
                 args: [
                     "bundle",
@@ -1336,13 +2669,23 @@ export function startWebSocketSimulator(opts) {
                     "simulator-ui/src/main.tsx",
                 ],
                 cwd: path.resolve(moduleDir, ".."),
-                stdout: "null",
-                stderr: "null",
+                stdout: "piped",
+                stderr: "piped",
             });
-            p.outputSync();
+            const out = p.outputSync();
+            if (!out.success) {
+                const stderr = decode.decode(out.stderr).trim();
+                const stdout = decode.decode(out.stdout).trim();
+                const details = stderr || stdout || `exit ${out.code}`;
+                throw new Error(`simulator UI bundle command failed (exit ${out.code}): ${details}`);
+            }
         }
         catch (err) {
-            logger.warn(`[sim] auto-bundle failed: ${err instanceof Error ? err.message : err}`);
+            const message = err instanceof Error ? err.message : String(err);
+            if (forceBundle) {
+                throw new Error(`[sim] auto-bundle failed: ${message}`);
+            }
+            logger.warn(`[sim] auto-bundle failed: ${message}`);
         }
     }
     const server = dntShim.Deno.serve({ port, signal: opts.signal, onListen: () => { } }, async (req) => {
@@ -1350,6 +2693,286 @@ export function startWebSocketSimulator(opts) {
         if (url.pathname.startsWith("/api/durable-streams/stream/")) {
             return handleDurableStreamRequest(req);
         }
+        if (url.pathname === "/v1/responses") {
+            if (req.method !== "POST") {
+                return new Response("Method not allowed", { status: 405 });
+            }
+            if (!opts.modelProvider.responses) {
+                return jsonResponse({ error: "Configured provider does not support responses." }, 501);
+            }
+            try {
+                const body = parseBodyObject(await req.json());
+                const model = typeof body.model === "string" ? body.model : undefined;
+                if (!model) {
+                    throw new Error("model is required");
+                }
+                const input = normalizeInputItems(body.input);
+                const stream = body.stream === true;
+                const instructions = typeof body.instructions === "string"
+                    ? body.instructions
+                    : undefined;
+                const previousResponseId = typeof body.previous_response_id === "string"
+                    ? body.previous_response_id
+                    : undefined;
+                const store = typeof body.store === "boolean"
+                    ? body.store
+                    : undefined;
+                const tools = normalizeTools(body.tools);
+                const toolChoice = normalizeToolChoice(body.tool_choice);
+                const reasoning = (body.reasoning &&
+                    typeof body.reasoning === "object" &&
+                    !Array.isArray(body.reasoning))
+                    ? body.reasoning
+                    : undefined;
+                const parallelToolCalls = typeof body.parallel_tool_calls === "boolean"
+                    ? body.parallel_tool_calls
+                    : undefined;
+                const maxToolCalls = typeof body.max_tool_calls === "number"
+                    ? body.max_tool_calls
+                    : undefined;
+                const temperature = typeof body.temperature === "number"
+                    ? body.temperature
+                    : undefined;
+                const topP = typeof body.top_p === "number" ? body.top_p : undefined;
+                const frequencyPenalty = typeof body.frequency_penalty === "number"
+                    ? body.frequency_penalty
+                    : undefined;
+                const presencePenalty = typeof body.presence_penalty === "number"
+                    ? body.presence_penalty
+                    : undefined;
+                const maxOutputTokens = typeof body.max_output_tokens === "number"
+                    ? body.max_output_tokens
+                    : undefined;
+                const topLogprobs = typeof body.top_logprobs === "number"
+                    ? body.top_logprobs
+                    : undefined;
+                const truncation = body.truncation === "auto" ||
+                    body.truncation === "disabled"
+                    ? body.truncation
+                    : undefined;
+                const text = (body.text && typeof body.text === "object" &&
+                    !Array.isArray(body.text))
+                    ? body.text
+                    : undefined;
+                const streamOptions = (body.stream_options &&
+                    typeof body.stream_options === "object" &&
+                    !Array.isArray(body.stream_options))
+                    ? body.stream_options
+                    : undefined;
+                const background = typeof body.background === "boolean"
+                    ? body.background
+                    : undefined;
+                const include = Array.isArray(body.include)
+                    ? body.include.filter((entry) => typeof entry === "string")
+                    : undefined;
+                const serviceTier = body.service_tier === "auto" ||
+                    body.service_tier === "default" || body.service_tier === "flex" ||
+                    body.service_tier === "priority"
+                    ? body.service_tier
+                    : undefined;
+                const metadata = (body.metadata &&
+                    typeof body.metadata === "object" &&
+                    !Array.isArray(body.metadata))
+                    ? body.metadata
+                    : undefined;
+                const safetyIdentifier = typeof body.safety_identifier === "string"
+                    ? body.safety_identifier
+                    : undefined;
+                const promptCacheKey = typeof body.prompt_cache_key === "string"
+                    ? body.prompt_cache_key
+                    : undefined;
+                const passthrough = {};
+                for (const [key, value] of Object.entries(body)) {
+                    if (key === "model" || key === "input" || key === "stream" ||
+                        key === "instructions" || key === "tools" ||
+                        key === "tool_choice" || key === "max_output_tokens" ||
+                        key === "previous_response_id" || key === "store" ||
+                        key === "reasoning" || key === "parallel_tool_calls" ||
+                        key === "max_tool_calls" || key === "temperature" ||
+                        key === "top_p" || key === "frequency_penalty" ||
+                        key === "presence_penalty" || key === "include" ||
+                        key === "text" || key === "stream_options" ||
+                        key === "background" || key === "truncation" ||
+                        key === "service_tier" || key === "top_logprobs" ||
+                        key === "metadata" || key === "safety_identifier" ||
+                        key === "prompt_cache_key" || key === "params") {
+                        continue;
+                    }
+                    passthrough[key] = value;
+                }
+                const explicitParams = (body.params &&
+                    typeof body.params === "object" &&
+                    !Array.isArray(body.params))
+                    ? body.params
+                    : undefined;
+                const params = explicitParams || Object.keys(passthrough).length > 0
+                    ? { ...(explicitParams ?? {}), ...passthrough }
+                    : undefined;
+                const requestBody = {
+                    model,
+                    input,
+                    instructions,
+                    previous_response_id: previousResponseId,
+                    store,
+                    tools,
+                    tool_choice: toolChoice,
+                    reasoning,
+                    parallel_tool_calls: parallelToolCalls,
+                    max_tool_calls: maxToolCalls,
+                    temperature,
+                    top_p: topP,
+                    frequency_penalty: frequencyPenalty,
+                    presence_penalty: presencePenalty,
+                    stream,
+                    stream_options: streamOptions,
+                    max_output_tokens: maxOutputTokens,
+                    top_logprobs: topLogprobs,
+                    truncation,
+                    text,
+                    include,
+                    background,
+                    service_tier: serviceTier,
+                    metadata,
+                    safety_identifier: safetyIdentifier,
+                    prompt_cache_key: promptCacheKey,
+                    params,
+                };
+                if (!stream) {
+                    const response = await opts.modelProvider.responses({
+                        request: requestBody,
+                    });
+                    return jsonResponse(toStrictResponseResource({
+                        request: requestBody,
+                        response,
+                    }));
+                }
+                const streamBody = new ReadableStream({
+                    start: async (controller) => {
+                        let sequence = 1;
+                        const itemIdByOutputIndex = new Map();
+                        const streamRequest = {
+                            ...requestBody,
+                            stream: true,
+                        };
+                        try {
+                            const result = await opts.modelProvider.responses({
+                                request: streamRequest,
+                                onStreamEvent: (event) => {
+                                    if (event.type === "response.created") {
+                                        controller.enqueue(sseFrame({
+                                            type: "response.created",
+                                            sequence_number: sequence++,
+                                            response: toStrictResponseResource({
+                                                request: streamRequest,
+                                                response: event.response,
+                                                statusOverride: "in_progress",
+                                            }),
+                                        }));
+                                        return;
+                                    }
+                                    if (event.type === "response.output_text.delta") {
+                                        const itemId = event.item_id ??
+                                            itemIdByOutputIndex.get(event.output_index) ??
+                                            `msg_${event.output_index + 1}`;
+                                        itemIdByOutputIndex.set(event.output_index, itemId);
+                                        controller.enqueue(sseFrame({
+                                            type: "response.output_text.delta",
+                                            sequence_number: sequence++,
+                                            output_index: event.output_index,
+                                            item_id: itemId,
+                                            content_index: event.content_index ?? 0,
+                                            delta: event.delta,
+                                            logprobs: event.logprobs ?? [],
+                                        }));
+                                        return;
+                                    }
+                                    if (event.type === "response.output_text.done") {
+                                        const itemId = event.item_id ??
+                                            itemIdByOutputIndex.get(event.output_index) ??
+                                            `msg_${event.output_index + 1}`;
+                                        itemIdByOutputIndex.set(event.output_index, itemId);
+                                        controller.enqueue(sseFrame({
+                                            type: "response.output_text.done",
+                                            sequence_number: sequence++,
+                                            output_index: event.output_index,
+                                            item_id: itemId,
+                                            content_index: event.content_index ?? 0,
+                                            text: event.text,
+                                            logprobs: [],
+                                        }));
+                                        return;
+                                    }
+                                    if (event.type === "response.completed") {
+                                        controller.enqueue(sseFrame({
+                                            type: "response.completed",
+                                            sequence_number: sequence++,
+                                            response: toStrictResponseResource({
+                                                request: streamRequest,
+                                                response: event.response,
+                                                statusOverride: "completed",
+                                            }),
+                                        }));
+                                        return;
+                                    }
+                                    if (event.type === "response.failed") {
+                                        controller.enqueue(sseFrame({
+                                            type: "response.failed",
+                                            sequence_number: sequence++,
+                                            response: {
+                                                ...toStrictResponseResource({
+                                                    request: streamRequest,
+                                                    response: {
+                                                        id: `resp_${crypto.randomUUID().slice(0, 8)}`,
+                                                        object: "response",
+                                                        output: [],
+                                                        status: "failed",
+                                                        error: event.error ??
+                                                            { message: "Unknown error" },
+                                                    },
+                                                    statusOverride: "failed",
+                                                }),
+                                                error: event.error ?? { message: "Unknown error" },
+                                            },
+                                        }));
+                                    }
+                                },
+                            });
+                            controller.enqueue(sseFrame({
+                                type: "response.completed",
+                                sequence_number: sequence++,
+                                response: toStrictResponseResource({
+                                    request: streamRequest,
+                                    response: result,
+                                    statusOverride: "completed",
+                                }),
+                            }));
+                            controller.enqueue(new TextEncoder().encode("data: [DONE]\n\n"));
+                        }
+                        catch (err) {
+                            controller.enqueue(sseFrame({
+                                type: "error",
+                                code: "internal_error",
+                                message: err instanceof Error ? err.message : String(err),
+                                param: null,
+                            }));
+                        }
+                        finally {
+                            controller.close();
+                        }
+                    },
+                });
+                return new Response(streamBody, {
+                    headers: {
+                        "content-type": "text/event-stream",
+                        "cache-control": "no-cache",
+                        "connection": "keep-alive",
+                    },
+                });
+            }
+            catch (err) {
+                return jsonResponse({ error: err instanceof Error ? err.message : String(err) }, 400);
+            }
+        }
         if (url.pathname === "/favicon.ico") {
             if (req.method !== "GET" && req.method !== "HEAD") {
                 return new Response("Method not allowed", { status: 405 });
@@ -1372,16 +2995,72 @@ export function startWebSocketSimulator(opts) {
                 }
             }
         }
-        if (url.pathname === "/api/calibrate") {
+        const workspaceTestRunGetMatch = url.pathname.match(/^\/api\/workspaces\/([^/]+)\/test\/([^/]+)$/);
+        if (workspaceTestRunGetMatch) {
             if (req.method !== "GET") {
                 return new Response("Method not allowed", { status: 405 });
             }
-            await deckLoadPromise.catch(() => null);
-            const sessions = listSessions();
-            return new Response(JSON.stringify({
-                graderDecks: availableGraderDecks,
-                sessions,
-            }), { headers: { "content-type": "application/json" } });
+            const workspaceId = decodeURIComponent(workspaceTestRunGetMatch[1]);
+            const requestedTestRunId = decodeURIComponent(workspaceTestRunGetMatch[2]);
+            await logWorkspaceBotRoot("/api/workspaces/:id/test/:runId", workspaceId);
+            await activateWorkspaceDeck(workspaceId);
+            const payload = await buildWorkspaceReadModel(workspaceId, {
+                requestedTestDeckPath: url.searchParams.get("deckPath"),
+                requestedTestRunId,
+            });
+            if ("error" in payload) {
+                return new Response(JSON.stringify({ error: payload.error }), {
+                    status: payload.status,
+                    headers: { "content-type": "application/json" },
+                });
+            }
+            return new Response(JSON.stringify(payload), {
+                headers: { "content-type": "application/json" },
+            });
+        }
+        const workspaceGradeRunGetMatch = url.pathname.match(/^\/api\/workspaces\/([^/]+)\/grade\/([^/]+)$/);
+        if (workspaceGradeRunGetMatch) {
+            if (req.method !== "GET") {
+                return new Response("Method not allowed", { status: 405 });
+            }
+            const workspaceId = decodeURIComponent(workspaceGradeRunGetMatch[1]);
+            const requestedGradeRunId = decodeURIComponent(workspaceGradeRunGetMatch[2]);
+            await logWorkspaceBotRoot("/api/workspaces/:id/grade/:runId", workspaceId);
+            await activateWorkspaceDeck(workspaceId);
+            const payload = await buildWorkspaceReadModel(workspaceId, {
+                requestedTestDeckPath: url.searchParams.get("deckPath"),
+                requestedGradeRunId,
+            });
+            if ("error" in payload) {
+                return new Response(JSON.stringify({ error: payload.error }), {
+                    status: payload.status,
+                    headers: { "content-type": "application/json" },
+                });
+            }
+            return new Response(JSON.stringify(payload), {
+                headers: { "content-type": "application/json" },
+            });
+        }
+        const workspaceGetMatch = url.pathname.match(/^\/api\/workspaces\/([^/]+)$/);
+        if (workspaceGetMatch) {
+            if (req.method !== "GET") {
+                return new Response("Method not allowed", { status: 405 });
+            }
+            const workspaceId = decodeURIComponent(workspaceGetMatch[1]);
+            await logWorkspaceBotRoot("/api/workspaces/:id", workspaceId);
+            await activateWorkspaceDeck(workspaceId);
+            const payload = await buildWorkspaceReadModel(workspaceId, {
+                requestedTestDeckPath: url.searchParams.get("deckPath"),
+            });
+            if ("error" in payload) {
+                return new Response(JSON.stringify({ error: payload.error }), {
+                    status: payload.status,
+                    headers: { "content-type": "application/json" },
+                });
+            }
+            return new Response(JSON.stringify(payload), {
+                headers: { "content-type": "application/json" },
+            });
         }
         if (url.pathname === "/api/calibrate/run") {
             if (req.method !== "POST") {
@@ -1389,10 +3068,12 @@ export function startWebSocketSimulator(opts) {
             }
             try {
                 const body = await req.json();
-                if (!body.sessionId) {
-                    throw new Error("Missing sessionId");
+                const workspaceId = getWorkspaceIdFromBody(body);
+                if (!workspaceId) {
+                    throw new Error("Missing workspaceId");
                 }
-                const sessionId = body.sessionId;
+                await logWorkspaceBotRoot("/api/calibrate/run", workspaceId);
+                await activateWorkspaceDeck(workspaceId);
                 await deckLoadPromise.catch(() => null);
                 const grader = body.graderId
                     ? resolveGraderDeck(body.graderId)
@@ -1400,9 +3081,28 @@ export function startWebSocketSimulator(opts) {
                 if (!grader) {
                     throw new Error("Unknown grader deck selection");
                 }
-                const sessionState = readSessionState(sessionId);
+                const sessionState = readSessionState(workspaceId);
                 if (!sessionState) {
-                    throw new Error("Session not found");
+                    throw new Error("Workspace not found");
+                }
+                const requestedScenarioRunId = typeof body.scenarioRunId === "string" &&
+                    body.scenarioRunId.trim().length > 0
+                    ? body.scenarioRunId
+                    : undefined;
+                const requestedLiveRun = requestedScenarioRunId
+                    ? testBotRuns.get(requestedScenarioRunId)?.run
+                    : undefined;
+                const requestedLiveRunMatchesWorkspace = Boolean(requestedLiveRun &&
+                    (requestedLiveRun.workspaceId === workspaceId ||
+                        requestedLiveRun.sessionId === workspaceId));
+                const requestedPersistedRun = requestedScenarioRunId
+                    ? readPersistedTestRunStatusById(sessionState, workspaceId, requestedScenarioRunId)
+                    : null;
+                const selectedScenarioRun = requestedLiveRunMatchesWorkspace
+                    ? requestedLiveRun
+                    : requestedPersistedRun;
+                if (requestedScenarioRunId && !selectedScenarioRun) {
+                    throw new Error(`Scenario run "${requestedScenarioRunId}" not found for workspace`);
                 }
                 const graderSchema = await describeDeckInputSchemaFromPath(grader.path);
                 const runMode = schemaHasField(graderSchema.schema, "messageToGrade")
@@ -1417,7 +3117,24 @@ export function startWebSocketSimulator(opts) {
                     delete next.gradingRuns;
                     return next;
                 })();
-                const conversationMessages = buildConversationMessages(sessionState);
+                const conversationArtifacts = selectedScenarioRun
+                    ? buildScenarioConversationArtifactsFromRun(selectedScenarioRun)
+                    : buildScenarioConversationArtifacts(sessionState);
+                const conversationMessages = conversationArtifacts.messages;
+                const activeScenarioRunId = requestedScenarioRunId ??
+                    (typeof sessionState.meta?.scenarioRunId === "string" &&
+                        sessionState.meta.scenarioRunId.trim().length > 0
+                        ? sessionState.meta.scenarioRunId
+                        : undefined);
+                const sessionMetaForPayload = {
+                    ...(metaForGrading ?? {}),
+                    ...(activeScenarioRunId
+                        ? {
+                            scenarioRunId: activeScenarioRunId,
+                            testBotRunId: activeScenarioRunId,
+                        }
+                        : {}),
+                };
                 const sessionPayload = {
                     messages: conversationMessages.length > 0
                         ? conversationMessages.map((msg) => ({
@@ -1426,7 +3143,7 @@ export function startWebSocketSimulator(opts) {
                             name: msg.name,
                         }))
                         : undefined,
-                    meta: metaForGrading,
+                    meta: sessionMetaForPayload,
                     notes: sessionState.notes
                         ? { text: sessionState.notes.text }
                         : undefined,
@@ -1452,10 +3169,20 @@ export function startWebSocketSimulator(opts) {
                             gradingRuns: nextRuns,
                         },
                     });
-                    const sessionMeta = buildSessionMeta(sessionId, nextState);
+                    appendGradingLog(nextState, {
+                        type: "grading.run",
+                        run: nextEntry,
+                    });
+                    const sessionMeta = buildSessionMeta(workspaceId, nextState);
+                    appendDurableStreamEvent(WORKSPACE_STREAM_ID, {
+                        type: "calibrateSession",
+                        workspaceId,
+                        run: nextEntry,
+                        session: sessionMeta,
+                    });
                     appendDurableStreamEvent(GRADE_STREAM_ID, {
                         type: "calibrateSession",
-                        sessionId,
+                        workspaceId,
                         run: nextEntry,
                         session: sessionMeta,
                     });
@@ -1467,11 +3194,13 @@ export function startWebSocketSimulator(opts) {
                         if (runMode !== "turns") {
                             entry = {
                                 id: runId,
+                                workspaceId,
                                 graderId: grader.id,
                                 graderPath: grader.path,
                                 graderLabel: grader.label,
                                 status: "running",
                                 runAt: startedAt,
+                                gradingRunId: runId,
                                 input: { session: sessionPayload },
                             };
                             currentState = upsertCalibrationRun(currentState, entry);
@@ -1487,27 +3216,28 @@ export function startWebSocketSimulator(opts) {
                             });
                         }
                         const messages = sessionPayload.messages ?? [];
-                        const assistantTurns = messages
-                            .map((msg, idx) => ({ msg, idx }))
-                            .filter(({ msg }) => msg.role === "assistant" &&
-                            typeof msg.content === "string" &&
-                            msg.content.trim().length > 0);
+                        const assistantTurns = conversationArtifacts.assistantTurns;
                         const totalTurns = assistantTurns.length;
                         const turns = [];
                         entry = {
                             id: runId,
+                            workspaceId,
                             graderId: grader.id,
                             graderPath: grader.path,
                             graderLabel: grader.label,
                             status: "running",
                             runAt: startedAt,
+                            gradingRunId: runId,
+                            input: { session: sessionPayload },
                             result: { mode: "turns", totalTurns, turns: [] },
                         };
                         currentState = upsertCalibrationRun(currentState, entry);
                         if (totalTurns === 0) {
                             return { mode: "turns", totalTurns, turns: [] };
                         }
-                        for (const { msg, idx } of assistantTurns) {
+                        for (const turnEntry of assistantTurns) {
+                            const msg = turnEntry.message;
+                            const idx = turnEntry.conversationIndex;
                             const input = {
                                 session: {
                                     ...sessionPayload,
@@ -1527,6 +3257,9 @@ export function startWebSocketSimulator(opts) {
                             });
                             turns.push({
                                 index: idx,
+                                gradingRunId: runId,
+                                artifactRevisionId: randomId("grade-rev"),
+                                messageRefId: turnEntry.messageRefId,
                                 message: msg,
                                 input,
                                 result: turnResult,
@@ -1541,39 +3274,57 @@ export function startWebSocketSimulator(opts) {
                     })();
                     entry = {
                         id: runId,
+                        workspaceId,
                         graderId: grader.id,
                         graderPath: grader.path,
                         graderLabel: grader.label,
                         status: "completed",
                         runAt: startedAt,
+                        gradingRunId: runId,
                         input: { session: sessionPayload },
                         result,
                     };
                 }
                 catch (err) {
                     const message = err instanceof Error ? err.message : String(err);
+                    logger.error("[sim] calibrate run failed", {
+                        workspaceId,
+                        runId,
+                        runMode,
+                        graderId: grader.id,
+                        graderPath: grader.path,
+                        error: message,
+                        stack: err instanceof Error ? err.stack : undefined,
+                    });
                     entry = {
                         id: runId,
+                        workspaceId,
                         graderId: grader.id,
                         graderPath: grader.path,
                         graderLabel: grader.label,
                         status: "error",
                         runAt: startedAt,
+                        gradingRunId: runId,
                         input: { session: sessionPayload },
                         error: message,
                     };
                 }
                 const nextState = upsertCalibrationRun(currentState, entry);
-                const sessionMeta = buildSessionMeta(body.sessionId, nextState);
+                const sessionMeta = buildSessionMeta(workspaceId, nextState);
                 return new Response(JSON.stringify({
-                    sessionId: body.sessionId,
+                    workspaceId,
                     run: entry,
                     session: sessionMeta,
                 }), { headers: { "content-type": "application/json" } });
             }
             catch (err) {
-                return new Response(JSON.stringify({
-                    error: err instanceof Error ? err.message : String(err),
+                const message = err instanceof Error ? err.message : String(err);
+                logger.error("[sim] /api/calibrate/run request failed", {
+                    error: message,
+                    stack: err instanceof Error ? err.stack : undefined,
+                });
+                return new Response(JSON.stringify({
+                    error: message,
                 }), { status: 400, headers: { "content-type": "application/json" } });
             }
         }
@@ -1583,12 +3334,14 @@ export function startWebSocketSimulator(opts) {
             }
             try {
                 const body = await req.json();
-                if (!body.sessionId || !body.refId) {
-                    throw new Error("Missing sessionId or refId");
+                const workspaceId = getWorkspaceIdFromBody(body);
+                if (!workspaceId || !body.refId) {
+                    throw new Error("Missing workspaceId or refId");
                 }
-                const state = readSessionState(body.sessionId);
+                await logWorkspaceBotRoot("/api/calibrate/flag", workspaceId);
+                const state = readSessionState(workspaceId);
                 if (!state) {
-                    throw new Error("Session not found");
+                    throw new Error("Workspace not found");
                 }
                 const meta = (state.meta && typeof state.meta === "object")
                     ? { ...state.meta }
@@ -1599,22 +3352,25 @@ export function startWebSocketSimulator(opts) {
                 const flagIndex = existingFlags.findIndex((flag) => flag?.refId === body.refId);
                 let nextFlags;
                 let flagged = false;
+                let flagEntry;
                 if (flagIndex >= 0) {
+                    flagEntry = existingFlags[flagIndex];
                     nextFlags = existingFlags.filter((_, idx) => idx !== flagIndex);
                     flagged = false;
                 }
                 else {
                     const now = new Date().toISOString();
+                    flagEntry = {
+                        id: randomId("flag"),
+                        refId: body.refId,
+                        runId: body.runId,
+                        turnIndex: body.turnIndex,
+                        reason: body.reason?.trim() || undefined,
+                        createdAt: now,
+                    };
                     nextFlags = [
                         ...existingFlags,
-                        {
-                            id: randomId("flag"),
-                            refId: body.refId,
-                            runId: body.runId,
-                            turnIndex: body.turnIndex,
-                            reason: body.reason?.trim() || undefined,
-                            createdAt: now,
-                        },
+                        flagEntry,
                     ];
                     flagged = true;
                 }
@@ -1625,14 +3381,25 @@ export function startWebSocketSimulator(opts) {
                         gradingFlags: nextFlags,
                     },
                 });
-                const sessionMeta = buildSessionMeta(body.sessionId, updated);
+                appendGradingLog(updated, {
+                    type: "grading.flag",
+                    flagged,
+                    flag: flagEntry,
+                    refId: body.refId,
+                });
+                const sessionMeta = buildSessionMeta(workspaceId, updated);
+                appendDurableStreamEvent(WORKSPACE_STREAM_ID, {
+                    type: "calibrateSession",
+                    workspaceId,
+                    session: sessionMeta,
+                });
                 appendDurableStreamEvent(GRADE_STREAM_ID, {
                     type: "calibrateSession",
-                    sessionId: body.sessionId,
+                    workspaceId,
                     session: sessionMeta,
                 });
                 return new Response(JSON.stringify({
-                    sessionId: body.sessionId,
+                    workspaceId,
                     flagged,
                     flags: nextFlags,
                 }), { headers: { "content-type": "application/json" } });
@@ -1649,12 +3416,14 @@ export function startWebSocketSimulator(opts) {
             }
             try {
                 const body = await req.json();
-                if (!body.sessionId || !body.refId) {
-                    throw new Error("Missing sessionId or refId");
+                const workspaceId = getWorkspaceIdFromBody(body);
+                if (!workspaceId || !body.refId) {
+                    throw new Error("Missing workspaceId or refId");
                 }
-                const state = readSessionState(body.sessionId);
+                await logWorkspaceBotRoot("/api/calibrate/flag/reason", workspaceId);
+                const state = readSessionState(workspaceId);
                 if (!state) {
-                    throw new Error("Session not found");
+                    throw new Error("Workspace not found");
                 }
                 const meta = (state.meta && typeof state.meta === "object")
                     ? { ...state.meta }
@@ -1678,104 +3447,25 @@ export function startWebSocketSimulator(opts) {
                         gradingFlags: nextFlags,
                     },
                 });
-                const sessionMeta = buildSessionMeta(body.sessionId, updated);
-                appendDurableStreamEvent(GRADE_STREAM_ID, {
+                appendGradingLog(updated, {
+                    type: "grading.flag.reason",
+                    flag: updatedFlag,
+                    refId: body.refId,
+                });
+                const sessionMeta = buildSessionMeta(workspaceId, updated);
+                appendDurableStreamEvent(WORKSPACE_STREAM_ID, {
                     type: "calibrateSession",
-                    sessionId: body.sessionId,
+                    workspaceId,
                     session: sessionMeta,
                 });
-                return new Response(JSON.stringify({
-                    sessionId: body.sessionId,
-                    flags: nextFlags,
-                }), { headers: { "content-type": "application/json" } });
-            }
-            catch (err) {
-                return new Response(JSON.stringify({
-                    error: err instanceof Error ? err.message : String(err),
-                }), { status: 400, headers: { "content-type": "application/json" } });
-            }
-        }
-        if (url.pathname === "/api/grading/reference") {
-            if (req.method !== "POST") {
-                return new Response("Method not allowed", { status: 405 });
-            }
-            try {
-                const body = await req.json();
-                if (!body.sessionId)
-                    throw new Error("Missing sessionId");
-                if (!body.runId)
-                    throw new Error("Missing runId");
-                if (!body.referenceSample) {
-                    throw new Error("Missing referenceSample");
-                }
-                const score = body.referenceSample.score;
-                if (typeof score !== "number" || Number.isNaN(score)) {
-                    throw new Error("Invalid reference score");
-                }
-                const reason = body.referenceSample.reason;
-                if (typeof reason !== "string" || reason.trim().length === 0) {
-                    throw new Error("Missing reference reason");
-                }
-                const evidence = Array.isArray(body.referenceSample.evidence)
-                    ? body.referenceSample.evidence.filter((e) => typeof e === "string" && e.trim().length > 0)
-                    : undefined;
-                const state = readSessionState(body.sessionId);
-                if (!state)
-                    throw new Error("Session not found");
-                const previousRuns = Array.isArray(state.meta?.gradingRuns)
-                    ? (state.meta
-                        .gradingRuns)
-                    : Array.isArray(state.meta?.calibrationRuns)
-                        ? state.meta?.calibrationRuns
-                        : [];
-                const index = previousRuns.findIndex((run) => run.id === body.runId);
-                if (index < 0)
-                    throw new Error("Run not found");
-                const run = previousRuns[index];
-                const nextRun = {
-                    ...run,
-                };
-                if (typeof body.turnIndex === "number") {
-                    const result = run.result;
-                    const turnIndex = body.turnIndex;
-                    if (!result || typeof result !== "object" ||
-                        result.mode !== "turns" ||
-                        !Array.isArray(result.turns)) {
-                        throw new Error("Run does not support turn references");
-                    }
-                    const turns = result.turns.map((turn) => ({ ...turn }));
-                    const targetIndex = turns.findIndex((turn) => turn.index === turnIndex);
-                    if (targetIndex < 0) {
-                        throw new Error("Turn not found");
-                    }
-                    turns[targetIndex] = {
-                        ...turns[targetIndex],
-                        referenceSample: { score, reason, evidence },
-                    };
-                    nextRun.result = { ...result, turns };
-                }
-                else {
-                    nextRun.referenceSample = { score, reason, evidence };
-                }
-                const nextRuns = previousRuns.map((entry, i) => i === index ? nextRun : entry);
-                const nextState = persistSessionState({
-                    ...state,
-                    meta: {
-                        ...(state.meta ?? {}),
-                        gradingRuns: nextRuns,
-                    },
-                });
-                const sessionMeta = buildSessionMeta(body.sessionId, nextState);
                 appendDurableStreamEvent(GRADE_STREAM_ID, {
                     type: "calibrateSession",
-                    sessionId: body.sessionId,
-                    run: nextRun,
+                    workspaceId,
                     session: sessionMeta,
                 });
                 return new Response(JSON.stringify({
-                    sessionId: body.sessionId,
-                    run: nextRun,
-                    session: sessionMeta,
+                    workspaceId,
+                    flags: nextFlags,
                 }), { headers: { "content-type": "application/json" } });
             }
             catch (err) {
@@ -1784,8 +3474,28 @@ export function startWebSocketSimulator(opts) {
                 }), { status: 400, headers: { "content-type": "application/json" } });
             }
         }
+        const gradingReferenceResponse = await handleGradingReferenceRoute({
+            url,
+            req,
+            getWorkspaceIdFromBody,
+            logWorkspaceBotRoot,
+            readSessionState,
+            persistSessionState,
+            appendGradingLog,
+            buildSessionMeta,
+            appendDurableStreamEvent,
+            workspaceStreamId: WORKSPACE_STREAM_ID,
+            gradeStreamId: GRADE_STREAM_ID,
+            parseFiniteInteger,
+            randomId,
+        });
+        if (gradingReferenceResponse)
+            return gradingReferenceResponse;
         if (url.pathname === "/api/test") {
             if (req.method === "GET") {
+                const workspaceId = getWorkspaceIdFromQuery(url);
+                await logWorkspaceBotRoot("/api/test", workspaceId);
+                await activateWorkspaceDeck(workspaceId);
                 await deckLoadPromise.catch(() => null);
                 const requestedDeck = url.searchParams.get("deckPath");
                 const selection = requestedDeck
@@ -1793,7 +3503,7 @@ export function startWebSocketSimulator(opts) {
                     : availableTestDecks[0];
                 if (requestedDeck && !selection) {
                     return new Response(JSON.stringify({
-                        error: "Unknown test deck selection",
+                        error: "Unknown scenario deck selection",
                     }), {
                         status: 400,
                         headers: { "content-type": "application/json" },
@@ -1837,6 +3547,7 @@ export function startWebSocketSimulator(opts) {
             let inheritBotInput = false;
             let userProvidedDeckInput = false;
             let initFillRequestMissing = undefined;
+            let sessionId = undefined;
             try {
                 const body = await req.json();
                 if (typeof body.maxTurns === "number" && Number.isFinite(body.maxTurns)) {
@@ -1856,10 +3567,11 @@ export function startWebSocketSimulator(opts) {
                 if (body.initFill && Array.isArray(body.initFill.missing)) {
                     initFillRequestMissing = body.initFill.missing.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
                 }
+                sessionId = getWorkspaceIdFromBody(body);
                 if (typeof body.botDeckPath === "string") {
                     const resolved = resolveTestDeck(body.botDeckPath);
                     if (!resolved) {
-                        return new Response(JSON.stringify({ error: "Unknown test deck selection" }), {
+                        return new Response(JSON.stringify({ error: "Unknown scenario deck selection" }), {
                             status: 400,
                             headers: { "content-type": "application/json" },
                         });
@@ -1877,6 +3589,10 @@ export function startWebSocketSimulator(opts) {
             catch {
                 // ignore parse errors; use defaults
             }
+            if (sessionId) {
+                await logWorkspaceBotRoot("/api/test/run", sessionId);
+                await activateWorkspaceDeck(sessionId);
+            }
             if (deckInput === undefined) {
                 try {
                     const desc = await schemaPromise;
@@ -1892,7 +3608,7 @@ export function startWebSocketSimulator(opts) {
                 deckInput = cloneValue(botInput);
             }
             if (!botDeckSelection) {
-                return new Response(JSON.stringify({ error: "No test decks configured" }), { status: 400, headers: { "content-type": "application/json" } });
+                return new Response(JSON.stringify({ error: "No scenario decks configured" }), { status: 400, headers: { "content-type": "application/json" } });
             }
             let initFillInfo;
             let initFillTrace;
@@ -1934,12 +3650,14 @@ export function startWebSocketSimulator(opts) {
                             error: parsed.error,
                             initFill: initFillInfo,
                             botDeckPath: botDeckSelection.path,
+                            botDeckId: botDeckSelection.id,
+                            botDeckLabel: botDeckSelection.label,
                         });
                         return new Response(JSON.stringify({
                             error: parsed.error,
                             initFill: initFillInfo,
-                            sessionId: failure.sessionId,
-                            sessionPath: failure.sessionPath,
+                            workspaceId: failure.workspaceId,
+                            workspacePath: failure.workspacePath,
                         }), {
                             status: 400,
                             headers: { "content-type": "application/json" },
@@ -1996,12 +3714,14 @@ export function startWebSocketSimulator(opts) {
                             error: message,
                             initFill: initFillInfo,
                             botDeckPath: botDeckSelection.path,
+                            botDeckId: botDeckSelection.id,
+                            botDeckLabel: botDeckSelection.label,
                         });
                         return new Response(JSON.stringify({
                             error: message,
                             initFill: initFillInfo,
-                            sessionId: failure.sessionId,
-                            sessionPath: failure.sessionPath,
+                            workspaceId: failure.workspaceId,
+                            workspacePath: failure.workspacePath,
                         }), {
                             status: 400,
                             headers: { "content-type": "application/json" },
@@ -2037,126 +3757,896 @@ export function startWebSocketSimulator(opts) {
                     error: message,
                     initFill: initFillInfo,
                     botDeckPath: botDeckSelection.path,
+                    botDeckId: botDeckSelection.id,
+                    botDeckLabel: botDeckSelection.label,
                 });
                 return new Response(JSON.stringify({
                     error: message,
                     initFill: initFillInfo,
-                    sessionId: failure.sessionId,
-                    sessionPath: failure.sessionPath,
+                    workspaceId: failure.workspaceId,
+                    workspacePath: failure.workspacePath,
                 }), { status: 400, headers: { "content-type": "application/json" } });
             }
+            const existingSessionState = sessionId
+                ? readSessionState(sessionId)
+                : undefined;
+            const workspaceRecord = sessionId
+                ? resolveWorkspaceRecord(sessionId) ?? {
+                    id: sessionId,
+                    rootDir: path.dirname(resolvedDeckPath),
+                    rootDeckPath: resolvedDeckPath,
+                    createdAt: new Date().toISOString(),
+                }
+                : undefined;
+            if (workspaceRecord && !resolveWorkspaceRecord(sessionId)) {
+                registerWorkspace(workspaceRecord);
+            }
             const run = startTestBotRun({
                 maxTurnsOverride,
                 deckInput,
                 botInput,
                 initialUserMessage,
                 botDeckPath: botDeckSelection.path,
+                botDeckId: botDeckSelection.id,
+                botDeckLabel: botDeckSelection.label,
                 initFill: initFillInfo,
                 initFillTrace,
+                workspaceId: sessionId,
+                workspaceRecord,
+                baseMeta: existingSessionState?.meta ??
+                    undefined,
             });
             return new Response(JSON.stringify({ run }), { headers: { "content-type": "application/json" } });
         }
-        if (url.pathname === "/api/test/status") {
-            const runId = url.searchParams.get("runId") ?? undefined;
-            const sessionId = url.searchParams.get("sessionId") ?? undefined;
-            let entry = runId ? testBotRuns.get(runId) : undefined;
-            if (!entry && sessionId) {
-                for (const candidate of testBotRuns.values()) {
-                    if (candidate.run.sessionId === sessionId) {
-                        entry = candidate;
-                        break;
+        if (url.pathname === "/api/test/message") {
+            if (req.method !== "POST") {
+                return new Response("Method not allowed", { status: 405 });
+            }
+            // 1) Parse request payload and stitch together run/session state.
+            let payload = {};
+            try {
+                payload = await req.json();
+            }
+            catch {
+                // ignore parse errors
+            }
+            const requestedRunId = typeof payload.runId === "string"
+                ? payload.runId
+                : undefined;
+            let runId = requestedRunId;
+            const workspaceId = (() => {
+                const workspaceId = typeof payload.workspaceId === "string" &&
+                    payload.workspaceId.trim().length > 0
+                    ? payload.workspaceId
+                    : undefined;
+                if (workspaceId)
+                    return workspaceId;
+                return undefined;
+            })();
+            await logWorkspaceBotRoot("/api/test/message", workspaceId);
+            if (workspaceId) {
+                await activateWorkspaceDeck(workspaceId);
+            }
+            let savedState = workspaceId
+                ? readSessionState(workspaceId, { withTraces: true })
+                : undefined;
+            if (savedState && requestedRunId) {
+                const savedRunId = typeof savedState.meta?.testBotRunId === "string"
+                    ? savedState.meta.testBotRunId
+                    : savedState.runId;
+                if (!savedRunId || savedRunId !== requestedRunId) {
+                    // Explicit runId in the same workspace means "start a fresh run".
+                    savedState = undefined;
+                }
+            }
+            if (!savedState && runId) {
+                const entry = testBotRuns.get(runId);
+                const runWorkspaceId = entry?.run.workspaceId ?? entry?.run.sessionId;
+                if (runWorkspaceId &&
+                    (!workspaceId || runWorkspaceId === workspaceId)) {
+                    savedState = readSessionState(runWorkspaceId, {
+                        withTraces: true,
+                    });
+                }
+            }
+            if (savedState && !runId) {
+                runId = typeof savedState.meta?.testBotRunId === "string"
+                    ? savedState.meta.testBotRunId
+                    : savedState.runId;
+            }
+            runId = runId ?? randomId("testbot");
+            const workspaceRecord = workspaceId
+                ? resolveWorkspaceRecord(workspaceId) ?? {
+                    id: workspaceId,
+                    rootDir: path.dirname(resolvedDeckPath),
+                    rootDeckPath: resolvedDeckPath,
+                    createdAt: new Date().toISOString(),
+                }
+                : undefined;
+            if (workspaceRecord && !resolveWorkspaceRecord(workspaceId)) {
+                registerWorkspace(workspaceRecord);
+            }
+            const workspaceMeta = workspaceRecord
+                ? buildWorkspaceMeta(workspaceRecord, savedState?.meta ?? {})
+                : (savedState?.meta ?? {});
+            const existingEntry = testBotRuns.get(runId);
+            if (existingEntry?.promise) {
+                return new Response(JSON.stringify({ error: "Scenario run already in progress" }), { status: 409, headers: { "content-type": "application/json" } });
+            }
+            // 2) Resolve which scenario deck to use and derive initial input.
+            await deckLoadPromise.catch(() => null);
+            const requestedDeck = typeof payload.botDeckPath === "string"
+                ? payload.botDeckPath
+                : undefined;
+            const selection = (() => {
+                if (requestedDeck)
+                    return resolveTestDeck(requestedDeck);
+                const metaPath = typeof savedState?.meta?.testBotConfigPath === "string"
+                    ? savedState.meta.testBotConfigPath
+                    : undefined;
+                if (metaPath)
+                    return resolveTestDeck(metaPath);
+                return availableTestDecks[0];
+            })();
+            if (requestedDeck && !selection) {
+                return new Response(JSON.stringify({ error: "Unknown scenario deck selection" }), { status: 400, headers: { "content-type": "application/json" } });
+            }
+            const botConfigPath = selection?.path ?? resolvedDeckPath;
+            const testBotName = selection
+                ? path.basename(botConfigPath).replace(/\.deck\.(md|ts)$/i, "")
+                : toDeckLabel(resolvedDeckPath);
+            const selectedScenarioDeckId = selection?.id ?? testBotName;
+            const selectedScenarioDeckLabel = selection?.label ?? testBotName;
+            const message = typeof payload.message === "string"
+                ? payload.message.trim()
+                : "";
+            const hasSavedMessages = (savedState?.messages?.length ?? 0) > 0;
+            let deckInput = payload.context ?? payload.init;
+            if (!hasSavedMessages && deckInput === undefined) {
+                try {
+                    const desc = await schemaPromise;
+                    deckInput = desc.defaults !== undefined
+                        ? desc.defaults
+                        : deriveInitialFromSchema(desc.schema);
+                }
+                catch {
+                    // ignore; keep undefined
+                }
+            }
+            const stream = typeof payload.stream === "boolean"
+                ? payload.stream
+                : true;
+            const deckForStart = await deckLoadPromise.catch(() => null);
+            const startMode = deckForStart &&
+                (deckForStart.startMode === "assistant" ||
+                    deckForStart.startMode === "user")
+                ? deckForStart.startMode
+                : "assistant";
+            const startOnly = !message && startMode === "assistant" &&
+                !hasSavedMessages;
+            if (!message && !startOnly) {
+                return new Response(JSON.stringify({ error: "Missing message" }), { status: 400, headers: { "content-type": "application/json" } });
+            }
+            // 3) Initialize the run, sync from prior session state, and prep tracing.
+            const entry = existingEntry ?? {
+                run: {
+                    id: runId,
+                    status: "idle",
+                    messages: [],
+                    traces: [],
+                    toolInserts: [],
+                },
+                promise: null,
+                abort: null,
+            };
+            testBotRuns.set(runId, entry);
+            const run = entry.run;
+            const emitTestBot = (payload) => broadcastTestBot(payload, run.workspaceId ?? workspaceId ?? runId);
+            run.status = "running";
+            run.error = undefined;
+            run.startedAt = run.startedAt ?? new Date().toISOString();
+            if (savedState) {
+                syncTestBotRunFromState(run, savedState);
+            }
+            emitTestBot({ type: "testBotStatus", run });
+            const controller = new AbortController();
+            entry.abort = controller;
+            const isAborted = () => controller.signal.aborted;
+            const capturedTraces = Array.isArray(savedState?.traces)
+                ? cloneTraces(savedState.traces)
+                : [];
+            const pendingTraceEvents = [];
+            const flushPendingTraceEvents = (state) => {
+                if (!pendingTraceEvents.length)
+                    return;
+                for (const pending of pendingTraceEvents) {
+                    appendSessionEvent(state, {
+                        ...pending,
+                        kind: "trace",
+                        category: traceCategory(pending.type),
+                    });
+                }
+                pendingTraceEvents.length = 0;
+            };
+            const tracer = (event) => {
+                const stamped = event.ts ? event : { ...event, ts: Date.now() };
+                capturedTraces.push(stamped);
+                consoleTracer?.(stamped);
+                if (savedState?.meta?.sessionId) {
+                    appendSessionEvent(savedState, {
+                        ...stamped,
+                        kind: "trace",
+                        category: traceCategory(stamped.type),
+                    });
+                }
+                else {
+                    pendingTraceEvents.push(stamped);
+                }
+            };
+            const appendFromState = (state) => {
+                const snapshot = buildTestBotSnapshot(state);
+                run.messages = snapshot.messages;
+                run.toolInserts = snapshot.toolInserts;
+                run.traces = Array.isArray(state.traces)
+                    ? [...state.traces]
+                    : undefined;
+                const nextWorkspaceId = typeof state.meta?.workspaceId === "string"
+                    ? state.meta.workspaceId
+                    : typeof state.meta?.sessionId === "string"
+                        ? state.meta.sessionId
+                        : undefined;
+                if (nextWorkspaceId) {
+                    run.workspaceId = nextWorkspaceId;
+                    run.sessionId = nextWorkspaceId;
+                }
+                emitTestBot({ type: "testBotStatus", run });
+            };
+            // 4) Execute the deck run(s): optional assistant start, then user message.
+            entry.promise = (async () => {
+                try {
+                    const countAssistantMessages = (state) => {
+                        if (!state?.messages?.length)
+                            return 0;
+                        let count = 0;
+                        for (const msg of state.messages) {
+                            if (msg?.role === "assistant")
+                                count += 1;
+                        }
+                        return count;
+                    };
+                    const runOnce = async (initialUserMessage, turn, shouldStream = stream) => {
+                        if (isAborted())
+                            return undefined;
+                        const hasSavedMessages = (savedState?.messages?.length ?? 0) > 0;
+                        const inputProvided = !hasSavedMessages &&
+                            deckInput !== undefined;
+                        const input = inputProvided ? deckInput : undefined;
+                        const result = await runDeck({
+                            path: resolvedDeckPath,
+                            input,
+                            inputProvided,
+                            modelProvider: opts.modelProvider,
+                            isRoot: true,
+                            allowRootStringInput: true,
+                            defaultModel: typeof payload.model === "string"
+                                ? payload.model
+                                : opts.model,
+                            modelOverride: typeof payload.modelForce === "string"
+                                ? payload.modelForce
+                                : opts.modelForce,
+                            trace: tracer,
+                            stream: shouldStream,
+                            state: savedState,
+                            responsesMode: opts.responsesMode,
+                            signal: controller.signal,
+                            initialUserMessage,
+                            onStateUpdate: (state) => {
+                                if (isAborted())
+                                    return;
+                                const nextStateWithSource = applyUserMessageRefSource(savedState, state, "manual");
+                                const nextMeta = {
+                                    ...workspaceMeta,
+                                    ...(nextStateWithSource.meta ?? {}),
+                                    testBot: true,
+                                    testBotRunId: runId,
+                                    testBotConfigPath: botConfigPath,
+                                    testBotName,
+                                    scenarioRunId: runId,
+                                    selectedScenarioDeckId,
+                                    selectedScenarioDeckLabel,
+                                    scenarioConfigPath: botConfigPath,
+                                    ...(workspaceId ? { workspaceId } : {}),
+                                };
+                                const enriched = persistSessionState({
+                                    ...nextStateWithSource,
+                                    meta: nextMeta,
+                                    traces: capturedTraces,
+                                });
+                                savedState = enriched;
+                                flushPendingTraceEvents(enriched);
+                                appendFromState(enriched);
+                            },
+                            onStreamText: (chunk) => emitTestBot({
+                                type: "testBotStream",
+                                runId,
+                                role: "assistant",
+                                chunk,
+                                turn,
+                                ts: Date.now(),
+                            }),
+                        });
+                        if (isAborted())
+                            return result;
+                        if (shouldStream) {
+                            emitTestBot({
+                                type: "testBotStreamEnd",
+                                runId,
+                                role: "assistant",
+                                turn,
+                                ts: Date.now(),
+                            });
+                        }
+                        return result;
+                    };
+                    let assistantTurn = countAssistantMessages(savedState);
+                    if (startMode === "assistant" &&
+                        !hasSavedMessages) {
+                        if (isAborted()) {
+                            run.status = "canceled";
+                            return;
+                        }
+                        await runOnce(undefined, assistantTurn, stream);
+                        assistantTurn += 1;
+                    }
+                    let result = undefined;
+                    if (message) {
+                        if (isAborted()) {
+                            run.status = "canceled";
+                            return;
+                        }
+                        result = await runOnce(message, assistantTurn, stream);
                     }
+                    if (isAborted()) {
+                        run.status = "canceled";
+                    }
+                    else if (result !== undefined && isGambitEndSignal(result)) {
+                        run.status = "completed";
+                    }
+                    else {
+                        run.status = "completed";
+                    }
+                }
+                catch (err) {
+                    if (isAborted() || isRunCanceledError(err)) {
+                        run.status = "canceled";
+                        run.error = undefined;
+                    }
+                    else {
+                        run.status = "error";
+                        run.error = err instanceof Error ? err.message : String(err);
+                        logger.warn(`[sim] build bot run failed (workspaceId=${workspaceId}): ${run.error}`);
+                    }
+                }
+                finally {
+                    if (savedState) {
+                        syncTestBotRunFromState(run, savedState);
+                    }
+                    run.finishedAt = new Date().toISOString();
+                    entry.abort = null;
+                    entry.promise = null;
+                    emitTestBot({ type: "testBotStatus", run });
+                }
+            })();
+            // 5) Return the current run snapshot to the caller.
+            return new Response(JSON.stringify({ run }), { headers: { "content-type": "application/json" } });
+        }
+        if (url.pathname === "/api/test/stop") {
+            if (req.method !== "POST") {
+                return new Response("Method not allowed", { status: 405 });
+            }
+            let runId = undefined;
+            try {
+                const body = await req.json();
+                if (typeof body.runId === "string")
+                    runId = body.runId;
+            }
+            catch {
+                // ignore
+            }
+            const entry = runId ? testBotRuns.get(runId) : undefined;
+            const wasRunning = Boolean(entry?.promise);
+            if (entry?.abort) {
+                entry.abort.abort();
+            }
+            if (entry?.run?.status === "running") {
+                entry.run.status = "canceled";
+                entry.run.finishedAt = entry.run.finishedAt ??
+                    new Date().toISOString();
+            }
+            return new Response(JSON.stringify({
+                stopped: wasRunning,
+                run: entry?.run ?? {
+                    id: runId ?? "",
+                    status: "idle",
+                    messages: [],
+                    traces: [],
+                    toolInserts: [],
+                },
+            }), { headers: { "content-type": "application/json" } });
+        }
+        if (url.pathname === "/api/build/reset") {
+            if (req.method !== "POST") {
+                return new Response("Method not allowed", { status: 405 });
+            }
+            let workspaceId = undefined;
+            try {
+                const body = await req.json();
+                workspaceId = getWorkspaceIdFromBody(body);
+            }
+            catch {
+                // ignore
+            }
+            if (!workspaceId) {
+                return new Response(JSON.stringify({ error: "Missing workspaceId" }), { status: 400, headers: { "content-type": "application/json" } });
+            }
+            const entry = buildBotRuns.get(workspaceId);
+            if (entry?.abort) {
+                entry.abort.abort();
+            }
+            if (entry?.run) {
+                if (entry.run.status === "running") {
+                    entry.run.status = "canceled";
+                }
+                entry.run.finishedAt = entry.run.finishedAt ??
+                    new Date().toISOString();
+                const state = readSessionState(workspaceId);
+                if (state) {
+                    persistSessionState({
+                        ...state,
+                        meta: {
+                            ...(state.meta ?? {}),
+                            buildStatus: entry.run.status,
+                            buildFinishedAt: entry.run.finishedAt,
+                            buildError: entry.run.error,
+                        },
+                    });
+                }
+            }
+            buildBotRuns.delete(workspaceId);
+            broadcastBuildBot({
+                type: "buildBotStatus",
+                run: {
+                    id: workspaceId,
+                    status: "idle",
+                    messages: [],
+                    traces: [],
+                    toolInserts: [],
+                },
+            }, workspaceId);
+            return new Response(JSON.stringify({ reset: true }), {
+                headers: { "content-type": "application/json" },
+            });
+        }
+        if (url.pathname === "/api/build/stop") {
+            if (req.method !== "POST") {
+                return new Response("Method not allowed", { status: 405 });
+            }
+            let workspaceId = undefined;
+            try {
+                const body = await req.json();
+                workspaceId = getWorkspaceIdFromBody(body);
+            }
+            catch {
+                // ignore
+            }
+            if (!workspaceId) {
+                return new Response(JSON.stringify({ error: "Missing workspaceId" }), { status: 400, headers: { "content-type": "application/json" } });
+            }
+            const entry = buildBotRuns.get(workspaceId);
+            const wasRunning = Boolean(entry?.promise);
+            if (entry?.abort) {
+                entry.abort.abort();
+            }
+            if (entry?.run?.status === "running") {
+                entry.run.status = "canceled";
+                entry.run.finishedAt = entry.run.finishedAt ??
+                    new Date().toISOString();
+            }
+            if (entry?.run) {
+                const state = readSessionState(workspaceId);
+                if (state) {
+                    persistSessionState({
+                        ...state,
+                        meta: {
+                            ...(state.meta ?? {}),
+                            buildStatus: entry.run.status,
+                            buildFinishedAt: entry.run.finishedAt,
+                            buildError: entry.run.error,
+                        },
+                    });
                 }
             }
             const run = entry?.run ?? {
-                id: runId ?? "",
+                id: workspaceId,
                 status: "idle",
                 messages: [],
                 traces: [],
                 toolInserts: [],
-                sessionId,
             };
-            if (!entry && sessionId) {
-                const state = readSessionState(sessionId);
+            broadcastBuildBot({ type: "buildBotStatus", run, state: entry?.state ?? undefined }, workspaceId);
+            return new Response(JSON.stringify({
+                stopped: wasRunning,
+                run,
+            }), { headers: { "content-type": "application/json" } });
+        }
+        if (url.pathname === "/api/build/message") {
+            if (req.method !== "POST") {
+                return new Response("Method not allowed", { status: 405 });
+            }
+            let payload = {};
+            try {
+                payload = await req.json();
+            }
+            catch {
+                // ignore
+            }
+            let workspaceId = typeof payload.workspaceId === "string"
+                ? payload.workspaceId
+                : typeof payload.runId === "string"
+                    ? payload.runId
+                    : undefined;
+            if (!workspaceId) {
+                const created = await createWorkspaceSession();
+                workspaceId = created.id;
+            }
+            await logWorkspaceBotRoot("/api/build/message", workspaceId);
+            const message = typeof payload.message === "string"
+                ? payload.message
+                : "";
+            const workspaceRecord = resolveWorkspaceRecord(workspaceId) ?? {
+                id: workspaceId,
+                rootDir: path.dirname(resolvedDeckPath),
+                rootDeckPath: resolvedDeckPath,
+                createdAt: new Date().toISOString(),
+            };
+            if (!resolveWorkspaceRecord(workspaceId)) {
+                registerWorkspace(workspaceRecord);
+            }
+            const existingEntry = buildBotRuns.get(workspaceId);
+            if (existingEntry?.promise) {
+                return new Response(JSON.stringify({ error: "Run already in progress" }), { status: 409, headers: { "content-type": "application/json" } });
+            }
+            const entry = existingEntry ?? {
+                run: {
+                    id: workspaceId,
+                    status: "idle",
+                    messages: [],
+                    traces: [],
+                    toolInserts: [],
+                },
+                state: null,
+                promise: null,
+                abort: null,
+            };
+            buildBotRuns.set(workspaceId, entry);
+            if (!entry.state) {
+                const projection = readBuildState(workspaceId);
+                if (projection?.state) {
+                    entry.state = projection.state;
+                }
+            }
+            const run = entry.run;
+            run.status = "running";
+            run.error = undefined;
+            run.startedAt = run.startedAt ?? new Date().toISOString();
+            if (entry.state) {
+                syncBuildBotRunFromState(run, entry.state);
+            }
+            broadcastBuildBot({
+                type: "buildBotStatus",
+                run,
+                state: entry.state ?? undefined,
+            }, workspaceId);
+            const workspaceBaseState = readSessionState(workspaceId) ?? {
+                runId: workspaceId,
+                messages: [],
+                meta: {},
+            };
+            persistSessionState({
+                ...workspaceBaseState,
+                meta: {
+                    ...buildWorkspaceMeta(workspaceRecord, workspaceBaseState.meta ?? {}),
+                    buildStatus: run.status,
+                    buildStartedAt: run.startedAt,
+                },
+            });
+            const controller = new AbortController();
+            entry.abort = controller;
+            const isAborted = () => controller.signal.aborted;
+            const botDeckUrl = new URL("./decks/gambit-bot/PROMPT.md", globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url);
+            if (botDeckUrl.protocol !== "file:") {
+                run.status = "error";
+                run.error = "Unable to resolve Gambit Bot deck path";
+                broadcastBuildBot({ type: "buildBotStatus", run }, workspaceId);
+                const state = readSessionState(workspaceId);
                 if (state) {
-                    run.id = typeof state.runId === "string" ? state.runId : run.id;
-                    run.status = "completed";
-                    syncTestBotRunFromState(run, state);
+                    persistSessionState({
+                        ...state,
+                        meta: {
+                            ...(state.meta ?? {}),
+                            buildStatus: "error",
+                            buildError: run.error,
+                            buildFinishedAt: new Date().toISOString(),
+                        },
+                    });
+                }
+                return new Response(JSON.stringify({ error: run.error }), { status: 500, headers: { "content-type": "application/json" } });
+            }
+            const botDeckPath = path.fromFileUrl(botDeckUrl);
+            let botRoot;
+            try {
+                botRoot = await resolveBuildBotRoot(workspaceId);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                run.status = "error";
+                run.error = msg;
+                broadcastBuildBot({ type: "buildBotStatus", run }, workspaceId);
+                const state = readSessionState(workspaceId);
+                if (state) {
+                    persistSessionState({
+                        ...state,
+                        meta: {
+                            ...(state.meta ?? {}),
+                            buildStatus: "error",
+                            buildError: msg,
+                            buildFinishedAt: new Date().toISOString(),
+                        },
+                    });
                 }
+                return new Response(JSON.stringify({ error: msg }), { status: 400, headers: { "content-type": "application/json" } });
+            }
+            const prevBotRoot = dntShim.Deno.env.get("GAMBIT_BOT_ROOT");
+            dntShim.Deno.env.set("GAMBIT_BOT_ROOT", botRoot);
+            const capturedTraces = Array.isArray(entry.state?.traces)
+                ? cloneTraces(entry.state.traces)
+                : [];
+            const tracer = (event) => {
+                const stamped = event.ts ? event : { ...event, ts: Date.now() };
+                capturedTraces.push(stamped);
+                consoleTracer?.(stamped);
+                broadcastBuildBot({
+                    type: "buildBotTrace",
+                    runId: workspaceId,
+                    event: stamped,
+                }, workspaceId);
+            };
+            const appendFromState = (state) => {
+                syncBuildBotRunFromState(run, state);
+                run.traces = Array.isArray(state.traces) ? [...state.traces] : [];
+                broadcastBuildBot({ type: "buildBotStatus", run, state }, workspaceId);
+                const base = readSessionState(workspaceId) ?? {
+                    runId: workspaceId,
+                    messages: [],
+                    meta: {},
+                };
+                persistSessionState({
+                    ...base,
+                    meta: {
+                        ...buildWorkspaceMeta(workspaceRecord, base.meta ?? {}),
+                        buildStatus: run.status,
+                        buildStartedAt: run.startedAt,
+                        buildFinishedAt: run.finishedAt,
+                        buildError: run.error,
+                    },
+                });
+            };
+            entry.promise = (async () => {
+                try {
+                    const runOnce = async (initialUserMessage, turn, shouldStream = true) => {
+                        if (isAborted())
+                            return undefined;
+                        const result = await runDeck({
+                            path: botDeckPath,
+                            input: undefined,
+                            inputProvided: false,
+                            modelProvider: opts.modelProvider,
+                            allowRootStringInput: true,
+                            defaultModel: typeof payload.model === "string"
+                                ? payload.model
+                                : opts.model,
+                            modelOverride: typeof payload.modelForce === "string"
+                                ? payload.modelForce
+                                : opts.modelForce,
+                            trace: tracer,
+                            stream: shouldStream,
+                            state: entry.state ?? undefined,
+                            responsesMode: opts.responsesMode,
+                            signal: controller.signal,
+                            initialUserMessage,
+                            onStateUpdate: (state) => {
+                                if (isAborted())
+                                    return;
+                                const nextState = {
+                                    ...state,
+                                    traces: capturedTraces,
+                                };
+                                entry.state = nextState;
+                                appendFromState(nextState);
+                            },
+                            onStreamText: (chunk) => broadcastBuildBot({
+                                type: "buildBotStream",
+                                runId: workspaceId,
+                                role: "assistant",
+                                chunk,
+                                turn,
+                                ts: Date.now(),
+                            }, workspaceId),
+                        });
+                        if (shouldStream) {
+                            broadcastBuildBot({
+                                type: "buildBotStreamEnd",
+                                runId: workspaceId,
+                                role: "assistant",
+                                turn,
+                                ts: Date.now(),
+                            }, workspaceId);
+                        }
+                        return result;
+                    };
+                    const hasSavedMessages = (entry.state?.messages?.length ?? 0) > 0;
+                    let assistantTurn = 0;
+                    if (Array.isArray(entry.state?.messages)) {
+                        for (const msg of entry.state.messages) {
+                            if (msg?.role === "assistant")
+                                assistantTurn += 1;
+                        }
+                    }
+                    if (!hasSavedMessages && message.trim().length === 0) {
+                        await runOnce(undefined, assistantTurn, true);
+                    }
+                    else {
+                        await runOnce(message, assistantTurn, true);
+                    }
+                    if (isAborted()) {
+                        run.status = "canceled";
+                    }
+                    else {
+                        run.status = "completed";
+                    }
+                }
+                catch (err) {
+                    if (isAborted() || isRunCanceledError(err)) {
+                        run.status = "canceled";
+                        run.error = undefined;
+                    }
+                    else {
+                        run.status = "error";
+                        run.error = err instanceof Error ? err.message : String(err);
+                        logger.warn(`[sim] build bot run failed (workspaceId=${workspaceId}): ${run.error}`);
+                    }
+                }
+                finally {
+                    run.finishedAt = new Date().toISOString();
+                    entry.abort = null;
+                    entry.promise = null;
+                    const base = readSessionState(workspaceId) ?? {
+                        runId: workspaceId,
+                        messages: [],
+                        meta: {},
+                    };
+                    persistSessionState({
+                        ...base,
+                        meta: {
+                            ...buildWorkspaceMeta(workspaceRecord, base.meta ?? {}),
+                            buildStatus: run.status,
+                            buildStartedAt: run.startedAt,
+                            buildFinishedAt: run.finishedAt,
+                            buildError: run.error,
+                        },
+                    });
+                    try {
+                        reloadPrimaryDeck();
+                    }
+                    catch (err) {
+                        logger.warn(`[sim] failed to reload primary deck after build: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                    broadcastBuildBot({ type: "buildBotStatus", run, state: entry.state ?? undefined }, workspaceId);
+                    if (prevBotRoot === undefined) {
+                        try {
+                            dntShim.Deno.env.delete("GAMBIT_BOT_ROOT");
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }
+                    else {
+                        dntShim.Deno.env.set("GAMBIT_BOT_ROOT", prevBotRoot);
+                    }
+                }
+            })();
+            return new Response(JSON.stringify({ run }), {
+                headers: { "content-type": "application/json" },
+            });
+        }
+        if (url.pathname === "/api/build/files") {
+            if (req.method !== "GET") {
+                return new Response("Method not allowed", { status: 405 });
             }
-            if (run.sessionId) {
-                const state = readSessionState(run.sessionId);
-                if (state) {
-                    syncTestBotRunFromState(run, state);
-                }
+            try {
+                const workspaceId = getWorkspaceIdFromQuery(url);
+                await logWorkspaceBotRoot("/api/build/files", workspaceId);
+                const root = await resolveBuildBotRoot(workspaceId);
+                const entries = await listBuildBotFiles(root);
+                return new Response(JSON.stringify({ root, entries }), {
+                    headers: { "content-type": "application/json" },
+                });
             }
-            await deckLoadPromise.catch(() => null);
-            const requestedDeck = url.searchParams.get("deckPath");
-            const selection = requestedDeck
-                ? resolveTestDeck(requestedDeck)
-                : availableTestDecks[0];
-            if (requestedDeck && !selection) {
-                return new Response(JSON.stringify({
-                    error: "Unknown test deck selection",
-                }), {
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return new Response(JSON.stringify({ error: message }), {
                     status: 400,
                     headers: { "content-type": "application/json" },
                 });
             }
-            if (selection) {
-                const schemaDesc = await describeDeckInputSchemaFromPath(selection.path);
-                return new Response(JSON.stringify({
-                    run,
-                    botPath: selection.path,
-                    botLabel: selection.label,
-                    botDescription: selection.description,
-                    selectedDeckId: selection.id,
-                    inputSchema: schemaDesc.schema,
-                    inputSchemaError: schemaDesc.error,
-                    defaults: { input: schemaDesc.defaults },
-                    testDecks: availableTestDecks,
-                }), { headers: { "content-type": "application/json" } });
-            }
-            return new Response(JSON.stringify({
-                run,
-                botPath: null,
-                botLabel: null,
-                botDescription: null,
-                selectedDeckId: null,
-                inputSchema: null,
-                inputSchemaError: null,
-                defaults: {},
-                testDecks: availableTestDecks,
-            }), { headers: { "content-type": "application/json" } });
         }
-        if (url.pathname === "/api/test/stop") {
-            if (req.method !== "POST") {
+        if (url.pathname === "/api/build/file") {
+            if (req.method !== "GET") {
                 return new Response("Method not allowed", { status: 405 });
             }
-            let runId = undefined;
-            try {
-                const body = await req.json();
-                if (typeof body.runId === "string")
-                    runId = body.runId;
+            const workspaceId = getWorkspaceIdFromQuery(url);
+            await logWorkspaceBotRoot("/api/build/file", workspaceId);
+            const inputPath = url.searchParams.get("path") ?? "";
+            if (!inputPath) {
+                appendServerErrorLog(workspaceId, {
+                    endpoint: "/api/build/file",
+                    status: 400,
+                    message: "Missing path",
+                    method: req.method,
+                });
+                return new Response(JSON.stringify({ error: "Missing path" }), {
+                    status: 400,
+                    headers: { "content-type": "application/json" },
+                });
             }
-            catch {
-                // ignore
+            try {
+                const root = await resolveBuildBotRoot(workspaceId);
+                const resolved = await resolveBuildBotPath(root, inputPath);
+                if (!resolved.stat.isFile) {
+                    return new Response(JSON.stringify({ error: "Path is not a file" }), {
+                        status: 400,
+                        headers: { "content-type": "application/json" },
+                    });
+                }
+                if (resolved.stat.size > MAX_FILE_PREVIEW_BYTES) {
+                    return new Response(JSON.stringify({
+                        path: resolved.relativePath,
+                        tooLarge: true,
+                        size: resolved.stat.size,
+                    }), { headers: { "content-type": "application/json" } });
+                }
+                const bytes = await dntShim.Deno.readFile(resolved.fullPath);
+                const text = readPreviewText(bytes);
+                if (text === null) {
+                    return new Response(JSON.stringify({
+                        path: resolved.relativePath,
+                        binary: true,
+                        size: resolved.stat.size,
+                    }), { headers: { "content-type": "application/json" } });
+                }
+                return new Response(JSON.stringify({
+                    path: resolved.relativePath,
+                    contents: text,
+                    size: resolved.stat.size,
+                }), { headers: { "content-type": "application/json" } });
             }
-            const entry = runId ? testBotRuns.get(runId) : undefined;
-            const wasRunning = Boolean(entry?.promise);
-            if (entry?.abort) {
-                entry.abort.abort();
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return new Response(JSON.stringify({ error: message }), {
+                    status: 400,
+                    headers: { "content-type": "application/json" },
+                });
             }
-            return new Response(JSON.stringify({
-                stopped: wasRunning,
-                run: entry?.run ?? {
-                    id: runId ?? "",
-                    status: "idle",
-                    messages: [],
-                    traces: [],
-                    toolInserts: [],
-                },
-            }), { headers: { "content-type": "application/json" } });
         }
         if (url.pathname === "/api/simulator/run") {
             if (req.method !== "POST") {
@@ -2178,18 +4668,44 @@ export function startWebSocketSimulator(opts) {
                 simulatorCapturedTraces = [];
                 simulatorCurrentRunId = undefined;
             }
-            if (payload.sessionId) {
-                const loaded = readSessionState(payload.sessionId);
-                if (loaded) {
-                    simulatorSavedState = loaded;
-                    simulatorCapturedTraces = Array.isArray(loaded.traces)
-                        ? cloneTraces(loaded.traces)
-                        : [];
+            if (payload.workspaceId) {
+                let loaded;
+                try {
+                    loaded = readSessionStateStrict(payload.workspaceId, {
+                        withTraces: true,
+                    });
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    emitSimulator({ type: "error", message });
+                    return new Response(JSON.stringify({ error: message }), { status: 400, headers: { "content-type": "application/json" } });
                 }
+                if (!loaded) {
+                    const message = "Workspace not found";
+                    emitSimulator({ type: "error", message });
+                    return new Response(JSON.stringify({ error: message }), { status: 404, headers: { "content-type": "application/json" } });
+                }
+                simulatorSavedState = loaded;
+                simulatorCapturedTraces = Array.isArray(loaded.traces)
+                    ? cloneTraces(loaded.traces)
+                    : [];
             }
             simulatorCurrentRunId = undefined;
             const stream = payload.stream ?? true;
             const forwardTrace = payload.trace ?? true;
+            const pendingTraceEvents = [];
+            const flushPendingTraceEvents = (state) => {
+                if (!pendingTraceEvents.length)
+                    return;
+                for (const pending of pendingTraceEvents) {
+                    appendSessionEvent(state, {
+                        ...pending,
+                        kind: "trace",
+                        category: traceCategory(pending.type),
+                    });
+                }
+                pendingTraceEvents.length = 0;
+            };
             const tracer = (event) => {
                 const stamped = event.ts ? event : { ...event, ts: Date.now() };
                 if (stamped.type === "run.start") {
@@ -2199,6 +4715,16 @@ export function startWebSocketSimulator(opts) {
                 consoleTracer?.(stamped);
                 if (forwardTrace)
                     emitSimulator({ type: "trace", event: stamped });
+                if (simulatorSavedState?.meta?.sessionId) {
+                    appendSessionEvent(simulatorSavedState, {
+                        ...stamped,
+                        kind: "trace",
+                        category: traceCategory(stamped.type),
+                    });
+                }
+                else {
+                    pendingTraceEvents.push(stamped);
+                }
             };
             let initialUserMessage = typeof payload.message === "string"
                 ? payload.message
@@ -2245,6 +4771,7 @@ export function startWebSocketSimulator(opts) {
                             traces: simulatorCapturedTraces,
                         });
                         simulatorSavedState = enrichedState;
+                        flushPendingTraceEvents(enrichedState);
                         emitSimulator({ type: "state", state: enrichedState });
                     },
                     initialUserMessage,
@@ -2262,7 +4789,7 @@ export function startWebSocketSimulator(opts) {
                 });
                 return new Response(JSON.stringify({
                     runId: simulatorCurrentRunId,
-                    sessionId: simulatorSavedState?.meta?.sessionId,
+                    workspaceId: simulatorSavedState?.meta?.workspaceId,
                 }), { headers: { "content-type": "application/json" } });
             }
             catch (err) {
@@ -2284,56 +4811,112 @@ export function startWebSocketSimulator(opts) {
             }
             try {
                 const body = await req.json();
-                if (!body.sessionId) {
-                    throw new Error("Missing sessionId");
+                const workspaceId = getWorkspaceIdFromBody(body);
+                if (!workspaceId) {
+                    throw new Error("Missing workspaceId");
                 }
                 if (!body.messageRefId) {
                     throw new Error("Missing messageRefId");
                 }
-                if (typeof body.score !== "number" || Number.isNaN(body.score)) {
+                if (body.score !== null &&
+                    (typeof body.score !== "number" || Number.isNaN(body.score))) {
                     throw new Error("Invalid score");
                 }
-                const state = readSessionState(body.sessionId);
+                let state;
+                try {
+                    state = readSessionStateStrict(workspaceId, { withTraces: true });
+                }
+                catch (err) {
+                    throw new Error(err instanceof Error ? err.message : String(err));
+                }
                 if (!state)
-                    throw new Error("Session not found");
+                    throw new Error("Workspace not found");
+                const requestedRunId = typeof body.runId === "string" &&
+                    body.runId.trim().length > 0
+                    ? body.runId.trim()
+                    : undefined;
+                const feedbackEligible = isFeedbackEligibleMessageRef(state, body.messageRefId) ||
+                    (requestedRunId
+                        ? isFeedbackEligiblePersistedTestRunMessageRef(state, requestedRunId, body.messageRefId)
+                        : false);
+                if (!feedbackEligible) {
+                    throw new Error("Feedback target is not eligible");
+                }
                 simulatorSavedState = state;
                 simulatorCapturedTraces = Array.isArray(state.traces)
                     ? cloneTraces(state.traces)
                     : [];
-                const clamped = Math.max(-3, Math.min(3, Math.round(body.score)));
-                const reason = typeof body.reason === "string"
-                    ? body.reason
-                    : undefined;
-                const runId = typeof state.runId === "string" ? state.runId : "run";
                 const existing = state.feedback ?? [];
                 const idx = existing.findIndex((f) => f.messageRefId === body.messageRefId);
-                const now = new Date().toISOString();
-                const entry = idx >= 0
-                    ? {
-                        ...existing[idx],
-                        score: clamped,
-                        reason,
-                        runId: existing[idx].runId ?? runId,
+                let entry;
+                let feedback = existing;
+                let deleted = false;
+                if (body.score === null) {
+                    if (idx >= 0) {
+                        feedback = existing.filter((_, i) => i !== idx);
+                        deleted = true;
                     }
-                    : {
-                        id: randomId("fb"),
-                        runId,
-                        messageRefId: body.messageRefId,
-                        score: clamped,
-                        reason,
-                        createdAt: now,
-                    };
-                const feedback = idx >= 0
-                    ? existing.map((f, i) => i === idx ? entry : f)
-                    : [...existing, entry];
+                }
+                else {
+                    const clamped = Math.max(-3, Math.min(3, Math.round(body.score)));
+                    const reason = typeof body.reason === "string"
+                        ? body.reason
+                        : undefined;
+                    const runId = requestedRunId ??
+                        (typeof state.runId === "string" ? state.runId : "run");
+                    const scenarioRunId = typeof state.meta?.scenarioRunId === "string"
+                        ? state.meta.scenarioRunId
+                        : runId;
+                    const now = new Date().toISOString();
+                    entry = idx >= 0
+                        ? {
+                            ...existing[idx],
+                            score: clamped,
+                            reason,
+                            runId: existing[idx].runId ?? runId,
+                        }
+                        : {
+                            id: randomId("fb"),
+                            runId,
+                            messageRefId: body.messageRefId,
+                            score: clamped,
+                            reason,
+                            createdAt: now,
+                        };
+                    if (entry) {
+                        entry.workspaceId = workspaceId;
+                        entry.scenarioRunId = scenarioRunId;
+                    }
+                    feedback = idx >= 0
+                        ? existing.map((f, i) => i === idx ? entry : f)
+                        : [...existing, entry];
+                }
                 const enriched = persistSessionState({
                     ...state,
                     feedback,
                     traces: simulatorCapturedTraces,
                 });
+                appendFeedbackLog(enriched, {
+                    type: "feedback.update",
+                    messageRefId: body.messageRefId,
+                    feedback: entry,
+                    deleted,
+                });
+                appendSessionEvent(enriched, {
+                    type: "feedback.update",
+                    kind: "artifact",
+                    category: "feedback",
+                    workspaceId,
+                    scenarioRunId: typeof enriched.meta?.scenarioRunId === "string"
+                        ? enriched.meta.scenarioRunId
+                        : enriched.runId,
+                    messageRefId: body.messageRefId,
+                    feedback: entry,
+                    deleted,
+                });
                 simulatorSavedState = enriched;
                 emitSimulator({ type: "state", state: enriched });
-                return new Response(JSON.stringify({ feedback: entry }), { headers: { "content-type": "application/json" } });
+                return new Response(JSON.stringify({ feedback: entry, deleted }), { headers: { "content-type": "application/json" } });
             }
             catch (err) {
                 return new Response(JSON.stringify({
@@ -2347,12 +4930,19 @@ export function startWebSocketSimulator(opts) {
             }
             try {
                 const body = await req.json();
-                if (!body.sessionId) {
-                    throw new Error("Missing sessionId");
+                const workspaceId = getWorkspaceIdFromBody(body);
+                if (!workspaceId) {
+                    throw new Error("Missing workspaceId");
+                }
+                let state;
+                try {
+                    state = readSessionStateStrict(workspaceId, { withTraces: true });
+                }
+                catch (err) {
+                    throw new Error(err instanceof Error ? err.message : String(err));
                 }
-                const state = readSessionState(body.sessionId);
                 if (!state)
-                    throw new Error("Session not found");
+                    throw new Error("Workspace not found");
                 simulatorSavedState = state;
                 simulatorCapturedTraces = Array.isArray(state.traces)
                     ? cloneTraces(state.traces)
@@ -2363,6 +4953,13 @@ export function startWebSocketSimulator(opts) {
                     notes: { text: body.text ?? "", updatedAt: now },
                     traces: simulatorCapturedTraces,
                 });
+                appendSessionEvent(enriched, {
+                    type: "notes.update",
+                    kind: "artifact",
+                    category: "notes",
+                    workspaceId,
+                    notes: enriched.notes,
+                });
                 simulatorSavedState = enriched;
                 emitSimulator({ type: "state", state: enriched });
                 return new Response(JSON.stringify({ notes: enriched.notes, saved: true }), { headers: { "content-type": "application/json" } });
@@ -2379,15 +4976,22 @@ export function startWebSocketSimulator(opts) {
             }
             try {
                 const body = await req.json();
-                if (!body.sessionId) {
-                    throw new Error("Missing sessionId");
+                const workspaceId = getWorkspaceIdFromBody(body);
+                if (!workspaceId) {
+                    throw new Error("Missing workspaceId");
                 }
                 if (typeof body.score !== "number" || Number.isNaN(body.score)) {
                     throw new Error("Invalid score");
                 }
-                const state = readSessionState(body.sessionId);
+                let state;
+                try {
+                    state = readSessionStateStrict(workspaceId, { withTraces: true });
+                }
+                catch (err) {
+                    throw new Error(err instanceof Error ? err.message : String(err));
+                }
                 if (!state)
-                    throw new Error("Session not found");
+                    throw new Error("Workspace not found");
                 simulatorSavedState = state;
                 simulatorCapturedTraces = Array.isArray(state.traces)
                     ? cloneTraces(state.traces)
@@ -2399,6 +5003,13 @@ export function startWebSocketSimulator(opts) {
                     conversationScore: { score: clamped, updatedAt: now },
                     traces: simulatorCapturedTraces,
                 });
+                appendSessionEvent(enriched, {
+                    type: "conversation.score.update",
+                    kind: "artifact",
+                    category: "score",
+                    workspaceId,
+                    conversationScore: enriched.conversationScore,
+                });
                 simulatorSavedState = enriched;
                 emitSimulator({ type: "state", state: enriched });
                 return new Response(JSON.stringify({
@@ -2418,12 +5029,19 @@ export function startWebSocketSimulator(opts) {
             }
             try {
                 const body = await req.json();
-                if (!body.sessionId) {
-                    throw new Error("Missing sessionId");
+                const workspaceId = getWorkspaceIdFromBody(body);
+                if (!workspaceId) {
+                    throw new Error("Missing workspaceId");
+                }
+                let state;
+                try {
+                    state = readSessionStateStrict(workspaceId, { withTraces: true });
+                }
+                catch (err) {
+                    throw new Error(err instanceof Error ? err.message : String(err));
                 }
-                const state = readSessionState(body.sessionId);
                 if (!state) {
-                    throw new Error("Session not found");
+                    throw new Error("Workspace not found");
                 }
                 simulatorSavedState = state;
                 simulatorCapturedTraces = Array.isArray(state.traces)
@@ -2438,48 +5056,34 @@ export function startWebSocketSimulator(opts) {
                 }), { status: 400, headers: { "content-type": "application/json" } });
             }
         }
-        if (url.pathname === "/api/session") {
-            if (req.method !== "GET") {
-                return new Response("Method not allowed", { status: 405 });
-            }
-            const sessionId = url.searchParams.get("sessionId");
-            if (!sessionId) {
-                return new Response(JSON.stringify({ error: "Missing sessionId" }), { status: 400, headers: { "content-type": "application/json" } });
-            }
-            const state = readSessionState(sessionId);
-            if (!state) {
-                return new Response(JSON.stringify({ error: "Session not found" }), { status: 404, headers: { "content-type": "application/json" } });
-            }
-            return new Response(JSON.stringify({
-                sessionId,
-                messages: state.messages,
-                messageRefs: state.messageRefs,
-                feedback: state.feedback,
-                traces: state.traces,
-                notes: state.notes,
-                meta: state.meta,
-            }), { headers: { "content-type": "application/json" } });
-        }
         if (url.pathname === "/api/session/notes") {
             if (req.method !== "POST") {
                 return new Response("Method not allowed", { status: 405 });
             }
             try {
                 const body = await req.json();
-                if (!body.sessionId) {
-                    throw new Error("Missing sessionId");
+                const workspaceId = getWorkspaceIdFromBody(body);
+                if (!workspaceId) {
+                    throw new Error("Missing workspaceId");
                 }
-                const state = readSessionState(body.sessionId);
+                const state = readSessionState(workspaceId);
                 if (!state) {
-                    throw new Error("Session not found");
+                    throw new Error("Workspace not found");
                 }
                 const now = new Date().toISOString();
                 const nextState = persistSessionState({
                     ...state,
                     notes: { text: body.text ?? "", updatedAt: now },
                 });
+                appendSessionEvent(nextState, {
+                    type: "notes.update",
+                    kind: "artifact",
+                    category: "notes",
+                    workspaceId,
+                    notes: nextState.notes,
+                });
                 return new Response(JSON.stringify({
-                    sessionId: body.sessionId,
+                    workspaceId,
                     notes: nextState.notes,
                     saved: true,
                 }), { headers: { "content-type": "application/json" } });
@@ -2496,51 +5100,100 @@ export function startWebSocketSimulator(opts) {
             }
             try {
                 const body = await req.json();
-                if (!body.sessionId) {
-                    throw new Error("Missing sessionId");
+                const workspaceId = getWorkspaceIdFromBody(body);
+                if (!workspaceId) {
+                    throw new Error("Missing workspaceId");
                 }
                 if (!body.messageRefId) {
                     throw new Error("Missing messageRefId");
                 }
-                if (typeof body.score !== "number" || Number.isNaN(body.score)) {
+                if (body.score !== null &&
+                    (typeof body.score !== "number" || Number.isNaN(body.score))) {
                     throw new Error("Invalid score");
                 }
-                const state = readSessionState(body.sessionId);
+                const state = readSessionState(workspaceId);
                 if (!state) {
-                    throw new Error("Session not found");
+                    throw new Error("Workspace not found");
                 }
-                const clamped = Math.max(-3, Math.min(3, Math.round(body.score)));
-                const reason = typeof body.reason === "string"
-                    ? body.reason
+                const requestedRunId = typeof body.runId === "string" &&
+                    body.runId.trim().length > 0
+                    ? body.runId.trim()
                     : undefined;
-                const runId = typeof state.runId === "string"
-                    ? state.runId
-                    : "session";
+                const feedbackEligible = isFeedbackEligibleMessageRef(state, body.messageRefId) ||
+                    (requestedRunId
+                        ? isFeedbackEligiblePersistedTestRunMessageRef(state, requestedRunId, body.messageRefId)
+                        : false);
+                if (!feedbackEligible) {
+                    throw new Error("Feedback target is not eligible");
+                }
                 const existing = state.feedback ?? [];
                 const idx = existing.findIndex((entry) => entry.messageRefId === body.messageRefId);
-                const now = new Date().toISOString();
-                const entry = idx >= 0
-                    ? {
-                        ...existing[idx],
-                        score: clamped,
-                        reason,
-                        runId: existing[idx].runId ?? runId,
+                let entry;
+                let feedback = existing;
+                let deleted = false;
+                if (body.score === null) {
+                    if (idx >= 0) {
+                        feedback = existing.filter((_, i) => i !== idx);
+                        deleted = true;
                     }
-                    : {
-                        id: randomId("fb"),
-                        runId,
-                        messageRefId: body.messageRefId,
-                        score: clamped,
-                        reason,
-                        createdAt: now,
-                    };
-                const feedback = idx >= 0
-                    ? existing.map((item, i) => i === idx ? entry : item)
-                    : [...existing, entry];
+                }
+                else {
+                    const clamped = Math.max(-3, Math.min(3, Math.round(body.score)));
+                    const reason = typeof body.reason === "string"
+                        ? body.reason
+                        : undefined;
+                    const runId = requestedRunId ??
+                        (typeof state.runId === "string" ? state.runId : "session");
+                    const scenarioRunId = requestedRunId ??
+                        (typeof state.meta?.scenarioRunId === "string"
+                            ? state.meta.scenarioRunId
+                            : runId);
+                    const now = new Date().toISOString();
+                    entry = idx >= 0
+                        ? {
+                            ...existing[idx],
+                            score: clamped,
+                            reason,
+                            runId: existing[idx].runId ?? runId,
+                        }
+                        : {
+                            id: randomId("fb"),
+                            runId,
+                            messageRefId: body.messageRefId,
+                            score: clamped,
+                            reason,
+                            createdAt: now,
+                        };
+                    if (entry) {
+                        entry.workspaceId = workspaceId;
+                        entry.scenarioRunId = scenarioRunId;
+                    }
+                    feedback = idx >= 0
+                        ? existing.map((item, i) => i === idx ? entry : item)
+                        : [...existing, entry];
+                }
                 const nextState = persistSessionState({
                     ...state,
                     feedback,
                 });
+                appendFeedbackLog(nextState, {
+                    type: "feedback.update",
+                    messageRefId: body.messageRefId,
+                    feedback: entry,
+                    deleted,
+                });
+                appendSessionEvent(nextState, {
+                    type: "feedback.update",
+                    kind: "artifact",
+                    category: "feedback",
+                    workspaceId,
+                    scenarioRunId: typeof nextState.meta?.scenarioRunId === "string"
+                        ? nextState.meta.scenarioRunId
+                        : nextState.runId,
+                    messageRefId: body.messageRefId,
+                    feedback: entry,
+                    deleted,
+                });
                 const testBotRunId = typeof nextState.meta?.testBotRunId === "string"
                     ? nextState.meta.testBotRunId
                     : undefined;
@@ -2548,13 +5201,14 @@ export function startWebSocketSimulator(opts) {
                     const testEntry = testBotRuns.get(testBotRunId);
                     if (testEntry) {
                         syncTestBotRunFromState(testEntry.run, nextState);
-                        broadcastTestBot({ type: "testBotStatus", run: testEntry.run });
+                        broadcastTestBot({ type: "testBotStatus", run: testEntry.run }, workspaceId);
                     }
                 }
                 return new Response(JSON.stringify({
-                    sessionId: body.sessionId,
+                    workspaceId,
                     feedback: entry,
-                    saved: true,
+                    saved: !deleted,
+                    deleted,
                 }), { headers: { "content-type": "application/json" } });
             }
             catch (err) {
@@ -2569,118 +5223,17 @@ export function startWebSocketSimulator(opts) {
             }
             try {
                 const body = await req.json();
-                if (!body.sessionId) {
-                    throw new Error("Missing sessionId");
+                const workspaceId = getWorkspaceIdFromBody(body);
+                if (!workspaceId) {
+                    throw new Error("Missing workspaceId");
                 }
-                const removed = deleteSessionState(body.sessionId);
+                const removed = deleteSessionState(workspaceId);
                 if (!removed) {
-                    return new Response(JSON.stringify({ error: "Session not found" }), { status: 404, headers: { "content-type": "application/json" } });
-                }
-                return new Response(JSON.stringify({ sessionId: body.sessionId, deleted: true }), { headers: { "content-type": "application/json" } });
-            }
-            catch (err) {
-                return new Response(JSON.stringify({
-                    error: err instanceof Error ? err.message : String(err),
-                }), { status: 400, headers: { "content-type": "application/json" } });
-            }
-        }
-        if (url.pathname === "/api/feedback") {
-            if (req.method !== "GET") {
-                return new Response("Method not allowed", { status: 405 });
-            }
-            const deckPathParam = url.searchParams.get("deckPath");
-            if (!deckPathParam) {
-                return new Response(JSON.stringify({ error: "Missing deckPath" }), { status: 400, headers: { "content-type": "application/json" } });
-            }
-            const items = [];
-            try {
-                for await (const entry of dntShim.Deno.readDir(sessionsRoot)) {
-                    if (!entry.isDirectory)
-                        continue;
-                    const sessionId = entry.name;
-                    const state = readSessionState(sessionId);
-                    if (!state)
-                        continue;
-                    if (state.meta?.deck !== deckPathParam)
-                        continue;
-                    const feedbackList = Array.isArray(state.feedback)
-                        ? state.feedback
-                        : [];
-                    feedbackList.forEach((fb) => {
-                        if (!fb || typeof fb !== "object")
-                            return;
-                        const messageRefId = fb
-                            .messageRefId;
-                        if (typeof messageRefId !== "string")
-                            return;
-                        let messageContent = undefined;
-                        if (Array.isArray(state.messageRefs) &&
-                            Array.isArray(state.messages)) {
-                            const idx = state.messageRefs.findIndex((ref) => ref?.id === messageRefId);
-                            if (idx >= 0) {
-                                messageContent = state.messages[idx]?.content;
-                            }
-                        }
-                        items.push({
-                            sessionId,
-                            deck: state.meta?.deck,
-                            sessionCreatedAt: state.meta?.sessionCreatedAt,
-                            messageRefId,
-                            score: fb.score,
-                            reason: fb.reason,
-                            createdAt: fb.createdAt,
-                            archivedAt: fb.archivedAt,
-                            messageContent,
-                        });
-                    });
-                }
-            }
-            catch (err) {
-                return new Response(JSON.stringify({
-                    error: err instanceof Error ? err.message : String(err),
-                }), { status: 400, headers: { "content-type": "application/json" } });
-            }
-            items.sort((a, b) => {
-                const aTime = String(a.createdAt ?? "") || "";
-                const bTime = String(b.createdAt ?? "") || "";
-                return bTime.localeCompare(aTime);
-            });
-            return new Response(JSON.stringify({ deckPath: deckPathParam, items }), {
-                headers: { "content-type": "application/json" },
-            });
-        }
-        if (url.pathname === "/api/feedback/archive" && req.method === "POST") {
-            try {
-                const body = await req.json();
-                if (!body.sessionId || !body.messageRefId) {
-                    throw new Error("Missing sessionId or messageRefId");
-                }
-                const state = readSessionState(body.sessionId);
-                if (!state || !Array.isArray(state.feedback)) {
-                    throw new Error("Session not found");
-                }
-                const idx = state.feedback.findIndex((fb) => fb.messageRefId === body.messageRefId);
-                if (idx === -1)
-                    throw new Error("Feedback not found");
-                const next = { ...state.feedback[idx] };
-                if (body.archived === false) {
-                    delete next.archivedAt;
-                }
-                else {
-                    next.archivedAt = new Date()
-                        .toISOString();
+                    return new Response(JSON.stringify({ error: "Workspace not found" }), { status: 404, headers: { "content-type": "application/json" } });
                 }
-                const nextFeedback = state.feedback.map((fb, i) => i === idx ? next : fb);
-                const updated = persistSessionState({
-                    ...state,
-                    feedback: nextFeedback,
-                });
                 return new Response(JSON.stringify({
-                    sessionId: body.sessionId,
-                    messageRefId: body.messageRefId,
-                    archivedAt: next.archivedAt,
-                    saved: true,
-                    feedbackCount: updated.feedback?.length ?? 0,
+                    workspaceId,
+                    deleted: true,
                 }), { headers: { "content-type": "application/json" } });
             }
             catch (err) {
@@ -2689,102 +5242,42 @@ export function startWebSocketSimulator(opts) {
                 }), { status: 400, headers: { "content-type": "application/json" } });
             }
         }
-        if (url.pathname === "/" || url.pathname.startsWith("/sessions/") ||
-            url.pathname.startsWith("/simulate") ||
-            url.pathname.startsWith("/debug") ||
-            url.pathname.startsWith("/editor") ||
-            url.pathname.startsWith("/docs") ||
-            url.pathname.startsWith("/test") ||
-            url.pathname.startsWith("/grade")) {
-            const hasBundle = await canServeReactBundle();
-            if (!hasBundle) {
-                return new Response("Simulator UI bundle missing. Run `deno task bundle:sim` (or start with `--bundle`).", { status: 500 });
-            }
-            await deckLoadPromise.catch(() => null);
-            const resolvedLabel = deckLabel ?? toDeckLabel(resolvedDeckPath);
-            return new Response(simulatorReactHtml(resolvedDeckPath, resolvedLabel), {
-                headers: { "content-type": "text/html; charset=utf-8" },
-            });
-        }
-        if (url.pathname === "/schema") {
-            const desc = await schemaPromise;
-            const deck = await deckLoadPromise.catch(() => null);
-            const startMode = deck &&
-                (deck.startMode === "assistant" || deck.startMode === "user")
-                ? deck.startMode
-                : undefined;
-            return new Response(JSON.stringify({
-                deck: resolvedDeckPath,
-                startMode,
-                ...desc,
-            }), {
-                headers: { "content-type": "application/json; charset=utf-8" },
-            });
-        }
-        if (url.pathname === "/api/deck-source") {
-            if (req.method !== "GET") {
-                return new Response("Method not allowed", { status: 405 });
-            }
-            try {
-                const content = await dntShim.Deno.readTextFile(resolvedDeckPath);
-                return new Response(JSON.stringify({
-                    path: resolvedDeckPath,
-                    content,
-                }), { headers: { "content-type": "application/json; charset=utf-8" } });
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                return new Response(JSON.stringify({
-                    path: resolvedDeckPath,
-                    error: message,
-                }), {
-                    status: 500,
-                    headers: { "content-type": "application/json; charset=utf-8" },
-                });
-            }
-        }
-        if (url.pathname === "/ui/bundle.js") {
-            const data = await readReactBundle();
-            if (!data) {
-                return new Response("Bundle missing. Run `deno task bundle:sim` (or start with `--bundle`).", { status: 404 });
-            }
-            try {
-                const headers = new Headers({
-                    "content-type": "application/javascript; charset=utf-8",
-                });
-                // Hint the browser about the external source map since Deno's bundle
-                // output does not embed a sourceMappingURL comment.
-                if (shouldAdvertiseSourceMap()) {
-                    headers.set("SourceMap", "/ui/bundle.js.map");
-                }
-                return new Response(data, { headers });
-            }
-            catch (err) {
-                return new Response(`Failed to read bundle: ${err instanceof Error ? err.message : String(err)}`, { status: 500 });
-            }
-        }
-        if (url.pathname === "/ui/bundle.js.map") {
-            const data = await readReactBundleSourceMap();
-            if (!data) {
-                return new Response("Source map missing. Run `deno task bundle:sim:sourcemap` (or start with `--bundle --sourcemap`).", { status: 404 });
-            }
-            try {
-                return new Response(data, {
-                    headers: {
-                        "content-type": "application/json; charset=utf-8",
-                    },
-                });
-            }
-            catch (err) {
-                return new Response(`Failed to read source map: ${err instanceof Error ? err.message : String(err)}`, { status: 500 });
-            }
-        }
-        if (url.pathname === "/sessions") {
-            const sessions = listSessions();
-            return new Response(JSON.stringify({ sessions }), {
-                headers: { "content-type": "application/json; charset=utf-8" },
-            });
-        }
+        const feedbackResponse = await handleFeedbackRoutes({
+            url,
+            req,
+            sessionsRoot,
+            getWorkspaceIdFromBody,
+            readSessionState,
+            persistSessionState,
+            appendFeedbackLog,
+            appendSessionEvent,
+        });
+        if (feedbackResponse)
+            return feedbackResponse;
+        const uiRoutesResponse = await handleUiRoutes({
+            url,
+            req,
+            workspaceRouteBase: WORKSPACE_ROUTE_BASE,
+            activeWorkspaceId,
+            activeWorkspaceOnboarding,
+            resolvedDeckPath,
+            deckLabel,
+            getWorkspaceIdFromQuery,
+            activateWorkspaceDeck,
+            schemaPromise,
+            deckLoadPromise,
+            canServeReactBundle,
+            simulatorReactHtml,
+            toDeckLabel,
+            readReactBundle,
+            shouldAdvertiseSourceMap,
+            readReactBundleSourceMap,
+            listSessions,
+            createWorkspaceSession,
+            workspaceStateSchemaVersion: WORKSPACE_STATE_SCHEMA_VERSION,
+        });
+        if (uiRoutesResponse)
+            return uiRoutesResponse;
         return new Response("Not found", { status: 404 });
     });
     const listenPort = server.addr.port;
@@ -2919,9 +5412,36 @@ async function readRemoteBundle(url, kind) {
         return null;
     }
 }
-function simulatorReactHtml(deckPath, deckLabel) {
+function simulatorReactHtml(deckPath, deckLabel, opts) {
     const safeDeckPath = deckPath.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
     const safeDeckLabel = deckLabel?.replaceAll("<", "&lt;").replaceAll(">", "&gt;") ?? null;
+    const buildTabEnabled = (() => {
+        const raw = dntShim.Deno.env.get("GAMBIT_SIMULATOR_BUILD_TAB");
+        if (raw === undefined)
+            return true;
+        const normalized = raw.trim().toLowerCase();
+        return !(normalized === "0" || normalized === "false" ||
+            normalized === "no" ||
+            normalized === "off");
+    })();
+    const chatAccordionEnabled = (() => {
+        const raw = dntShim.Deno.env.get("GAMBIT_SIMULATOR_CHAT_ACCORDION");
+        if (raw === undefined)
+            return true;
+        const normalized = raw.trim().toLowerCase();
+        return normalized === "1" || normalized === "true" ||
+            normalized === "yes" ||
+            normalized === "on";
+    })();
+    const buildStreamDebugEnabled = (() => {
+        const raw = dntShim.Deno.env.get("GAMBIT_SIMULATOR_BUILD_STREAM_DEBUG");
+        if (raw === undefined)
+            return false;
+        const normalized = raw.trim().toLowerCase();
+        return normalized === "1" || normalized === "true" ||
+            normalized === "yes" ||
+            normalized === "on";
+    })();
     const bundleStamp = (() => {
         try {
             const stat = dntShim.Deno.statSync(simulatorBundlePath);
@@ -2935,6 +5455,8 @@ function simulatorReactHtml(deckPath, deckLabel) {
     const bundleUrl = bundleStamp
         ? `/ui/bundle.js?v=${bundleStamp}`
         : "/ui/bundle.js";
+    const workspaceId = opts?.workspaceId ?? null;
+    const workspaceOnboarding = Boolean(opts?.onboarding);
     return `<!doctype html>
 <html lang="en">
 <head>
@@ -2951,6 +5473,12 @@ function simulatorReactHtml(deckPath, deckLabel) {
   <script>
     window.__GAMBIT_DECK_PATH__ = ${JSON.stringify(safeDeckPath)};
     window.__GAMBIT_DECK_LABEL__ = ${JSON.stringify(safeDeckLabel)};
+    window.__GAMBIT_VERSION__ = ${JSON.stringify(gambitVersion)};
+    window.__GAMBIT_BUILD_TAB_ENABLED__ = ${JSON.stringify(buildTabEnabled)};
+    window.__GAMBIT_CHAT_ACCORDION_ENABLED__ = ${JSON.stringify(chatAccordionEnabled)};
+    window.__GAMBIT_WORKSPACE_ID__ = ${JSON.stringify(workspaceId)};
+    window.__GAMBIT_WORKSPACE_ONBOARDING__ = ${JSON.stringify(workspaceOnboarding)};
+    window.__GAMBIT_BUILD_STREAM_DEBUG__ = ${JSON.stringify(buildStreamDebugEnabled)};
   </script>
   <script type="module" src="${bundleUrl}"></script>
 </body>
@@ -2995,6 +5523,9 @@ async function runDeckWithFallback(args) {
             stream: args.stream,
             onStreamText: args.onStreamText,
             responsesMode: args.responsesMode,
+            workerSandbox: args.workerSandbox,
+            signal: args.signal,
+            onCancel: args.onCancel,
         });
     }
     catch (error) {
@@ -3011,6 +5542,9 @@ async function runDeckWithFallback(args) {
                 stream: args.stream,
                 onStreamText: args.onStreamText,
                 responsesMode: args.responsesMode,
+                workerSandbox: args.workerSandbox,
+                signal: args.signal,
+                onCancel: args.onCancel,
             });
         }
         throw error;