codex-chatgpt-control 0.5.1-alpha.2 → 0.5.1-alpha.4

package/dist/src/runtime/value-boundaries.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Accept genuine one-byte typed-array views across JavaScript realms.
+ *
+ * `instanceof Uint8Array` is realm-sensitive. `ArrayBuffer.isView` checks the
+ * internal view slot across realms; the one-byte width and length relation
+ * then exclude DataView and wider typed arrays without trusting a type tag.
+ */
+export declare function isByteArrayView(value: unknown): value is Uint8Array;
+/**
+ * Accept descriptor-safe plain records across JavaScript realms.
+ *
+ * Comparing a prototype directly with this realm's `Object.prototype`
+ * rejects ordinary objects returned by a VM or browser bridge. A foreign
+ * intrinsic Object prototype is still a direct child of `null`; custom class
+ * instances have at least one additional layer. Only own data descriptors
+ * are accepted, so getters are never invoked by the boundary.
+ */
+export declare function isPlainDataRecord(value: unknown): value is Record<string, unknown>;

package/dist/src/runtime/value-boundaries.js

@@ -0,0 +1,49 @@
+/**
+ * Accept genuine one-byte typed-array views across JavaScript realms.
+ *
+ * `instanceof Uint8Array` is realm-sensitive. `ArrayBuffer.isView` checks the
+ * internal view slot across realms; the one-byte width and length relation
+ * then exclude DataView and wider typed arrays without trusting a type tag.
+ */
+export function isByteArrayView(value) {
+    if (!ArrayBuffer.isView(value))
+        return false;
+    try {
+        const view = value;
+        return view.BYTES_PER_ELEMENT === 1
+            && Number.isSafeInteger(view.length)
+            && view.length === view.byteLength;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Accept descriptor-safe plain records across JavaScript realms.
+ *
+ * Comparing a prototype directly with this realm's `Object.prototype`
+ * rejects ordinary objects returned by a VM or browser bridge. A foreign
+ * intrinsic Object prototype is still a direct child of `null`; custom class
+ * instances have at least one additional layer. Only own data descriptors
+ * are accepted, so getters are never invoked by the boundary.
+ */
+export function isPlainDataRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    try {
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== null
+            && prototype !== Object.prototype
+            && Object.getPrototypeOf(prototype) !== null) {
+            return false;
+        }
+        for (const descriptor of Object.values(Object.getOwnPropertyDescriptors(value))) {
+            if (!("value" in descriptor) || descriptor.get !== undefined || descriptor.set !== undefined)
+                return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/safety/blockers.js

@@ -45,7 +45,14 @@ export function classifyVisibleText(text) {
     const visibleText = compactVisibleText(text);
     const lowerable = visibleText.length > 0 ? visibleText : text;
     for (const rule of RULES) {
-        if (rule.patterns.some(pattern => pattern.test(lowerable))) {
+        // The Work effort picker describes higher effort with this informational
+        // copy. It is not an exhausted quota, even on an otherwise empty page.
+        // Inspect the full rate-limit text so stripping this copy cannot hide a
+        // real notice later in the same surface behind the display-text truncation.
+        const candidate = rule.kind === "rate_limit"
+            ? text.replace(/\bConsumes\s+usage\s+limits\s+faster\b/gi, "")
+            : lowerable;
+        if (rule.patterns.some(pattern => pattern.test(candidate))) {
             return { kind: rule.kind, message: rule.message, visibleText };
         }
     }

package/dist/src/safety/untrusted-output.js

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { link, mkdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
+import { nodeErrorCode } from "../errors.js";
 export const UNTRUSTED_OUTPUT_INLINE_LIMIT_BYTES = 12_000;
 export const UNTRUSTED_OUTPUT_SCHEMA_VERSION = "chatgpt.browser_control.untrusted_output_return.v1";
 export const INTEGRITY_SCHEMA_VERSION = "chatgpt.browser_control.integrity.v1";
@@ -195,5 +196,5 @@ function isNotFoundError(error) {
     return isNodeError(error) && error.code === "ENOENT";
 }
 function isNodeError(error) {
-    return error instanceof Error && "code" in error;
+    return nodeErrorCode(error) !== undefined;
 }

package/dist/src/scripts/backend-server.js

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
 import { runBackendStdioServer } from "../backend/stdio-server.js";
+import { detectPackagedBackendIdentity } from "../backend/runtime-identity.js";
+const backendIdentity = await detectPackagedBackendIdentity(import.meta.url);
 await runBackendStdioServer({
     input: process.stdin,
     output: process.stdout,
-    error: process.stderr
+    error: process.stderr,
+    backendIdentity
 });

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

@@ -281,10 +281,15 @@ export function parseArgs(argv) {
     })) {
         assertNormalizedSlug(value, `--${field.replace(/[A-Z]/g, letter => `-${letter.toLowerCase()}`)}`);
     }
-    const defaultOut = resolve(process.cwd(), "..", "..", "outputs", "surface-profiles", `${new Date().toISOString().slice(0, 10)}-${id}.json`);
+    if (out === undefined && typeof process === "undefined") {
+        throw new UsageError("--out is required in a browser host without a working directory.");
+    }
+    const outputPath = out === undefined
+        ? resolve(process.cwd(), "..", "..", "outputs", "surface-profiles", `${new Date().toISOString().slice(0, 10)}-${id}.json`)
+        : resolve(out);
     return {
         id,
-        out: resolve(out ?? defaultOut),
+        out: outputPath,
         ...(locale === undefined ? {} : { locale }),
         region,
         accountScope,

package/dist/src/scripts/journal-server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/scripts/journal-server.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { startJournalRpcServer } from "../operations/journal-rpc-server.js";
+async function main() {
+    const args = process.argv.slice(2);
+    let stateRoot;
+    let directory;
+    for (let index = 0; index < args.length; index += 2) {
+        const option = args[index];
+        const value = args[index + 1];
+        if (value === undefined || (option !== "--state-root" && option !== "--directory"))
+            throw new Error();
+        if (option === "--state-root") {
+            if (stateRoot !== undefined)
+                throw new Error();
+            stateRoot = value;
+        }
+        else {
+            if (directory !== undefined)
+                throw new Error();
+            directory = value;
+        }
+    }
+    if (stateRoot === undefined || directory === undefined)
+        throw new Error();
+    const server = await startJournalRpcServer({ stateRoot, directory });
+    // The private descriptor contains authentication material. It is never printed.
+    process.stdout.write(`${JSON.stringify({ status: "ready", transport: "file" })}\n`);
+    const stop = () => {
+        void server.close().then(() => { process.exitCode = 0; }, () => { process.exitCode = 2; });
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+}
+void main().catch(() => {
+    process.stderr.write("Journal authority startup failed. Supply absolute --state-root and a new private --directory.\n");
+    process.exitCode = 2;
+});

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

@@ -1,5 +1,6 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import { tabIdFromPage } from "../../browser/attach.js";
 import { redactReportValue } from "../../safety/report-redaction.js";
 const CLEANUP_TIMEOUT_MS = 10_000;
 export function envFlag(name) {
@@ -24,6 +25,7 @@ function readEnv(name) {
 export async function runScenario(scenario, context) {
     const startedAt = new Date().toISOString();
     const startedMs = Date.now();
+    const tabBaseline = await snapshotBrowserTabIds(context.browser);
     let result;
     if (!scenario.enabled(context)) {
         result = {
@@ -55,7 +57,7 @@ export async function runScenario(scenario, context) {
             };
         }
     }
-    const cleanup = await finalizeBrowserTabs(context.browser);
+    const cleanup = await finalizeBrowserTabs(context.cleanupBrowser ?? context.browser, context.browser, tabBaseline);
     return { ...result, cleanup };
 }
 export async function runLiveSmoke(context, scenarios) {
@@ -108,19 +110,89 @@ export function filterScenarios(scenarios, namesCsv) {
         .filter(Boolean));
     return scenarios.filter(scenario => wanted.has(scenario.name));
 }
-async function finalizeBrowserTabs(browser) {
-    const tabs = browser?.tabs;
-    const finalize = tabs?.finalize;
+async function finalizeBrowserTabs(finalizerBrowser, behaviorBrowser, baseline) {
+    const finalizerTabs = finalizerBrowser?.tabs;
+    const finalize = finalizerTabs?.finalize;
     if (typeof finalize !== "function") {
+        return closeNewExactTabs(behaviorBrowser, baseline);
+    }
+    try {
+        await withTimeout(finalize.call(finalizerTabs, { keep: [] }), CLEANUP_TIMEOUT_MS, `browser.tabs.finalize timed out after ${CLEANUP_TIMEOUT_MS}ms`);
+        return { attempted: true, ok: true };
+    }
+    catch (error) {
+        return {
+            attempted: true,
+            ok: false,
+            error: {
+                name: error instanceof Error ? error.name : "Error",
+                message: error instanceof Error ? error.message : String(error)
+            }
+        };
+    }
+}
+async function snapshotBrowserTabIds(browser) {
+    const tabs = browser?.tabs;
+    const list = tabs?.list;
+    if (tabs === undefined || typeof list !== "function") {
+        return { ok: false, reason: "browser.tabs.list unavailable" };
+    }
+    try {
+        const pages = await list.call(tabs);
+        const ids = new Set();
+        for (const page of pages) {
+            const id = tabIdFromPage(page);
+            if (id === undefined) {
+                return { ok: false, reason: "browser.tabs.list returned a tab without an exact id" };
+            }
+            ids.add(id);
+        }
+        return { ok: true, ids };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: `browser.tabs.list failed: ${error instanceof Error ? error.message : String(error)}`
+        };
+    }
+}
+async function closeNewExactTabs(browser, baseline) {
+    if (!baseline.ok) {
+        return { attempted: false, ok: false, reason: baseline.reason };
+    }
+    const tabs = browser?.tabs;
+    const list = tabs?.list;
+    const get = tabs?.get;
+    if (tabs === undefined || typeof list !== "function" || typeof get !== "function") {
         return {
             attempted: false,
             ok: false,
-            reason: "browser.tabs.finalize unavailable"
+            reason: "browser.tabs.finalize unavailable and exact tabs.list/get cleanup is unavailable"
         };
     }
     try {
-        await withTimeout(finalize.call(tabs, { keep: [] }), CLEANUP_TIMEOUT_MS, `browser.tabs.finalize timed out after ${CLEANUP_TIMEOUT_MS}ms`);
-        return { attempted: true, ok: true };
+        const pages = await list.call(tabs);
+        const newTabIds = [];
+        for (const page of pages) {
+            const id = tabIdFromPage(page);
+            if (id === undefined) {
+                throw new Error("browser.tabs.list returned a tab without an exact id");
+            }
+            if (!baseline.ids.has(id) && !newTabIds.includes(id)) {
+                newTabIds.push(id);
+            }
+        }
+        for (const id of newTabIds) {
+            const page = await get.call(tabs, id);
+            if (tabIdFromPage(page) !== id) {
+                throw new Error(`browser.tabs.get did not preserve exact cleanup affinity for tab ${id}`);
+            }
+            if (typeof page.close !== "function") {
+                throw new Error(`browser tab ${id} does not expose close()`);
+            }
+            await withTimeout(Promise.resolve(page.close()), CLEANUP_TIMEOUT_MS, `browser tab ${id} close timed out after ${CLEANUP_TIMEOUT_MS}ms`);
+        }
+        return { attempted: true, ok: true, closedTabCount: newTabIds.length };
     }
     catch (error) {
         return {

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

@@ -1,6 +1,47 @@
-import type { AskReadData, CommandResult, ConfigurationInspectionData, ConfigurationSelection } from "../../types.js";
+import { createChatGPT } from "../../index.js";
+import type { AskReadData, CommandResult, ConfigurationAxis, ConfigurationInspectionData, ConfigurationSelection } from "../../types.js";
 import type { LiveSmokeScenario } from "./types.js";
+type WorkConfigurationCommands = Pick<ReturnType<typeof createChatGPT>["configuration"], "apply" | "inspect">;
+type ExperienceCommands = Pick<ReturnType<typeof createChatGPT>["experience"], "detect" | "open">;
+export type WorkConfigurationRestoreResult = {
+    command: CommandResult<unknown>;
+    verified: boolean;
+    attempts: number;
+    observedSelection?: ConfigurationSelection;
+};
+export type WorkEffortRestoreResult = {
+    command: CommandResult<unknown>;
+    verified: boolean;
+    attempts: number;
+    observedEffort?: string;
+};
+export type ChatExperienceRestoreResult = {
+    command: CommandResult<unknown>;
+    verified: boolean;
+    attempts: number;
+    observedExperience?: string;
+};
+export declare function restoreChatExperience(experience: ExperienceCommands, options?: {
+    attempts?: number;
+    delayMs?: number;
+    timeoutMs?: number;
+    sleep?: (milliseconds: number) => Promise<void>;
+}): Promise<ChatExperienceRestoreResult>;
+export declare function restoreWorkConfiguration(configuration: WorkConfigurationCommands, desired: ConfigurationSelection, options?: {
+    attempts?: number;
+    delayMs?: number;
+    timeoutMs?: number;
+    sleep?: (milliseconds: number) => Promise<void>;
+}): Promise<WorkConfigurationRestoreResult>;
+export declare function restoreWorkEffort(configuration: WorkConfigurationCommands, effort: string, options?: Parameters<typeof restoreWorkConfiguration>[2]): Promise<WorkEffortRestoreResult>;
+/** Prefer the smallest observed setting change; never invent an effort label. */
+export declare function workMutationCandidate(inspection: ConfigurationInspectionData): {
+    axis: ConfigurationAxis;
+    original: string;
+    alternative: string;
+} | undefined;
 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;
+export {};

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

@@ -1,9 +1,113 @@
 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, openExperience, openThread, readLatest, runSequence, searchThreads, selectTool, setMode, stopGeneration, submitMessage, twoTurnExchange, waitAndRead, waitForMessage } from "../../index.js";
+import { attachAskRead, attachFiles, configurationMatchesSelection, askMessage, bootstrap, composeMessage, createChatGPT, copyResponse, detectExperience, 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";
+import { transactionalSubmitOnceScenario } from "./transactional.js";
+export async function restoreChatExperience(experience, options = {}) {
+    const attempts = Math.max(1, Math.min(5, options.attempts ?? 3));
+    const delayMs = Math.max(0, Math.min(5000, options.delayMs ?? 750));
+    const timeoutMs = Math.max(1000, Math.min(120000, options.timeoutMs ?? 60000));
+    const sleep = options.sleep ?? (async (milliseconds) => {
+        await new Promise(resolve => setTimeout(resolve, milliseconds));
+    });
+    let terminal;
+    let observedExperience;
+    for (let attempt = 1; attempt <= attempts; attempt += 1) {
+        const detectedBefore = await experience.detect({ timeoutMs });
+        terminal = asCommand(detectedBefore);
+        observedExperience = detectedBefore.data?.experience;
+        if (detectedBefore.ok && observedExperience === "chat") {
+            return { command: terminal, verified: true, attempts: attempt, observedExperience };
+        }
+        const opened = await experience.open({ experience: "chat", timeoutMs });
+        terminal = asCommand(opened);
+        if (opened.ok && opened.data?.experience === "chat") {
+            const detectedAfter = await experience.detect({ timeoutMs });
+            terminal = asCommand(detectedAfter);
+            observedExperience = detectedAfter.data?.experience;
+            if (detectedAfter.ok && observedExperience === "chat") {
+                return { command: terminal, verified: true, attempts: attempt, observedExperience };
+            }
+        }
+        if (attempt < attempts) {
+            await sleep(delayMs);
+        }
+    }
+    return {
+        command: terminal,
+        verified: false,
+        attempts,
+        ...(observedExperience === undefined ? {} : { observedExperience })
+    };
+}
+export async function restoreWorkConfiguration(configuration, desired, options = {}) {
+    const attempts = Math.max(1, Math.min(5, options.attempts ?? 3));
+    const delayMs = Math.max(0, Math.min(5000, options.delayMs ?? 750));
+    const timeoutMs = Math.max(1000, Math.min(120000, options.timeoutMs ?? 60000));
+    const sleep = options.sleep ?? (async (milliseconds) => {
+        await new Promise(resolve => setTimeout(resolve, milliseconds));
+    });
+    let terminal;
+    let observedSelection;
+    for (let attempt = 1; attempt <= attempts; attempt += 1) {
+        const applied = await configuration.apply({
+            experience: "work",
+            desired,
+            strict: true,
+            timeoutMs
+        });
+        terminal = asCommand(applied);
+        if (applied.ok && applied.data?.verified === true) {
+            const inspected = await configuration.inspect({
+                experience: "work",
+                includeOptions: false,
+                timeoutMs
+            });
+            terminal = asCommand(inspected);
+            observedSelection = inspected.data === undefined ? undefined : activeSelection(inspected.data, Object.keys(desired));
+            if (inspected.ok
+                && inspected.data !== undefined
+                && configurationMatchesSelection(inspected.data, desired)) {
+                return {
+                    command: terminal,
+                    verified: true,
+                    attempts: attempt,
+                    ...(observedSelection === undefined ? {} : { observedSelection })
+                };
+            }
+        }
+        if (attempt < attempts) {
+            await sleep(delayMs);
+        }
+    }
+    return {
+        command: terminal,
+        verified: false,
+        attempts,
+        ...(observedSelection === undefined ? {} : { observedSelection })
+    };
+}
+export async function restoreWorkEffort(configuration, effort, options = {}) {
+    const restored = await restoreWorkConfiguration(configuration, { effort }, options);
+    const observedEffort = restored.observedSelection?.effort;
+    return { command: restored.command, verified: restored.verified, attempts: restored.attempts,
+        ...(observedEffort === undefined ? {} : { observedEffort }) };
+}
+/** Prefer the smallest observed setting change; never invent an effort label. */
+export function workMutationCandidate(inspection) {
+    for (const axis of ["effort", "speed", "model"]) {
+        const original = inspection.active[axis];
+        if (original === undefined || !inspection.availableAxes.includes(axis))
+            continue;
+        const option = inspection.options[axis]?.find(option => option.selected !== true && option.disabled !== true
+            && !configurationMatchesSelection(inspection, { [axis]: option.label }));
+        if (option !== undefined)
+            return { axis, original, alternative: option.label };
+    }
+    return undefined;
+}
 export const requiredScenarios = [
     scenario("bootstrap-new-tab", true, () => true, async (context, meta) => {
         const env = envFor(context);
@@ -167,9 +271,10 @@ export const requiredScenarios = [
             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"]));
+                && hasAxes(workConfiguration.data, ["model", "effort"]));
+            const observedWorkAxes = ["model", "effort", "speed"].filter(axis => workConfiguration.data.availableAxes.includes(axis));
+            const workDesired = activeSelection(workConfiguration.data, observedWorkAxes);
+            requireLiveCommand("configuration.inspect.work.active", workConfiguration, hasSelectionAxes(workDesired, observedWorkAxes));
             const verifiedWorkConfiguration = await chatgpt.configuration.apply({
                 experience: "work",
                 desired: workDesired,
@@ -265,10 +370,11 @@ export const requiredScenarios = [
         }
         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));
+                const restored = await restoreChatExperience(chatgpt.experience);
+                terminal = restored.command;
+                details.experienceRestoreAttempts = restored.attempts;
+                if (!restored.verified) {
+                    failure = new LiveSmokeCommandFailure("experience.restore.chat", restored.command);
                 }
                 else {
                     details.restoredExperience = "chat";
@@ -605,12 +711,13 @@ export const requiredScenarios = [
     })
 ];
 export const optionalScenarios = [
+    transactionalSubmitOnceScenario,
     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 originalSelection;
         let terminal = syntheticCommand(meta.startedAt);
         let failure;
         try {
@@ -628,21 +735,24 @@ export const optionalScenarios = [
             });
             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);
+            const candidate = inspected.data === undefined ? undefined : workMutationCandidate(inspected.data);
+            originalSelection = inspected.data === undefined ? undefined : activeSelection(inspected.data, ["model", "effort", "speed"]);
+            requireLiveCommand("configuration.inspect.work.alternative", inspected, candidate !== undefined && originalSelection !== undefined);
             restoreNeeded = true;
             const changed = await chatgpt.configuration.apply({
                 experience: "work",
-                desired: { effort: alternative },
+                desired: { [candidate.axis]: candidate.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;
+            const observedChange = await chatgpt.configuration.inspect({ experience: "work", includeOptions: false, timeoutMs: 60000 });
+            terminal = asCommand(observedChange);
+            requireLiveCommand("configuration.inspect.work.changed", observedChange, observedChange.ok && observedChange.data !== undefined && configurationMatchesSelection(observedChange.data, { [candidate.axis]: candidate.alternative }));
+            details.axis = candidate.axis;
+            details.changedFrom = candidate.original;
+            details.changedTo = candidate.alternative;
         }
         catch (error) {
             if (error instanceof LiveSmokeCommandFailure) {
@@ -653,26 +763,26 @@ export const optionalScenarios = [
             }
         }
         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));
+            if (booted && restoreNeeded && originalSelection !== undefined) {
+                const restoredConfiguration = await restoreWorkConfiguration(chatgpt.configuration, originalSelection);
+                terminal = restoredConfiguration.command;
+                details.configurationRestoreAttempts = restoredConfiguration.attempts;
+                if (restoredConfiguration.observedSelection !== undefined) {
+                    details.restoredConfiguration = restoredConfiguration.observedSelection;
+                }
+                if (!restoredConfiguration.verified) {
+                    failure = new LiveSmokeCommandFailure("configuration.restore.work", restoredConfiguration.command);
                 }
                 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));
+                const restoredExperience = await restoreChatExperience(chatgpt.experience);
+                terminal = restoredExperience.command;
+                details.experienceRestoreAttempts = restoredExperience.attempts;
+                if (!restoredExperience.verified) {
+                    failure = new LiveSmokeCommandFailure("experience.restore.chat", restoredExperience.command);
                 }
                 else {
                     details.restoredExperience = "chat";
@@ -890,6 +1000,13 @@ async function bootNewThread(context, meta) {
     const env = await boot(context, meta);
     if ("status" in env)
         return env;
+    const chat = await restoreChatExperience({
+        detect: args => detectExperience(env, args),
+        open: args => openExperience(env, args)
+    });
+    if (!chat.verified) {
+        return fail(meta, chat.command, { failedStage: "experience.open.chat" });
+    }
     const created = await newThread(env);
     return created.ok ? env : fail(meta, created);
 }

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

@@ -0,0 +1,17 @@
+import { type ChatGPTClient } from "../../client.js";
+import type { LiveSmokeScenario } from "./types.js";
+type TransactionalSmokeClient = Pick<ChatGPTClient, "ask" | "operations" | "messages">;
+type TransactionalSmokeEvidence = {
+    passed: boolean;
+    details: Record<string, string | number | boolean>;
+};
+/**
+ * Explicit opt-in: one new synthetic conversation, zero attachments, and at
+ * most one Send. Uses the production runtime with an optional explicit journal service.
+ * An ambiguous submission permits one guarded, observation-only recovery.
+ * A completed receipt is required before the final same-identity replay.
+ */
+export declare const transactionalSubmitOnceScenario: LiveSmokeScenario;
+/** The injected client is solely a harness test seam; the live entrypoint uses the public production facade. */
+export declare function qualifyTransactionalSubmitOnce(chatgpt: TransactionalSmokeClient): Promise<TransactionalSmokeEvidence>;
+export {};