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

package/dist/src/commands/configuration.js

@@ -6,16 +6,19 @@ import { tabIdFromPage } from "../browser/attach.js";
 import { contextFromPage } from "./context.js";
 import { detectExperience, openExperience } from "./experience.js";
 import { setMode } from "./modes.js";
+import { closeChatPopover, inspectChatPopover, readChatPopover, selectChatPopoverEffort, selectChatPopoverModel, selectChatPopoverSpeed } from "./chat-popover.js";
 import { ensurePage } from "./session.js";
 const WORK_AXES = ["model", "effort", "speed"];
 const CONFIGURATION_CONTROL_DISCOVERY_TIMEOUT_MS = 5_000;
 const CONFIGURATION_CONTROL_POLL_MS = 250;
+const CONFIGURATION_SELECTION_MAX_ATTEMPTS = 6;
+const CONFIGURATION_SELECTION_RETRY_MS = 400;
 const CONFIGURATION_AXIS_ORDER = [
+    "modelVersion",
     "model",
     "intelligence",
     "effort",
     "speed",
-    "modelVersion",
 ];
 export async function inspectConfiguration(env, args = {}) {
     const boot = await ensurePage(env);
@@ -47,11 +50,25 @@ export async function inspectConfiguration(env, args = {}) {
             };
         }
         const experience = detected.data.experience;
+        const initialChatPopover = experience !== "unknown" ? (await readChatPopover(page)).snapshot : undefined;
         const initialPanel = await readConfigurationPanel(page);
         const rootOpened = experience !== "unknown" && await waitForConfigurationRoot(page, experience, args.timeoutMs);
         if (rootOpened) {
             await page.waitForTimeout?.(150);
         }
+        if (experience !== "unknown" && (await readChatPopover(page)).snapshot !== undefined) {
+            try {
+                const chat = await inspectChatPopover(page);
+                const data = configurationInspectionFromPopover(experience, detected.data.evidence, chat);
+                if (args.includeOptions === false)
+                    data.options = {};
+                return resultOk(data, await contextFromPage(page, { experience, selectorProfile: data.selectorProfile }), data.verified ? [] : ["The owned configuration views did not provide unique active model and effort evidence."]);
+            }
+            finally {
+                if (initialChatPopover === undefined)
+                    await closeConfigurationMenus(page);
+            }
+        }
         const workAdvancedOpened = experience !== "work"
             || (rootOpened && await ensureWorkAdvancedPanel(page));
         if (experience === "work" && workAdvancedOpened) {
@@ -93,6 +110,32 @@ export async function inspectConfiguration(env, args = {}) {
         return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
     }
 }
+/** Shared owned popover, with surface-specific model semantics and observed axes only. */
+export function configurationInspectionFromPopover(experience, evidence, popover) {
+    const data = { experience, selectorProfile: experience === "work" ? "work_basic_v1" : "chat_simplified_v1",
+        availableAxes: [], active: {}, options: {}, verified: false, evidence };
+    if (popover?.slider !== undefined) {
+        data.availableAxes.push("effort");
+        if (popover.effort !== undefined) {
+            data.active.effort = popover.effort;
+            data.options.effort = [{ id: normalizeConfigurationId(popover.effort), label: popover.effort, selected: true }];
+        }
+    }
+    if (popover !== undefined && popover.modelOptions.length > 0) {
+        const axis = experience === "work" ? "model" : "modelVersion";
+        data.availableAxes.push(axis);
+        if (popover.activeModel !== undefined)
+            data.active[axis] = popover.activeModel;
+        data.options[axis] = popover.modelOptions.map(option => ({ id: normalizeConfigurationId(option.label), label: option.label, selected: option.checked }));
+    }
+    if (experience === "work" && popover?.speed !== undefined) {
+        data.availableAxes.push("speed");
+        data.active.speed = popover.speed;
+        data.options.speed = ["Standard", "Fast"].map(label => ({ id: normalizeConfigurationId(label), label, selected: label === popover.speed }));
+    }
+    data.verified = popover?.effort !== undefined && popover.activeModel !== undefined;
+    return data;
+}
 async function waitForConfigurationRoot(page, experience, timeoutMs) {
     const discoveryMs = Math.min(timeoutMs ?? CONFIGURATION_CONTROL_DISCOVERY_TIMEOUT_MS, CONFIGURATION_CONTROL_DISCOVERY_TIMEOUT_MS);
     const attempts = Math.max(1, Math.ceil(Math.max(0, discoveryMs) / CONFIGURATION_CONTROL_POLL_MS));
@@ -152,13 +195,21 @@ export async function applyConfiguration(env, args) {
         }
         const selected = [];
         for (const [axis, requested] of selectionEntries(desired)) {
-            const active = activeConfigurationValue(before, axis);
+            // A model change can reset effort and alter its available range.
+            // Re-observe between axes instead of trusting the initial snapshot.
+            const currentResult = selected.length === 0 ? beforeResult : await inspectConfiguration(env, { includeOptions: false });
+            if (!currentResult.ok || currentResult.data === undefined)
+                return forwardFailure(currentResult);
+            const current = currentResult.data;
+            if (current.experience !== before.experience)
+                return configurationFailure(page, before, desired, selected, "The composer experience changed during configuration selection.", "experience_mismatch");
+            const active = activeConfigurationValue(current, axis);
             if (active !== undefined && configurationValueMatches(active, requested)) {
                 selected.push({ axis, requested, selected: active });
                 continue;
             }
             const selection = before.experience === "work"
-                ? await selectWorkAxis(env, axis, requested)
+                ? await selectWorkAxis(env, axis, requested, args.timeoutMs)
                 : await selectChatAxis(env, axis, requested, args.timeoutMs);
             if (selection === undefined) {
                 return configurationFailure(page, before, desired, selected, `Configuration option "${requested}" for ${axis} was not found or was ambiguous on the ${before.experience} surface.`, "configuration_option_not_found", before.options[axis]?.map(option => option.label));
@@ -226,22 +277,37 @@ export function configurationInspectionFromSurface(experience, detectedProfile,
         const simplified = chatMenuLooksSimplified(menuItems);
         selectorProfile = simplified ? "chat_simplified_v1" : detectedProfile;
         const axis = simplified ? "intelligence" : "effort";
-        if (menuItems.length > 0 || panel.openerLabel !== undefined) {
-            availableAxes.push(axis);
-        }
-        if (panel.openerLabel !== undefined) {
-            active[axis] = panel.openerLabel;
-        }
+        const modelRows = menuItems.filter(item => item.role === "menuitemradio"
+            && item.hasPopup !== true
+            && (/^(?:gpt[\s-]|o\d+(?:\b|$)|\d+(?:\.\d+)?$)/i.test(item.label)
+                || localeLabels.modeOptions.latest.some(label => visibleLabelMatches(item.label, label))));
         const chatOptions = menuItems
-            .filter(item => !isConfigurationAxisRow(item.label))
+            .filter(item => !isConfigurationAxisRow(item.label)
+            && !modelRows.includes(item)
+            && item.hasPopup !== true
+            && !/^gpt[\s-]/i.test(item.label)
+            && item.ariaLabel !== "Select model")
             .map(menuItemToOption);
-        if (chatOptions.length > 0) {
+        const selectedEffort = chatOptions.filter(option => option.selected === true);
+        const openerValue = panel.openerValue ?? panel.openerLabel;
+        if (chatOptions.length > 0 || openerValue !== undefined)
+            availableAxes.push(axis);
+        if (selectedEffort.length === 1)
+            active[axis] = selectedEffort[0].label;
+        else if (openerValue !== undefined
+            && !isConfigurationAxisRow(openerValue)
+            && !/^(?:thinking effort|select model|power)$/i.test(openerValue))
+            active[axis] = openerValue;
+        if (chatOptions.length > 0)
             options[axis] = chatOptions;
-        }
-        const modelRows = menuItems.filter(item => /^gpt[\s-]/i.test(item.label) || item.hasPopup === true);
-        if (modelRows.length > 0) {
+        const modelOpeners = menuItems.filter(item => item.role !== "menuitemradio"
+            && /^gpt[\s-]/i.test(item.label));
+        if (modelRows.length > 0 || modelOpeners.length > 0) {
             availableAxes.push("modelVersion");
-            options.modelVersion = modelRows.map(menuItemToOption);
+            options.modelVersion = [...modelRows, ...modelOpeners].map(menuItemToOption);
+            const checked = modelRows.filter(item => item.checked === true);
+            if (checked.length === 1)
+                active.modelVersion = checked[0].label;
         }
     }
     return {
@@ -261,24 +327,46 @@ async function inspectWorkAxisOptions(env, axis) {
     await closeConfigurationSubmenu(page);
     return dedupeOptions(options);
 }
-async function selectWorkAxis(env, axis, requested) {
+async function selectWorkAxis(env, axis, requested, timeoutMs) {
     const page = env.page;
     if (!WORK_AXES.includes(axis)) {
         return undefined;
     }
-    for (let attempt = 0; attempt < 2; attempt += 1) {
+    const initialPopover = (await readChatPopover(page)).snapshot;
+    await openConfigurationRoot(page, "work");
+    if ((await readChatPopover(page)).snapshot !== undefined) {
+        try {
+            const labels = configurationSemanticLabels(requested);
+            if (axis === "model")
+                return await selectChatPopoverModel(page, labels);
+            if (axis === "effort")
+                return await selectChatPopoverEffort(page, labels);
+            if (axis === "speed")
+                return await selectChatPopoverSpeed(page, labels);
+            return undefined;
+        }
+        finally {
+            if (initialPopover === undefined)
+                await closeConfigurationMenus(page);
+        }
+    }
+    const retryWindowMs = Math.min(timeoutMs ?? CONFIGURATION_CONTROL_DISCOVERY_TIMEOUT_MS, CONFIGURATION_CONTROL_DISCOVERY_TIMEOUT_MS);
+    const attempts = Math.max(2, Math.min(CONFIGURATION_SELECTION_MAX_ATTEMPTS, Math.ceil(Math.max(0, retryWindowMs) / CONFIGURATION_SELECTION_RETRY_MS) + 1));
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
         const candidates = await openWorkAxisOptions(env, axis);
         const match = findConfigurationOption(candidates, requested);
         if (match !== undefined && await clickVisibleMenuItem(page, match)) {
             await page.waitForTimeout?.(150);
             return match.label;
         }
-        if (attempt === 0) {
+        if (attempt + 1 < attempts) {
             // The submenu can disappear between enumeration and the visible click
-            // when ChatGPT's pointer-grace timer fires. Reopen once and click from a
-            // fresh DOM instance instead of treating that transient race as drift.
+            // when ChatGPT's pointer-grace timer fires, and Work may briefly retain
+            // the previous submenu immediately after a selection. Reopen from a
+            // fresh DOM instance for a small bounded window instead of treating the
+            // transient state as permanent selector drift.
             await closeConfigurationMenus(page);
-            await page.waitForTimeout?.(200);
+            await page.waitForTimeout?.(CONFIGURATION_SELECTION_RETRY_MS);
         }
     }
     return undefined;
@@ -418,6 +506,22 @@ function workAxisOptionLabelMatches(axis, label) {
     return candidates.some(candidate => visibleLabelMatches(label, candidate));
 }
 async function selectChatAxis(env, axis, requested, timeoutMs) {
+    const page = env.page;
+    const initialPopover = (await readChatPopover(page)).snapshot;
+    await openConfigurationRoot(page, "chat");
+    if ((await readChatPopover(page)).snapshot !== undefined) {
+        try {
+            if (axis === "modelVersion")
+                return await selectChatPopoverModel(page, configurationSemanticLabels(requested));
+            if (axis === "effort" || axis === "intelligence" || axis === "model")
+                return await selectChatPopoverEffort(page, configurationSemanticLabels(requested));
+            return undefined;
+        }
+        finally {
+            if (initialPopover === undefined)
+                await closeConfigurationMenus(page);
+        }
+    }
     const legacyArgs = axis === "modelVersion"
         ? { modelVersion: requested }
         : axis === "intelligence"
@@ -437,6 +541,8 @@ async function selectChatAxis(env, axis, requested, timeoutMs) {
     return result.ok ? result.data?.selected.at(-1) : undefined;
 }
 async function openConfigurationRoot(page, experience) {
+    if (experience !== "unknown" && (await readChatPopover(page)).snapshot !== undefined)
+        return true;
     const existing = await readConfigurationPanel(page);
     if (existing.axisRows.length > 0) {
         return true;
@@ -648,6 +754,7 @@ async function readConfigurationPanel(page) {
             const html = control;
             return {
                 label: normalize(control.getAttribute("aria-label") ?? html.innerText ?? control.textContent ?? ""),
+                value: normalize(html.innerText ?? control.textContent ?? ""),
                 testId: control.getAttribute("data-testid") ?? ""
             };
         })
@@ -660,6 +767,8 @@ async function readConfigurationPanel(page) {
         };
         if (openerCandidates.length === 1 && openerCandidates[0]?.label.length) {
             result.openerLabel = openerCandidates[0].label;
+            if (openerCandidates[0].value.length > 0)
+                result.openerValue = openerCandidates[0].value;
         }
         return result;
     }, localeLabels.configurationAxes).catch(() => ({ axisRows: [], advancedVisible: false }));
@@ -826,6 +935,10 @@ function normalizeConfigurationId(value) {
         .trim();
 }
 async function closeConfigurationMenus(page) {
+    if ((await readChatPopover(page)).snapshot !== undefined) {
+        await closeChatPopover(page);
+        return;
+    }
     if (!await pressConfigurationEscape(page))
         return;
     await page.waitForTimeout?.(50);

package/dist/src/commands/context.js

@@ -1,11 +1,18 @@
 import { countPageMessages } from "../dom/messages.js";
 import { parseConversationId } from "../browser/page-state.js";
 import { withTimeout } from "./timeouts.js";
+import { chatGPTAttachmentContextUrl } from "../browser/chatgpt-url.js";
 export async function contextFromPage(page, partial = {}, options = {}) {
+    const partialAttachmentUrl = chatGPTAttachmentContextUrl(partial.url);
+    const safePartial = partialAttachmentUrl === undefined ? partial : { ...partial, url: partialAttachmentUrl };
     if (page === undefined || options.minimal === true) {
-        return { timestamp: new Date().toISOString(), ...partial };
+        return { timestamp: new Date().toISOString(), ...safePartial };
+    }
+    const url = typeof page.url === "function" ? await Promise.resolve().then(() => page.url()).catch(() => safePartial.url) : safePartial.url;
+    const attachmentUrl = chatGPTAttachmentContextUrl(url);
+    if (attachmentUrl !== undefined) {
+        return { timestamp: new Date().toISOString(), ...safePartial, url: attachmentUrl };
     }
-    const url = typeof page.url === "function" ? await Promise.resolve(page.url()).catch(() => partial.url) : partial.url;
     const title = typeof page.title === "function"
         ? await withTimeout(page.title(), 1000, "Timed out while reading page title.").catch(() => partial.title)
         : partial.title;
@@ -16,7 +23,7 @@ export async function contextFromPage(page, partial = {}, options = {}) {
     const conversationId = url !== undefined ? parseConversationId(url) : partial.conversationId;
     const context = {
         timestamp: new Date().toISOString(),
-        ...partial
+        ...safePartial
     };
     if (url !== undefined) {
         context.url = url;

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

@@ -1,6 +1,6 @@
 import type { BootstrapArgs, CommandResult, RuntimeEnv } from "../types.js";
 import type { RunReportOptions } from "./reports.js";
-export type DoctorCheckName = "bridge" | "login" | "upload" | "download" | "clipboard" | "modes" | "tools" | "selectors" | "existing_tab" | "artifacts" | "file_preflight" | "localization" | "reports";
+export type DoctorCheckName = "compatibility" | "bridge" | "login" | "upload" | "download" | "clipboard" | "modes" | "tools" | "selectors" | "existing_tab" | "artifacts" | "file_preflight" | "localization" | "reports";
 export type CapabilityStatus = "ok" | "blocked" | "unsupported" | "unknown";
 export type CapabilityCheck = {
     status: CapabilityStatus;

package/dist/src/commands/doctor.js

@@ -4,12 +4,12 @@ import { readSystemClipboard } from "../browser/clipboard.js";
 import { readPageState } from "../browser/page-state.js";
 import { localeLabels } from "../dom/locale-labels.js";
 import { localeCoverageSummary } from "../dom/locale/index.js";
-import { BROWSER_BRIDGE_REMEDIATION, resultOk } from "../errors.js";
+import { BROWSER_BRIDGE_REMEDIATION, nodeErrorCode, resultOk } from "../errors.js";
 import { explainCommandBlocker } from "../diagnostics/blockers.js";
 import { preflightFiles } from "./files.js";
 import { contextFromPage } from "./context.js";
 import { bootstrap } from "./session.js";
-const DEFAULT_CHECKS = ["bridge", "login", "upload", "download", "clipboard", "modes", "tools", "selectors"];
+const DEFAULT_CHECKS = ["compatibility", "bridge", "login", "upload", "download", "clipboard", "modes", "tools", "selectors"];
 const BOOTSTRAP_CHECKS = new Set(["bridge", "login", "upload", "download", "modes", "tools", "selectors"]);
 const UPLOAD_REMEDIATION = [
     "Codex Settings > Computer Use > Chrome > Permissions > Uploads: set to Always allow, or add chatgpt.com to the allowed upload domains.",
@@ -47,6 +47,9 @@ export async function doctor(env, args = {}) {
         : undefined;
     for (const check of wanted) {
         switch (check) {
+            case "compatibility":
+                checks.compatibility = compatibilityCheck(env.compatibility);
+                break;
             case "bridge":
                 checks.bridge = boot?.ok
                     ? ok("Chrome bridge is available.")
@@ -95,6 +98,26 @@ export async function doctor(env, args = {}) {
     const ready = Object.values(checks).every(check => check?.status === "ok" || check?.status === "unknown");
     return resultOk({ ready, checks }, await contextFromPage(env.page));
 }
+function compatibilityCheck(report) {
+    if (report === undefined)
+        return unknown("Backend compatibility has not been negotiated.");
+    const firstWarning = report.warnings[0];
+    const message = firstWarning === undefined
+        ? "Backend protocol and advertised capabilities are compatible."
+        : firstWarning.message;
+    return {
+        status: report.status === "blocked"
+            ? "blocked"
+            : report.status === "warning"
+                ? "unknown"
+                : report.status === "unknown"
+                    ? "unknown"
+                    : "ok",
+        message,
+        ...(firstWarning?.code === undefined ? {} : { code: firstWarning.code }),
+        details: report
+    };
+}
 function bridgeCheck(boot) {
     if (boot === undefined) {
         return unknown("Bridge readiness was not requested.");
@@ -138,7 +161,7 @@ function downloadCheck(env) {
     if (page === undefined)
         return unknown("Download readiness requires a bootstrapped ChatGPT page.");
     return typeof page.waitForEvent === "function"
-        ? ok("Browser download events are available.")
+        ? ok("The browser exposes a download event API; a completed download receipt has not been verified.")
         : unsupported("The active browser page does not expose download events.");
 }
 async function clipboardCheck() {
@@ -410,5 +433,5 @@ function capability(status, message, remediation, details, nextCommand, blockerK
     return check;
 }
 function isNodeError(error) {
-    return error instanceof Error && "code" in error;
+    return nodeErrorCode(error) !== undefined;
 }

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

@@ -3,6 +3,11 @@ type SurfaceSnapshot = {
     url: string;
     composerLabels: string[];
     mainControls: string[];
+    /** Controls outside overlays, scoped to the composer (or main fallback). */
+    composerControls?: string[];
+    /** Separate visible control roots; unrelated overlays cannot combine axes. */
+    controlGroups?: string[][];
+    rootBudgetExceeded?: true;
     mainText: string;
     selectedSurfaceLabels?: string[];
 };

package/dist/src/commands/experience.js

@@ -1,4 +1,5 @@
 import { resultError, resultOk } from "../errors.js";
+import { readPageState } from "../browser/page-state.js";
 import { localeLabels } from "../dom/locale-labels.js";
 import { normalizeForLabelMatch, visibleLabelMatches } from "../dom/label-match.js";
 import { contextFromPage } from "./context.js";
@@ -6,15 +7,30 @@ import { ensurePage } from "./session.js";
 const CHATGPT_HOME = "https://chatgpt.com/";
 const EXPERIENCE_CONTROL_DISCOVERY_TIMEOUT_MS = 15_000;
 const EXPERIENCE_POLL_MS = 250;
+const EXPERIENCE_READINESS_TIMEOUT_MS = 1500;
 export async function detectExperience(env, args = {}) {
-    void args;
     const boot = await ensurePage(env);
     if (!boot.ok) {
         return boot;
     }
     const page = env.page;
     try {
-        const data = detectExperienceFromSnapshot(await readSurfaceSnapshot(page));
+        const readinessMs = Math.max(0, Math.min(args.timeoutMs ?? EXPERIENCE_READINESS_TIMEOUT_MS, EXPERIENCE_CONTROL_DISCOVERY_TIMEOUT_MS));
+        const readinessDeadline = Date.now() + readinessMs;
+        let data = detectExperienceFromSnapshot(await readSurfaceSnapshot(page));
+        // An empty post-navigation capture is loading evidence, not a final
+        // classification. Never wait out a known blocker or a genuine score tie.
+        for (let attempt = 1; data.experience === "unknown" && data.evidence.length === 0
+            && Date.now() < readinessDeadline
+            && attempt < pollAttempts(readinessMs, EXPERIENCE_POLL_MS); attempt += 1) {
+            const blocker = await experiencePageBlocker(page, data);
+            if (blocker !== undefined)
+                return blocker;
+            if (page.waitForTimeout === undefined || Date.now() >= readinessDeadline)
+                break;
+            await page.waitForTimeout(Math.min(EXPERIENCE_POLL_MS, readinessDeadline - Date.now()));
+            data = detectExperienceFromSnapshot(await readSurfaceSnapshot(page));
+        }
         return resultOk(data, await contextFromPage(page, {
             experience: data.experience,
             selectorProfile: data.selectorProfile
@@ -34,6 +50,9 @@ export async function openExperience(env, args) {
     const page = env.page;
     try {
         const before = detectExperienceFromSnapshot(await readSurfaceSnapshot(page));
+        const initialBlocker = await experiencePageBlocker(page, before);
+        if (initialBlocker !== undefined)
+            return initialBlocker;
         if (before.experience === args.experience) {
             return resultOk({
                 experience: args.experience,
@@ -52,6 +71,9 @@ export async function openExperience(env, args) {
         let controlClicked = await clickUniqueExperienceControl(page, labels);
         if (!controlClicked && await navigateConversationToSurfaceHome(page, args.timeoutMs)) {
             observed = detectExperienceFromSnapshot(await readSurfaceSnapshot(page));
+            const navigationBlocker = await experiencePageBlocker(page, observed);
+            if (navigationBlocker !== undefined)
+                return navigationBlocker;
             if (observed.experience === args.experience) {
                 return resultOk({
                     experience: args.experience,
@@ -85,6 +107,9 @@ export async function openExperience(env, args) {
             controlClicked = await clickUniqueExperienceControl(page, labels);
         }
         if (!controlClicked) {
+            const discoveryBlocker = await experiencePageBlocker(page, observed);
+            if (discoveryBlocker !== undefined)
+                return discoveryBlocker;
             return experienceSelectorDrift(page, `No unique visible ChatGPT ${args.experience === "work" ? "Work" : "Chat"} surface control was found.`, observed);
         }
         let after = before;
@@ -103,6 +128,9 @@ export async function openExperience(env, args) {
                 }));
             }
         }
+        const postconditionBlocker = await experiencePageBlocker(page, after);
+        if (postconditionBlocker !== undefined)
+            return postconditionBlocker;
         return {
             ok: false,
             status: "blocked",
@@ -125,6 +153,28 @@ export async function openExperience(env, args) {
         return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
     }
 }
+async function experiencePageBlocker(page, observed) {
+    const state = await readPageState(page);
+    if (state.blocker === undefined)
+        return undefined;
+    return {
+        ok: false,
+        status: "blocked",
+        warnings: [],
+        blocker: {
+            kind: state.blocker.kind,
+            code: `experience_blocked_${state.blocker.kind}`,
+            fieldPath: "experience",
+            message: state.blocker.message,
+            ...(state.blocker.visibleText === undefined ? {} : { visibleText: state.blocker.visibleText }),
+            resumable: true
+        },
+        context: await contextFromPage(page, {
+            experience: observed.experience,
+            selectorProfile: observed.selectorProfile
+        })
+    };
+}
 function pollAttempts(timeoutMs, pollMs) {
     return Math.max(1, Math.ceil(Math.max(0, timeoutMs) / pollMs));
 }
@@ -142,9 +192,14 @@ async function navigateConversationToSurfaceHome(page, timeoutMs) {
     return true;
 }
 export function detectExperienceFromSnapshot(snapshot) {
+    if (snapshot.rootBudgetExceeded === true) {
+        return {
+            experience: "unknown", selectorProfile: "unknown", confidence: "low",
+            evidence: [{ source: "control", label: "Experience surface root budget exceeded" }]
+        };
+    }
     const evidence = [];
     const composerLabels = snapshot.composerLabels.map(normalizeForLabelMatch);
-    const controls = snapshot.mainControls.map(normalizeForLabelMatch);
     const mainText = normalizeForLabelMatch(snapshot.mainText);
     const selectedSurfaceLabels = (snapshot.selectedSurfaceLabels ?? []).map(normalizeForLabelMatch);
     const url = snapshot.url.toLowerCase();
@@ -166,13 +221,18 @@ export function detectExperienceFromSnapshot(snapshot) {
     for (const label of chatComposer) {
         evidence.push({ source: "composer", label });
     }
-    const workAxisCount = ["model", "effort", "speed"]
-        .filter(axis => hasAnyLabel(controls, localeLabels.configurationAxes[axis]))
-        .length;
-    if (workAxisCount >= 2) {
-        evidence.push({ source: "control", label: `Work configuration axes (${workAxisCount}/3)` });
+    // Model and effort also occur in the Chat composer popover. Only the
+    // complete Work axis group, including speed in the same visible pane,
+    // supplies Work evidence. Do not combine labels across unrelated overlays.
+    const workAxes = (snapshot.controlGroups ?? [snapshot.mainControls]).some(group => {
+        const groupLabels = group.map(normalizeForLabelMatch);
+        return ["model", "effort", "speed"].every(axis => hasAnyLabel(groupLabels, localeLabels.configurationAxes[axis]));
+    });
+    if (workAxes) {
+        evidence.push({ source: "control", label: "Work configuration axes (3/3)" });
     }
-    const workConfigurationOpener = controls.some(label => /\b(?:gpt[\s-]?\d|\d+(?:\.\d+)+|sol|luna|terra)\b/i.test(label)
+    const composerControls = (snapshot.composerControls ?? snapshot.mainControls).map(normalizeForLabelMatch);
+    const workConfigurationOpener = composerControls.some(label => /\b(?:gpt[\s-]?\d|\d+(?:\.\d+)+|sol|luna|terra)\b/i.test(label)
         && hasAnyLabel([label], [
             ...localeLabels.configurationOptions.light,
             ...localeLabels.configurationOptions.medium,
@@ -192,7 +252,7 @@ export function detectExperienceFromSnapshot(snapshot) {
     }
     const workScore = workComposer.length * 4
         + (workSurfaceSelected ? 10 : 0)
-        + (workAxisCount >= 2 ? 4 : 0)
+        + (workAxes ? 6 : 0)
         // The active Work task drops the Chat/Work radio and keeps the shared
         // "Chat with ChatGPT" textbox name. Its compound model + effort opener is
         // therefore strong enough to disambiguate that continuation surface.
@@ -253,7 +313,19 @@ export async function readSurfaceSnapshot(page) {
         const normalize = (value) => value.replace(/\s+/g, " ").trim();
         const normalizeComparable = (value) => normalize(value).toLocaleLowerCase();
         const wantedSurfaceLabels = new Set(surfaceOptionLabels.map(normalizeComparable));
-        const composerRoots = Array.from(document.querySelectorAll("main form, main [data-testid*='composer' i], main [class*='composer' i]"));
+        const composerRoots = Array.from(document.querySelectorAll("main form, main [data-testid*='composer' i], main [class*='composer' i]")).filter(visible);
+        const main = document.querySelector("main");
+        const overlayRoots = Array.from(document.querySelectorAll("[role='menu'], [role='listbox'], [data-radix-popper-content-wrapper], [data-radix-menu-content]")).filter(visible);
+        const composerControlRoots = composerRoots.length > 0 ? composerRoots : main === null ? [] : [main];
+        const effectiveControlRoots = Array.from(new Set([...composerControlRoots, ...overlayRoots]));
+        // Reject oversized captures before expanding overlapping subtrees. A
+        // truncated prefix could omit contradictory surface evidence.
+        if (effectiveControlRoots.length > 32) {
+            return {
+                composerLabels: [], mainControls: [], composerControls: [], controlGroups: [],
+                mainText: "", selectedSurfaceLabels: [], rootBudgetExceeded: true
+            };
+        }
         const composerNodes = composerRoots.flatMap(root => [
             root,
             ...Array.from(root.querySelectorAll("textarea, [contenteditable='true'], [role='textbox'], input"))
@@ -264,18 +336,29 @@ export async function readSurfaceSnapshot(page) {
             .map(normalize)
             .filter(Boolean)))
             .slice(0, 16);
-        const main = document.querySelector("main");
-        const overlayRoots = Array.from(document.querySelectorAll("[role='menu'], [role='listbox'], [data-radix-popper-content-wrapper], [data-radix-menu-content]")).filter(visible);
-        const controlRoots = Array.from(new Set([...composerRoots, ...overlayRoots]));
-        const effectiveControlRoots = controlRoots.length > 0
-            ? controlRoots
-            : main === null ? [] : [main];
-        const mainControls = Array.from(new Set(effectiveControlRoots.flatMap(root => Array.from(root.querySelectorAll("button, [role='button'], [role='menuitem'], [role='menuitemradio'], [role='option']")))
+        const overlayRootSet = new Set(overlayRoots);
+        const owningOverlay = (node) => {
+            let current = node;
+            while (current !== null) {
+                if (overlayRootSet.has(current))
+                    return current;
+                current = current.parentElement;
+            }
+            return undefined;
+        };
+        const controlsFor = (root) => Array.from(new Set(Array.from(root.querySelectorAll("button, [role='button'], [role='menuitem'], [role='menuitemradio'], [role='option']"))
             .filter(visible)
+            // An ancestor composer/popover must not aggregate independent or
+            // nested menus. Each overlay contributes only its own nearest scope.
+            .filter(node => owningOverlay(node) === (overlayRootSet.has(root) ? root : undefined))
             .map(labelFor)
             .map(normalize)
-            .filter(Boolean)))
-            .slice(0, 120);
+            .filter(Boolean))).slice(0, 120);
+        const rootGroups = new Map(effectiveControlRoots.map(root => [root, controlsFor(root)]));
+        const controlGroups = [...rootGroups.values()];
+        const mainControls = Array.from(new Set(controlGroups.flat())).slice(0, 120);
+        const composerControls = Array.from(new Set(composerControlRoots
+            .flatMap(root => rootGroups.get(root) ?? []))).slice(0, 120);
         const surfaceTextNodes = main === null ? [] : Array.from(main.querySelectorAll("h1, h2, h3, form, [data-testid*='composer' i], [class*='composer' i]"))
             .filter(visible)
             .slice(0, 32);
@@ -286,7 +369,7 @@ export async function readSurfaceSnapshot(page) {
             .map(normalize)
             .filter(label => wantedSurfaceLabels.has(normalizeComparable(label)))))
             .slice(0, 4);
-        return { composerLabels, mainControls, mainText, selectedSurfaceLabels };
+        return { composerLabels, mainControls, composerControls, controlGroups, mainText, selectedSurfaceLabels };
     }, [
         ...localeLabels.experienceOptions.chat,
         ...localeLabels.experienceOptions.work,