@bolt-foundry/gambit 0.8.1 → 0.8.3

package/script/src/server.js

@@ -42,6 +42,7 @@ const trace_js_1 = require("./trace.js");
 const cli_utils_js_1 = require("./cli_utils.js");
 const gambit_core_2 = require("@bolt-foundry/gambit-core");
 const durable_streams_js_1 = require("./durable_streams.js");
+const GAMBIT_TOOL_RESPOND = "gambit_respond";
 const logger = console;
 const moduleLocation = (() => {
     const directoryFromUrl = (url) => {
@@ -83,11 +84,12 @@ const simulatorBundleSourceMapUrl = (() => {
 let cachedRemoteBundle = null;
 let cachedRemoteBundleSourceMap = null;
 const simulatorBundlePath = path.resolve(moduleDir, "..", "simulator-ui", "dist", "bundle.js");
-const simulatorUiEntryPath = path.resolve(moduleDir, "..", "simulator-ui", "src", "main.tsx");
 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 SIMULATOR_STREAM_ID = "gambit-simulator";
-const TEST_BOT_STREAM_ID = "gambit-test-bot";
-const CALIBRATE_STREAM_ID = "gambit-calibrate";
+const GRADE_STREAM_ID = "gambit-grade";
+const TEST_STREAM_ID = "gambit-test";
 let availableTestDecks = [];
 const testDeckByPath = new Map();
 const testDeckById = new Map();
@@ -343,6 +345,162 @@ function deriveInitialFromSchema(schema) {
             return undefined;
     }
 }
+function getPathValue(value, path) {
+    let current = value;
+    for (const segment of path) {
+        if (!current || typeof current !== "object" ||
+            !(segment in current)) {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+function setPathValue(value, path, nextValue) {
+    if (path.length === 0)
+        return nextValue;
+    const root = value && typeof value === "object"
+        ? cloneValue(value)
+        : {};
+    let cursor = root;
+    for (let i = 0; i < path.length - 1; i++) {
+        const segment = path[i];
+        const existing = cursor[segment];
+        const next = existing && typeof existing === "object"
+            ? cloneValue(existing)
+            : {};
+        cursor[segment] = next;
+        cursor = next;
+    }
+    const last = path[path.length - 1];
+    if (nextValue === undefined) {
+        delete cursor[last];
+    }
+    else {
+        cursor[last] = nextValue;
+    }
+    return root;
+}
+function findMissingRequiredFields(schema, value, prefix = []) {
+    if (!schema)
+        return [];
+    if (schema.optional)
+        return [];
+    if (schema.kind === "object" && schema.fields) {
+        if (value !== undefined && value !== null &&
+            (typeof value !== "object" || Array.isArray(value))) {
+            return [];
+        }
+        const asObj = value && typeof value === "object"
+            ? value
+            : undefined;
+        const missing = [];
+        for (const [key, child] of Object.entries(schema.fields)) {
+            missing.push(...findMissingRequiredFields(child, asObj ? asObj[key] : undefined, [...prefix, key]));
+        }
+        return missing;
+    }
+    const key = prefix.join(".") || "(root)";
+    if (value === undefined || value === null) {
+        return schema.defaultValue !== undefined ? [] : [key];
+    }
+    if (schema.kind === "string" || schema.kind === "enum") {
+        return typeof value === "string" && value.trim() === "" ? [key] : [];
+    }
+    if (schema.kind === "array") {
+        return Array.isArray(value) && value.length === 0 ? [key] : [];
+    }
+    if (schema.kind === "number") {
+        return typeof value === "number" && Number.isFinite(value) ? [] : [key];
+    }
+    if (schema.kind === "boolean") {
+        return typeof value === "boolean" ? [] : [key];
+    }
+    return [];
+}
+function getSchemaAtPath(schema, path) {
+    let current = schema;
+    for (const segment of path) {
+        if (!current || current.kind !== "object" || !current.fields)
+            return;
+        current = current.fields[segment];
+    }
+    return current;
+}
+function buildInitFillPrompt(args) {
+    const schemaHints = args.missing.map((path) => {
+        const segments = path === "(root)" ? [] : path.split(".");
+        const leaf = getSchemaAtPath(args.schema, segments);
+        return {
+            path,
+            kind: leaf?.kind,
+            description: leaf?.description,
+            enumValues: leaf?.enumValues,
+        };
+    });
+    const payload = {
+        type: "gambit_test_bot_init_fill",
+        missing: args.missing,
+        current: args.current ?? null,
+        schemaHints,
+    };
+    return [
+        "You are filling missing required init fields for a Gambit Test Bot 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.",
+        "",
+        JSON.stringify(payload, null, 2),
+    ].join("\n");
+}
+function unwrapRespondPayload(output) {
+    if (!output || typeof output !== "object")
+        return output;
+    const record = output;
+    if ("payload" in record) {
+        return record.payload;
+    }
+    return output;
+}
+function parseInitFillOutput(output) {
+    if (output === null || output === undefined) {
+        return { error: "Persona returned empty init fill output." };
+    }
+    if (typeof output === "object") {
+        return { data: unwrapRespondPayload(output) };
+    }
+    if (typeof output === "string") {
+        const text = output.trim();
+        if (!text)
+            return { error: "Persona returned empty init fill output." };
+        try {
+            const parsed = JSON.parse(text);
+            return { data: unwrapRespondPayload(parsed) };
+        }
+        catch (err) {
+            return {
+                error: `Persona returned invalid JSON for init fill: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    }
+    return { error: "Persona returned unsupported init fill output." };
+}
+function validateInitInput(schema, value) {
+    if (!schema)
+        return value;
+    if (typeof schema.safeParse !== "function") {
+        throw new Error("Init schema missing safeParse");
+    }
+    const result = schema.safeParse(value);
+    if (!result.success) {
+        const issue = result.error.issues?.[0];
+        const message = issue
+            ? `${issue.path.join(".") || "(root)"}: ${issue.message}`
+            : result.error.message;
+        throw new Error(`Schema validation failed: ${message}`);
+    }
+    return result.data;
+}
 /**
  * Start the WebSocket simulator server used by the Gambit debug UI.
  */
@@ -381,9 +539,10 @@ function startWebSocketSimulator(opts) {
     };
     const testBotRuns = new Map();
     const broadcastTestBot = (payload) => {
-        (0, durable_streams_js_1.appendDurableStreamEvent)(TEST_BOT_STREAM_ID, payload);
+        (0, durable_streams_js_1.appendDurableStreamEvent)(TEST_STREAM_ID, payload);
     };
     let deckSlug = deckSlugFromPath(resolvedDeckPath);
+    let deckLabel = undefined;
     const enrichStateWithSession = (state) => {
         const meta = { ...(state.meta ?? {}) };
         const now = new Date();
@@ -575,6 +734,59 @@ function startWebSocketSimulator(opts) {
             return String(value);
         }
     };
+    const safeParseJson = (text) => {
+        if (typeof text !== "string" || text.trim().length === 0)
+            return undefined;
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const summarizeRespondCall = (message) => {
+        if (!message || message.role !== "tool")
+            return null;
+        const name = typeof message.name === "string" ? message.name : undefined;
+        if (name !== GAMBIT_TOOL_RESPOND)
+            return null;
+        const parsed = safeParseJson(typeof message.content === "string" ? message.content : "");
+        const payload = parsed && typeof parsed === "object"
+            ? ("payload" in parsed
+                ? parsed.payload
+                : parsed)
+            : undefined;
+        const status = typeof parsed?.status === "number"
+            ? parsed.status
+            : undefined;
+        const code = typeof parsed?.code === "string"
+            ? parsed.code
+            : undefined;
+        const respondMessage = typeof parsed?.message === "string"
+            ? parsed.message
+            : undefined;
+        const meta = parsed && typeof parsed.meta === "object"
+            ? parsed.meta
+            : undefined;
+        const summary = {};
+        if (status !== undefined)
+            summary.status = status;
+        if (code !== undefined)
+            summary.code = code;
+        if (respondMessage !== undefined)
+            summary.message = respondMessage;
+        if (meta !== undefined)
+            summary.meta = meta;
+        summary.payload = payload ?? null;
+        return {
+            status,
+            code,
+            message: respondMessage,
+            meta,
+            payload,
+            displayText: JSON.stringify(summary, null, 2),
+        };
+    };
     const updateTestDeckRegistry = (list) => {
         testDeckByPath.clear();
         testDeckById.clear();
@@ -627,11 +839,11 @@ function startWebSocketSimulator(opts) {
         const fallbackToolInserts = [];
         for (let i = 0; i < rawMessages.length; i++) {
             const msg = rawMessages[i];
+            const refId = refs[i]?.id;
             if (msg?.role === "assistant" || msg?.role === "user") {
                 const content = stringifyContent(msg.content).trim();
                 if (!content)
                     continue;
-                const refId = refs[i]?.id;
                 messages.push({
                     role: msg.role,
                     content,
@@ -640,6 +852,21 @@ function startWebSocketSimulator(opts) {
                 });
                 continue;
             }
+            const respondSummary = summarizeRespondCall(msg);
+            if (respondSummary) {
+                messages.push({
+                    role: "assistant",
+                    content: respondSummary.displayText,
+                    messageRefId: refId,
+                    feedback: refId ? feedbackByRef.get(refId) : undefined,
+                    respondStatus: respondSummary.status,
+                    respondCode: respondSummary.code,
+                    respondMessage: respondSummary.message,
+                    respondPayload: respondSummary.payload,
+                    respondMeta: respondSummary.meta,
+                });
+                continue;
+            }
             if (msg?.role === "tool") {
                 const actionCallId = typeof msg.tool_call_id === "string"
                     ? msg.tool_call_id
@@ -660,6 +887,33 @@ function startWebSocketSimulator(opts) {
                 : fallbackToolInserts,
         };
     };
+    const buildConversationMessages = (state) => {
+        const rawMessages = state.messages ?? [];
+        const conversation = [];
+        for (const msg of rawMessages) {
+            if (msg?.role === "assistant" || msg?.role === "user") {
+                const content = stringifyContent(msg.content).trim();
+                if (!content)
+                    continue;
+                conversation.push({
+                    role: msg.role,
+                    content,
+                    name: msg.name,
+                    tool_calls: msg.tool_calls,
+                });
+                continue;
+            }
+            const respondSummary = summarizeRespondCall(msg);
+            if (respondSummary) {
+                conversation.push({
+                    role: "assistant",
+                    content: respondSummary.displayText,
+                    name: GAMBIT_TOOL_RESPOND,
+                });
+            }
+        }
+        return conversation;
+    };
     const deriveToolInsertsFromTraces = (state, messageCount) => {
         const traces = Array.isArray(state.traces) ? state.traces : [];
         if (!traces.length)
@@ -704,6 +958,10 @@ function startWebSocketSimulator(opts) {
             : undefined;
         if (sessionId)
             run.sessionId = sessionId;
+        const initFill = state.meta
+            ?.testBotInitFill;
+        if (initFill)
+            run.initFill = initFill;
         run.traces = Array.isArray(state.traces) ? [...state.traces] : undefined;
     };
     const startTestBotRun = (runOpts = {}) => {
@@ -741,9 +999,27 @@ function startWebSocketSimulator(opts) {
         };
         testBotRuns.set(runId, entry);
         const run = entry.run;
+        if (runOpts.initFill)
+            run.initFill = runOpts.initFill;
         let savedState = undefined;
         let lastCount = 0;
         const capturedTraces = [];
+        if (runOpts.initFillTrace) {
+            const actionCallId = randomId("initfill");
+            capturedTraces.push({
+                type: "tool.call",
+                runId,
+                actionCallId,
+                name: "gambit_test_bot_init_fill",
+                args: runOpts.initFillTrace.args,
+            }, {
+                type: "tool.result",
+                runId,
+                actionCallId,
+                name: "gambit_test_bot_init_fill",
+                result: runOpts.initFillTrace.result,
+            });
+        }
         const setSessionId = (state) => {
             const sessionId = typeof state?.meta?.sessionId === "string"
                 ? state.meta.sessionId
@@ -799,6 +1075,7 @@ function startWebSocketSimulator(opts) {
                 },
                 stream: Boolean(streamOpts?.onStreamText),
                 onStreamText: streamOpts?.onStreamText,
+                responsesMode: opts.responsesMode,
             });
             if ((0, gambit_core_1.isGambitEndSignal)(result)) {
                 sessionEnded = true;
@@ -822,6 +1099,7 @@ function startWebSocketSimulator(opts) {
                         state: savedState,
                         allowRootStringInput: true,
                         initialUserMessage: initialUserMessage || undefined,
+                        responsesMode: opts.responsesMode,
                         onStateUpdate: (state) => {
                             const nextMeta = {
                                 ...(savedState?.meta ?? {}),
@@ -830,6 +1108,7 @@ function startWebSocketSimulator(opts) {
                                 testBotRunId: runId,
                                 testBotConfigPath: botConfigPath,
                                 testBotName,
+                                ...(run.initFill ? { testBotInitFill: run.initFill } : {}),
                             };
                             const enriched = persistSessionState({
                                 ...state,
@@ -881,6 +1160,7 @@ function startWebSocketSimulator(opts) {
                         state: savedState,
                         allowRootStringInput: true,
                         initialUserMessage: userMessage,
+                        responsesMode: opts.responsesMode,
                         onStateUpdate: (state) => {
                             const nextMeta = {
                                 ...(savedState?.meta ?? {}),
@@ -889,6 +1169,7 @@ function startWebSocketSimulator(opts) {
                                 testBotRunId: runId,
                                 testBotConfigPath: botConfigPath,
                                 testBotName,
+                                ...(run.initFill ? { testBotInitFill: run.initFill } : {}),
                             };
                             const enriched = persistSessionState({
                                 ...state,
@@ -947,10 +1228,60 @@ function startWebSocketSimulator(opts) {
         broadcastTestBot({ type: "testBotStatus", run });
         return run;
     };
+    const persistFailedInitFill = (args) => {
+        const failedRunId = randomId("testbot");
+        const testBotName = path.basename(args.botDeckPath).replace(/\.deck\.(md|ts)$/i, "");
+        const actionCallId = randomId("initfill");
+        const traces = [
+            {
+                type: "tool.call",
+                runId: failedRunId,
+                actionCallId,
+                name: "gambit_test_bot_init_fill",
+                args: { missing: args.initFill?.requested ?? [] },
+            },
+            {
+                type: "tool.result",
+                runId: failedRunId,
+                actionCallId,
+                name: "gambit_test_bot_init_fill",
+                result: {
+                    error: args.error,
+                    provided: args.initFill?.provided,
+                },
+            },
+        ];
+        const failedState = persistSessionState({
+            runId: failedRunId,
+            messages: [],
+            traces,
+            meta: {
+                testBot: true,
+                testBotRunId: failedRunId,
+                testBotConfigPath: args.botDeckPath,
+                testBotName,
+                testBotInitFill: args.initFill,
+                testBotInitFillError: args.error,
+            },
+        });
+        const sessionId = typeof failedState.meta?.sessionId === "string"
+            ? failedState.meta.sessionId
+            : undefined;
+        const sessionPath = typeof failedState.meta?.sessionStatePath === "string"
+            ? failedState.meta.sessionStatePath
+            : undefined;
+        if (sessionPath) {
+            logger.warn(`[sim] init fill failed; session saved to ${sessionPath}`);
+        }
+        return { sessionId, sessionPath };
+    };
     const deckLoadPromise = (0, gambit_core_2.loadDeck)(resolvedDeckPath)
         .then((deck) => {
         resolvedDeckPath = deck.path;
         deckSlug = deckSlugFromPath(resolvedDeckPath);
+        deckLabel = typeof deck.label === "string"
+            ? deck.label
+            : toDeckLabel(deck.path);
         availableTestDecks = (deck.testDecks ?? []).map((testDeck, index) => {
             const label = testDeck.label && typeof testDeck.label === "string"
                 ? testDeck.label
@@ -1014,14 +1345,21 @@ function startWebSocketSimulator(opts) {
     const wantsSourceMap = Boolean(opts.sourceMap);
     const bundlePlatform = opts.bundlePlatform ?? "deno";
     const autoBundle = opts.autoBundle ?? true;
+    const forceBundle = opts.forceBundle ?? false;
     const needsBundle = !hasReactBundle() ||
         (wantsSourceMap && !hasReactBundleSourceMap()) ||
         isReactBundleStale();
-    const shouldAutoBundle = autoBundle && moduleLocation.isLocal && needsBundle;
+    const shouldAutoBundle = autoBundle && moduleLocation.isLocal &&
+        (forceBundle || needsBundle);
     if (autoBundle && !moduleLocation.isLocal && opts.verbose) {
         logger.log("[sim] auto-bundle disabled for remote package; using packaged bundle.");
     }
+    if (autoBundle && moduleLocation.isLocal && !shouldAutoBundle) {
+        logger.log("[sim] auto-bundle enabled; bundle already up to date.");
+    }
     if (shouldAutoBundle) {
+        logger.log(`[sim] auto-bundle enabled; rebuilding simulator UI (${forceBundle ? "forced" : "stale"})...`);
+        logger.log(`[sim] bundling simulator UI (${forceBundle ? "forced" : "stale"})...`);
         try {
             const p = new dntShim.Deno.Command("deno", {
                 args: [
@@ -1048,6 +1386,28 @@ function startWebSocketSimulator(opts) {
         if (url.pathname.startsWith("/api/durable-streams/stream/")) {
             return (0, durable_streams_js_1.handleDurableStreamRequest)(req);
         }
+        if (url.pathname === "/favicon.ico") {
+            if (req.method !== "GET" && req.method !== "HEAD") {
+                return new Response("Method not allowed", { status: 405 });
+            }
+            try {
+                const data = await dntShim.Deno.readFile(simulatorFaviconDistPath);
+                return new Response(req.method === "HEAD" ? null : data, {
+                    headers: { "content-type": "image/x-icon" },
+                });
+            }
+            catch {
+                try {
+                    const data = await dntShim.Deno.readFile(simulatorFaviconSrcPath);
+                    return new Response(req.method === "HEAD" ? null : data, {
+                        headers: { "content-type": "image/x-icon" },
+                    });
+                }
+                catch {
+                    return new Response("Not found", { status: 404 });
+                }
+            }
+        }
         if (url.pathname === "/api/calibrate") {
             if (req.method !== "GET") {
                 return new Response("Method not allowed", { status: 405 });
@@ -1093,9 +1453,10 @@ function startWebSocketSimulator(opts) {
                     delete next.gradingRuns;
                     return next;
                 })();
+                const conversationMessages = buildConversationMessages(sessionState);
                 const sessionPayload = {
-                    messages: Array.isArray(sessionState.messages)
-                        ? sessionState.messages.map((msg) => ({
+                    messages: conversationMessages.length > 0
+                        ? conversationMessages.map((msg) => ({
                             role: msg.role,
                             content: msg.content,
                             name: msg.name,
@@ -1128,7 +1489,7 @@ function startWebSocketSimulator(opts) {
                         },
                     });
                     const sessionMeta = buildSessionMeta(sessionId, nextState);
-                    (0, durable_streams_js_1.appendDurableStreamEvent)(CALIBRATE_STREAM_ID, {
+                    (0, durable_streams_js_1.appendDurableStreamEvent)(GRADE_STREAM_ID, {
                         type: "calibrateSession",
                         sessionId,
                         run: nextEntry,
@@ -1158,6 +1519,7 @@ function startWebSocketSimulator(opts) {
                                 allowRootStringInput: false,
                                 initialUserMessage: undefined,
                                 stream: false,
+                                responsesMode: opts.responsesMode,
                             });
                         }
                         const messages = sessionPayload.messages ?? [];
@@ -1197,6 +1559,7 @@ function startWebSocketSimulator(opts) {
                                 allowRootStringInput: false,
                                 initialUserMessage: undefined,
                                 stream: false,
+                                responsesMode: opts.responsesMode,
                             });
                             turns.push({
                                 index: idx,
@@ -1299,7 +1662,7 @@ function startWebSocketSimulator(opts) {
                     },
                 });
                 const sessionMeta = buildSessionMeta(body.sessionId, updated);
-                (0, durable_streams_js_1.appendDurableStreamEvent)(CALIBRATE_STREAM_ID, {
+                (0, durable_streams_js_1.appendDurableStreamEvent)(GRADE_STREAM_ID, {
                     type: "calibrateSession",
                     sessionId: body.sessionId,
                     session: sessionMeta,
@@ -1352,7 +1715,7 @@ function startWebSocketSimulator(opts) {
                     },
                 });
                 const sessionMeta = buildSessionMeta(body.sessionId, updated);
-                (0, durable_streams_js_1.appendDurableStreamEvent)(CALIBRATE_STREAM_ID, {
+                (0, durable_streams_js_1.appendDurableStreamEvent)(GRADE_STREAM_ID, {
                     type: "calibrateSession",
                     sessionId: body.sessionId,
                     session: sessionMeta,
@@ -1439,7 +1802,7 @@ function startWebSocketSimulator(opts) {
                     },
                 });
                 const sessionMeta = buildSessionMeta(body.sessionId, nextState);
-                (0, durable_streams_js_1.appendDurableStreamEvent)(CALIBRATE_STREAM_ID, {
+                (0, durable_streams_js_1.appendDurableStreamEvent)(GRADE_STREAM_ID, {
                     type: "calibrateSession",
                     sessionId: body.sessionId,
                     run: nextRun,
@@ -1457,7 +1820,7 @@ function startWebSocketSimulator(opts) {
                 }), { status: 400, headers: { "content-type": "application/json" } });
             }
         }
-        if (url.pathname === "/api/test-bot") {
+        if (url.pathname === "/api/test") {
             if (req.method === "GET") {
                 await deckLoadPromise.catch(() => null);
                 const requestedDeck = url.searchParams.get("deckPath");
@@ -1498,7 +1861,7 @@ function startWebSocketSimulator(opts) {
             }
             return new Response("Method not allowed", { status: 405 });
         }
-        if (url.pathname === "/api/test-bot/run") {
+        if (url.pathname === "/api/test/run") {
             if (req.method !== "POST") {
                 return new Response("Method not allowed", { status: 405 });
             }
@@ -1507,17 +1870,28 @@ function startWebSocketSimulator(opts) {
             let botInput = undefined;
             let initialUserMessage = undefined;
             let botDeckSelection;
+            let inheritBotInput = false;
+            let userProvidedDeckInput = false;
+            let initFillRequestMissing = undefined;
             try {
                 const body = await req.json();
                 if (typeof body.maxTurns === "number" && Number.isFinite(body.maxTurns)) {
                     maxTurnsOverride = body.maxTurns;
                 }
                 deckInput = body.context ?? body.init;
+                if (body.context !== undefined || body.init !== undefined) {
+                    userProvidedDeckInput = true;
+                }
                 if (body.init !== undefined && body.context === undefined) {
-                    logger.warn('[gambit] Received deprecated "init" field in test-bot API; use "context" instead.');
+                    logger.warn('[gambit] Received deprecated "init" field in test API; use "context" instead.');
                 }
                 botInput = body.botInput;
-                await deckLoadPromise.catch(() => null);
+                if (typeof body.inheritBotInput === "boolean") {
+                    inheritBotInput = body.inheritBotInput;
+                }
+                if (body.initFill && Array.isArray(body.initFill.missing)) {
+                    initFillRequestMissing = body.initFill.missing.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+                }
                 if (typeof body.botDeckPath === "string") {
                     const resolved = resolveTestDeck(body.botDeckPath);
                     if (!resolved) {
@@ -1550,19 +1924,175 @@ function startWebSocketSimulator(opts) {
                     // ignore; keep undefined
                 }
             }
+            if (!userProvidedDeckInput && inheritBotInput && botInput !== undefined) {
+                deckInput = cloneValue(botInput);
+            }
             if (!botDeckSelection) {
                 return new Response(JSON.stringify({ error: "No test decks configured" }), { status: 400, headers: { "content-type": "application/json" } });
             }
+            let initFillInfo;
+            let initFillTrace;
+            try {
+                const rootDeck = await deckLoadPromise.catch(() => null);
+                const rootSchema = rootDeck?.contextSchema ?? rootDeck?.inputSchema;
+                const normalizedSchema = rootSchema
+                    ? normalizeSchema(rootSchema)
+                    : undefined;
+                const missing = normalizedSchema
+                    ? findMissingRequiredFields(normalizedSchema, deckInput)
+                    : [];
+                const requested = initFillRequestMissing?.length
+                    ? missing.filter((entry) => initFillRequestMissing?.includes(entry))
+                    : missing;
+                if (requested.length > 0) {
+                    const fillPrompt = buildInitFillPrompt({
+                        missing: requested,
+                        current: deckInput,
+                        schema: normalizedSchema,
+                    });
+                    const fillOutput = await runDeckWithFallback({
+                        path: botDeckSelection.path,
+                        input: botInput,
+                        inputProvided: botInput !== undefined,
+                        modelProvider: opts.modelProvider,
+                        allowRootStringInput: true,
+                        initialUserMessage: fillPrompt,
+                        responsesMode: opts.responsesMode,
+                    });
+                    const parsed = parseInitFillOutput(fillOutput);
+                    if (parsed.error) {
+                        initFillInfo = {
+                            requested,
+                            provided: fillOutput,
+                            error: parsed.error,
+                        };
+                        const failure = persistFailedInitFill({
+                            error: parsed.error,
+                            initFill: initFillInfo,
+                            botDeckPath: botDeckSelection.path,
+                        });
+                        return new Response(JSON.stringify({
+                            error: parsed.error,
+                            initFill: initFillInfo,
+                            sessionId: failure.sessionId,
+                            sessionPath: failure.sessionPath,
+                        }), {
+                            status: 400,
+                            headers: { "content-type": "application/json" },
+                        });
+                    }
+                    let appliedObject = {};
+                    let appliedRoot = undefined;
+                    let nextInput = deckInput;
+                    for (const pathKey of requested) {
+                        const segments = pathKey === "(root)" ? [] : pathKey.split(".");
+                        const leafSchema = getSchemaAtPath(normalizedSchema, segments);
+                        const currentValue = getPathValue(nextInput, segments);
+                        if (currentValue !== undefined && currentValue !== null &&
+                            !(typeof currentValue === "string" &&
+                                (leafSchema?.kind === "string" ||
+                                    leafSchema?.kind === "enum") &&
+                                currentValue.trim() === "") &&
+                            !(Array.isArray(currentValue) && leafSchema?.kind === "array" &&
+                                currentValue.length === 0)) {
+                            continue;
+                        }
+                        const fillValue = getPathValue(parsed.data, segments);
+                        if (fillValue === undefined)
+                            continue;
+                        if (segments.length === 0) {
+                            nextInput = fillValue;
+                            appliedRoot = fillValue;
+                            continue;
+                        }
+                        nextInput = setPathValue(nextInput, segments, fillValue);
+                        const appliedValue = setPathValue(appliedObject, segments, fillValue);
+                        if (appliedValue && typeof appliedValue === "object") {
+                            appliedObject = appliedValue;
+                        }
+                    }
+                    const validated = validateInitInput(rootSchema, nextInput);
+                    deckInput = validated;
+                    const remainingMissing = normalizedSchema
+                        ? findMissingRequiredFields(normalizedSchema, deckInput)
+                        : [];
+                    if (remainingMissing.length > 0) {
+                        const message = `Init fill incomplete: missing ${remainingMissing.join(", ")}`;
+                        initFillInfo = {
+                            requested,
+                            applied: appliedRoot !== undefined
+                                ? appliedRoot
+                                : Object.keys(appliedObject).length
+                                    ? appliedObject
+                                    : undefined,
+                            provided: parsed.data,
+                            error: message,
+                        };
+                        const failure = persistFailedInitFill({
+                            error: message,
+                            initFill: initFillInfo,
+                            botDeckPath: botDeckSelection.path,
+                        });
+                        return new Response(JSON.stringify({
+                            error: message,
+                            initFill: initFillInfo,
+                            sessionId: failure.sessionId,
+                            sessionPath: failure.sessionPath,
+                        }), {
+                            status: 400,
+                            headers: { "content-type": "application/json" },
+                        });
+                    }
+                    initFillInfo = {
+                        requested,
+                        applied: appliedRoot !== undefined
+                            ? appliedRoot
+                            : Object.keys(appliedObject).length
+                                ? appliedObject
+                                : undefined,
+                        provided: parsed.data,
+                    };
+                    initFillTrace = {
+                        args: {
+                            missing: requested,
+                        },
+                        result: {
+                            applied: initFillInfo.applied,
+                            provided: initFillInfo.provided,
+                        },
+                    };
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                initFillInfo = initFillInfo ?? {
+                    requested: [],
+                };
+                initFillInfo.error = message;
+                const failure = persistFailedInitFill({
+                    error: message,
+                    initFill: initFillInfo,
+                    botDeckPath: botDeckSelection.path,
+                });
+                return new Response(JSON.stringify({
+                    error: message,
+                    initFill: initFillInfo,
+                    sessionId: failure.sessionId,
+                    sessionPath: failure.sessionPath,
+                }), { status: 400, headers: { "content-type": "application/json" } });
+            }
             const run = startTestBotRun({
                 maxTurnsOverride,
                 deckInput,
                 botInput,
                 initialUserMessage,
                 botDeckPath: botDeckSelection.path,
+                initFill: initFillInfo,
+                initFillTrace,
             });
             return new Response(JSON.stringify({ run }), { headers: { "content-type": "application/json" } });
         }
-        if (url.pathname === "/api/test-bot/status") {
+        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;
@@ -1635,7 +2165,7 @@ function startWebSocketSimulator(opts) {
                 testDecks: availableTestDecks,
             }), { headers: { "content-type": "application/json" } });
         }
-        if (url.pathname === "/api/test-bot/stop") {
+        if (url.pathname === "/api/test/stop") {
             if (req.method !== "POST") {
                 return new Response("Method not allowed", { status: 405 });
             }
@@ -1736,6 +2266,7 @@ function startWebSocketSimulator(opts) {
                     trace: tracer,
                     stream,
                     state: simulatorSavedState,
+                    responsesMode: opts.responsesMode,
                     onStateUpdate: (state) => {
                         const nextMeta = {
                             ...(simulatorSavedState?.meta ?? {}),
@@ -2199,20 +2730,28 @@ function startWebSocketSimulator(opts) {
             url.pathname.startsWith("/debug") ||
             url.pathname.startsWith("/editor") ||
             url.pathname.startsWith("/docs") ||
-            url.pathname.startsWith("/test-bot") ||
-            url.pathname.startsWith("/calibrate")) {
+            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 });
             }
-            return new Response(simulatorReactHtml(resolvedDeckPath), {
+            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" },
@@ -2306,18 +2845,58 @@ function hasReactBundleSourceMap() {
         return false;
     }
 }
+function newestMtimeInDir(dirPath) {
+    const stack = [dirPath];
+    let newest = undefined;
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current)
+            continue;
+        let entries;
+        try {
+            entries = Array.from(dntShim.Deno.readDirSync(current));
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const entryPath = path.join(current, entry.name);
+            if (entry.isDirectory) {
+                stack.push(entryPath);
+                continue;
+            }
+            if (!entry.isFile)
+                continue;
+            try {
+                const stat = dntShim.Deno.statSync(entryPath);
+                if (!stat.isFile)
+                    continue;
+                const mtime = stat.mtime?.getTime();
+                if (typeof mtime !== "number")
+                    continue;
+                newest = newest === undefined ? mtime : Math.max(newest, mtime);
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return newest;
+}
 function isReactBundleStale() {
     try {
         const bundleStat = dntShim.Deno.statSync(simulatorBundlePath);
-        const entryStat = dntShim.Deno.statSync(simulatorUiEntryPath);
-        if (!bundleStat.isFile || !entryStat.isFile)
+        if (!bundleStat.isFile)
             return false;
         const bundleTime = bundleStat.mtime?.getTime();
-        const entryTime = entryStat.mtime?.getTime();
-        if (typeof bundleTime !== "number" || typeof entryTime !== "number") {
+        if (typeof bundleTime !== "number") {
             return false;
         }
-        return entryTime > bundleTime;
+        const srcRoot = path.resolve(moduleDir, "..", "simulator-ui", "src");
+        const newestSource = newestMtimeInDir(srcRoot);
+        if (typeof newestSource !== "number")
+            return false;
+        return newestSource > bundleTime;
     }
     catch {
         return false;
@@ -2376,8 +2955,9 @@ async function readRemoteBundle(url, kind) {
         return null;
     }
 }
-function simulatorReactHtml(deckPath) {
-    const deckLabel = deckPath.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+function simulatorReactHtml(deckPath, deckLabel) {
+    const safeDeckPath = deckPath.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+    const safeDeckLabel = deckLabel?.replaceAll("<", "&lt;").replaceAll(">", "&gt;") ?? null;
     const bundleStamp = (() => {
         try {
             const stat = dntShim.Deno.statSync(simulatorBundlePath);
@@ -2405,7 +2985,8 @@ function simulatorReactHtml(deckPath) {
 <body>
   <div id="root"></div>
   <script>
-    window.__GAMBIT_DECK_PATH__ = ${JSON.stringify(deckLabel)};
+    window.__GAMBIT_DECK_PATH__ = ${JSON.stringify(safeDeckPath)};
+    window.__GAMBIT_DECK_LABEL__ = ${JSON.stringify(safeDeckLabel)};
   </script>
   <script type="module" src="${bundleUrl}"></script>
 </body>
@@ -2449,6 +3030,7 @@ async function runDeckWithFallback(args) {
             onStateUpdate: args.onStateUpdate,
             stream: args.stream,
             onStreamText: args.onStreamText,
+            responsesMode: args.responsesMode,
         });
     }
     catch (error) {
@@ -2464,6 +3046,7 @@ async function runDeckWithFallback(args) {
                 onStateUpdate: args.onStateUpdate,
                 stream: args.stream,
                 onStreamText: args.onStreamText,
+                responsesMode: args.responsesMode,
             });
         }
         throw error;