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

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/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/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,34 @@
+import { createChatGPT } from "../../index.js";
 import type { AskReadData, CommandResult, 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 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 restoreWorkEffort(configuration: WorkConfigurationCommands, effort: string, options?: {
+    attempts?: number;
+    delayMs?: number;
+    timeoutMs?: number;
+    sleep?: (milliseconds: number) => Promise<void>;
+}): Promise<WorkEffortRestoreResult>;
 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,93 @@
 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";
+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 restoreWorkEffort(configuration, effort, 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 observedEffort;
+    for (let attempt = 1; attempt <= attempts; attempt += 1) {
+        const applied = await configuration.apply({
+            experience: "work",
+            desired: { effort },
+            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);
+            observedEffort = inspected.data?.active.effort;
+            if (inspected.ok
+                && inspected.data !== undefined
+                && configurationMatchesSelection(inspected.data, { effort })) {
+                return {
+                    command: terminal,
+                    verified: true,
+                    attempts: attempt,
+                    ...(observedEffort === undefined ? {} : { observedEffort })
+                };
+            }
+        }
+        if (attempt < attempts) {
+            await sleep(delayMs);
+        }
+    }
+    return {
+        command: terminal,
+        verified: false,
+        attempts,
+        ...(observedEffort === undefined ? {} : { observedEffort })
+    };
+}
 export const requiredScenarios = [
     scenario("bootstrap-new-tab", true, () => true, async (context, meta) => {
         const env = envFor(context);
@@ -265,10 +349,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";
@@ -654,25 +739,25 @@ 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));
+                const restoredConfiguration = await restoreWorkEffort(chatgpt.configuration, originalEffort);
+                terminal = restoredConfiguration.command;
+                details.configurationRestoreAttempts = restoredConfiguration.attempts;
+                if (restoredConfiguration.observedEffort !== undefined) {
+                    details.restoredEffort = restoredConfiguration.observedEffort;
+                }
+                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 +975,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/types.d.ts

@@ -3,6 +3,7 @@ export type LiveSmokeStatus = "pass" | "fail" | "skip";
 export type LiveSmokeCleanupResult = {
     attempted: boolean;
     ok: boolean;
+    closedTabCount?: number;
     reason?: string;
     error?: {
         name: string;
@@ -34,6 +35,8 @@ export type LiveSmokeBrowser = BrowserLike & {
 export type LiveSmokeContext = {
     agent: unknown;
     browser?: LiveSmokeBrowser;
+    /** Optional tool-scoped browser that owns tab finalization but is not used for behavior. */
+    cleanupBrowser?: LiveSmokeBrowser;
     env?: Record<string, string | undefined>;
     reportDir: string;
     knownThreadQuery?: string;

package/dist/src/scripts/release-canary-module.js

@@ -1,5 +1,6 @@
 import { mkdir } from "node:fs/promises";
 import { join, resolve } from "node:path";
+import { resolveChatGPTBrowser } from "../browser/attach.js";
 import { main as captureSurfaceProfile } from "./capture-surface-profile.js";
 import { filterScenarios, runLiveSmoke } from "./live-smoke/harness.js";
 import { optionalScenarios, requiredScenarios } from "./live-smoke/scenarios.js";
@@ -15,6 +16,11 @@ export async function runReleaseCanary(runtime, options) {
     if (options.tabId.trim().length === 0) {
         throw new Error("runReleaseCanary requires an exact dedicated ChatGPT tab id.");
     }
+    // Acquire through the agent once so bridge capability proxies are normalized
+    // before coordination. Passing globalThis.browser back through RuntimeEnv
+    // bypasses that acquisition boundary and can lose user-open-tab visibility
+    // or private-field receiver bindings on Chrome bridge methods.
+    const managedBrowser = await resolveChatGPTBrowser({ agent: runtime.agent });
     const reportDir = resolve(options.reportDir ?? join(process.cwd(), "reports", "release-canary"));
     const profileDir = join(reportDir, "surface-profiles");
     await mkdir(profileDir, { recursive: true });
@@ -32,7 +38,7 @@ export async function runReleaseCanary(runtime, options) {
                 "--if-missing", "block",
                 "--out", profilePaths[index],
                 "--provenance", "Sanitized release canary capture from a dedicated visible ChatGPT tab."
-            ], runtime);
+            ], { agent: runtime.agent });
             if (exitCode !== 0) {
                 return {
                     ok: false,
@@ -44,14 +50,18 @@ export async function runReleaseCanary(runtime, options) {
         }
     }
     finally {
-        await closeDedicatedProfileTab(runtime.browser, options.tabId);
+        await closeDedicatedProfileTab(managedBrowser, options.tabId);
     }
     const names = options.includeUpload === true
         ? [...CORE_SCENARIOS, "attach-one-file"]
         : CORE_SCENARIOS;
     const context = {
         agent: runtime.agent,
-        ...(runtime.browser === undefined ? {} : { browser: runtime.browser }),
+        browser: managedBrowser,
+        // The agent-acquired browser is authoritative for tab discovery and page
+        // behavior. The bridge-hosted global browser separately owns finalize(),
+        // which closes only this tool call's temporary tabs after each scenario.
+        ...(runtime.browser === undefined ? {} : { cleanupBrowser: runtime.browser }),
         reportDir: join(reportDir, "live-smoke"),
         env: {
             CHATGPT_E2E_CONFIGURATION_MUTATION: "1",
@@ -63,7 +73,10 @@ export async function runReleaseCanary(runtime, options) {
         throw new Error(`Release canary scenario registration drift: expected ${names.length}, found ${scenarios.length}.`);
     }
     const smoke = await runLiveSmoke(context, scenarios);
-    const failures = smoke.results.filter(result => result.status !== "pass").map(result => result.name);
+    const failures = smoke.results.flatMap(result => [
+        ...(result.status === "pass" ? [] : [result.name]),
+        ...(result.cleanup?.ok === true ? [] : [`${result.name}:cleanup`])
+    ]);
     return {
         ok: failures.length === 0,
         profilePaths,

package/dist/src/types.d.ts

@@ -1,3 +1,5 @@
+import type { OperationControlReceiptV1, OperationHandleV1 } from "./operations/types.js";
+import type { BackendCompatibilityReport } from "./backend/protocol.js";
 export type CommandStatus = "ok" | "partial" | "timeout" | "blocked" | "needs_confirmation" | "not_found" | "unsupported" | "error";
 export type SubmissionState = "not_submitted" | "submitted" | "submitted_unconfirmed" | "submitted_generating";
 export type CompletionState = "complete" | "generating" | "stopped" | "partial" | "unknown";
@@ -663,6 +665,8 @@ export type WorkTaskRef = {
 };
 export type StartWorkArgs = {
     prompt: string;
+    /** Caller-owned durable identity. Supplying it opts Work start into operations.run. */
+    operationId?: string;
     /** Start from a blank Work task when possible. Defaults to true. */
     newTask?: boolean;
     files?: string[];
@@ -674,6 +678,17 @@ export type StartWorkArgs = {
 export type StartWorkData = {
     task: WorkTaskRef;
     submitted: SubmitData;
+    /** Requested runner output format for the transactional Work path. */
+    responseFormat?: Extract<ResponseFormat, "markdown" | "text">;
+    /** Effective durable operation identity when the transactional path was selected. */
+    operationId?: string;
+    /** Durable locator returned by the transactional Work path. */
+    handle?: OperationHandleV1;
+    requestDigest?: string;
+    pending?: boolean;
+    responseDigest?: string;
+    responseBytes?: number;
+    complete?: boolean;
     configuration?: ApplyConfigurationData;
     wait?: WaitData;
     response?: ReadLatestData;
@@ -691,11 +706,31 @@ export type WorkWaitArgs = WaitArgs;
 export type WorkWaitData = WaitData;
 export type SteerWorkArgs = {
     prompt: string;
+    /**
+     * Caller-owned parent operation identity. A transactional steer must also
+     * provide the exact parent handle, control action ID, and assistant turn;
+     * omitting all operation fields preserves the legacy primitive path.
+     */
+    operationId?: string;
+    handle?: OperationHandleV1;
+    /** Caller-owned immutable identity for this one steer action. */
+    controlActionId?: string;
+    expectedAssistantTurnId?: string;
     wait?: boolean | WaitArgs;
     read?: boolean | ReadLatestArgs;
     timeoutMs?: number;
 };
-export type SteerWorkData = AskReadData;
+export type SteerWorkData = Omit<AskReadData, "prompt"> & {
+    /** Legacy steering returns the prompt; transactional errors never echo it. */
+    prompt?: string;
+    operationId?: string;
+    controlActionId?: string;
+    requestDigest?: string;
+    /** Exact parent locator used for a transactional steer. */
+    handle?: OperationHandleV1;
+    parentHandle?: OperationHandleV1;
+    control?: OperationControlReceiptV1;
+};
 export type ReadWorkLatestArgs = ReadLatestArgs;
 export type ReadWorkLatestData = ReadLatestData;
 export type SelectToolArgs = {
@@ -854,6 +889,8 @@ export type RuntimeEnv = {
     clipboard?: ClipboardLike;
     now?: () => Date;
     expectedTabId?: string;
+    /** Optional transport-owned compatibility diagnostics for doctor. */
+    compatibility?: BackendCompatibilityReport;
 };
 export type ClipboardLike = {
     read: () => Promise<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-chatgpt-control",
-  "version": "0.5.1-alpha.2",
+  "version": "0.5.1-alpha.3",
   "description": "Unofficial SDK for controlling visible ChatGPT Chat and Work sessions.",
   "type": "module",
   "license": "MIT",