codex-chatgpt-control 0.3.0-alpha.1 → 0.5.0-alpha.1

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

@@ -0,0 +1,304 @@
+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 { 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.";
+class UsageError extends Error {
+    exitCode;
+    constructor(message, exitCode = 2) {
+        super(message);
+        this.exitCode = exitCode;
+        this.name = "UsageError";
+    }
+}
+const USAGE = [
+    "Usage:",
+    "  npm run capture:surface-profile -- --id work-basic-en",
+    "  npm run capture:surface-profile -- --id chat-simplified-de --locale de-DE --out ../../outputs/surface-profiles/chat-simplified-de.json",
+    "",
+    "Options:",
+    "  --id               Required normalized profile id.",
+    "  --out              Draft JSON path. Defaults under ../../outputs/surface-profiles/.",
+    "  --locale           Known BCP47 locale; otherwise reads documentElement.lang.",
+    "  --region           Normalized supplied region group. Default: not-recorded.",
+    "  --account-scope    Normalized supplied account group. Default: not-recorded.",
+    "  --plan-scope       Normalized supplied plan group. Default: not-recorded.",
+    "  --workspace-scope  Normalized supplied workspace group. Default: not-recorded.",
+    "  --support-state    current|compatibility|unverified|retired. Default: unverified.",
+    "  --provenance       Non-private provenance note.",
+    "  --tab-id           Claim an exact already-open ChatGPT tab.",
+    "  --if-missing       block|open|create. Default: block.",
+    "",
+    "The capture is read-only with respect to ChatGPT configuration. It opens and",
+    "closes visible menus, 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) {
+    let options;
+    try {
+        options = parseArgs(argv);
+    }
+    catch (error) {
+        if (error instanceof UsageError) {
+            console.log(error.message);
+            return error.exitCode;
+        }
+        throw error;
+    }
+    if ((runtime.agent === undefined || runtime.agent === null) && runtime.browser === undefined) {
+        console.log(JSON.stringify({
+            ok: false,
+            status: "blocked",
+            blocker: {
+                kind: "browser_bridge_unavailable",
+                code: "codex_chrome_bridge_unavailable",
+                message: BROWSER_BRIDGE_UNAVAILABLE_MESSAGE,
+                remediation: BROWSER_BRIDGE_REMEDIATION
+            }
+        }, null, 2));
+        return 2;
+    }
+    try {
+        const env = {};
+        if (runtime.agent !== undefined && runtime.agent !== null)
+            env.agent = runtime.agent;
+        if (runtime.browser !== undefined)
+            env.browser = runtime.browser;
+        const attached = await attachChatGPTBrowser(env, {
+            existingTab: {
+                target: options.tabId === undefined
+                    ? { type: "selected", host: "chatgpt" }
+                    : { type: "tabId", tabId: options.tabId },
+                ifMissing: options.ifMissing,
+                ifMultiple: "first",
+                requireChatGPT: true
+            },
+            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 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));
+        return 1;
+    }
+}
+export function buildSurfaceProfileDraft(options, locale, snapshot, detected, inspection, observedAt = new Date().toISOString().slice(0, 10)) {
+    const activeEntries = Object.entries(inspection.active)
+        .filter((entry) => typeof entry[1] === "string");
+    const axisRows = inspection.experience === "work"
+        ? activeEntries.map(([axis, value]) => ({
+            axis,
+            label: `${titleCase(axis)} ${value}`,
+            value
+        }))
+        : [];
+    const openerLabel = inspection.experience === "chat"
+        ? inspection.active.intelligence ?? inspection.active.effort
+        : undefined;
+    const menuItems = Object.values(inspection.options)
+        .flatMap(optionsForAxis => optionsForAxis ?? [])
+        .map(option => ({
+        label: option.label,
+        normalized: option.id,
+        role: option.hasSubmenu === true ? "menuitem" : "menuitemradio",
+        checked: option.selected,
+        ...(option.hasSubmenu === undefined ? {} : { hasPopup: option.hasSubmenu })
+    }));
+    const safeComposerLabels = dedupeBounded(detected.evidence
+        .filter(item => item.source === "composer")
+        .map(item => item.label), 16);
+    const safeMainControls = dedupeBounded([
+        ...axisRows.map(row => row.label),
+        ...(openerLabel === undefined ? [] : [openerLabel]),
+        ...menuItems.map(item => item.label),
+        ...(inspection.selectorProfile === "work_advanced_v1" ? ["Advanced"] : [])
+    ], 80);
+    return {
+        schemaVersion: "chatgpt.browser_control.surface_profile.v1",
+        id: options.id,
+        observedAt,
+        provenance: options.provenance,
+        locale,
+        region: options.region,
+        accountScope: options.accountScope,
+        planScope: options.planScope,
+        workspaceScope: options.workspaceScope,
+        supportState: options.supportState,
+        snapshot: {
+            url: sanitizeChatGPTUrl(snapshot.url),
+            composerLabels: safeComposerLabels,
+            mainControls: safeMainControls,
+            mainText: detected.evidence
+                .filter(item => item.source === "heading")
+                .map(item => item.label)
+                .join(" ")
+                .slice(0, 2000)
+        },
+        panel: {
+            ...(openerLabel === undefined ? {} : { openerLabel }),
+            axisRows,
+            advancedVisible: inspection.selectorProfile === "work_advanced_v1"
+        },
+        menuItems,
+        expected: {
+            experience: detected.experience,
+            selectorProfile: inspection.selectorProfile,
+            availableAxes: inspection.availableAxes,
+            active: inspection.active
+        }
+    };
+}
+export function parseArgs(argv) {
+    let id;
+    let out;
+    let locale;
+    let region = "not-recorded";
+    let accountScope = "not-recorded";
+    let planScope = "not-recorded";
+    let workspaceScope = "not-recorded";
+    let supportState = "unverified";
+    let provenance = DEFAULT_PROVENANCE;
+    let tabId;
+    let ifMissing = "block";
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === undefined)
+            continue;
+        switch (arg) {
+            case "--help":
+            case "-h":
+                throw new UsageError(USAGE, 0);
+            case "--id":
+                id = requiredValue(argv, ++index, arg);
+                break;
+            case "--out":
+                out = requiredValue(argv, ++index, arg);
+                break;
+            case "--locale":
+                locale = requiredValue(argv, ++index, arg);
+                break;
+            case "--region":
+                region = requiredValue(argv, ++index, arg);
+                break;
+            case "--account-scope":
+                accountScope = requiredValue(argv, ++index, arg);
+                break;
+            case "--plan-scope":
+                planScope = requiredValue(argv, ++index, arg);
+                break;
+            case "--workspace-scope":
+                workspaceScope = requiredValue(argv, ++index, arg);
+                break;
+            case "--support-state":
+                supportState = parseSupportState(requiredValue(argv, ++index, arg));
+                break;
+            case "--provenance":
+                provenance = requiredValue(argv, ++index, arg);
+                break;
+            case "--tab-id":
+                tabId = requiredValue(argv, ++index, arg);
+                break;
+            case "--if-missing":
+                ifMissing = parseIfMissing(requiredValue(argv, ++index, arg));
+                break;
+            default:
+                throw new UsageError(`Unknown argument: ${arg}\n\n${USAGE}`);
+        }
+    }
+    if (id === undefined) {
+        throw new UsageError(`--id is required.\n\n${USAGE}`);
+    }
+    for (const [field, value] of Object.entries({
+        id,
+        region,
+        accountScope,
+        planScope,
+        workspaceScope
+    })) {
+        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`);
+    return {
+        id,
+        out: resolve(out ?? defaultOut),
+        ...(locale === undefined ? {} : { locale }),
+        region,
+        accountScope,
+        planScope,
+        workspaceScope,
+        supportState,
+        provenance,
+        ...(tabId === undefined ? {} : { tabId }),
+        ifMissing
+    };
+}
+async function readDocumentLocale(page) {
+    if (page.evaluate === undefined)
+        return undefined;
+    return page.evaluate(() => document.documentElement.lang || undefined).catch(() => undefined);
+}
+function sanitizeChatGPTUrl(value) {
+    const url = new URL(value || CHATGPT_HOME, CHATGPT_HOME);
+    url.search = "";
+    url.hash = "";
+    if (/^\/c\/[^/]+/.test(url.pathname)) {
+        url.pathname = url.pathname.replace(/^\/c\/[^/]+/, "/c/sanitized");
+    }
+    return `${url.origin}${url.pathname}`;
+}
+function titleCase(value) {
+    return value.length === 0 ? value : `${value[0].toUpperCase()}${value.slice(1)}`;
+}
+function dedupeBounded(values, limit) {
+    return Array.from(new Set(values.map(value => value.trim()).filter(Boolean))).slice(0, limit);
+}
+function requiredValue(argv, index, flag) {
+    const value = argv[index];
+    if (value === undefined || value.startsWith("--")) {
+        throw new UsageError(`${flag} requires a value.`);
+    }
+    return value;
+}
+function parseSupportState(value) {
+    if (["current", "compatibility", "unverified", "retired"].includes(value)) {
+        return value;
+    }
+    throw new UsageError(`Invalid --support-state: ${value}`);
+}
+function parseIfMissing(value) {
+    if (value === "block" || value === "open" || value === "create")
+        return value;
+    throw new UsageError(`Invalid --if-missing: ${value}`);
+}
+function assertNormalizedSlug(value, flag) {
+    if (!/^[a-z0-9][a-z0-9._-]{0,63}$/.test(value)) {
+        throw new UsageError(`${flag} must be a normalized lowercase slug without private names.`);
+    }
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    process.exitCode = await main();
+}

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

@@ -1,7 +1,7 @@
 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, newThread, openThread, readLatest, runSequence, searchThreads, selectTool, setMode, submitMessage, twoTurnExchange, waitAndRead, waitForMessage } from "../../index.js";
+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 { contextEnvFlag, contextEnvText } from "./harness.js";
 export const requiredScenarios = [
@@ -496,6 +496,39 @@ export const optionalScenarios = [
             ? pass(meta, waited, details)
             : fail(meta, waited, details);
     }),
+    scenario("running-status-detection", false, context => contextEnvFlag(context, "CHATGPT_E2E_RUNNING_STATUS"), async (context, meta) => {
+        const env = await bootNewThread(context, meta);
+        if ("status" in env)
+            return env;
+        let status;
+        try {
+            const asked = await askMessage(env, {
+                text: [
+                    "Live running-status stress test. Write exactly 500 numbered items.",
+                    "Each item should be a complete sentence. Continue until item 500."
+                ].join("\n"),
+                wait: false,
+                read: false
+            });
+            if (!asked.ok)
+                return fail(meta, asked);
+            await waitForGenerationSignal(env, 30000);
+            status = await messageStatus(env, { maxPreviewChars: 400 });
+            const data = status.data;
+            const details = {
+                completionState: data?.completionState,
+                generationActive: data?.generationActive,
+                latestAssistantTextLength: data?.latestAssistantTextLength,
+                status: status.status
+            };
+            return status.ok && (data?.completionState === "generating" || data?.generationActive === true)
+                ? pass(meta, status, details)
+                : fail(meta, status, details);
+        }
+        finally {
+            await stopGenerationIfVisible(env);
+        }
+    }),
     scenario("download-generated-file", false, context => contextEnvFlag(context, "CHATGPT_E2E_DOWNLOAD"), async (context, meta) => {
         const env = await bootNewThread(context, meta);
         if ("status" in env)

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

@@ -44,6 +44,7 @@ else {
         CHATGPT_E2E_DOWNLOAD: envText("CHATGPT_E2E_DOWNLOAD"),
         CHATGPT_E2E_LOGIN_PROFILE: envText("CHATGPT_E2E_LOGIN_PROFILE"),
         CHATGPT_E2E_MODE_LABEL: envText("CHATGPT_E2E_MODE_LABEL"),
+        CHATGPT_E2E_RUNNING_STATUS: envText("CHATGPT_E2E_RUNNING_STATUS"),
         CHATGPT_E2E_STREAM: envText("CHATGPT_E2E_STREAM"),
         CHATGPT_E2E_UPLOAD_PERMISSION_MANUAL: envText("CHATGPT_E2E_UPLOAD_PERMISSION_MANUAL"),
         CHATGPT_E2E_WEB_SEARCH: envText("CHATGPT_E2E_WEB_SEARCH")

package/dist/src/types.d.ts

@@ -1,4 +1,6 @@
 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";
 export type BlockerKind = "browser_bridge_unavailable" | "login_required" | "captcha" | "rate_limit" | "modal" | "permission" | "confirmation" | "selector_drift" | "artifact_unavailable" | "artifact_selector_drift" | "artifact_download_unavailable" | "download_unavailable" | "upload_failed" | "not_found" | "unknown";
 export type CommandContext = {
     url?: string;
@@ -6,6 +8,8 @@ export type CommandContext = {
     title?: string;
     turnCount?: number;
     assistantTurnCount?: number;
+    experience?: ChatGPTExperience;
+    selectorProfile?: SurfaceSelectorProfile;
     browserName?: string;
     tabId?: string;
     timestamp: string;
@@ -174,6 +178,10 @@ export type SubmitData = {
     submitted: boolean;
     userTurnText?: string;
     turnCount?: number;
+    submissionState?: SubmissionState;
+    completionState?: CompletionState;
+    generationActive?: boolean;
+    generationSignals?: string[];
 };
 export type WaitArgs = {
     afterTurnCount?: number;
@@ -193,6 +201,9 @@ export type WaitData = {
     responseContent?: "include" | "metadata";
     assistantTurnCount: number;
     elapsedMs: number;
+    completionState?: CompletionState;
+    generationActive?: boolean;
+    generationSignals?: string[];
 };
 export type ResponseFormat = "markdown" | "text" | "normalized_text" | "visible_text" | "html" | "blocks" | "all";
 export type ResponseCitation = {
@@ -277,10 +288,14 @@ export type ReadLatestData = {
     actions?: ResponseAction[];
     thoughtDurationText?: string;
     sourcesAvailable?: boolean;
+    completionState?: CompletionState;
+    generationActive?: boolean;
+    generationSignals?: string[];
 };
 export type WaitAndReadArgs = WaitArgs & ReadLatestArgs;
 export type AskArgs = {
-    text: string;
+    text?: string;
+    prompt?: string;
     wait?: boolean | WaitArgs;
     read?: boolean | ReadLatestArgs;
     timeoutMs?: number;
@@ -291,6 +306,24 @@ export type AskReadData = {
     complete?: boolean;
     conversationId?: string;
     title?: string;
+    submissionState?: SubmissionState;
+    completionState?: CompletionState;
+    generationActive?: boolean;
+    generationSignals?: string[];
+};
+export type MessageStatusArgs = {
+    maxPreviewChars?: number;
+};
+export type MessageStatusData = {
+    turnCount?: number;
+    assistantTurnCount: number;
+    latestAssistantTurnIndex?: number;
+    latestAssistantText?: string;
+    latestAssistantPreview?: string;
+    latestAssistantTextLength?: number;
+    completionState: CompletionState;
+    generationActive: boolean;
+    generationSignals: string[];
 };
 export type AttachFilesArgs = {
     paths: string[];
@@ -488,6 +521,172 @@ export type GetModeArgs = {
 export type GetModeData = {
     modes: string[];
 };
+export type ChatGPTExperience = "chat" | "work" | "unknown";
+export type SurfaceSelectorProfile = "chat_legacy_v1" | "chat_simplified_v1" | "work_basic_v1" | "work_advanced_v1" | "unknown";
+export type SurfaceProfileSupportState = "current" | "compatibility" | "unverified" | "retired";
+export type SurfaceProfileObservation = {
+    observedAt: string;
+    provenance: string;
+    locale: string;
+    region: string;
+    accountScope: string;
+    planScope: string;
+    workspaceScope: string;
+    supportState: SurfaceProfileSupportState;
+};
+export type ExperienceConfidence = "high" | "medium" | "low";
+export type ExperienceEvidence = {
+    source: "url" | "composer" | "control" | "menu" | "heading";
+    label: string;
+};
+export type DetectExperienceArgs = {
+    timeoutMs?: number;
+};
+export type DetectExperienceData = {
+    experience: ChatGPTExperience;
+    selectorProfile: SurfaceSelectorProfile;
+    confidence: ExperienceConfidence;
+    evidence: ExperienceEvidence[];
+};
+export type OpenExperienceArgs = {
+    experience: Exclude<ChatGPTExperience, "unknown">;
+    timeoutMs?: number;
+};
+export type OpenExperienceData = {
+    experience: Exclude<ChatGPTExperience, "unknown">;
+    previousExperience: ChatGPTExperience;
+    changed: boolean;
+    selectorProfile: SurfaceSelectorProfile;
+};
+export type ConfigurationAxis = "model" | "intelligence" | "effort" | "speed" | "modelVersion";
+export type SurfaceProfileFixture = SurfaceProfileObservation & {
+    schemaVersion: "chatgpt.browser_control.surface_profile.v1";
+    id: string;
+    snapshot: {
+        url: string;
+        composerLabels: string[];
+        mainControls: string[];
+        mainText: string;
+    };
+    panel: {
+        openerLabel?: string;
+        axisRows: Array<{
+            axis: ConfigurationAxis;
+            label: string;
+            value?: string;
+        }>;
+        advancedVisible: boolean;
+    };
+    menuItems: Array<{
+        label: string;
+        normalized: string;
+        role?: string;
+        checked?: boolean;
+        expanded?: boolean;
+        hasPopup?: boolean;
+        testId?: string;
+        ariaLabel?: string;
+    }>;
+    expected: {
+        experience: ChatGPTExperience;
+        selectorProfile: SurfaceSelectorProfile;
+        availableAxes: ConfigurationAxis[];
+        active: Partial<Record<ConfigurationAxis, string>>;
+    };
+};
+export type ConfigurationOption = {
+    id: string;
+    label: string;
+    selected: boolean;
+    disabled?: boolean;
+    description?: string;
+    hasSubmenu?: boolean;
+};
+export type ConfigurationSelection = {
+    model?: string;
+    intelligence?: string;
+    effort?: string;
+    speed?: string;
+    modelVersion?: string;
+    /** Backward-compatible alias for modelVersion. */
+    version?: string;
+};
+export type InspectConfigurationArgs = {
+    experience?: Exclude<ChatGPTExperience, "unknown">;
+    includeOptions?: boolean;
+    timeoutMs?: number;
+};
+export type ConfigurationInspectionData = {
+    experience: ChatGPTExperience;
+    selectorProfile: SurfaceSelectorProfile;
+    availableAxes: ConfigurationAxis[];
+    active: Partial<Record<ConfigurationAxis, string>>;
+    options: Partial<Record<ConfigurationAxis, ConfigurationOption[]>>;
+    verified: boolean;
+    evidence: ExperienceEvidence[];
+};
+export type ApplyConfigurationArgs = {
+    experience?: Exclude<ChatGPTExperience, "unknown">;
+    desired: ConfigurationSelection;
+    strict?: boolean;
+    timeoutMs?: number;
+};
+export type AppliedConfigurationSelection = {
+    axis: ConfigurationAxis;
+    requested: string;
+    selected: string;
+};
+export type ApplyConfigurationData = {
+    requested: ConfigurationSelection;
+    selected: AppliedConfigurationSelection[];
+    before: ConfigurationInspectionData;
+    after: ConfigurationInspectionData;
+    verified: boolean;
+};
+export type WorkTaskRef = {
+    url?: string;
+    conversationId?: string;
+    title?: string;
+    baselineTurnCount?: number;
+    baselineAssistantTurnCount?: number;
+};
+export type StartWorkArgs = {
+    prompt: string;
+    /** Start from a blank Work task when possible. Defaults to true. */
+    newTask?: boolean;
+    files?: string[];
+    configuration?: ConfigurationSelection;
+    wait?: boolean | WaitArgs;
+    read?: boolean | ReadLatestArgs;
+    timeoutMs?: number;
+};
+export type StartWorkData = {
+    task: WorkTaskRef;
+    submitted: SubmitData;
+    configuration?: ApplyConfigurationData;
+    wait?: WaitData;
+    response?: ReadLatestData;
+};
+export type WorkStatusArgs = MessageStatusArgs & {
+    includeArtifacts?: boolean;
+};
+export type WorkStatusData = {
+    experience: "work";
+    task: WorkTaskRef;
+    message: MessageStatusData;
+    artifacts?: ArtifactListData;
+};
+export type WorkWaitArgs = WaitArgs;
+export type WorkWaitData = WaitData;
+export type SteerWorkArgs = {
+    prompt: string;
+    wait?: boolean | WaitArgs;
+    read?: boolean | ReadLatestArgs;
+    timeoutMs?: number;
+};
+export type SteerWorkData = AskReadData;
+export type ReadWorkLatestArgs = ReadLatestArgs;
+export type ReadWorkLatestData = ReadLatestData;
 export type SelectToolArgs = {
     tool: "web_search" | "deep_research" | "create_image" | string;
     timeoutMs?: number;
@@ -496,6 +695,42 @@ export type SequenceStep = {
     id: string;
     command: "session.bootstrap";
     args?: BootstrapArgs;
+} | {
+    id: string;
+    command: "experience.detect";
+    args?: DetectExperienceArgs;
+} | {
+    id: string;
+    command: "experience.open";
+    args: OpenExperienceArgs;
+} | {
+    id: string;
+    command: "configuration.inspect";
+    args?: InspectConfigurationArgs;
+} | {
+    id: string;
+    command: "configuration.apply";
+    args: ApplyConfigurationArgs;
+} | {
+    id: string;
+    command: "work.start";
+    args: StartWorkArgs;
+} | {
+    id: string;
+    command: "work.status";
+    args?: WorkStatusArgs;
+} | {
+    id: string;
+    command: "work.wait";
+    args?: WorkWaitArgs;
+} | {
+    id: string;
+    command: "work.steer";
+    args: SteerWorkArgs;
+} | {
+    id: string;
+    command: "work.readLatest";
+    args?: ReadWorkLatestArgs;
 } | {
     id: string;
     command: "threads.search";
@@ -528,6 +763,10 @@ export type SequenceStep = {
     id: string;
     command: "messages.readLatest";
     args?: ReadLatestArgs;
+} | {
+    id: string;
+    command: "messages.status";
+    args?: MessageStatusArgs;
 } | {
     id: string;
     command: "messages.waitAndRead";
@@ -599,6 +838,7 @@ export type RuntimeEnv = {
     page?: PageLike;
     clipboard?: ClipboardLike;
     now?: () => Date;
+    expectedTabId?: string;
 };
 export type ClipboardLike = {
     read: () => Promise<string>;
@@ -656,6 +896,8 @@ export type WaitForEventOptions = {
     timeoutMs?: number;
 };
 export type PageLike = {
+    id?: string;
+    tabId?: string;
     url?: () => string | Promise<string>;
     goto?: (url: string, options?: unknown) => Promise<unknown>;
     title?: () => Promise<string>;
@@ -694,7 +936,8 @@ export type PageLike = {
         [key: string]: unknown;
     };
 };
-export type AskHelperArgs = AskArgs & {
+export type AskHelperArgs = Omit<AskArgs, "text" | "prompt"> & {
+    text: string;
     thread?: ThreadTarget;
 };
 export type AskInThreadArgs = AskHelperArgs & {