codex-chatgpt-control 0.5.0-alpha.1 → 0.5.1-alpha.2

package/dist/src/scripts/capture-surface-profile.d.ts

@@ -1,5 +1,5 @@
 import { detectExperienceFromSnapshot, readSurfaceSnapshot } from "../commands/experience.js";
-import type { BrowserLike, ConfigurationInspectionData, ExistingTabPolicy, SurfaceProfileFixture, SurfaceProfileSupportState } from "../types.js";
+import type { BrowserLike, ChatGPTExperience, ConfigurationInspectionData, ExistingTabPolicy, SurfaceProfileFixture, SurfaceProfileSupportState } from "../types.js";
 type CaptureRuntime = {
     agent?: unknown;
     browser?: BrowserLike;
@@ -16,6 +16,8 @@ type CaptureOptions = {
     provenance: string;
     tabId?: string;
     ifMissing: NonNullable<ExistingTabPolicy["ifMissing"]>;
+    experience?: Exclude<ChatGPTExperience, "unknown">;
+    restoreExperience: boolean;
 };
 export declare function main(argv?: string[], runtime?: CaptureRuntime): Promise<number>;
 export declare function buildSurfaceProfileDraft(options: Pick<CaptureOptions, "id" | "region" | "accountScope" | "planScope" | "workspaceScope" | "supportState" | "provenance">, locale: string, snapshot: Awaited<ReturnType<typeof readSurfaceSnapshot>>, detected: ReturnType<typeof detectExperienceFromSnapshot>, inspection: ConfigurationInspectionData, observedAt?: string): SurfaceProfileFixture;

package/dist/src/scripts/capture-surface-profile.js

@@ -2,7 +2,7 @@ import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { attachChatGPTBrowser } from "../browser/attach.js";
 import { inspectConfiguration } from "../commands/configuration.js";
-import { detectExperienceFromSnapshot, readSurfaceSnapshot } from "../commands/experience.js";
+import { detectExperienceFromSnapshot, openExperience, readSurfaceSnapshot } from "../commands/experience.js";
 import { BROWSER_BRIDGE_REMEDIATION, BROWSER_BRIDGE_UNAVAILABLE_MESSAGE, toCommandResult } from "../errors.js";
 const CHATGPT_HOME = "https://chatgpt.com/";
 const DEFAULT_PROVENANCE = "Read-only sanitized capture from visible ChatGPT controls; review before committing.";
@@ -31,9 +31,12 @@ const USAGE = [
     "  --provenance       Non-private provenance note.",
     "  --tab-id           Claim an exact already-open ChatGPT tab.",
     "  --if-missing       block|open|create. Default: block.",
+    "  --experience       Capture chat|work, switching visibly when needed.",
+    "  --no-restore-experience  Leave the requested surface selected. Default: restore.",
     "",
-    "The capture is read-only with respect to ChatGPT configuration. It opens and",
-    "closes visible menus, writes a sanitized draft locally, and never records",
+    "The capture does not mutate model configuration. With --experience it visibly",
+    "switches panes and restores the prior pane by default. It writes a sanitized draft",
+    "locally and never records",
     "prompts, responses, sidebar titles, account names, cookies, or network data."
 ].join("\n");
 export async function main(argv = process.argv.slice(2), runtime = globalThis) {
@@ -79,27 +82,53 @@ export async function main(argv = process.argv.slice(2), runtime = globalThis) {
             url: CHATGPT_HOME
         });
         env.page = attached.page;
-        const snapshot = await readSurfaceSnapshot(attached.page);
-        const detected = detectExperienceFromSnapshot(snapshot);
-        const inspectionResult = await inspectConfiguration(env, { includeOptions: true });
-        if (!inspectionResult.ok || inspectionResult.data === undefined) {
-            console.log(JSON.stringify(inspectionResult, null, 2));
-            return 1;
+        const initial = detectExperienceFromSnapshot(await readSurfaceSnapshot(attached.page));
+        const previousExperience = initial.experience === "unknown" ? undefined : initial.experience;
+        if (options.experience !== undefined && previousExperience === undefined) {
+            throw new Error("Cannot safely switch surfaces because the initial Chat/Work pane could not be identified.");
+        }
+        try {
+            if (options.experience !== undefined) {
+                const opened = await openExperience(env, { experience: options.experience, timeoutMs: 60_000 });
+                if (!opened.ok || opened.data?.experience !== options.experience) {
+                    console.log(JSON.stringify(opened, null, 2));
+                    return 1;
+                }
+            }
+            const snapshot = await readSurfaceSnapshot(attached.page);
+            const detected = detectExperienceFromSnapshot(snapshot);
+            const inspectionResult = await inspectConfiguration(env, { includeOptions: true });
+            if (!inspectionResult.ok || inspectionResult.data === undefined) {
+                console.log(JSON.stringify(inspectionResult, null, 2));
+                return 1;
+            }
+            const locale = options.locale ?? await readDocumentLocale(attached.page) ?? "und";
+            const profile = buildSurfaceProfileDraft(options, locale, snapshot, detected, inspectionResult.data);
+            await mkdir(dirname(options.out), { recursive: true });
+            await writeFile(options.out, `${JSON.stringify(profile, null, 2)}\n`, { encoding: "utf8", flag: "wx" });
+            console.log(JSON.stringify({
+                ok: true,
+                status: "ok",
+                path: options.out,
+                id: profile.id,
+                experience: profile.expected.experience,
+                selectorProfile: profile.expected.selectorProfile,
+                supportState: profile.supportState,
+                restoreExperience: options.restoreExperience
+            }, null, 2));
+            return 0;
+        }
+        finally {
+            if (options.experience !== undefined
+                && options.restoreExperience
+                && previousExperience !== undefined
+                && previousExperience !== options.experience) {
+                const restored = await openExperience(env, { experience: previousExperience, timeoutMs: 60_000 });
+                if (!restored.ok || restored.data?.experience !== previousExperience) {
+                    throw new Error(`Captured ${options.experience}, but failed to restore ${previousExperience}.`);
+                }
+            }
         }
-        const locale = options.locale ?? await readDocumentLocale(attached.page) ?? "und";
-        const profile = buildSurfaceProfileDraft(options, locale, snapshot, detected, inspectionResult.data);
-        await mkdir(dirname(options.out), { recursive: true });
-        await writeFile(options.out, `${JSON.stringify(profile, null, 2)}\n`, { encoding: "utf8", flag: "wx" });
-        console.log(JSON.stringify({
-            ok: true,
-            status: "ok",
-            path: options.out,
-            id: profile.id,
-            experience: profile.expected.experience,
-            selectorProfile: profile.expected.selectorProfile,
-            supportState: profile.supportState
-        }, null, 2));
-        return 0;
     }
     catch (error) {
         console.log(JSON.stringify(toCommandResult(error), null, 2));
@@ -184,6 +213,8 @@ export function parseArgs(argv) {
     let provenance = DEFAULT_PROVENANCE;
     let tabId;
     let ifMissing = "block";
+    let experience;
+    let restoreExperience = true;
     for (let index = 0; index < argv.length; index += 1) {
         const arg = argv[index];
         if (arg === undefined)
@@ -225,6 +256,15 @@ export function parseArgs(argv) {
             case "--if-missing":
                 ifMissing = parseIfMissing(requiredValue(argv, ++index, arg));
                 break;
+            case "--experience":
+                experience = parseExperience(requiredValue(argv, ++index, arg));
+                break;
+            case "--restore-experience":
+                restoreExperience = true;
+                break;
+            case "--no-restore-experience":
+                restoreExperience = false;
+                break;
             default:
                 throw new UsageError(`Unknown argument: ${arg}\n\n${USAGE}`);
         }
@@ -253,7 +293,9 @@ export function parseArgs(argv) {
         supportState,
         provenance,
         ...(tabId === undefined ? {} : { tabId }),
-        ifMissing
+        ifMissing,
+        ...(experience === undefined ? {} : { experience }),
+        restoreExperience
     };
 }
 async function readDocumentLocale(page) {
@@ -289,6 +331,11 @@ function parseSupportState(value) {
     }
     throw new UsageError(`Invalid --support-state: ${value}`);
 }
+function parseExperience(value) {
+    if (value === "chat" || value === "work")
+        return value;
+    throw new UsageError("--experience must be chat or work.");
+}
 function parseIfMissing(value) {
     if (value === "block" || value === "open" || value === "create")
         return value;
@@ -299,6 +346,9 @@ function assertNormalizedSlug(value, flag) {
         throw new UsageError(`${flag} must be a normalized lowercase slug without private names.`);
     }
 }
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (typeof process !== "undefined"
+    && Array.isArray(process.argv)
+    && typeof process.argv[1] === "string"
+    && import.meta.url === `file://${process.argv[1]}`) {
     process.exitCode = await main();
 }

package/dist/src/scripts/live-smoke/scenarios.d.ts

@@ -1,3 +1,6 @@
+import type { AskReadData, CommandResult, ConfigurationInspectionData, ConfigurationSelection } from "../../types.js";
 import type { LiveSmokeScenario } from "./types.js";
 export declare const requiredScenarios: LiveSmokeScenario[];
 export declare const optionalScenarios: LiveSmokeScenario[];
+export declare function generatedFileAskCanProceed(result: CommandResult<AskReadData>): boolean;
+export declare function chatActiveSelection(inspection: ConfigurationInspectionData): ConfigurationSelection;

package/dist/src/scripts/live-smoke/scenarios.js

@@ -1,8 +1,8 @@
 import { mkdtemp, readFile, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { attachAskRead, attachFiles, askMessage, bootstrap, composeMessage, createChatGPT, copyResponse, downloadLatestAttachment, messageStatus, newThread, openThread, readLatest, runSequence, searchThreads, selectTool, setMode, submitMessage, twoTurnExchange, waitAndRead, waitForMessage } from "../../index.js";
-import { readAssistantGenerationState } from "../../dom/generation-state.js";
+import { attachAskRead, attachFiles, askMessage, bootstrap, composeMessage, createChatGPT, copyResponse, downloadLatestAttachment, messageStatus, newThread, openExperience, openThread, readLatest, runSequence, searchThreads, selectTool, setMode, stopGeneration, submitMessage, twoTurnExchange, waitAndRead, waitForMessage } from "../../index.js";
+import { EMPTY_GENERATION_STATE, readAssistantGenerationState } from "../../dom/generation-state.js";
 import { contextEnvFlag, contextEnvText } from "./harness.js";
 export const requiredScenarios = [
     scenario("bootstrap-new-tab", true, () => true, async (context, meta) => {
@@ -122,6 +122,163 @@ export const requiredScenarios = [
             ? pass(meta, result)
             : fail(meta, result, { uploadRemediation });
     }),
+    scenario("chat-work-expansion", true, () => true, async (context, meta) => {
+        const chatgpt = createChatGPT(clientOptionsFor(context));
+        const details = {};
+        let booted = false;
+        let terminal = syntheticCommand(meta.startedAt);
+        let failure;
+        try {
+            const boot = await chatgpt.session.bootstrap({ preferExistingTab: false, timeoutMs: 60000 });
+            terminal = asCommand(boot);
+            requireLiveCommand("session.bootstrap", boot);
+            booted = true;
+            const openedChat = await chatgpt.experience.open({ experience: "chat", timeoutMs: 60000 });
+            terminal = asCommand(openedChat);
+            requireLiveCommand("experience.open.chat", openedChat, openedChat.ok && openedChat.data?.experience === "chat");
+            const chatConfiguration = await chatgpt.configuration.inspect({
+                experience: "chat",
+                includeOptions: true,
+                timeoutMs: 60000
+            });
+            terminal = asCommand(chatConfiguration);
+            requireLiveCommand("configuration.inspect.chat", chatConfiguration, chatConfiguration.ok
+                && chatConfiguration.data?.experience === "chat"
+                && chatConfiguration.data.verified === true);
+            const chatDesired = chatActiveSelection(chatConfiguration.data);
+            requireLiveCommand("configuration.inspect.chat.active", chatConfiguration, Object.keys(chatDesired).length > 0);
+            const verifiedChatConfiguration = await chatgpt.configuration.apply({
+                experience: "chat",
+                desired: chatDesired,
+                strict: true,
+                timeoutMs: 60000
+            });
+            terminal = asCommand(verifiedChatConfiguration);
+            requireLiveCommand("configuration.apply.chat.noop", verifiedChatConfiguration, verifiedChatConfiguration.ok && verifiedChatConfiguration.data?.verified === true);
+            const openedWork = await chatgpt.experience.open({ experience: "work", timeoutMs: 60000 });
+            terminal = asCommand(openedWork);
+            requireLiveCommand("experience.open.work", openedWork, openedWork.ok && openedWork.data?.experience === "work");
+            const workConfiguration = await chatgpt.configuration.inspect({
+                experience: "work",
+                includeOptions: true,
+                timeoutMs: 60000
+            });
+            terminal = asCommand(workConfiguration);
+            requireLiveCommand("configuration.inspect.work", workConfiguration, workConfiguration.ok
+                && workConfiguration.data?.experience === "work"
+                && workConfiguration.data.verified === true
+                && hasAxes(workConfiguration.data, ["model", "effort", "speed"]));
+            const workDesired = activeSelection(workConfiguration.data, ["model", "effort", "speed"]);
+            requireLiveCommand("configuration.inspect.work.active", workConfiguration, hasSelectionAxes(workDesired, ["model", "effort", "speed"]));
+            const verifiedWorkConfiguration = await chatgpt.configuration.apply({
+                experience: "work",
+                desired: workDesired,
+                strict: true,
+                timeoutMs: 60000
+            });
+            terminal = asCommand(verifiedWorkConfiguration);
+            requireLiveCommand("configuration.apply.work.noop", verifiedWorkConfiguration, verifiedWorkConfiguration.ok && verifiedWorkConfiguration.data?.verified === true);
+            const started = await chatgpt.work.start({
+                prompt: "Reply with exactly WORK_EXPANSION_START_OK.",
+                newTask: true,
+                wait: { timeoutMs: 180000, stableMs: 1500, pollMs: 750 },
+                read: { format: "normalized_text" },
+                timeoutMs: 60000
+            });
+            terminal = asCommand(started);
+            const startedText = started.data?.response?.text ?? started.output_text;
+            requireLiveCommand("work.start", started, started.ok && textEquals(startedText, "WORK_EXPANSION_START_OK"));
+            const status = await chatgpt.work.status({ includeArtifacts: true, maxPreviewChars: 200 });
+            terminal = asCommand(status);
+            requireLiveCommand("work.status", status, status.ok && status.data?.experience === "work");
+            const waited = await chatgpt.work.wait({
+                timeoutMs: 30000,
+                stableMs: 1000,
+                pollMs: 500,
+                responseContent: "metadata"
+            });
+            terminal = asCommand(waited);
+            requireLiveCommand("work.wait", waited, waited.ok && waited.data?.complete === true);
+            const read = await chatgpt.work.readLatest({ format: "normalized_text" });
+            terminal = asCommand(read);
+            requireLiveCommand("work.readLatest", read, read.ok && textEquals(read.data?.text, "WORK_EXPANSION_START_OK"));
+            const artifacts = await chatgpt.work.artifacts.listLatest({});
+            terminal = asCommand(artifacts);
+            requireLiveCommand("work.artifacts.listLatest", artifacts, artifacts.ok);
+            const steered = await chatgpt.work.steer({
+                prompt: "Reply with exactly WORK_EXPANSION_STEER_OK.",
+                wait: { timeoutMs: 180000, stableMs: 1500, pollMs: 750 },
+                read: { format: "normalized_text" },
+                timeoutMs: 60000
+            });
+            terminal = asCommand(steered);
+            requireLiveCommand("work.steer", steered, steered.ok && textEquals(okText(steered), "WORK_EXPANSION_STEER_OK"));
+            const workAgent = chatgpt.agent({
+                name: "live-smoke-work-runner",
+                defaults: {
+                    wait: { timeoutMs: 180000, stableMs: 1500, pollMs: 750 },
+                    read: { format: "normalized_text" }
+                }
+            });
+            const runner = await chatgpt.runner.run(workAgent, {
+                input: "Reply with exactly WORK_EXPANSION_RUNNER_OK.",
+                thread: { type: "current" },
+                experience: "work",
+                configuration: workDesired,
+                response: { format: "normalized_text" }
+            });
+            terminal = asCommand(runner);
+            requireLiveCommand("runner.run.work", runner, runner.ok && textEquals(runner.output_text, "WORK_EXPANSION_RUNNER_OK"));
+            const response = await chatgpt.responses.create({
+                input: "Reply with exactly WORK_EXPANSION_RESPONSES_OK.",
+                thread: { type: "current" },
+                experience: "work",
+                configuration: workDesired,
+                text: { format: "normalized_text" },
+                stream: false
+            });
+            const responseResult = responseCommand(response);
+            terminal = responseResult;
+            requireLiveCommand("responses.create.work", responseResult, response.object === "chatgpt.browser.response"
+                && response.status === "ok"
+                && textEquals(response.output_text, "WORK_EXPANSION_RESPONSES_OK"));
+            details.chat = configurationDetails(chatConfiguration.data);
+            details.work = configurationDetails(workConfiguration.data);
+            details.workLifecycle = {
+                start: true,
+                status: true,
+                wait: true,
+                read: true,
+                steer: true,
+                artifacts: true,
+                runner: true,
+                responses: true
+            };
+        }
+        catch (error) {
+            if (error instanceof LiveSmokeCommandFailure) {
+                failure = error;
+            }
+            else {
+                throw error;
+            }
+        }
+        finally {
+            if (booted) {
+                const restored = await chatgpt.experience.open({ experience: "chat", timeoutMs: 60000 });
+                terminal = asCommand(restored);
+                if (!restored.ok || restored.data?.experience !== "chat") {
+                    failure = new LiveSmokeCommandFailure("experience.restore.chat", asCommand(restored));
+                }
+                else {
+                    details.restoredExperience = "chat";
+                }
+            }
+        }
+        return failure === undefined
+            ? pass(meta, terminal, details)
+            : fail(meta, failure.command, { ...details, failedStage: failure.stage });
+    }),
     scenario("redacted-run-report", true, () => true, async (context, meta) => {
         const chatgpt = createChatGPT(clientOptionsFor(context));
         const command = {
@@ -448,6 +605,84 @@ export const requiredScenarios = [
     })
 ];
 export const optionalScenarios = [
+    scenario("configuration-mutate-restore", false, context => contextEnvFlag(context, "CHATGPT_E2E_CONFIGURATION_MUTATION"), async (context, meta) => {
+        const chatgpt = createChatGPT(clientOptionsFor(context));
+        const details = {};
+        let booted = false;
+        let restoreNeeded = false;
+        let originalEffort;
+        let terminal = syntheticCommand(meta.startedAt);
+        let failure;
+        try {
+            const boot = await chatgpt.session.bootstrap({ preferExistingTab: false, timeoutMs: 60000 });
+            terminal = asCommand(boot);
+            requireLiveCommand("session.bootstrap", boot);
+            booted = true;
+            const opened = await chatgpt.experience.open({ experience: "work", timeoutMs: 60000 });
+            terminal = asCommand(opened);
+            requireLiveCommand("experience.open.work", opened, opened.ok && opened.data?.experience === "work");
+            const inspected = await chatgpt.configuration.inspect({
+                experience: "work",
+                includeOptions: true,
+                timeoutMs: 60000
+            });
+            terminal = asCommand(inspected);
+            requireLiveCommand("configuration.inspect.work", inspected, inspected.ok && inspected.data?.verified === true);
+            originalEffort = inspected.data?.active.effort;
+            const alternative = inspected.data?.options.effort?.find(option => !option.selected && option.disabled !== true)?.label;
+            requireLiveCommand("configuration.inspect.work.alternative", inspected, originalEffort !== undefined && alternative !== undefined);
+            restoreNeeded = true;
+            const changed = await chatgpt.configuration.apply({
+                experience: "work",
+                desired: { effort: alternative },
+                strict: true,
+                timeoutMs: 60000
+            });
+            terminal = asCommand(changed);
+            requireLiveCommand("configuration.apply.work.mutate", changed, changed.ok && changed.data?.verified === true);
+            details.axis = "effort";
+            details.changedFrom = originalEffort;
+            details.changedTo = alternative;
+        }
+        catch (error) {
+            if (error instanceof LiveSmokeCommandFailure) {
+                failure = error;
+            }
+            else {
+                throw error;
+            }
+        }
+        finally {
+            if (booted && restoreNeeded && originalEffort !== undefined) {
+                const restoredConfiguration = await chatgpt.configuration.apply({
+                    experience: "work",
+                    desired: { effort: originalEffort },
+                    strict: true,
+                    timeoutMs: 60000
+                });
+                terminal = asCommand(restoredConfiguration);
+                if (!restoredConfiguration.ok || restoredConfiguration.data?.verified !== true) {
+                    failure = new LiveSmokeCommandFailure("configuration.restore.work", asCommand(restoredConfiguration));
+                }
+                else {
+                    details.configurationRestored = true;
+                }
+            }
+            if (booted) {
+                const restoredExperience = await chatgpt.experience.open({ experience: "chat", timeoutMs: 60000 });
+                terminal = asCommand(restoredExperience);
+                if (!restoredExperience.ok || restoredExperience.data?.experience !== "chat") {
+                    failure = new LiveSmokeCommandFailure("experience.restore.chat", asCommand(restoredExperience));
+                }
+                else {
+                    details.restoredExperience = "chat";
+                }
+            }
+        }
+        return failure === undefined
+            ? pass(meta, terminal, details)
+            : fail(meta, failure.command, { ...details, failedStage: failure.stage });
+    }),
     scenario("long-response-partial-short-timeout", false, context => contextEnvFlag(context, "CHATGPT_E2E_LONG_PARTIAL"), async (context, meta) => {
         const env = await bootNewThread(context, meta);
         if ("status" in env)
@@ -533,17 +768,35 @@ export const optionalScenarios = [
         const env = await bootNewThread(context, meta);
         if ("status" in env)
             return env;
+        const chat = await openExperience(env, { experience: "chat", timeoutMs: 60000 });
+        if (!chat.ok || chat.data?.experience !== "chat") {
+            return fail(meta, chat, { failedStage: "experience.open.chat" });
+        }
         const asked = await askMessage(env, {
             text: "Create a tiny CSV file named chatgpt-live-smoke.csv containing one row with columns name,value and values smoke,1. Provide it as a downloadable file.",
             wait: { timeoutMs: 180000, stableMs: 3000 },
             read: true
         });
-        if (!asked.ok)
+        if (!generatedFileAskCanProceed(asked))
             return fail(meta, asked);
-        const result = await downloadLatestAttachment({ destDir: context.reportDir, timeoutMs: 120000 }, env);
-        const path = typeof result.data === "object" && result.data !== null ? result.data.path : undefined;
+        const result = await downloadLatestAttachment({
+            destDir: context.reportDir,
+            filenamePattern: "^chatgpt-live-smoke\\.csv$",
+            timeoutMs: 120000
+        }, env);
+        const download = typeof result.data === "object" && result.data !== null
+            ? result.data
+            : undefined;
+        const path = download?.path;
         const bytes = path === undefined ? 0 : (await stat(path).catch(() => undefined))?.size ?? 0;
-        return result.ok && bytes > 0 ? pass(meta, result, { path, bytes }) : fail(meta, result, { path, bytes });
+        const content = path === undefined ? "" : await readFile(path, "utf8").catch(() => "");
+        const rows = content.replace(/^\uFEFF/, "").trim().split(/\r?\n/).map(row => row.trim());
+        const exactFile = download?.suggestedFilename === "chatgpt-live-smoke.csv";
+        const exactContent = rows[0] === "name,value" && rows[1] === "smoke,1" && rows.length === 2;
+        const details = { path, bytes, suggestedFilename: download?.suggestedFilename, exactFile, exactContent, askStatus: asked.status };
+        return result.ok && bytes > 0 && exactFile && exactContent
+            ? pass(meta, result, details)
+            : fail(meta, result, details);
     }),
     scenario("set-mode-visible", false, context => contextEnvText(context, "CHATGPT_E2E_MODE_LABEL") !== undefined, async (context, meta) => {
         const label = requireInput(contextEnvText(context, "CHATGPT_E2E_MODE_LABEL"), "CHATGPT_E2E_MODE_LABEL");
@@ -606,6 +859,10 @@ export const optionalScenarios = [
             : fail(meta, result, { events });
     })
 ];
+export function generatedFileAskCanProceed(result) {
+    return result.ok
+        || (result.status === "partial" && result.data?.generationActive !== true);
+}
 function scenario(name, required, enabled, run) {
     return {
         name,
@@ -722,6 +979,61 @@ function responseCommand(response) {
         context: { timestamp: new Date(response.created_at * 1000).toISOString() }
     };
 }
+class LiveSmokeCommandFailure extends Error {
+    stage;
+    command;
+    constructor(stage, command) {
+        super(`Live smoke command failed at ${stage}`);
+        this.stage = stage;
+        this.command = command;
+        this.name = "LiveSmokeCommandFailure";
+    }
+}
+function requireLiveCommand(stage, command, condition = command.ok) {
+    if (!condition) {
+        throw new LiveSmokeCommandFailure(stage, asCommand(command));
+    }
+}
+function asCommand(command) {
+    return command;
+}
+function syntheticCommand(timestamp) {
+    return {
+        ok: true,
+        status: "ok",
+        warnings: [],
+        context: { timestamp }
+    };
+}
+function activeSelection(inspection, axes) {
+    const selection = {};
+    for (const axis of axes) {
+        const value = inspection.active[axis];
+        if (value !== undefined) {
+            selection[axis] = value;
+        }
+    }
+    return selection;
+}
+export function chatActiveSelection(inspection) {
+    return activeSelection(inspection, ["intelligence", "model", "modelVersion", "effort"]);
+}
+function hasAxes(inspection, axes) {
+    return axes.every(axis => inspection.availableAxes.includes(axis));
+}
+function hasSelectionAxes(selection, axes) {
+    return axes.every(axis => selection[axis] !== undefined);
+}
+function configurationDetails(inspection) {
+    return {
+        experience: inspection.experience,
+        selectorProfile: inspection.selectorProfile,
+        verified: inspection.verified,
+        availableAxes: inspection.availableAxes,
+        active: inspection.active,
+        optionCounts: Object.fromEntries(Object.entries(inspection.options).map(([axis, options]) => [axis, options?.length ?? 0]))
+    };
+}
 function partialCaptureDetails(result, output) {
     return {
         resultStatus: result.status,
@@ -734,21 +1046,17 @@ async function waitForGenerationSignal(env, timeoutMs) {
     const started = Date.now();
     while (Date.now() - started < timeoutMs) {
         if (env.page !== undefined) {
-            const state = await readAssistantGenerationState(env.page).catch(() => ({ active: false, stopped: false, signals: [] }));
+            const state = await readAssistantGenerationState(env.page).catch(() => EMPTY_GENERATION_STATE);
             if (state.active || state.stopped) {
                 return state;
             }
         }
         await env.page?.waitForTimeout?.(500);
     }
-    return { active: false, stopped: false, signals: [] };
+    return EMPTY_GENERATION_STATE;
 }
 async function stopGenerationIfVisible(env) {
-    const stop = env.page?.getByRole?.("button", { name: /Stop answering|Stop generating|Stop streaming|Cancel/i });
-    const clicked = stop?.click?.({ timeoutMs: 5000 });
-    if (clicked !== undefined) {
-        await clicked.catch(() => undefined);
-    }
+    await stopGeneration(env, { confirmStop: true, timeoutMs: 5_000 }).catch(() => undefined);
 }
 function hashPreview(text) {
     let hash = 0;

package/dist/src/scripts/live-smoke.js

@@ -39,6 +39,7 @@ else {
         context.knownConversationId = knownConversationId;
     }
     context.env = {
+        CHATGPT_E2E_CONFIGURATION_MUTATION: envText("CHATGPT_E2E_CONFIGURATION_MUTATION"),
         CHATGPT_E2E_CREATE_IMAGE: envText("CHATGPT_E2E_CREATE_IMAGE"),
         CHATGPT_E2E_DEEP_RESEARCH: envText("CHATGPT_E2E_DEEP_RESEARCH"),
         CHATGPT_E2E_DOWNLOAD: envText("CHATGPT_E2E_DOWNLOAD"),

package/dist/src/scripts/locale-capture/surface-graph.d.ts

@@ -0,0 +1,31 @@
+export type RawSurfaceOption = {
+    label: string;
+    checked: boolean;
+};
+export type RawConfigurationRow = {
+    label: string;
+    axisLabel: string;
+    valueLabel?: string;
+    options: Array<{
+        label: string;
+        checked: boolean;
+    }>;
+};
+export type RawWorkConfigurationRow = RawConfigurationRow;
+export type CapturedChatConfigurationRow = RawConfigurationRow & {
+    axis: "model" | "effort";
+};
+export type CapturedWorkConfigurationRow = RawConfigurationRow & {
+    axis: "model" | "effort" | "speed";
+};
+export declare function assignChatSelectedSurfaceOptions(options: readonly RawSurfaceOption[]): {
+    chatLabel: string;
+    workLabel: string;
+};
+export declare function assignOrderedSurfaceOptions(options: readonly RawSurfaceOption[]): {
+    chatLabel: string;
+    workLabel: string;
+    selected: "chat" | "work";
+};
+export declare function assignOrderedWorkConfigurationRows(rows: readonly RawWorkConfigurationRow[]): CapturedWorkConfigurationRow[];
+export declare function assignOrderedChatConfigurationRows(rows: readonly RawConfigurationRow[]): CapturedChatConfigurationRow[];

package/dist/src/scripts/locale-capture/surface-graph.js

@@ -0,0 +1,50 @@
+export function assignChatSelectedSurfaceOptions(options) {
+    const unique = dedupeByLabel(options.filter(option => option.label.trim().length > 0));
+    const selected = unique.filter(option => option.checked);
+    const unselected = unique.filter(option => !option.checked);
+    if (unique.length !== 2 || selected.length !== 1 || unselected.length !== 1) {
+        throw new Error(`Expected one selected Chat radio and one unselected Work radio; observed ${unique.length} options.`);
+    }
+    return {
+        chatLabel: selected[0].label,
+        workLabel: unselected[0].label
+    };
+}
+export function assignOrderedSurfaceOptions(options) {
+    const unique = dedupeByLabel(options.filter(option => option.label.trim().length > 0));
+    const selected = unique.filter(option => option.checked);
+    if (unique.length !== 2 || selected.length !== 1) {
+        throw new Error(`Expected ordered Chat and Work radios with one selected option; observed ${unique.length} options.`);
+    }
+    return {
+        chatLabel: unique[0].label,
+        workLabel: unique[1].label,
+        selected: unique[0].checked ? "chat" : "work"
+    };
+}
+export function assignOrderedWorkConfigurationRows(rows) {
+    if (rows.length !== 3) {
+        throw new Error(`Expected three ordered Work configuration rows; observed ${rows.length}.`);
+    }
+    const axes = ["model", "effort", "speed"];
+    return rows.map((row, index) => ({ ...row, axis: axes[index] }));
+}
+export function assignOrderedChatConfigurationRows(rows) {
+    if (rows.length !== 2) {
+        throw new Error(`Expected two ordered Chat configuration rows; observed ${rows.length}.`);
+    }
+    const axes = ["model", "effort"];
+    return rows.map((row, index) => ({ ...row, axis: axes[index] }));
+}
+function dedupeByLabel(options) {
+    const seen = new Set();
+    const result = [];
+    for (const option of options) {
+        const key = option.label.replace(/\s+/g, " ").trim().toLocaleLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push({ label: option.label.replace(/\s+/g, " ").trim(), checked: option.checked });
+    }
+    return result;
+}