codex-chatgpt-control 0.5.0-alpha.1 → 0.5.1-alpha.2

package/dist/src/dom/locale/zh-TW.js

@@ -5,9 +5,27 @@
  *
  * Some non-Intelligence surfaces may still fall back to English + `selector_drift`.
  *
- * Intelligence picker labels updated 2026-06-10 and stop-control labels updated 2026-06-15 from visible ChatGPT Pro sessions.
+ * Intelligence picker labels updated 2026-06-10, stop-control labels updated 2026-06-15, Chat/Work surface labels updated 2026-07-17, and Power/Advanced selector labels updated 2026-08-08 from visible ChatGPT sessions.
  */
 export const zhTW = {
+    configurationAxes: {
+        power: ["能力"],
+        model: ["模型"],
+        effort: ["推理強度"],
+        speed: ["速度"],
+        advanced: ["進階"],
+    },
+    configurationOptions: {
+        instant: ["即時"],
+        light: ["快思"],
+        medium: ["中"],
+        high: ["高"],
+        extraHigh: ["極高", "超高"],
+        max: ["最高"],
+        ultra: ["極致"],
+        standard: ["標準"],
+        fast: ["快速"],
+    },
     composerTextbox: ["與 ChatGPT 對話"],
     sendButton: ["傳送提示詞"],
     searchChatsButton: ["搜尋對話"],
@@ -17,15 +35,19 @@ export const zhTW = {
     addFilesOpenerCandidates: ["新增檔案等更多功能"],
     addPhotosFilesMenuItem: ["新增照片和檔案"],
     copyResponse: ["複製回應"],
-    modeLabels: ["即時", "中等", "高", "超高", "專業"],
+    modeLabels: ["即時", "中等", "高", "超高", "專業", "中"],
     modeOptions: {
         instant: ["即時"],
-        medium: ["中等"],
+        medium: ["中等", "中"],
         high: ["高"],
         extraHigh: ["超高"],
         pro: ["專業"],
     },
     modeOpenerExtra: ["設定"],
+    experienceOptions: {
+        chat: ["對話"],
+        work: ["工作"],
+    },
     tools: {
         web_search: ["網頁搜尋"],
         deep_research: ["深入研究"],

package/dist/src/dom/menus.js

@@ -10,6 +10,28 @@ export function extractMenuItemsFromText(text) {
 export async function enumerateVisibleMenuItems(page) {
     if (typeof page.evaluate === "function") {
         const labels = await page.evaluate(() => {
+            const visible = (element) => {
+                const html = element;
+                const rect = html.getBoundingClientRect?.();
+                if (rect !== undefined && (rect.width <= 0 || rect.height <= 0))
+                    return false;
+                let current = element;
+                while (current !== null) {
+                    if (current.hasAttribute?.("inert") || current.getAttribute?.("aria-hidden") === "true") {
+                        return false;
+                    }
+                    const style = typeof window !== "undefined"
+                        ? window.getComputedStyle?.(current)
+                        : undefined;
+                    if (style?.display === "none"
+                        || style?.visibility === "hidden"
+                        || style?.opacity === "0") {
+                        return false;
+                    }
+                    current = current.parentElement ?? null;
+                }
+                return true;
+            };
             const toItem = (node) => {
                 const element = node;
                 const label = (element.innerText ?? element.textContent ?? "").replace(/\s+/g, " ").trim();
@@ -37,13 +59,14 @@ export async function enumerateVisibleMenuItems(page) {
                     item.ariaLabel = ariaLabel;
                 return item;
             };
-            const allRoleNodes = Array.from(document.querySelectorAll("[role='menuitem'], [role='menuitemradio'], [role='option']"));
+            const allRoleNodes = Array.from(document.querySelectorAll("[role='menuitem'], [role='menuitemradio'], [role='option']"))
+                .filter(visible);
             // Scope to open menu containers when any exist, so stray role items elsewhere on
             // the page (sidebar rows, decorative listboxes) cannot contaminate menu matching.
             // An empty scoped set falls back to the unscoped list: real menus keep their items
             // inside the container, so an empty intersection means the container heuristic failed.
             const containers = Array.from(document.querySelectorAll("[role='menu'], [role='listbox'], [data-radix-popper-content-wrapper]"))
-                .filter(container => typeof container.contains === "function");
+                .filter(container => visible(container) && typeof container.contains === "function");
             const scopedRoleNodes = containers.length > 0
                 ? allRoleNodes.filter(node => containers.some(container => container.contains(node)))
                 : allRoleNodes;
@@ -54,6 +77,7 @@ export async function enumerateVisibleMenuItems(page) {
                 return { items: roleItems, labels: [], split: false };
             }
             const menus = Array.from(document.querySelectorAll("[role='menu'], [role='listbox'], [data-radix-popper-content-wrapper]"))
+                .filter(visible)
                 .map(node => node.innerText ?? node.textContent ?? "")
                 .filter(Boolean);
             return { items: [], labels: menus, split: true };

package/dist/src/dom/selectors.d.ts

@@ -10,6 +10,7 @@ export declare const cssSelectors: {
 };
 export declare function composerTextbox(page: PageLike): LocatorLike;
 export declare function sendButton(page: PageLike): LocatorLike;
+export declare function stopGenerationButton(page: PageLike): LocatorLike;
 export declare function searchChatsButton(page: PageLike): LocatorLike;
 export declare function searchChatsInput(page: PageLike): LocatorLike;
 export declare function newChatButton(page: PageLike): LocatorLike;

package/dist/src/dom/selectors.js

@@ -1,4 +1,4 @@
-import { anyLabelPattern, localeLabels } from "./locale-labels.js";
+import { anyLabelPattern, escapeRegExp, localeLabels } from "./locale-labels.js";
 // Language-sensitive label tokens are sourced from the locale registry; the structural
 // clauses (download attributes, file-backend hrefs, blob/data sources) are language-agnostic
 // and stay literal. For a single English candidate the generated selectors are identical to
@@ -57,6 +57,14 @@ export function sendButton(page) {
     }
     return page.getByRole("button", { name: anyLabelPattern(localeLabels.sendButton) });
 }
+export function stopGenerationButton(page) {
+    if (typeof page.getByRole !== "function") {
+        return requiredLocator(page, "button[aria-label*='Stop'], button[title*='Stop']");
+    }
+    return page.getByRole("button", {
+        name: new RegExp(`^(?:${localeLabels.stopControl.map(escapeRegExp).join("|")})$`, "i")
+    });
+}
 export function searchChatsButton(page) {
     if (typeof page.getByRole !== "function") {
         return requiredLocator(page, "button");

package/dist/src/dom/wait-snapshot.d.ts

@@ -15,6 +15,7 @@ export type WaitDomSnapshot = {
     latestAssistantTurnIndex?: number;
     text: WaitTextMetadata;
     generation: {
+        observed: boolean;
         active: boolean;
         stopped: boolean;
         signals: string[];

package/dist/src/dom/wait-snapshot.js

@@ -53,35 +53,57 @@ export async function readWaitDomSnapshot(page) {
             || /^reading (?:the )?images?$/.test(trimmedForTransient);
         // --- Generation state: mirrors dom/generation-state.ts readAssistantGenerationState ---
         const isVisible = (element) => {
+            if (element.hidden || element.closest("[hidden], [inert], [aria-hidden='true']") !== null) {
+                return false;
+            }
             const style = window.getComputedStyle(element);
-            return style.display !== "none"
-                && style.visibility !== "hidden"
-                && style.opacity !== "0"
-                && element.getAttribute("aria-hidden") !== "true";
+            if (style.display === "none"
+                || style.visibility === "hidden"
+                || style.opacity === "0"
+                || style.pointerEvents === "none") {
+                return false;
+            }
+            const rect = element.getBoundingClientRect();
+            return rect.width > 0 || rect.height > 0;
+        };
+        const elementValues = (element) => [
+            element.getAttribute("aria-label"),
+            element.getAttribute("title"),
+            element.innerText,
+            element.textContent
+        ].map(normalizeLower).filter(Boolean);
+        const matchingLabels = (element, phrases) => {
+            const values = elementValues(element);
+            return phrases.filter(phrase => values.includes(normalizeLower(phrase)));
+        };
+        const isScopedStopControl = (button) => {
+            if (button.matches("[data-testid='stop-button'], [data-testid*='stop' i]"))
+                return true;
+            if (button.closest("[data-testid*='composer' i], [aria-label*='composer' i]") !== null)
+                return true;
+            const form = button.closest("form");
+            return form?.querySelector("textarea, [contenteditable='true'], [role='textbox']") !== null;
         };
-        const visibleButtons = Array.from(document.querySelectorAll("button"))
+        const visibleStopButtons = Array.from(document.querySelectorAll("button"))
             .filter((button) => isVisible(button)
             && button.disabled !== true
-            && button.getAttribute("aria-disabled") !== "true");
-        const buttonTexts = visibleButtons
-            .map(button => [
-            button.innerText,
-            button.textContent,
-            button.getAttribute("aria-label"),
-            button.getAttribute("title")
-        ].map(normalizeLower).filter(Boolean).join(" "))
-            .filter(Boolean);
-        const bodyText = normalizeLower(document.body?.innerText);
-        const haystacks = [bodyText, ...buttonTexts];
-        const matchingSignals = (phrases) => haystacks.flatMap(text => phrases
-            .map(phrase => phrase.toLowerCase())
-            .filter(phrase => text.includes(phrase)));
-        const activeSignals = matchingSignals(args.stop);
-        const stoppedSignals = matchingSignals(args.stopped);
+            && button.getAttribute("aria-disabled") !== "true"
+            && isScopedStopControl(button)
+            && matchingLabels(button, args.send).length === 0
+            && matchingLabels(button, args.stop).length > 0);
+        const activeSignals = [...new Set(visibleStopButtons.flatMap(button => matchingLabels(button, args.stop)))];
+        const latestAssistantTurn = latestAssistant?.closest("[data-testid^='conversation-turn']")
+            ?? Array.from(document.querySelectorAll("[data-testid^='conversation-turn']")).at(-1);
+        const stoppedSignals = latestAssistantTurn === undefined
+            ? []
+            : [...new Set(Array.from(latestAssistantTurn.querySelectorAll("button, [role='status'], [aria-label], [title], p, span, div"))
+                    .filter(element => isVisible(element))
+                    .flatMap(element => matchingLabels(element, args.stopped)))];
         const generation = {
+            observed: true,
             active: activeSignals.length > 0,
             stopped: stoppedSignals.length > 0,
-            signals: [...new Set([...activeSignals, ...stoppedSignals, ...buttonTexts.filter(text => /stop|cancel|stopped|answering|thinking/i.test(text))])].slice(0, 5)
+            signals: [...new Set([...activeSignals, ...stoppedSignals])].slice(0, 5)
         };
         // --- Response actions: mirrors dom/generation-state.ts latestAssistantTurnHasResponseActions ---
         const turns = Array.from(document.querySelectorAll("[data-testid^='conversation-turn']"));
@@ -122,6 +144,7 @@ export async function readWaitDomSnapshot(page) {
         transient: [...localeLabels.transientAssistant],
         stop: [...localeLabels.stopControl],
         stopped: [...localeLabels.stoppedAssistant],
+        send: [...localeLabels.sendButton],
         actions: [...localeLabels.responseActions]
     });
 }

package/dist/src/errors.d.ts

@@ -1,6 +1,6 @@
 import type { BlockerKind, CommandContext, CommandResult } from "./types.js";
 type BlockerDetails = Partial<Omit<NonNullable<CommandResult["blocker"]>, "kind" | "message" | "visibleText">>;
-export declare const BROWSER_BRIDGE_UNAVAILABLE_MESSAGE = "Codex cannot access the ChatGPT browser bridge from this backend process. In an ordinary shell this is expected; for a live Codex Chrome run, bootstrap the Chrome plugin runtime with setupBrowserRuntime({ globals: globalThis }) before using globalThis.agent.";
+export declare const BROWSER_BRIDGE_UNAVAILABLE_MESSAGE = "Codex cannot access the ChatGPT browser bridge from this backend process. In an ordinary shell this is expected; for a live Codex Chrome run, assign the Chrome plugin runtime returned by setupBrowserRuntime() to globalThis.agent before using it.";
 export declare const BROWSER_BRIDGE_REMEDIATION: NonNullable<NonNullable<CommandResult["blocker"]>["remediation"]>;
 export declare class ChatGPTControlError extends Error {
     readonly kind: BlockerKind;

package/dist/src/errors.js

@@ -1,4 +1,4 @@
-export const BROWSER_BRIDGE_UNAVAILABLE_MESSAGE = "Codex cannot access the ChatGPT browser bridge from this backend process. In an ordinary shell this is expected; for a live Codex Chrome run, bootstrap the Chrome plugin runtime with setupBrowserRuntime({ globals: globalThis }) before using globalThis.agent.";
+export const BROWSER_BRIDGE_UNAVAILABLE_MESSAGE = "Codex cannot access the ChatGPT browser bridge from this backend process. In an ordinary shell this is expected; for a live Codex Chrome run, assign the Chrome plugin runtime returned by setupBrowserRuntime() to globalThis.agent before using it.";
 export const BROWSER_BRIDGE_REMEDIATION = [
     {
         label: "Ordinary shell",
@@ -7,7 +7,7 @@ export const BROWSER_BRIDGE_REMEDIATION = [
     },
     {
         label: "Codex Chrome bootstrap",
-        instruction: "For a live run, initialize the Chrome plugin runtime in node_repl with setupBrowserRuntime({ globals: globalThis }), then set globalThis.browser = await agent.browsers.get(\"extension\") before calling createChatGPT({ agent: globalThis.agent }).",
+        instruction: "For a live run, initialize the Chrome plugin runtime in node_repl with globalThis.agent = await setupBrowserRuntime(), then set globalThis.browser = await agent.browsers.get(\"extension\") before calling createChatGPT({ agent: globalThis.agent }).",
         userActionRequired: false
     },
     {

package/dist/src/platform/local-paths.d.ts

@@ -1,4 +1,5 @@
 export type HostPathPlatform = NodeJS.Platform;
+export declare function currentHostPathPlatform(): HostPathPlatform;
 export declare function isHostAbsolutePath(value: string, platform?: HostPathPlatform): boolean;
 export declare function resolveForHostPath(value: string, platform?: HostPathPlatform): string;
 export declare function basenameForHostPath(value: string, platform?: HostPathPlatform): string;

package/dist/src/platform/local-paths.js

@@ -1,18 +1,22 @@
 import path from "node:path";
-export function isHostAbsolutePath(value, platform = process.platform) {
+import { platform as readHostPlatform } from "node:os";
+export function currentHostPathPlatform() {
+    return readHostPlatform();
+}
+export function isHostAbsolutePath(value, platform = currentHostPathPlatform()) {
     if (value.length === 0)
         return false;
     if (platform === "win32")
         return isFullyQualifiedWindowsPath(value);
     return path.posix.isAbsolute(value);
 }
-export function resolveForHostPath(value, platform = process.platform) {
+export function resolveForHostPath(value, platform = currentHostPathPlatform()) {
     if (!isHostAbsolutePath(value, platform)) {
         throw new Error(`File attachment path must be absolute for the backend host: ${value}`);
     }
     return platform === "win32" ? path.win32.resolve(value) : path.posix.resolve(value);
 }
-export function basenameForHostPath(value, platform = process.platform) {
+export function basenameForHostPath(value, platform = currentHostPathPlatform()) {
     return platform === "win32" ? path.win32.basename(value) : path.posix.basename(value);
 }
 function isFullyQualifiedWindowsPath(value) {

package/dist/src/safety/risk.d.ts

@@ -19,6 +19,7 @@ export declare const commandRisk: {
     readonly "messages.wait": "low";
     readonly "messages.readLatest": "medium";
     readonly "messages.status": "medium";
+    readonly "messages.stop": "medium";
     readonly "messages.waitAndRead": "medium";
     readonly "artifacts.listLatest": "medium";
     readonly "artifacts.wait": "low";

package/dist/src/safety/risk.js

@@ -18,6 +18,7 @@ export const commandRisk = {
     "messages.wait": "low",
     "messages.readLatest": "medium",
     "messages.status": "medium",
+    "messages.stop": "medium",
     "messages.waitAndRead": "medium",
     "artifacts.listLatest": "medium",
     "artifacts.wait": "low",

package/dist/src/scripts/apply-intelligence-locale-captures.d.ts

@@ -1,7 +1,16 @@
 type IntelligenceModeOptionId = "instant" | "medium" | "high" | "extraHigh" | "pro";
+type ExperienceOptionId = "chat" | "work";
+type ConfigurationAxisId = "model" | "intelligence" | "effort" | "speed" | "power" | "advanced";
+type ConfigurationOptionId = "instant" | "light" | "medium" | "high" | "extraHigh" | "max" | "ultra" | "pro" | "standard" | "fast";
+type SurfaceContribution = {
+    workComposerTextbox: string[];
+    experienceOptions: Partial<Record<ExperienceOptionId, string[]>>;
+    configurationAxes: Partial<Record<ConfigurationAxisId, string[]>>;
+    configurationOptions: Partial<Record<ConfigurationOptionId, string[]>>;
+};
 export declare function main(argv?: string[]): Promise<number>;
 export declare function mergeCapture(source: string, labels: readonly string[], modeOptions: Partial<Record<IntelligenceModeOptionId, string[]>>, generationLabels?: {
     stopControl?: readonly string[];
     stoppedAssistant?: readonly string[];
-}): string;
+}, surface?: SurfaceContribution): string;
 export {};

package/dist/src/scripts/apply-intelligence-locale-captures.js

@@ -4,6 +4,11 @@ import { fileURLToPath } from "node:url";
 import { readLanguageCoverage } from "./locale-capture/language-coverage.js";
 const ENGLISH_MODE_LABELS = new Set(["Latest", "Instant", "Thinking", "Extended", "Medium", "High", "Extra High", "Pro"]);
 const ENGLISH_STOP_CONTROL = new Set(["stop generating", "stop streaming", "stop answering", "cancel"]);
+// These labels are unsafe regardless of language provenance: they are generic
+// controls that can describe Send, dialog dismissal, or unrelated cancellation.
+// Keep this separate from the English-exclusion set so changing the canonical
+// English registry can never make them eligible for a locale stop selector.
+const UNSAFE_GENERIC_STOP_CONTROLS = new Set(["cancel"]);
 const ENGLISH_STOPPED_ASSISTANT = new Set(["stopped thinking", "stopped answering", "generation stopped"]);
 const INTELLIGENCE_MODE_OPTION_IDS = ["instant", "medium", "high", "extraHigh", "pro"];
 const ENGLISH_INTELLIGENCE_MODE_OPTIONS = {
@@ -13,7 +18,37 @@ const ENGLISH_INTELLIGENCE_MODE_OPTIONS = {
     extraHigh: "Extra High",
     pro: "Pro",
 };
-const UPDATE_NOTE = " * Intelligence picker labels updated 2026-06-10 and stop-control labels updated 2026-06-15 from visible ChatGPT Pro sessions.";
+const EXPERIENCE_OPTION_IDS = ["chat", "work"];
+const WORK_CONFIGURATION_AXIS_IDS = ["model", "effort", "speed"];
+const CHAT_CONFIGURATION_AXIS_IDS = ["model", "effort"];
+const CONFIGURATION_AXIS_IDS = ["power", "model", "intelligence", "effort", "speed", "advanced"];
+const CONFIGURATION_OPTION_IDS = ["instant", "light", "medium", "high", "extraHigh", "max", "ultra", "pro", "standard", "fast"];
+const CHAT_EFFORT_OPTION_IDS = ["instant", "medium", "high", "extraHigh", "pro"];
+const EFFORT_OPTION_IDS = ["light", "medium", "high", "extraHigh", "max", "ultra"];
+const SPEED_OPTION_IDS = ["standard", "fast"];
+const ENGLISH_EXPERIENCE_OPTIONS = new Set(["chat", "quick chat", "work"]);
+const ENGLISH_CONFIGURATION_AXES = {
+    model: "Model",
+    intelligence: "Intelligence",
+    effort: "Effort",
+    speed: "Speed",
+    power: "Power",
+    advanced: "Advanced"
+};
+const ENGLISH_CONFIGURATION_OPTIONS = {
+    instant: "Instant",
+    light: "Light",
+    medium: "Medium",
+    high: "High",
+    extraHigh: "Extra High",
+    max: "Max",
+    ultra: "Ultra",
+    pro: "Pro",
+    standard: "Standard",
+    fast: "Fast",
+};
+const ENGLISH_COMPOSER_LABELS = new Set(["chat with chatgpt", "ask chatgpt", "work on anything", "work on something"]);
+const UPDATE_NOTE = " * Intelligence picker labels updated 2026-06-10, stop-control labels updated 2026-06-15, Chat/Work surface labels updated 2026-07-17, and Power/Advanced selector labels updated 2026-08-08 from visible ChatGPT sessions.";
 class ApplyUsageError extends Error {
     exitCode;
     constructor(message, exitCode = 2) {
@@ -58,7 +93,15 @@ export async function main(argv = process.argv.slice(2)) {
         const modeOptions = observedNonEnglishModeOptions(record);
         const stopControl = observedNonEnglishGenerationLabels(record.generationStopLabels, ENGLISH_STOP_CONTROL);
         const stoppedAssistant = observedNonEnglishGenerationLabels(record.generationStoppedLabels, ENGLISH_STOPPED_ASSISTANT);
-        if (labels.length === 0 && Object.keys(modeOptions).length === 0 && stopControl.length === 0 && stoppedAssistant.length === 0)
+        const surface = observedNonEnglishSurface(record);
+        if (labels.length === 0
+            && Object.keys(modeOptions).length === 0
+            && stopControl.length === 0
+            && stoppedAssistant.length === 0
+            && surface.workComposerTextbox.length === 0
+            && Object.keys(surface.experienceOptions).length === 0
+            && Object.keys(surface.configurationAxes).length === 0
+            && Object.keys(surface.configurationOptions).length === 0)
             continue;
         planned.push({
             locale: language.bcp47,
@@ -67,6 +110,7 @@ export async function main(argv = process.argv.slice(2)) {
             modeOptions,
             stopControl,
             stoppedAssistant,
+            surface,
         });
     }
     if (!options.reviewed) {
@@ -81,10 +125,10 @@ export async function main(argv = process.argv.slice(2)) {
         const after = mergeCapture(before, change.labels, change.modeOptions, {
             stopControl: change.stopControl,
             stoppedAssistant: change.stoppedAssistant,
-        });
+        }, change.surface);
         if (after !== before) {
             await writeFile(change.file, after, "utf8");
-            console.log(`updated ${change.locale} labels=${change.labels.length} modeOptions=${Object.keys(change.modeOptions).length} stopControl=${change.stopControl.length} stoppedAssistant=${change.stoppedAssistant.length}`);
+            console.log(`updated ${change.locale} labels=${change.labels.length} modeOptions=${Object.keys(change.modeOptions).length} surfaces=${surfaceContributionCount(change.surface)} stopControl=${change.stopControl.length} stoppedAssistant=${change.stoppedAssistant.length}`);
         }
     }
     return 0;
@@ -130,9 +174,95 @@ function observedNonEnglishModeOptions(record) {
 function observedNonEnglishGenerationLabels(values, englishValues) {
     return dedupe((values ?? [])
         .map(value => value.replace(/\s+/g, " ").trim())
-        .filter(value => value.length > 0 && !englishValues.has(value.toLowerCase())));
+        .filter(value => value.length > 0
+        && !englishValues.has(value.toLowerCase())
+        && !UNSAFE_GENERIC_STOP_CONTROLS.has(value.toLowerCase())));
 }
-export function mergeCapture(source, labels, modeOptions, generationLabels = {}) {
+function observedNonEnglishSurface(record) {
+    const empty = {
+        workComposerTextbox: [],
+        experienceOptions: {},
+        configurationAxes: {},
+        configurationOptions: {},
+    };
+    const capture = record.surfaceCapture;
+    if (capture === undefined)
+        return empty;
+    if (capture.status !== "ok" || capture.chat === undefined || capture.work === undefined || !capture.restoredChat) {
+        throw new ApplyUsageError(`${record.requestedLocale} surface capture was not successful and restored: ${capture.blocker?.message ?? "unknown blocker"}.`, 1);
+    }
+    const contribution = { ...empty };
+    contribution.experienceOptions = {
+        ...nonEnglishSlot("chat", capture.chat.optionLabel, ENGLISH_EXPERIENCE_OPTIONS),
+        ...nonEnglishSlot("work", capture.work.optionLabel, ENGLISH_EXPERIENCE_OPTIONS),
+    };
+    const sharedComposerLabels = new Set(capture.chat.composerLabels.map(normalizedLower));
+    contribution.workComposerTextbox = dedupe(capture.work.composerLabels
+        .map(normalized)
+        .filter(label => label.length > 0
+        && !sharedComposerLabels.has(normalizedLower(label))
+        && !ENGLISH_COMPOSER_LABELS.has(normalizedLower(label))));
+    addLocalizedConfigurationAxis(contribution.configurationAxes, "power", capture.chat.power?.axisLabel);
+    addLocalizedConfigurationAxis(contribution.configurationAxes, "power", capture.work.power?.axisLabel);
+    addLocalizedConfigurationAxis(contribution.configurationAxes, "advanced", capture.chat.advanced?.label);
+    addLocalizedConfigurationAxis(contribution.configurationAxes, "advanced", capture.work.advanced?.label);
+    const chatRows = capture.chat.configurationRows;
+    if (chatRows !== undefined) {
+        if (chatRows.length !== CHAT_CONFIGURATION_AXIS_IDS.length
+            || chatRows.some((row, index) => row.axis !== CHAT_CONFIGURATION_AXIS_IDS[index])) {
+            throw new ApplyUsageError(`${record.requestedLocale} did not capture the ordered Chat Model/Effort rows.`, 1);
+        }
+        for (const row of chatRows) {
+            addLocalizedConfigurationAxis(contribution.configurationAxes, row.axis, row.axisLabel);
+            if (row.axis === "effort") {
+                assignOrderedLocalizedOptions(record.requestedLocale, row.options, CHAT_EFFORT_OPTION_IDS, contribution.configurationOptions, "Chat Effort");
+            }
+        }
+    }
+    const rows = capture.work.configurationRows;
+    if (rows.length !== WORK_CONFIGURATION_AXIS_IDS.length
+        || rows.some((row, index) => row.axis !== WORK_CONFIGURATION_AXIS_IDS[index])) {
+        throw new ApplyUsageError(`${record.requestedLocale} did not capture the ordered Model/Effort/Speed rows.`, 1);
+    }
+    for (const row of rows) {
+        addLocalizedConfigurationAxis(contribution.configurationAxes, row.axis, row.axisLabel);
+        if (row.axis === "effort") {
+            assignOrderedLocalizedOptions(record.requestedLocale, row.options, EFFORT_OPTION_IDS, contribution.configurationOptions, "Effort");
+        }
+        else if (row.axis === "speed") {
+            assignOrderedLocalizedOptions(record.requestedLocale, row.options, SPEED_OPTION_IDS, contribution.configurationOptions, "Speed");
+        }
+    }
+    return contribution;
+}
+function addLocalizedConfigurationAxis(target, axis, value) {
+    const label = normalized(value);
+    if (label.length === 0 || label === ENGLISH_CONFIGURATION_AXES[axis])
+        return;
+    target[axis] = dedupe([...(target[axis] ?? []), label]);
+}
+function assignOrderedLocalizedOptions(locale, options, ids, target, axis) {
+    if (options.length === 0 || options.length > ids.length) {
+        throw new ApplyUsageError(`${locale} captured ${options.length} ${axis} options; expected 1-${ids.length}.`, 1);
+    }
+    options.forEach((option, index) => {
+        const id = ids[index];
+        const label = normalized(option.label);
+        if (label.length > 0 && label !== ENGLISH_CONFIGURATION_OPTIONS[id]) {
+            target[id] = dedupe([...(target[id] ?? []), label]);
+        }
+    });
+}
+function nonEnglishSlot(id, value, englishValues) {
+    const label = normalized(value);
+    return label.length > 0 && !englishValues.has(normalizedLower(label)) ? { [id]: [label] } : {};
+}
+export function mergeCapture(source, labels, modeOptions, generationLabels = {}, surface = {
+    workComposerTextbox: [],
+    experienceOptions: {},
+    configurationAxes: {},
+    configurationOptions: {},
+}) {
     let text = updateComment(source);
     if (labels.length > 0) {
         const existing = parseExistingModeLabels(text);
@@ -149,6 +279,10 @@ export function mergeCapture(source, labels, modeOptions, generationLabels = {})
         }
     }
     text = mergeModeOptions(text, modeOptions);
+    text = mergeTopLevelStringArrayProperty(text, "workComposerTextbox", surface.workComposerTextbox, "composerTextbox");
+    text = mergeNestedOptions(text, "experienceOptions", EXPERIENCE_OPTION_IDS, surface.experienceOptions, "modeOpenerExtra");
+    text = mergeNestedOptions(text, "configurationAxes", CONFIGURATION_AXIS_IDS, surface.configurationAxes, "experienceOptions");
+    text = mergeNestedOptions(text, "configurationOptions", CONFIGURATION_OPTION_IDS, surface.configurationOptions, "configurationAxes");
     text = mergeStringArrayProperty(text, "stopControl", generationLabels.stopControl ?? []);
     text = mergeStringArrayProperty(text, "stoppedAssistant", generationLabels.stoppedAssistant ?? []);
     return text;
@@ -220,13 +354,71 @@ function formatModeOptions(modeOptions) {
     }
     return ["  modeOptions: {", ...lines, "  },"].join("\n");
 }
-function mergeStringArrayProperty(source, property, values) {
+function mergeTopLevelStringArrayProperty(source, property, values, insertAfterProperty) {
     if (values.length === 0)
         return source;
     const existing = parseExistingStringArrayProperty(source, property);
     const merged = dedupe([...existing, ...values]);
     const line = `  ${property}: [${merged.map(value => JSON.stringify(value)).join(", ")}],`;
     const propertyPattern = new RegExp(`^\\s*${property}:\\s*\\[[^\\]]*\\],`, "m");
+    if (propertyPattern.test(source))
+        return source.replace(propertyPattern, line);
+    const anchor = new RegExp(`^(\\s*${insertAfterProperty}:\\s*[^\\n]+,\\n)`, "m");
+    if (anchor.test(source))
+        return source.replace(anchor, `$1${line}\n`);
+    return source.replace(/^export const \w+ = \{\n/m, match => `${match}${line}\n`);
+}
+function mergeNestedOptions(source, property, ids, additions, insertAfterProperty) {
+    const existing = parseNestedOptions(source, property, ids);
+    const merged = {};
+    for (const id of ids) {
+        const values = dedupe([...(existing[id] ?? []), ...(additions[id] ?? [])]);
+        if (values.length > 0)
+            merged[id] = values;
+    }
+    const lines = ids.flatMap(id => {
+        const values = merged[id];
+        return values === undefined || values.length === 0
+            ? []
+            : [`    ${id}: [${values.map(value => JSON.stringify(value)).join(", ")}],`];
+    });
+    if (lines.length === 0)
+        return source;
+    const block = [`  ${property}: {`, ...lines, "  },"].join("\n");
+    const blockPattern = new RegExp(`^\\s*${property}:\\s*\\{[\\s\\S]*?^\\s*\\},\\n`, "m");
+    if (blockPattern.test(source))
+        return source.replace(blockPattern, `${block}\n`);
+    const nestedAnchor = new RegExp(`^(\\s*${insertAfterProperty}:\\s*\\{[\\s\\S]*?^\\s*\\},\\n)`, "m");
+    if (nestedAnchor.test(source))
+        return source.replace(nestedAnchor, `$1${block}\n`);
+    const lineAnchor = new RegExp(`^(\\s*${insertAfterProperty}:\\s*[^\\n]+,\\n)`, "m");
+    if (lineAnchor.test(source))
+        return source.replace(lineAnchor, `$1${block}\n`);
+    return source.replace(/^export const \w+ = \{\n/m, match => `${match}${block}\n`);
+}
+function parseNestedOptions(source, property, ids) {
+    const result = {};
+    const block = new RegExp(`^\\s*${property}:\\s*\\{(?<body>[\\s\\S]*?)^\\s*\\},`, "m").exec(source)?.groups?.body;
+    if (block === undefined)
+        return result;
+    for (const id of ids) {
+        const body = new RegExp(`^\\s*${id}:\\s*\\[(?<body>[^\\]]*)\\],`, "m").exec(block)?.groups?.body;
+        if (body === undefined)
+            continue;
+        const values = parseJsonStringList(body);
+        if (values.length > 0)
+            result[id] = values;
+    }
+    return result;
+}
+function mergeStringArrayProperty(source, property, values) {
+    if (values.length === 0)
+        return source;
+    const existing = parseExistingStringArrayProperty(source, property);
+    const merged = dedupe([...existing, ...values])
+        .filter(value => property !== "stopControl" || !UNSAFE_GENERIC_STOP_CONTROLS.has(value.toLowerCase()));
+    const line = `  ${property}: [${merged.map(value => JSON.stringify(value)).join(", ")}],`;
+    const propertyPattern = new RegExp(`^\\s*${property}:\\s*\\[[^\\]]*\\],`, "m");
     if (propertyPattern.test(source)) {
         return source.replace(propertyPattern, line);
     }
@@ -251,11 +443,31 @@ function parseExistingStringArrayProperty(source, property) {
 }
 function updateComment(source) {
     let text = source.replace(/\n \* Omitted because they match English case-insensitively: `modeLabels`[\s\S]*?blocker copy\.\n/g, "\n * Some non-Intelligence surfaces may still fall back to English + `selector_drift`.\n");
+    text = text.replace(/^ \* Intelligence picker labels updated 2026-06-10[^\n]*$/m, UPDATE_NOTE);
     if (!text.includes(UPDATE_NOTE)) {
         text = text.replace(/\n \*\//, `\n *\n${UPDATE_NOTE}\n */`);
     }
     return text;
 }
+function parseJsonStringList(body) {
+    const values = [];
+    for (const stringMatch of body.matchAll(/"((?:\\"|[^"])*)"/g)) {
+        values.push(JSON.parse(`"${stringMatch[1]}"`));
+    }
+    return values;
+}
+function normalized(value) {
+    return (value ?? "").replace(/\s+/g, " ").trim();
+}
+function normalizedLower(value) {
+    return normalized(value).toLocaleLowerCase();
+}
+function surfaceContributionCount(surface) {
+    return surface.workComposerTextbox.length
+        + Object.keys(surface.experienceOptions).length
+        + Object.keys(surface.configurationAxes).length
+        + Object.keys(surface.configurationOptions).length;
+}
 function dedupe(values) {
     const seen = new Set();
     const result = [];