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

package/dist/src/commands/messages.js

@@ -10,7 +10,7 @@ import { contextFromPage } from "./context.js";
 import { createDeadline } from "./deadline.js";
 import { withCommandOutputText } from "./output.js";
 import { createSingleFlightProbe } from "./probes.js";
-import { bootstrap } from "./session.js";
+import { ensurePage } from "./session.js";
 export function isResponseComplete(snapshot) {
     return snapshot.latestText.trim().length > 0
         && !isTransientAssistantText(snapshot.latestText)
@@ -98,8 +98,14 @@ export async function submitMessage(env, args = {}) {
         }
         if (userTurn === undefined) {
             const latestUser = await readLatestMessage(page, "user", "normalized_text");
+            const generation = await readAssistantGenerationState(page).catch(() => EMPTY_GENERATION_STATE);
+            const turnCount = await countPageMessages(page).catch(() => undefined);
             if (submittedUserTurnMatches(latestUser?.text, args.text)) {
-                return resultOk(submitData(latestUser?.text, await countPageMessages(page).catch(() => undefined)), await contextFromPage(page));
+                return resultOk(submitData(latestUser?.text, turnCount, generation.active ? "submitted_generating" : "submitted", generation), await contextFromPage(page));
+            }
+            const turnAdvanced = previousTurnCount !== undefined && turnCount !== undefined && turnCount > previousTurnCount;
+            if (turnAdvanced || generation.active) {
+                return resultOk(submitData(undefined, turnCount, generation.active ? "submitted_generating" : "submitted_unconfirmed", generation), await contextFromPage(page), ["Submitted prompt could not be matched to a rendered user turn yet, but ChatGPT page state indicates progress."]);
             }
             return {
                 ok: false,
@@ -113,7 +119,7 @@ export async function submitMessage(env, args = {}) {
                 context: await contextFromPage(page)
             };
         }
-        return resultOk(submitData(userTurn, await countPageMessages(page).catch(() => undefined)), await contextFromPage(page));
+        return resultOk(submitData(userTurn, await countPageMessages(page).catch(() => undefined), "submitted", await readAssistantGenerationState(page).catch(() => EMPTY_GENERATION_STATE)), await contextFromPage(page));
     }
     catch (error) {
         return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
@@ -287,6 +293,7 @@ export async function waitForMessage(env, args = {}) {
     let lastChangedAt = Date.now();
     let lastObservedTextLength = 0;
     let latestAssistantCount = await countPageMessages(page, "assistant").catch(() => 0);
+    let lastGeneration = EMPTY_GENERATION_STATE;
     while (Date.now() - started < timeoutMs) {
         const probeResult = await waitSnapshotProbe(page, deadline, { timeoutMs: probeTimeoutMs });
         addWarnings(waitWarnings, probeResult.warnings);
@@ -317,6 +324,7 @@ export async function waitForMessage(env, args = {}) {
         }
         pollIndex += 1;
         const hasResponseActions = await resolveResponseActions(page, snapshot);
+        lastGeneration = snapshot.generation;
         if (targetReached && snapshot.generation.stopped && snapshot.text.length > 0) {
             const stoppedText = normalizeWhitespace(await fetchLatestAssistantText(page) ?? "");
             // A failed re-read must not fabricate an empty capture: real text was observed in
@@ -324,6 +332,9 @@ export async function waitForMessage(env, args = {}) {
             const data = stoppedText.length > 0
                 ? waitDataFromText(args, false, stoppedText, latestAssistantCount, Date.now() - started)
                 : waitDataWithoutText(latestAssistantCount, Date.now() - started);
+            data.completionState = "stopped";
+            data.generationActive = snapshot.generation.active;
+            data.generationSignals = snapshot.generation.signals;
             if (stoppedText.length === 0) {
                 waitWarnings.add(`The interrupted assistant text (~${snapshot.text.length} chars observed) could not be re-read at wait exit; call messages.readLatest on the same thread to capture it.`);
             }
@@ -361,6 +372,9 @@ export async function waitForMessage(env, args = {}) {
             };
             if (fetchedMetadata.hash === snapshot.text.hash && isResponseComplete(completionSnapshot)) {
                 const data = waitDataFromText(args, true, latestText, latestAssistantCount, Date.now() - started);
+                data.completionState = "complete";
+                data.generationActive = false;
+                data.generationSignals = snapshot.generation.signals;
                 return withCommandOutputText(resultOk(data, await contextFromPage(page), [...waitWarnings, ...responseContentWarnings(args, true)]));
             }
             if (latestText.length > 0) {
@@ -374,7 +388,11 @@ export async function waitForMessage(env, args = {}) {
     if (lastObservedTextLength > 0) {
         const partialText = await fetchLatestAssistantText(page);
         if (partialText !== undefined && normalizeWhitespace(partialText).length > 0) {
-            const data = waitDataFromText(args, false, normalizeWhitespace(partialText), latestAssistantCount, Date.now() - started);
+            const normalizedPartialText = normalizeWhitespace(partialText);
+            const data = waitDataFromText(args, false, normalizedPartialText, latestAssistantCount, Date.now() - started);
+            data.completionState = completionStateFromGeneration(lastGeneration, false, normalizedPartialText.length > 0);
+            data.generationActive = lastGeneration.active;
+            data.generationSignals = lastGeneration.signals;
             return withCommandOutputText({
                 ok: false,
                 status: "partial",
@@ -552,9 +570,51 @@ export async function readLatest(env, args = {}) {
         data.thoughtDurationText = latest.thoughtDurationText;
     if (latest.sourcesAvailable !== undefined)
         data.sourcesAvailable = latest.sourcesAvailable;
+    if (role === "assistant") {
+        const generation = await readAssistantGenerationState(page).catch(() => EMPTY_GENERATION_STATE);
+        data.completionState = completionStateFromGeneration(generation, undefined, latest.text.trim().length > 0);
+        data.generationActive = generation.active;
+        data.generationSignals = generation.signals;
+    }
     return withCommandOutputText(resultOk(data, await contextFromPage(page), data.warnings ?? []));
 }
+export async function messageStatus(env, args = {}) {
+    const boot = await ensurePage(env);
+    if (!boot.ok) {
+        return boot;
+    }
+    const page = env.page;
+    // Reuse the combined wait-snapshot evaluate for counts and generation state in a single
+    // round trip; it never carries full assistant text, so a bounded preview is fetched
+    // separately below only when the snapshot proves an assistant turn has text.
+    const snapshot = await readWaitDomSnapshot(page).catch(() => undefined) ?? await fallbackWaitSnapshot(page, 0);
+    const maxPreviewChars = Math.max(0, args.maxPreviewChars ?? 240);
+    const latestText = snapshot.text.length > 0
+        ? normalizeWhitespace(await fetchLatestAssistantText(page) ?? "")
+        : "";
+    const data = {
+        turnCount: snapshot.turnCount,
+        assistantTurnCount: snapshot.assistantTurnCount,
+        completionState: completionStateFromGeneration(snapshot.generation, undefined, latestText.length > 0),
+        generationActive: snapshot.generation.active,
+        generationSignals: snapshot.generation.signals
+    };
+    if (snapshot.latestAssistantTurnIndex !== undefined)
+        data.latestAssistantTurnIndex = snapshot.latestAssistantTurnIndex;
+    if (latestText.length > 0) {
+        data.latestAssistantTextLength = latestText.length;
+        data.latestAssistantPreview = latestText.length > maxPreviewChars
+            ? `${latestText.slice(0, Math.max(0, maxPreviewChars - 1))}...`
+            : latestText;
+    }
+    return resultOk(data, await contextFromPage(page));
+}
 export async function askMessage(env, args) {
+    const normalizedPrompt = normalizeAskPrompt(args);
+    if (!normalizedPrompt.ok) {
+        return normalizedPrompt.result;
+    }
+    const prompt = normalizedPrompt.text;
     const boot = await ensurePage(env);
     if (!boot.ok) {
         return boot;
@@ -562,7 +622,7 @@ export async function askMessage(env, args) {
     const page = env.page;
     const beforeTurnCount = await countPageMessages(page).catch(() => undefined);
     const beforeAssistantTurnCount = await countPageMessages(page, "assistant").catch(() => undefined);
-    const composeArgs = { text: args.text, mode: "replace" };
+    const composeArgs = { text: prompt, mode: "replace" };
     if (args.timeoutMs !== undefined) {
         composeArgs.timeoutMs = args.timeoutMs;
     }
@@ -570,7 +630,7 @@ export async function askMessage(env, args) {
     if (!compose.ok) {
         return forwardFailure(compose);
     }
-    const submitArgs = { text: args.text };
+    const submitArgs = { text: prompt };
     if (beforeTurnCount !== undefined) {
         submitArgs.previousTurnCount = beforeTurnCount;
     }
@@ -627,7 +687,7 @@ export async function askMessage(env, args) {
         return forwardFailure(waitFailure);
     }
     const state = await readPageState(page).catch(() => undefined);
-    const data = { prompt: args.text };
+    const data = { prompt };
     const complete = waitResult?.data?.complete ?? (waitResult === undefined ? undefined : false);
     if (complete !== undefined) {
         data.complete = complete;
@@ -641,6 +701,7 @@ export async function askMessage(env, args) {
     if (state?.title !== undefined) {
         data.title = state.title;
     }
+    applyMessageState(data, submit.data, waitResult?.data);
     if (waitFailure !== undefined) {
         data.complete = false;
         return withCommandOutputText({
@@ -678,7 +739,7 @@ export async function waitAndRead(env, args = {}) {
         }
         return forwardFailure(read);
     }
-    const data = askReadData("", read.data?.text, wait.data?.complete);
+    const data = askReadData("", read.data?.text, wait.data?.complete, wait.data, read.data);
     const warnings = [...read.warnings, ...wait.warnings];
     if (!wait.ok && wait.status === "partial") {
         data.complete = false;
@@ -695,12 +756,6 @@ export async function waitAndRead(env, args = {}) {
     }
     return withCommandOutputText(resultOk(data, read.context, warnings));
 }
-async function ensurePage(env) {
-    if (env.page !== undefined) {
-        return resultOk({}, await contextFromPage(env.page));
-    }
-    return bootstrap(env, { preferExistingTab: true });
-}
 async function waitForSubmittedUserTurn(page, text, previousTurnCount, timeoutMs) {
     const started = Date.now();
     const wanted = text === undefined ? undefined : normalizeWhitespace(text);
@@ -820,7 +875,7 @@ async function sleep(page, ms) {
     }
     await new Promise(resolve => setTimeout(resolve, ms));
 }
-function submitData(userTurnText, turnCount) {
+function submitData(userTurnText, turnCount, submissionState, generation) {
     const data = { submitted: true };
     if (userTurnText !== undefined) {
         data.userTurnText = userTurnText;
@@ -828,9 +883,13 @@ function submitData(userTurnText, turnCount) {
     if (turnCount !== undefined) {
         data.turnCount = turnCount;
     }
+    data.submissionState = submissionState;
+    data.completionState = completionStateFromGeneration(generation);
+    data.generationActive = generation.active;
+    data.generationSignals = generation.signals;
     return data;
 }
-function askReadData(prompt, responseText, complete) {
+function askReadData(prompt, responseText, complete, wait, read) {
     const data = { prompt };
     if (responseText !== undefined) {
         data.responseText = responseText;
@@ -838,8 +897,71 @@ function askReadData(prompt, responseText, complete) {
     if (complete !== undefined) {
         data.complete = complete;
     }
+    applyMessageState(data, undefined, wait, read);
     return data;
 }
+function applyMessageState(data, submit, wait, read) {
+    if (submit?.submissionState !== undefined)
+        data.submissionState = submit.submissionState;
+    const completionState = wait?.completionState ?? read?.completionState ?? submit?.completionState;
+    if (completionState !== undefined)
+        data.completionState = completionState;
+    const generationActive = wait?.generationActive ?? read?.generationActive ?? submit?.generationActive;
+    if (generationActive !== undefined)
+        data.generationActive = generationActive;
+    const generationSignals = wait?.generationSignals ?? read?.generationSignals ?? submit?.generationSignals;
+    if (generationSignals !== undefined)
+        data.generationSignals = generationSignals;
+}
+function completionStateFromGeneration(generation, complete, hasPartialText = false) {
+    if (complete === true)
+        return "complete";
+    if (generation.active)
+        return "generating";
+    if (generation.stopped)
+        return "stopped";
+    if (complete === false || hasPartialText)
+        return "partial";
+    return "unknown";
+}
+function normalizeAskPrompt(args) {
+    const text = args.text;
+    const prompt = args.prompt;
+    if (text !== undefined && prompt !== undefined && text !== prompt) {
+        return {
+            ok: false,
+            result: {
+                ok: false,
+                status: "error",
+                warnings: [],
+                error: {
+                    name: "InvalidAskArgs",
+                    message: "messages.ask received both text and prompt with different values.",
+                    recoverable: false
+                },
+                context: { timestamp: new Date().toISOString() }
+            }
+        };
+    }
+    const normalized = text ?? prompt;
+    if (normalized === undefined || normalized.trim().length === 0) {
+        return {
+            ok: false,
+            result: {
+                ok: false,
+                status: "error",
+                warnings: [],
+                error: {
+                    name: "InvalidAskArgs",
+                    message: "messages.ask requires a non-empty text or prompt argument.",
+                    recoverable: false
+                },
+                context: { timestamp: new Date().toISOString() }
+            }
+        };
+    }
+    return { ok: true, text: normalized };
+}
 function readRole(read) {
     return typeof read === "object" ? read.role : undefined;
 }

package/dist/src/commands/modes.js

@@ -4,11 +4,12 @@ import { localeLabels } from "../dom/locale-labels.js";
 import { isShortLatinToken, normalizeForLabelMatch, visibleLabelMatches } from "../dom/label-match.js";
 import { normalizeLabel, normalizeWhitespace } from "../dom/visible-text.js";
 import { contextFromPage } from "./context.js";
-import { bootstrap } from "./session.js";
+import { ensurePage } from "./session.js";
 const DEFAULT_MODE_EFFORT = "Thinking";
 const CURRENT_MODE_LABELS = dedupeLabels([
     ...localeLabels.modeLabels,
     ...Object.values(localeLabels.modeOptions).flat(),
+    ...Object.values(localeLabels.configurationOptions).flat(),
 ]);
 const MODE_OPENER_LABELS = [...CURRENT_MODE_LABELS.filter(label => label !== "Pro"), ...localeLabels.modeOpenerExtra];
 const MODEL_VERSION_FAMILY_PATTERN = /^gpt[\s-]/i;
@@ -224,12 +225,6 @@ export async function selectTool(env, args) {
         return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
     }
 }
-async function ensurePage(env) {
-    if (env.page !== undefined) {
-        return resultOk({}, await contextFromPage(env.page));
-    }
-    return bootstrap(env, { preferExistingTab: true });
-}
 async function clickFirstUniqueButton(page, labels) {
     for (const label of labels) {
         const roleLocator = page.getByRole?.("button", { name: label, exact: true });
@@ -508,22 +503,35 @@ async function selectModelVersion(page, requestedVersion, currentCandidates, tim
             candidates = await enumerateVisibleMenuItems(page);
         }
     }
-    let exact = findExactMenuItem(candidates, requestedVersion);
+    let exact = findExactSelectableMenuItem(candidates, requestedVersion);
     if (exact !== undefined) {
-        return await clickMenuItem(page, exact.label)
+        return await clickResolvedMenuItem(page, exact)
             ? { selected: exact.label, candidates: candidates.map(candidate => candidate.label) }
             : { candidates: candidates.map(candidate => candidate.label) };
     }
     const opened = await openModelVersionSubmenu(page, currentCandidates);
     candidates = await enumerateVisibleMenuItems(page);
-    exact = findExactMenuItem(candidates, requestedVersion);
+    exact = findExactSelectableMenuItem(candidates, requestedVersion);
     if (!opened || exact === undefined) {
         return { candidates: candidates.map(candidate => candidate.label) };
     }
-    return await clickMenuItem(page, exact.label)
+    return await clickResolvedMenuItem(page, exact)
         ? { selected: exact.label, candidates: candidates.map(candidate => candidate.label) }
         : { candidates: candidates.map(candidate => candidate.label) };
 }
+function isModelVersionSubmenuOpener(item) {
+    return item.hasPopup === true
+        || (item.role !== "menuitemradio" && MODEL_VERSION_FAMILY_PATTERN.test(item.label));
+}
+async function clickResolvedMenuItem(page, item) {
+    if (item.testId !== undefined && await clickIfUnique(page.locator?.(`[data-testid="${escapeAttributeValue(item.testId)}"]`))) {
+        return true;
+    }
+    if (item.role !== undefined && await clickIfUnique(page.getByRole?.(item.role, { name: item.label, exact: true }))) {
+        return true;
+    }
+    return clickMenuItem(page, item.label);
+}
 async function openModelVersionSubmenu(page, candidates) {
     const submenuOpeners = candidates.filter(item => item.hasPopup === true || MODEL_VERSION_FAMILY_PATTERN.test(item.label));
     if (submenuOpeners.length === 0) {
@@ -604,9 +612,10 @@ async function modelVersionMenuItemsAreVisible(page) {
     return (await enumerateVisibleMenuItems(page))
         .some(candidate => candidate.role === "menuitemradio" && MODEL_VERSION_LABEL_PATTERN.test(candidate.label));
 }
-function findExactMenuItem(items, wanted) {
+function findExactSelectableMenuItem(items, wanted) {
     const normalized = normalizeLabel(wanted);
-    const matches = items.filter(item => item.normalized === normalized);
+    const matches = items.filter(item => item.normalized === normalized
+        && !isModelVersionSubmenuOpener(item));
     return matches.length === 1 ? matches[0] : undefined;
 }
 function dedupeLabels(labels) {
@@ -666,9 +675,12 @@ async function visibleModeButtonLabelList(page) {
             }
             return text.includes(token);
         };
+        const scopedRoots = Array.from(document.querySelectorAll("main form, main [data-testid*='composer' i], main [class*='composer' i]"));
         return Array.from(document.querySelectorAll("button, [role='button']"))
             .map(node => {
             const element = node;
+            if (scopedRoots.length > 0 && !scopedRoots.some(root => root.contains(node)))
+                return "";
             const visibleText = (element.innerText ?? element.textContent ?? "").replace(/\s+/g, " ").trim();
             const ariaLabel = (element.getAttribute("aria-label") ?? "").replace(/\s+/g, " ").trim();
             const label = visibleText.length > 0 ? visibleText : ariaLabel;
@@ -680,7 +692,9 @@ async function visibleModeButtonLabelList(page) {
             if (visibleText.length === 0 && /feedback|conversation options|dismiss/i.test(ariaLabel))
                 return "";
             const normalized = label.toLowerCase();
-            if (!normalizedModeLabels.some(modeLabel => tokenMatches(normalized, modeLabel)))
+            const structuralModelControl = /model-switcher|model-selector|mode-selector/i.test(testId)
+                || /\b(?:gpt|sol|luna|terra)\b/i.test(label);
+            if (!structuralModelControl && !normalizedModeLabels.some(modeLabel => tokenMatches(normalized, modeLabel)))
                 return "";
             return label;
         })

package/dist/src/commands/registry.js

@@ -7,8 +7,9 @@ const descriptors = [
         `await chatgpt.askInThread({ thread: { type: "search", query: "Naming macOS Utility" }, prompt: "Continue." });`,
         `await chatgpt.askInThread({ thread: { type: "url", url: "https://chatgpt.com/c/<conversation-id>" }, existingTab: true, prompt: "Continue." });`
     ]),
-    workflow("askWithFiles", "Attach absolute local file paths, optionally set mode, ask, wait, and read.", [
-        `await chatgpt.askWithFiles({ thread: { type: "url", url: "https://chatgpt.com/c/<conversation-id>" }, existingTab: true, mode: { model: "Pro" }, files: ["/absolute/host/path/brief.md"], prompt: "Summarize this.", wait: true, read: { format: "markdown" } });`
+    workflow("askWithFiles", "Attach absolute local file paths, optionally open/configure Chat or Work, ask, wait, and read.", [
+        `await chatgpt.askWithFiles({ thread: { type: "url", url: "https://chatgpt.com/c/<conversation-id>" }, existingTab: true, experience: "chat", configuration: { intelligence: "Pro" }, files: ["/absolute/host/path/brief.md"], prompt: "Summarize this.", wait: true, read: { format: "markdown" } });`,
+        `await chatgpt.askWithFiles({ mode: { model: "Pro" }, files: ["/absolute/host/path/image.jpg"], prompt: "Describe this image.", wait: true });`
     ]),
     workflow("askAndDownload", "Ask ChatGPT to produce a visible downloadable output and save the latest exposed file.", [
         `await chatgpt.askAndDownload({ prompt: "Create a CSV.", download: { destDir: "/absolute/host/output" }, wait: true });`
@@ -16,13 +17,16 @@ const descriptors = [
     workflow("runMessages", "Run sequential prompts where later prompts can use earlier step data.", [
         `await chatgpt.runMessages({ messages: [{ id: "first", prompt: "alpha" }, { id: "second", prompt: "beta" }] });`
     ]),
-    workflow("runner.run", "Agents-style facade: run a visible ChatGPT browser-control agent against input, files, thread, existing-tab, mode, and response options.", [
-        `const agent = chatgpt.agent({ name: "reviewer", instructions: "Review deeply." }); await chatgpt.runner.run(agent, { input: "Review this.", thread: { type: "new" } });`,
+    workflow("runner.run", "Agents-style facade: run a visible ChatGPT agent against input, files, thread, existing-tab, experience, configuration, legacy mode, and response options.", [
+        `const agent = chatgpt.agent({ name: "reviewer", instructions: "Review deeply." }); await chatgpt.runner.run(agent, { input: "Review this.", thread: { type: "new" }, experience: "chat" });`,
         `await chatgpt.runner.run(agent, { input: "Continue.", thread: { type: "url", url: "https://chatgpt.com/c/<conversation-id>" }, existingTab: true });`
     ]),
     workflow("responses.create", "Narrow Responses-shaped adapter over the visible ChatGPT browser-control runner; rejects unsupported API-only fields before prompt submission.", [
         `await chatgpt.responses.create({ input: "Summarize.", thread: { type: "current" }, text: { format: "markdown" }, stream: false });`
     ]),
+    workflow("work.start", "Open Work, optionally apply model/effort/speed configuration, submit one task, and optionally wait/read without blind resubmission.", [
+        `await chatgpt.work.start({ prompt: "Analyze the attached package.", files: ["/absolute/path/package.tgz"], configuration: { model: "GPT-5.6 Sol", effort: "High", speed: "Fast" }, wait: true, read: { format: "markdown" } });`
+    ]),
     workflow("copyLatest", "Copy or DOM-read the latest assistant response with Markdown-first fidelity.", [
         `await chatgpt.copyLatest({ prefer: "clipboard" });`
     ]),
@@ -63,6 +67,14 @@ const descriptors = [
         `await chatgpt.createReport(result, { destDir: "/absolute/host/reports" });`
     ]),
     primitive("session.bootstrap", "Attach to ChatGPT in Chrome and detect login/blocker state.", 30000),
+    primitive("experience.detect", "Detect whether the scoped visible composer is Chat, Work, or unknown and return its selector profile.", 30000),
+    primitive("experience.open", "Open Chat or Work and verify the target surface from scoped composer evidence.", 30000),
+    primitive("configuration.inspect", "Inspect the active Chat or Work selector profile, axes, options, and selected values.", 30000),
+    primitive("configuration.apply", "Apply model/intelligence/effort/speed configuration one axis at a time and verify the final visible state.", 30000),
+    primitive("work.status", "Read current Work task progress and optionally enumerate visible artifacts.", 5000),
+    primitive("work.wait", "Wait for the current Work task response to stabilize.", 120000),
+    primitive("work.steer", "Submit a visible steering message to the current Work task without opening a new task.", 120000),
+    primitive("work.readLatest", "Read the latest response from the current Work task.", 30000),
     primitive("threads.new", "Open a new ChatGPT thread.", 30000),
     primitive("threads.search", "Search visible ChatGPT history by query.", 30000),
     primitive("threads.open", "Open a thread by URL, conversation id, title, or search result.", 30000),
@@ -71,6 +83,7 @@ const descriptors = [
     primitive("messages.ask", "Compose, submit, optionally wait, and optionally read.", 120000),
     primitive("messages.wait", "Wait for the latest assistant response to stabilize.", 120000),
     primitive("messages.readLatest", "Read the latest message as Markdown, normalized text, blocks, or HTML.", 30000),
+    primitive("messages.status", "Read a compact latest-assistant progress snapshot without treating partial text as complete.", 5000),
     primitive("messages.waitAndRead", "Wait for completion and read the latest message.", 120000),
     primitive("artifacts.listLatest", "Detect the latest visible generated ChatGPT artifact, such as an image-only result.", 30000),
     primitive("artifacts.wait", "Wait for a visible generated ChatGPT artifact to appear and stabilize.", 120000),
@@ -82,8 +95,8 @@ const descriptors = [
     primitive("projects.sources.planAdd", "Dry-run an append-only Project Sources file add from explicit local files without opening ChatGPT.", 30000),
     primitive("projects.sources.add", "Append explicit local files to a visible ChatGPT Project Sources list after confirmMutation: true.", 180000),
     primitive("response.copy", "Click Copy response and return clipboard Markdown, with DOM fallback.", 5000),
-    primitive("modes.set", "Select a visible model, intelligence, effort, or nested model-version candidate when unambiguous.", 30000),
-    primitive("modes.get", "Read the mode labels shown on the visible composer controls without changing them.", 30000),
+    primitive("modes.set", "Legacy compatibility command: select a visible model/intelligence/effort/version candidate with historical warning-oriented verification.", 30000),
+    primitive("modes.get", "Legacy compatibility command: read mode labels shown on visible composer controls without changing them.", 30000),
     primitive("tools.select", "Select a visible ChatGPT tool when unambiguous.", 30000)
 ];
 export function commandDescriptors() {
@@ -191,12 +204,24 @@ function workflowArgs(name) {
         return { first: "first message", second: "second message" };
     if (name === "new-ask-read")
         return { prompt: "message to send" };
+    if (name === "work.start") {
+        return {
+            prompt: "visible Work task prompt",
+            newTask: "start from a blank Work task; defaults to true",
+            files: "optional absolute local file paths",
+            configuration: "optional Work model, effort, and speed values",
+            wait: "optional wait behavior",
+            read: "optional response capture behavior"
+        };
+    }
     if (name === "askWithFiles") {
         return {
             files: "absolute local file paths to attach before submitting",
             prompt: "message to send after files are attached",
             thread: "optional thread selector",
             existingTab: "true or explicit policy to claim a user-open Chrome tab instead of opening a replacement",
+            experience: "optional chat or work surface",
+            configuration: "optional strict visible configuration such as { intelligence: \"Pro\" } or Work model/effort/speed",
             mode: "optional visible mode selection, e.g. { model: \"Pro\" } or { intelligence: \"Pro\", modelVersion: \"5.4\" }",
             wait: "true or wait options; defaults to true",
             read: "true or read options such as { format: \"markdown\" }; defaults to Markdown",
@@ -207,6 +232,9 @@ function workflowArgs(name) {
         prompt: "message to send or workflow-specific input",
         thread: "optional thread selector",
         existingTab: "true or explicit policy to claim a user-open Chrome tab instead of opening a replacement",
+        experience: "optional chat or work surface",
+        configuration: "optional surface-aware visible configuration",
+        mode: "legacy visible mode preference",
         report: "optional redacted report settings"
     };
 }
@@ -243,6 +271,24 @@ function primitiveArgs(name) {
         };
     if (name === "messages.readLatest")
         return { role: "assistant or user", format: "markdown, normalized_text, visible_text, html, blocks, or all" };
+    if (name === "messages.status")
+        return { maxPreviewChars: "maximum latest-assistant preview characters to return; defaults to 240" };
+    if (name === "experience.detect")
+        return { timeoutMs: "optional timeout for attaching to the ChatGPT page" };
+    if (name === "experience.open")
+        return { experience: "chat or work", timeoutMs: "optional verified-switch timeout" };
+    if (name === "configuration.inspect")
+        return { experience: "optional expected chat or work surface", includeOptions: "open visible axis menus to enumerate options; defaults to true", timeoutMs: "optional inspection timeout" };
+    if (name === "configuration.apply")
+        return { experience: "optional target chat or work surface", desired: "model, intelligence, effort, speed, and/or modelVersion values", strict: "fail when visible postconditions are not verified; defaults to true", timeoutMs: "optional selection timeout" };
+    if (name === "work.status")
+        return { includeArtifacts: "include the latest visible artifact inventory; defaults to false for lightweight polling", maxPreviewChars: "maximum assistant preview characters" };
+    if (name === "work.wait")
+        return { timeoutMs: "optional Work wait timeout", stableMs: "required response stability window", pollMs: "polling interval" };
+    if (name === "work.steer")
+        return { prompt: "visible steering message for the current task", wait: "optional wait behavior", read: "optional response capture behavior" };
+    if (name === "work.readLatest")
+        return { format: "markdown, normalized_text, visible_text, html, blocks, or all", maxChars: "optional capture limit" };
     if (name === "artifacts.listLatest")
         return { kind: "artifact kind; currently image", max: "maximum artifacts to return" };
     if (name === "artifacts.wait")
@@ -306,6 +352,22 @@ function primitiveExamples(name) {
             `// Verify an expensive Pro consult before submitting: const current = await chatgpt.modes.get();`
         ];
     }
+    if (name === "experience.detect")
+        return [`await chatgpt.experience.detect();`];
+    if (name === "experience.open")
+        return [`await chatgpt.experience.open({ experience: "work" });`];
+    if (name === "configuration.inspect")
+        return [`await chatgpt.configuration.inspect({ experience: "work" });`];
+    if (name === "configuration.apply")
+        return [`await chatgpt.configuration.apply({ experience: "work", desired: { model: "GPT-5.6 Sol", effort: "High", speed: "Fast" }, strict: true });`];
+    if (name === "work.status")
+        return [`await chatgpt.work.status();`];
+    if (name === "work.wait")
+        return [`await chatgpt.work.wait({ timeoutMs: 600000 });`];
+    if (name === "work.steer")
+        return [`await chatgpt.work.steer({ prompt: "Focus the comparison on deployment ergonomics." });`];
+    if (name === "work.readLatest")
+        return [`await chatgpt.work.readLatest({ format: "markdown" });`];
     if (name === "files.preflight") {
         return [
             `await chatgpt.files.preflight({ paths: ["/absolute/host/path.md"] });`,
@@ -345,7 +407,7 @@ function primitiveBlockers(name) {
         return ["browser_bridge_unavailable", "login_required", "selector_drift", "confirmation", "permission", "upload_failed"];
     if (name.startsWith("artifacts."))
         return ["browser_bridge_unavailable", "login_required", "artifact_unavailable", "artifact_selector_drift", "artifact_download_unavailable"];
-    if (name.startsWith("modes.") || name.startsWith("tools."))
+    if (name.startsWith("modes.") || name.startsWith("tools.") || name.startsWith("experience.") || name.startsWith("configuration.") || name.startsWith("work."))
         return ["browser_bridge_unavailable", "login_required", "selector_drift"];
     return commonBlockers();
 }

package/dist/src/commands/response-actions.js

@@ -6,7 +6,7 @@ import { readLatestMessage, readMessages } from "../dom/messages.js";
 import { copyResponseButtons } from "../dom/selectors.js";
 import { contextFromPage } from "./context.js";
 import { withCommandOutputText } from "./output.js";
-import { bootstrap } from "./session.js";
+import { ensurePage } from "./session.js";
 export async function copyResponse(env, args = {}) {
     const boot = await ensurePage(env);
     if (!boot.ok) {
@@ -166,9 +166,3 @@ function mergeResponseMetadata(data, latest) {
     if (latest.sourcesAvailable !== undefined)
         data.sourcesAvailable = latest.sourcesAvailable;
 }
-async function ensurePage(env) {
-    if (env.page !== undefined) {
-        return resultOk({}, await contextFromPage(env.page));
-    }
-    return bootstrap(env, { preferExistingTab: true });
-}

package/dist/src/commands/sequence.js

@@ -1,12 +1,15 @@
 import { downloadLatestArtifact, listLatestArtifacts, waitForArtifact } from "./artifacts.js";
+import { applyConfiguration, inspectConfiguration } from "./configuration.js";
+import { detectExperience, openExperience } from "./experience.js";
 import { attachFiles, downloadLatestFile } from "./files.js";
 import { addProjectSources, buildProjectSourceAddPlan, listProjectSources } from "./project-sources.js";
-import { askMessage, composeMessage, readLatest, submitMessage, waitAndRead, waitForMessage } from "./messages.js";
+import { askMessage, composeMessage, messageStatus, readLatest, submitMessage, waitAndRead, waitForMessage } from "./messages.js";
 import { copyResponse } from "./response-actions.js";
 import { bootstrap } from "./session.js";
 import { newThread, openThread, searchThreads } from "./threads.js";
 import { setMode, selectTool } from "./modes.js";
 import { withCommandOutputText } from "./output.js";
+import { readLatestWork, startWork, steerWork, waitForWork, workStatus } from "./work.js";
 export const defaultSequencePolicy = {
     stopOnError: true,
     returnPartial: true,
@@ -43,6 +46,24 @@ export async function executeStep(step, env, previousResults) {
     switch (step.command) {
         case "session.bootstrap":
             return bootstrap(env, step.args);
+        case "experience.detect":
+            return detectExperience(env, step.args);
+        case "experience.open":
+            return openExperience(env, step.args);
+        case "configuration.inspect":
+            return inspectConfiguration(env, step.args);
+        case "configuration.apply":
+            return applyConfiguration(env, step.args);
+        case "work.start":
+            return startWork(env, step.args);
+        case "work.status":
+            return workStatus(env, step.args);
+        case "work.wait":
+            return waitForWork(env, step.args);
+        case "work.steer":
+            return steerWork(env, step.args);
+        case "work.readLatest":
+            return readLatestWork(env, step.args);
         case "threads.search":
             return searchThreads(env, step.args);
         case "threads.open":
@@ -59,6 +80,8 @@ export async function executeStep(step, env, previousResults) {
             return waitForMessage(env, step.args);
         case "messages.readLatest":
             return readLatest(env, step.args);
+        case "messages.status":
+            return messageStatus(env, step.args);
         case "messages.waitAndRead":
             return waitAndRead(env, step.args);
         case "artifacts.listLatest":

package/dist/src/commands/session.d.ts

@@ -1,2 +1,4 @@
 import type { BootstrapArgs, BootstrapData, CommandResult, RuntimeEnv } from "../types.js";
 export declare function bootstrap(env: RuntimeEnv, args?: BootstrapArgs): Promise<CommandResult<BootstrapData>>;
+export declare function ensurePage(env: RuntimeEnv): Promise<CommandResult<unknown>>;
+export declare function verifyTabAffinity(env: RuntimeEnv): Promise<CommandResult<unknown> | undefined>;