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

package/dist/src/runner/responses.js

@@ -4,6 +4,8 @@ const acceptedTopLevelFields = new Set([
     "thread",
     "existingTab",
     "preferExistingTab",
+    "experience",
+    "configuration",
     "attachments",
     "mode",
     "tools",
@@ -14,7 +16,7 @@ const acceptedTopLevelFields = new Set([
     "instructionsMode"
 ]);
 const unsupportedAlternatives = {
-    model: "Use mode for visible ChatGPT UI mode preference. This does not select an API model.",
+    model: "Use experience plus configuration for visible ChatGPT UI preferences. Legacy mode remains supported. These do not select an API model.",
     temperature: "No browser-control equivalent. ChatGPT web does not expose API temperature.",
     top_p: "No browser-control equivalent. ChatGPT web does not expose API nucleus sampling.",
     seed: "No browser-control equivalent. Visible ChatGPT web does not expose deterministic API seeds.",
@@ -112,6 +114,10 @@ export function responsesCreateArgsToRunInput(args) {
         runInput.existingTab = args.existingTab;
     if (args.preferExistingTab !== undefined)
         runInput.preferExistingTab = args.preferExistingTab;
+    if (args.experience !== undefined)
+        runInput.experience = args.experience;
+    if (args.configuration !== undefined)
+        runInput.configuration = args.configuration;
     if (args.attachments !== undefined)
         runInput.attachments = args.attachments;
     if (args.mode !== undefined)
@@ -133,6 +139,15 @@ export function responseFromRunResult(result, now = new Date()) {
     const reportPath = result.data?.reportPath ?? result.reportPath;
     if (reportPath !== undefined)
         browserControl.reportPath = reportPath;
+    const submissionState = result.state.submissionState ?? result.data?.submissionState;
+    const completionState = result.state.completionState ?? result.data?.completionState;
+    const generationActive = result.data?.generationActive;
+    if (submissionState !== undefined)
+        browserControl.submissionState = submissionState;
+    if (completionState !== undefined)
+        browserControl.completionState = completionState;
+    if (generationActive !== undefined)
+        browserControl.generationActive = generationActive;
     if (result.output_text.length > 0) {
         const envelopeArgs = {
             outputText: result.output_text,

package/dist/src/runner/result.js

@@ -9,6 +9,15 @@ export function toRunResult(agent, result) {
     const output = runItemsFromResult(result, outputText);
     const state = runStateFromResult(result, interruptions);
     const data = { outputText };
+    const submissionState = readSubmissionState(result.data);
+    const completionState = readCompletionState(result.data);
+    const generationActive = readGenerationActive(result.data);
+    if (submissionState !== undefined)
+        data.submissionState = submissionState;
+    if (completionState !== undefined)
+        data.completionState = completionState;
+    if (generationActive !== undefined)
+        data.generationActive = generationActive;
     if (outputText.length > 0) {
         const envelopeArgs = {
             outputText,
@@ -73,15 +82,56 @@ function parseFinalOutput(agent, outputText) {
     return outputText;
 }
 function runItemsFromResult(result, outputText) {
-    const items = messageItemsFromData(result.data);
-    if (!items.some(item => item.type === "message.completed") && outputText.length > 0) {
-        items.push({ type: "message.completed", role: "assistant", output_text: outputText, format: "markdown" });
+    const items = lifecycleItemsFromSteps(result.steps);
+    items.push(...messageItemsFromData(result.data));
+    if (!items.some(item => item.type === "message.completed" || item.type === "message.in_progress") && outputText.length > 0) {
+        if (result.status === "partial" && readCompletionState(result.data) !== "complete") {
+            items.push(inProgressItem(outputText, readCompletionState(result.data), readGenerationActive(result.data)));
+        }
+        else {
+            items.push({ type: "message.completed", role: "assistant", output_text: outputText, format: "markdown" });
+        }
     }
     if (result.blocker !== undefined) {
         items.push({ type: "run.blocked", blocker: augmentCommandBlocker(result.blocker) });
     }
     return items;
 }
+function lifecycleItemsFromSteps(steps) {
+    if (steps === undefined)
+        return [];
+    const items = [];
+    for (const step of steps) {
+        if (!step.ok || !isRecord(step.dataPreview))
+            continue;
+        if (step.command === "experience.open") {
+            const experience = step.dataPreview.experience;
+            if (experience === "chat" || experience === "work") {
+                const item = {
+                    type: "experience.opened",
+                    experience
+                };
+                if (typeof step.dataPreview.changed === "boolean")
+                    item.changed = step.dataPreview.changed;
+                items.push(item);
+            }
+            continue;
+        }
+        if (step.command === "configuration.apply") {
+            const item = {
+                type: "configuration.applied"
+            };
+            if (isRecord(step.dataPreview.requested)) {
+                item.requested = step.dataPreview.requested;
+            }
+            if (typeof step.dataPreview.verified === "boolean") {
+                item.verified = step.dataPreview.verified;
+            }
+            items.push(item);
+        }
+    }
+    return items;
+}
 function messageItemsFromData(data) {
     if (!isRecord(data))
         return [];
@@ -95,7 +145,12 @@ function messageItemsFromData(data) {
         });
     }
     if (typeof data.responseText === "string" && data.responseText.length > 0) {
-        items.push({ type: "message.completed", role: "assistant", output_text: data.responseText, format: "markdown" });
+        if (readCompletionState(data) === "complete" || data.complete === true) {
+            items.push({ type: "message.completed", role: "assistant", output_text: data.responseText, format: "markdown" });
+        }
+        else {
+            items.push(inProgressItem(data.responseText, readCompletionState(data), readGenerationActive(data)));
+        }
     }
     if (items.length > 0)
         return items;
@@ -116,8 +171,78 @@ function runStateFromResult(result, interruptions) {
     const thread = threadRefFromContext(result.context);
     if (thread !== undefined)
         state.thread = thread;
+    const submissionState = readSubmissionState(result.data);
+    const completionState = readCompletionState(result.data);
+    if (submissionState !== undefined)
+        state.submissionState = submissionState;
+    if (completionState !== undefined)
+        state.completionState = completionState;
     return state;
 }
+function inProgressItem(outputText, completionState, generationActive) {
+    const item = {
+        type: "message.in_progress",
+        role: "assistant",
+        output_text: outputText,
+        preview: outputText.length > 160 ? `${outputText.slice(0, 159)}...` : outputText,
+        format: "markdown",
+        textLength: outputText.length,
+        textHash: hashText(outputText)
+    };
+    if (completionState !== undefined)
+        item.completionState = completionState;
+    if (generationActive !== undefined)
+        item.generationActive = generationActive;
+    return item;
+}
+function readCompletionState(data) {
+    if (!isRecord(data))
+        return undefined;
+    const value = data.completionState;
+    if (value === "complete" || value === "generating" || value === "stopped" || value === "partial" || value === "unknown") {
+        return value;
+    }
+    for (const nested of Object.values(data)) {
+        const nestedState = readCompletionState(nested);
+        if (nestedState !== undefined)
+            return nestedState;
+    }
+    return undefined;
+}
+function readSubmissionState(data) {
+    if (!isRecord(data))
+        return undefined;
+    const value = data.submissionState;
+    if (value === "not_submitted" || value === "submitted" || value === "submitted_unconfirmed" || value === "submitted_generating") {
+        return value;
+    }
+    for (const nested of Object.values(data)) {
+        const nestedState = readSubmissionState(nested);
+        if (nestedState !== undefined)
+            return nestedState;
+    }
+    return undefined;
+}
+function readGenerationActive(data) {
+    if (!isRecord(data))
+        return undefined;
+    if (typeof data.generationActive === "boolean")
+        return data.generationActive;
+    for (const nested of Object.values(data)) {
+        const value = readGenerationActive(nested);
+        if (value !== undefined)
+            return value;
+    }
+    return undefined;
+}
+function hashText(value) {
+    let hash = 2166136261;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+}
 function threadRefFromContext(context) {
     const thread = {};
     if (context.url !== undefined)

package/dist/src/runner/stream.d.ts

@@ -1,5 +1,5 @@
 import type { ChatGPTRunItem, ChatGPTRunResult } from "./types.js";
-export type ChatGPTRunStreamEventName = "thread_opened" | "mode_selected" | "tool_selected" | "file_attached" | "message_submitted" | "message_completed" | "file_downloaded" | "run_blocked";
+export type ChatGPTRunStreamEventName = "thread_opened" | "experience_opened" | "configuration_applied" | "mode_selected" | "tool_selected" | "file_attached" | "message_submitted" | "message_in_progress" | "message_completed" | "file_downloaded" | "run_blocked";
 export type ChatGPTRunStreamEvent = {
     type: "run_item_stream_event";
     name: ChatGPTRunStreamEventName;

package/dist/src/runner/stream.js

@@ -47,6 +47,10 @@ function runItemEventName(item) {
     switch (item.type) {
         case "thread.opened":
             return "thread_opened";
+        case "experience.opened":
+            return "experience_opened";
+        case "configuration.applied":
+            return "configuration_applied";
         case "mode.selected":
             return "mode_selected";
         case "tool.selected":
@@ -55,6 +59,8 @@ function runItemEventName(item) {
             return "file_attached";
         case "message.submitted":
             return "message_submitted";
+        case "message.in_progress":
+            return "message_in_progress";
         case "message.completed":
             return "message_completed";
         case "file.downloaded":

package/dist/src/runner/types.d.ts

@@ -1,4 +1,4 @@
-import type { AttachedFile, CommandResult, CommandStatus, CopyResponseArgs, DownloadLatestArgs, BootstrapArgs, ReadLatestArgs, ResponseCaptureFidelity, ResponseCaptureSource, ResponseFormat, SequencePlan, SelectToolArgs, SetModeArgs, ThreadTarget, WaitArgs } from "../types.js";
+import type { AttachedFile, ChatGPTExperience, CommandResult, CommandStatus, CompletionState, ConfigurationSelection, CopyResponseArgs, DownloadLatestArgs, BootstrapArgs, ReadLatestArgs, ResponseCaptureFidelity, ResponseCaptureSource, ResponseFormat, SequencePlan, SelectToolArgs, SetModeArgs, SubmissionState, ThreadTarget, WaitArgs } from "../types.js";
 import type { RunReportOptions } from "../commands/reports.js";
 import type { UntrustedOutputReturnEnvelope } from "../safety/untrusted-output.js";
 import type { ChatGPTRunStream } from "./stream.js";
@@ -38,6 +38,10 @@ export type ChatGPTVisibleModePreference = SetModeArgs & {
     required?: boolean;
     ifUnavailable?: "continue" | "block" | "skip";
 };
+export type ChatGPTVisibleConfigurationPreference = ConfigurationSelection & {
+    required?: boolean;
+    ifUnavailable?: "continue" | "block" | "skip";
+};
 export type ChatGPTVisibleToolPreference = SelectToolArgs & {
     required?: boolean;
     ifUnavailable?: "continue" | "block" | "skip";
@@ -46,6 +50,8 @@ export type ChatGPTRunDefaults = {
     thread?: ChatGPTThreadSelector | ThreadTarget;
     existingTab?: BootstrapArgs["existingTab"];
     preferExistingTab?: boolean;
+    experience?: Exclude<ChatGPTExperience, "unknown">;
+    configuration?: ChatGPTVisibleConfigurationPreference;
     mode?: ChatGPTVisibleModePreference;
     wait?: boolean | WaitArgs;
     read?: boolean | ReadLatestArgs;
@@ -103,6 +109,8 @@ export type ChatGPTRunInput = string | {
     thread?: ChatGPTThreadSelector;
     existingTab?: BootstrapArgs["existingTab"];
     preferExistingTab?: boolean;
+    experience?: Exclude<ChatGPTExperience, "unknown">;
+    configuration?: ChatGPTVisibleConfigurationPreference;
     attachments?: ChatGPTAttachmentInput[];
     mode?: ChatGPTVisibleModePreference;
     tools?: ChatGPTVisibleToolPreference[];
@@ -126,6 +134,14 @@ export type DownloadedFileSummary = {
 export type ChatGPTRunItem = {
     type: "thread.opened";
     thread: ChatGPTThreadRef;
+} | {
+    type: "experience.opened";
+    experience: Exclude<ChatGPTExperience, "unknown">;
+    changed?: boolean;
+} | {
+    type: "configuration.applied";
+    requested?: ConfigurationSelection;
+    verified?: boolean;
 } | {
     type: "mode.selected";
     requested?: string;
@@ -144,6 +160,16 @@ export type ChatGPTRunItem = {
     role: "user";
     preview: string;
     redacted: boolean;
+} | {
+    type: "message.in_progress";
+    role: "assistant";
+    output_text?: string;
+    preview: string;
+    format: ResponseFormat;
+    completionState?: CompletionState;
+    generationActive?: boolean;
+    textLength?: number;
+    textHash?: string;
 } | {
     type: "message.completed";
     role: "assistant";
@@ -216,6 +242,8 @@ export type ChatGPTRunState = {
     resumable: boolean;
     thread?: ChatGPTThreadRef;
     nextStepId?: string;
+    submissionState?: SubmissionState;
+    completionState?: CompletionState;
 };
 export type ChatGPTRunData<TOutput = string> = {
     finalOutput?: TOutput;
@@ -224,6 +252,9 @@ export type ChatGPTRunData<TOutput = string> = {
     thread?: ChatGPTThreadRef;
     downloads?: DownloadedFileSummary[];
     reportPath?: string;
+    submissionState?: SubmissionState;
+    completionState?: CompletionState;
+    generationActive?: boolean;
 };
 export type ChatGPTRunResult<TOutput = string> = CommandResult<ChatGPTRunData<TOutput>> & {
     finalOutput?: TOutput;
@@ -256,6 +287,9 @@ export type ChatGPTResponse = {
         resultStatus: CommandStatus;
         thread?: ChatGPTThreadRef;
         reportPath?: string;
+        submissionState?: SubmissionState;
+        completionState?: CompletionState;
+        generationActive?: boolean;
         untrustedOutput?: UntrustedOutputReturnEnvelope;
         unsupported?: UnsupportedField[];
     };

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

@@ -1,6 +1,15 @@
 export type RiskLevel = "low" | "medium" | "high";
 export declare const commandRisk: {
     readonly "session.bootstrap": "low";
+    readonly "experience.detect": "low";
+    readonly "experience.open": "medium";
+    readonly "configuration.inspect": "low";
+    readonly "configuration.apply": "medium";
+    readonly "work.start": "medium";
+    readonly "work.status": "medium";
+    readonly "work.wait": "low";
+    readonly "work.steer": "medium";
+    readonly "work.readLatest": "medium";
     readonly "threads.search": "medium";
     readonly "threads.open": "medium";
     readonly "threads.new": "low";
@@ -9,6 +18,7 @@ export declare const commandRisk: {
     readonly "messages.ask": "medium";
     readonly "messages.wait": "low";
     readonly "messages.readLatest": "medium";
+    readonly "messages.status": "medium";
     readonly "messages.waitAndRead": "medium";
     readonly "artifacts.listLatest": "medium";
     readonly "artifacts.wait": "low";
@@ -21,6 +31,7 @@ export declare const commandRisk: {
     readonly "projects.sources.add": "medium";
     readonly "response.copy": "medium";
     readonly "modes.set": "medium";
+    readonly "modes.get": "low";
     readonly "tools.select": "medium";
     readonly "threads.delete": "high";
     readonly "threads.archive": "high";

package/dist/src/safety/risk.js

@@ -1,5 +1,14 @@
 export const commandRisk = {
     "session.bootstrap": "low",
+    "experience.detect": "low",
+    "experience.open": "medium",
+    "configuration.inspect": "low",
+    "configuration.apply": "medium",
+    "work.start": "medium",
+    "work.status": "medium",
+    "work.wait": "low",
+    "work.steer": "medium",
+    "work.readLatest": "medium",
     "threads.search": "medium",
     "threads.open": "medium",
     "threads.new": "low",
@@ -8,6 +17,7 @@ export const commandRisk = {
     "messages.ask": "medium",
     "messages.wait": "low",
     "messages.readLatest": "medium",
+    "messages.status": "medium",
     "messages.waitAndRead": "medium",
     "artifacts.listLatest": "medium",
     "artifacts.wait": "low",
@@ -20,6 +30,7 @@ export const commandRisk = {
     "projects.sources.add": "medium",
     "response.copy": "medium",
     "modes.set": "medium",
+    "modes.get": "low",
     "tools.select": "medium",
     "threads.delete": "high",
     "threads.archive": "high",

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

@@ -1 +1,7 @@
+type IntelligenceModeOptionId = "instant" | "medium" | "high" | "extraHigh" | "pro";
 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;
+export {};

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

@@ -3,7 +3,17 @@ import { dirname, resolve } from "node:path";
 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 UPDATE_NOTE = " * Intelligence picker labels updated 2026-06-10 from a visible ChatGPT Pro session.";
+const ENGLISH_STOP_CONTROL = new Set(["stop generating", "stop streaming", "stop answering", "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 = {
+    instant: "Instant",
+    medium: "Medium",
+    high: "High",
+    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.";
 class ApplyUsageError extends Error {
     exitCode;
     constructor(message, exitCode = 2) {
@@ -45,12 +55,18 @@ export async function main(argv = process.argv.slice(2)) {
             throw new ApplyUsageError(`Missing successful capture for ${language.bcp47}.`, 1);
         }
         const labels = observedNonEnglishLabels(record);
-        if (labels.length === 0)
+        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)
             continue;
         planned.push({
             locale: language.bcp47,
             file: resolve(root, "src/dom/locale", `${language.bcp47}.ts`),
             labels,
+            modeOptions,
+            stopControl,
+            stoppedAssistant,
         });
     }
     if (!options.reviewed) {
@@ -62,10 +78,13 @@ export async function main(argv = process.argv.slice(2)) {
     }
     for (const change of planned) {
         const before = await readFile(change.file, "utf8");
-        const after = mergeModeLabels(before, change.labels);
+        const after = mergeCapture(before, change.labels, change.modeOptions, {
+            stopControl: change.stopControl,
+            stoppedAssistant: change.stoppedAssistant,
+        });
         if (after !== before) {
             await writeFile(change.file, after, "utf8");
-            console.log(`updated ${change.locale} labels=${change.labels.length}`);
+            console.log(`updated ${change.locale} labels=${change.labels.length} modeOptions=${Object.keys(change.modeOptions).length} stopControl=${change.stopControl.length} stoppedAssistant=${change.stoppedAssistant.length}`);
         }
     }
     return 0;
@@ -93,18 +112,46 @@ function observedNonEnglishLabels(record) {
     }
     return labels;
 }
-function mergeModeLabels(source, labels) {
-    let text = updateComment(source);
-    const existing = parseExistingModeLabels(text);
-    const merged = dedupe([...existing, ...labels]);
-    const line = `  modeLabels: [${merged.map(label => JSON.stringify(label)).join(", ")}],`;
-    if (/^\s*modeLabels:\s*\[[^\]]*\],/m.test(text)) {
-        return text.replace(/^\s*modeLabels:\s*\[[^\]]*\],/m, line);
+function observedNonEnglishModeOptions(record) {
+    const labels = record.intelligenceLabels ?? [];
+    if (labels.length !== INTELLIGENCE_MODE_OPTION_IDS.length) {
+        throw new ApplyUsageError(`${record.requestedLocale} has ${labels.length} Intelligence labels; expected ${INTELLIGENCE_MODE_OPTION_IDS.length}.`, 1);
     }
-    if (/^\s*copyResponse:\s*.*,\n/m.test(text)) {
-        return text.replace(/^(\s*copyResponse:\s*.*,\n)/m, `$1${line}\n`);
+    const modeOptions = {};
+    for (let index = 0; index < INTELLIGENCE_MODE_OPTION_IDS.length; index += 1) {
+        const id = INTELLIGENCE_MODE_OPTION_IDS[index];
+        const label = labels[index];
+        if (label !== ENGLISH_INTELLIGENCE_MODE_OPTIONS[id]) {
+            modeOptions[id] = [label];
+        }
+    }
+    return modeOptions;
+}
+function observedNonEnglishGenerationLabels(values, englishValues) {
+    return dedupe((values ?? [])
+        .map(value => value.replace(/\s+/g, " ").trim())
+        .filter(value => value.length > 0 && !englishValues.has(value.toLowerCase())));
+}
+export function mergeCapture(source, labels, modeOptions, generationLabels = {}) {
+    let text = updateComment(source);
+    if (labels.length > 0) {
+        const existing = parseExistingModeLabels(text);
+        const merged = dedupe([...existing, ...labels]);
+        const line = `  modeLabels: [${merged.map(label => JSON.stringify(label)).join(", ")}],`;
+        if (/^\s*modeLabels:\s*\[[^\]]*\],/m.test(text)) {
+            text = text.replace(/^\s*modeLabels:\s*\[[^\]]*\],/m, line);
+        }
+        else if (/^\s*copyResponse:\s*.*,\n/m.test(text)) {
+            text = text.replace(/^(\s*copyResponse:\s*.*,\n)/m, `$1${line}\n`);
+        }
+        else {
+            text = text.replace(/^export const \w+ = \{\n/m, match => `${match}${line}\n`);
+        }
     }
-    return text.replace(/^export const \w+ = \{\n/m, match => `${match}${line}\n`);
+    text = mergeModeOptions(text, modeOptions);
+    text = mergeStringArrayProperty(text, "stopControl", generationLabels.stopControl ?? []);
+    text = mergeStringArrayProperty(text, "stoppedAssistant", generationLabels.stoppedAssistant ?? []);
+    return text;
 }
 function parseExistingModeLabels(source) {
     const match = /^\s*modeLabels:\s*\[(?<body>[^\]]*)\],/m.exec(source);
@@ -117,6 +164,91 @@ function parseExistingModeLabels(source) {
     }
     return labels;
 }
+function mergeModeOptions(source, modeOptions) {
+    const existing = parseExistingModeOptions(source);
+    const merged = {};
+    for (const id of INTELLIGENCE_MODE_OPTION_IDS) {
+        const values = dedupe([...(existing[id] ?? []), ...(modeOptions[id] ?? [])]);
+        if (values.length > 0) {
+            merged[id] = values;
+        }
+    }
+    const block = formatModeOptions(merged);
+    if (block === undefined) {
+        return source;
+    }
+    if (/^\s*modeOptions:\s*\{[\s\S]*?^\s*\},\n/m.test(source)) {
+        return source.replace(/^\s*modeOptions:\s*\{[\s\S]*?^\s*\},\n/m, `${block}\n`);
+    }
+    if (/^\s*modeLabels:\s*\[[^\]]*\],\n/m.test(source)) {
+        return source.replace(/^(\s*modeLabels:\s*\[[^\]]*\],\n)/m, `$1${block}\n`);
+    }
+    return source.replace(/^export const \w+ = \{\n/m, match => `${match}${block}\n`);
+}
+function parseExistingModeOptions(source) {
+    const options = {};
+    const blockMatch = /^\s*modeOptions:\s*\{(?<body>[\s\S]*?)^\s*\},/m.exec(source);
+    const body = blockMatch?.groups?.body;
+    if (body === undefined)
+        return options;
+    for (const id of INTELLIGENCE_MODE_OPTION_IDS) {
+        const lineMatch = new RegExp(`^\\s*${id}:\\s*\\[(?<body>[^\\]]*)\\],`, "m").exec(body);
+        const lineBody = lineMatch?.groups?.body;
+        if (lineBody === undefined)
+            continue;
+        const values = [];
+        for (const stringMatch of lineBody.matchAll(/"((?:\\"|[^"])*)"/g)) {
+            values.push(JSON.parse(`"${stringMatch[1]}"`));
+        }
+        if (values.length > 0) {
+            options[id] = values;
+        }
+    }
+    return options;
+}
+function formatModeOptions(modeOptions) {
+    const lines = INTELLIGENCE_MODE_OPTION_IDS
+        .map(id => {
+        const values = modeOptions[id];
+        return values === undefined || values.length === 0
+            ? undefined
+            : `    ${id}: [${values.map(value => JSON.stringify(value)).join(", ")}],`;
+    })
+        .filter((line) => line !== undefined);
+    if (lines.length === 0) {
+        return undefined;
+    }
+    return ["  modeOptions: {", ...lines, "  },"].join("\n");
+}
+function mergeStringArrayProperty(source, property, values) {
+    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);
+    }
+    if (/^\s*responseActions:\s*.*,\n/m.test(source)) {
+        return source.replace(/^(\s*responseActions:\s*.*,\n)/m, `$1${line}\n`);
+    }
+    if (/^\s*modeOptions:\s*\{[\s\S]*?^\s*\},\n/m.test(source)) {
+        return source.replace(/^(\s*modeOptions:\s*\{[\s\S]*?^\s*\},\n)/m, `$1${line}\n`);
+    }
+    return source.replace(/^export const \w+ = \{\n/m, match => `${match}${line}\n`);
+}
+function parseExistingStringArrayProperty(source, property) {
+    const match = new RegExp(`^\\s*${property}:\\s*\\[(?<body>[^\\]]*)\\],`, "m").exec(source);
+    const body = match?.groups?.body;
+    if (body === undefined)
+        return [];
+    const values = [];
+    for (const stringMatch of body.matchAll(/"((?:\\"|[^"])*)"/g)) {
+        values.push(JSON.parse(`"${stringMatch[1]}"`));
+    }
+    return values;
+}
 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");
     if (!text.includes(UPDATE_NOTE)) {
@@ -178,7 +310,7 @@ function requiredValue(argv, index, flag) {
 function packageRoot() {
     return resolve(dirname(fileURLToPath(import.meta.url)), "../..");
 }
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
+if (typeof process !== "undefined" && process.argv[1] === fileURLToPath(import.meta.url)) {
     const exitCode = await main();
     process.exitCode = exitCode;
 }

package/dist/src/scripts/capture-intelligence-locales.d.ts

@@ -9,6 +9,9 @@ type CaptureOptions = {
     limit: number | undefined;
     locales: string[] | undefined;
     openVersionSubmenu: boolean;
+    captureGenerationState: boolean;
+    generationPrompt: string;
+    generationCaptureTimeoutMs: number;
     restore: boolean;
     settleMs: number;
     switchTimeoutMs: number;