@steipete/oracle 0.11.1 → 0.12.0

package/dist/src/browser/projectSourcesRunner.js

@@ -9,6 +9,7 @@ import { acquireBrowserTabLease, hasOtherActiveBrowserTabLeases, } from "./tabLe
 import { acquireProfileRunLock, cleanupStaleProfileState, findRunningChromeDebugTargetForProfile, readChromePid, readDevToolsPort, shouldCleanupManualLoginProfileState, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from "./profileState.js";
 import { CHATGPT_URL } from "./constants.js";
 import { delay } from "./utils.js";
+import { assertManualLoginProfileReadyForRun, defaultManualLoginProfileDir, formatManualLoginSetupCommand, resolveManualLoginWaitMs, } from "./manualLoginProfile.js";
 import { openProjectSourcesTab, uploadProjectSources, waitForProjectSourcesReady, waitForProjectSourcesListSettled, } from "./actions/projectSources.js";
 import { normalizeProjectSourcesUrl } from "../projectSources/url.js";
 import { buildProjectSourcesUploadPlan, diffAddedProjectSources } from "../projectSources/plan.js";
@@ -45,13 +46,18 @@ export async function runBrowserProjectSources(request) {
     const manualLogin = Boolean(config.manualLogin);
     const manualProfileDir = config.manualLoginProfileDir
         ? path.resolve(config.manualLoginProfileDir)
-        : path.join(os.homedir(), ".oracle", "browser-profile");
+        : defaultManualLoginProfileDir();
     const userDataDir = manualLogin
         ? manualProfileDir
         : await mkdtemp(path.join(os.tmpdir(), "oracle-project-sources-"));
+    const effectiveKeepBrowser = Boolean(config.keepBrowser);
     if (manualLogin) {
         await mkdir(userDataDir, { recursive: true });
         logger(`Manual login mode enabled; reusing persistent profile at ${userDataDir}`);
+        await assertManualLoginProfileReadyForRun({
+            userDataDir,
+            keepBrowser: effectiveKeepBrowser,
+        });
     }
     else {
         logger(`Created temporary Chrome profile at ${userDataDir}`);
@@ -73,7 +79,6 @@ export async function runBrowserProjectSources(request) {
     let removeDialogHandler = null;
     let connectionClosedUnexpectedly = false;
     let completed = false;
-    const effectiveKeepBrowser = Boolean(config.keepBrowser);
     try {
         const acquired = manualLogin
             ? await acquireManualLoginChromeForProjectSources(userDataDir, config, logger)
@@ -140,6 +145,8 @@ export async function runBrowserProjectSources(request) {
             appliedCookies,
             manualLogin,
             timeoutMs: config.timeoutMs,
+            profileDir: userDataDir,
+            keepBrowser: effectiveKeepBrowser,
         }));
         await raceWithDisconnect(navigateToChatGPT(Page, Runtime, projectUrl, logger));
         await raceWithDisconnect(openProjectSourcesTab(Runtime, Input, config.inputTimeoutMs, logger));
@@ -261,12 +268,13 @@ async function applyProjectSourcesCookies({ config, network, manualLogin, logger
         : "No Chrome cookies found; continuing without session reuse");
     return cookieCount;
 }
-async function waitForProjectSourcesLogin({ runtime, logger, appliedCookies, manualLogin, timeoutMs, }) {
+async function waitForProjectSourcesLogin({ runtime, logger, appliedCookies, manualLogin, timeoutMs, profileDir, keepBrowser, }) {
     if (!manualLogin) {
         await ensureLoggedIn(runtime, logger, { appliedCookies });
         return;
     }
-    const deadline = Date.now() + Math.min(timeoutMs ?? 1_200_000, 20 * 60_000);
+    const waitMs = resolveManualLoginWaitMs(timeoutMs, Boolean(keepBrowser));
+    const deadline = Date.now() + waitMs;
     let lastNotice = 0;
     while (Date.now() < deadline) {
         try {
@@ -288,7 +296,10 @@ async function waitForProjectSourcesLogin({ runtime, logger, appliedCookies, man
             await delay(1000);
         }
     }
-    throw new Error("Manual login mode timed out waiting for ChatGPT session; please sign in and retry.");
+    const setupCommand = formatManualLoginSetupCommand(profileDir ?? defaultManualLoginProfileDir());
+    throw new Error("Manual login mode timed out waiting for ChatGPT session. " +
+        `Browser mode is using Oracle's private Chrome profile at ${profileDir ?? "(default profile)"}, not your normal Chrome profile. ` +
+        `Run first-time setup, sign in there, then retry: ${setupCommand}`);
 }
 async function acquireManualLoginChromeForProjectSources(userDataDir, config, logger) {
     const lockTimeoutMs = Math.max(0, config.profileLockTimeoutMs ?? 0);

package/dist/src/browser/prompt.js

@@ -5,6 +5,7 @@ import { readFiles, createFileSections, MODEL_CONFIGS, TOKENIZER_OPTIONS, format
 import { isKnownModel } from "../oracle/modelResolver.js";
 import { buildPromptMarkdown } from "../oracle/promptAssembly.js";
 import { buildAttachmentPlan } from "./policies.js";
+import { createStoredZip } from "./zipBundle.js";
 const DEFAULT_BROWSER_INLINE_CHAR_BUDGET = 60_000;
 const MEDIA_EXTENSIONS = new Set([
     ".mp4",
@@ -34,6 +35,49 @@ export function isMediaFile(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     return MEDIA_EXTENSIONS.has(ext);
 }
+function formatSectionsForBundle(sections) {
+    const bundleLines = [];
+    sections.forEach((section) => {
+        bundleLines.push(formatFileSection(section.displayPath, section.content).trimEnd());
+        bundleLines.push("");
+    });
+    return `${bundleLines
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trimEnd()}\n`;
+}
+async function writeBrowserBundle(sections, format) {
+    const bundleDir = await fs.mkdtemp(path.join(os.tmpdir(), "oracle-browser-bundle-"));
+    const tokenEstimateText = formatSectionsForBundle(sections);
+    if (format === "zip") {
+        const bundlePath = path.join(bundleDir, "attachments-bundle.zip");
+        const buffer = createStoredZip(sections.map((section) => ({
+            path: section.displayPath,
+            content: section.content,
+        })));
+        await fs.writeFile(bundlePath, buffer);
+        return {
+            attachment: {
+                path: bundlePath,
+                displayPath: bundlePath,
+                sizeBytes: buffer.length,
+            },
+            metadata: { originalCount: sections.length, bundlePath, format },
+            tokenEstimateText,
+        };
+    }
+    const bundlePath = path.join(bundleDir, "attachments-bundle.txt");
+    await fs.writeFile(bundlePath, tokenEstimateText, "utf8");
+    return {
+        attachment: {
+            path: bundlePath,
+            displayPath: bundlePath,
+            sizeBytes: Buffer.byteLength(tokenEstimateText, "utf8"),
+        },
+        metadata: { originalCount: sections.length, bundlePath, format },
+        tokenEstimateText,
+    };
+}
 export async function assembleBrowserPrompt(runOptions, deps = {}) {
     const cwd = deps.cwd ?? process.cwd();
     const readFilesFn = deps.readFilesImpl ?? readFiles;
@@ -49,7 +93,10 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
             sizeBytes: stats.size,
         };
     }));
-    const files = await readFilesFn(textFilePaths, { cwd });
+    const files = await readFilesFn(textFilePaths, {
+        cwd,
+        maxFileSizeBytes: runOptions.maxFileSizeBytes,
+    });
     const basePrompt = (runOptions.prompt ?? "").trim();
     const userPrompt = basePrompt;
     const systemPrompt = runOptions.system?.trim() || "";
@@ -59,6 +106,7 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
         ? "never"
         : (runOptions.browserAttachments ?? "auto");
     const bundleRequested = Boolean(runOptions.browserBundleFiles);
+    const bundleFormat = runOptions.browserBundleFormat ?? "text";
     const inlinePlan = buildAttachmentPlan(sections, { inlineFiles: true, bundleRequested });
     const uploadPlan = buildAttachmentPlan(sections, { inlineFiles: false, bundleRequested });
     const baseComposerSections = [];
@@ -88,26 +136,12 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
     let bundleText = null;
     let bundled = null;
     if (shouldBundle) {
-        const bundleDir = await fs.mkdtemp(path.join(os.tmpdir(), "oracle-browser-bundle-"));
-        const bundlePath = path.join(bundleDir, "attachments-bundle.txt");
-        const bundleLines = [];
-        sections.forEach((section) => {
-            bundleLines.push(formatFileSection(section.displayPath, section.content).trimEnd());
-            bundleLines.push("");
-        });
-        bundleText = `${bundleLines
-            .join("\n")
-            .replace(/\n{3,}/g, "\n\n")
-            .trimEnd()}\n`;
-        await fs.writeFile(bundlePath, bundleText, "utf8");
+        const writtenBundle = await writeBrowserBundle(sections, bundleFormat);
+        bundleText = writtenBundle.tokenEstimateText;
         attachments.length = 0;
-        attachments.push({
-            path: bundlePath,
-            displayPath: bundlePath,
-            sizeBytes: Buffer.byteLength(bundleText, "utf8"),
-        });
+        attachments.push(writtenBundle.attachment);
         attachments.push(...mediaAttachments);
-        bundled = { originalCount: sections.length, bundlePath };
+        bundled = writtenBundle.metadata;
     }
     const inlineFileCount = selectedPlan.inlineFileCount;
     const modelConfig = isKnownModel(runOptions.model)
@@ -140,26 +174,11 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
         const fallbackAttachments = [...uploadPlan.attachments, ...mediaAttachments];
         let fallbackBundled = null;
         if (uploadPlan.shouldBundle) {
-            const bundleDir = await fs.mkdtemp(path.join(os.tmpdir(), "oracle-browser-bundle-"));
-            const bundlePath = path.join(bundleDir, "attachments-bundle.txt");
-            const bundleLines = [];
-            sections.forEach((section) => {
-                bundleLines.push(formatFileSection(section.displayPath, section.content).trimEnd());
-                bundleLines.push("");
-            });
-            const fallbackBundleText = `${bundleLines
-                .join("\n")
-                .replace(/\n{3,}/g, "\n\n")
-                .trimEnd()}\n`;
-            await fs.writeFile(bundlePath, fallbackBundleText, "utf8");
+            const writtenBundle = await writeBrowserBundle(sections, bundleFormat);
             fallbackAttachments.length = 0;
-            fallbackAttachments.push({
-                path: bundlePath,
-                displayPath: bundlePath,
-                sizeBytes: Buffer.byteLength(fallbackBundleText, "utf8"),
-            });
+            fallbackAttachments.push(writtenBundle.attachment);
             fallbackAttachments.push(...mediaAttachments);
-            fallbackBundled = { originalCount: sections.length, bundlePath };
+            fallbackBundled = writtenBundle.metadata;
         }
         fallback = {
             composerText: fallbackComposerText,

package/dist/src/browser/sessionRunner.js

@@ -5,6 +5,61 @@ import { runBrowserMode } from "../browserMode.js";
 import { assembleBrowserPrompt } from "./prompt.js";
 import { BrowserAutomationError } from "../oracle/errors.js";
 import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportArtifact, } from "./artifacts.js";
+const LARGE_PRO_FAST_INPUT_TOKEN_THRESHOLD = 25_000;
+const LARGE_PRO_FAST_ELAPSED_MS_THRESHOLD = 120_000;
+function buildUnavailableModelSelectionEvidence(browserConfig) {
+    if (!browserConfig.desiredModel) {
+        return undefined;
+    }
+    return {
+        requestedModel: browserConfig.desiredModel,
+        resolvedLabel: null,
+        strategy: browserConfig.modelStrategy,
+        status: "unavailable",
+        verified: false,
+        source: "config",
+        capturedAt: new Date().toISOString(),
+    };
+}
+function formatModelSelectionEvidence(evidence) {
+    const requested = evidence.requestedModel ?? "(none)";
+    const resolved = evidence.resolvedLabel ?? "(unavailable)";
+    const strategy = evidence.strategy ?? "(default)";
+    const verified = evidence.verified ? "yes" : "no";
+    return `[browser] Model selection evidence: requested=${requested}; resolved=${resolved}; status=${evidence.status}; strategy=${strategy}; verified=${verified}.`;
+}
+function isRequestedProBrowserRun(runOptions, browserConfig, evidence) {
+    const candidates = [
+        runOptions.model,
+        browserConfig.desiredModel,
+        evidence?.requestedModel,
+        evidence?.resolvedLabel,
+    ];
+    return candidates.some((value) => typeof value === "string" && /\bpro\b/i.test(value));
+}
+export function buildBrowserRunWarningsForTest(args) {
+    return buildBrowserRunWarnings(args);
+}
+function buildBrowserRunWarnings(args) {
+    if (!isRequestedProBrowserRun(args.runOptions, args.browserConfig, args.modelSelection) ||
+        args.inputTokens < LARGE_PRO_FAST_INPUT_TOKEN_THRESHOLD ||
+        args.elapsedMs >= LARGE_PRO_FAST_ELAPSED_MS_THRESHOLD) {
+        return [];
+    }
+    return [
+        {
+            code: "browser-pro-fast-large-run",
+            severity: "warning",
+            message: `Large browser Pro run completed quickly (${(args.elapsedMs / 1000).toFixed(0)}s for ~${args.inputTokens.toLocaleString()} input tokens); verify the stored model selection evidence before claiming Pro Extended output.`,
+            details: {
+                inputTokens: args.inputTokens,
+                elapsedMs: args.elapsedMs,
+                requestedModel: args.modelSelection?.requestedModel ?? args.browserConfig.desiredModel,
+                resolvedLabel: args.modelSelection?.resolvedLabel ?? null,
+            },
+        },
+    ];
+}
 export async function runBrowserSessionExecution({ runOptions, browserConfig, cwd, log }, deps = {}) {
     const assemblePrompt = deps.assemblePrompt ?? assembleBrowserPrompt;
     const executeBrowser = deps.executeBrowser ?? runBrowserMode;
@@ -37,7 +92,7 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         if (typeof message !== "string")
             return;
         const shouldAlwaysPrint = message.startsWith("[browser] ") &&
-            /archive|fallback|follow-up|retry|thinking|waiting for chatgpt|browser slot|browser control|browser guidance/i.test(message);
+            /archive|fallback|follow-up|retry|thinking|waiting for chatgpt|browser slot|browser control|browser guidance|model selection|model picker/i.test(message);
         if (!runOptions.verbose && !shouldAlwaysPrint)
             return;
         log(message);
@@ -84,6 +139,20 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         const message = error instanceof Error ? error.message : "Browser automation failed.";
         throw new BrowserAutomationError(message, { stage: "execute-browser" }, error);
     }
+    const modelSelection = browserResult.modelSelection ?? buildUnavailableModelSelectionEvidence(browserConfig);
+    if (modelSelection) {
+        log(formatModelSelectionEvidence(modelSelection));
+    }
+    const warnings = buildBrowserRunWarnings({
+        runOptions,
+        browserConfig,
+        inputTokens: promptArtifacts.estimatedInputTokens,
+        elapsedMs: browserResult.tookMs,
+        modelSelection,
+    });
+    for (const warning of warnings) {
+        log(chalk.yellow(`[browser] ${warning.message}`));
+    }
     if (!runOptions.silent) {
         log(chalk.bold("Answer:"));
         log(browserResult.answerMarkdown || browserResult.answerText || chalk.dim("(no text output)"));
@@ -148,6 +217,8 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
             controllerPid: browserResult.controllerPid ?? process.pid,
         },
         archive: browserResult.archive,
+        modelSelection,
+        warnings,
         answerText,
         artifacts: savedArtifacts,
     };

package/dist/src/browser/utils.js

@@ -1,50 +1,4 @@
-export function parseDuration(input, fallback) {
-    if (!input) {
-        return fallback;
-    }
-    const trimmed = input.trim();
-    if (!trimmed) {
-        return fallback;
-    }
-    const lowercase = trimmed.toLowerCase();
-    if (/^[0-9]+$/.test(lowercase)) {
-        return Number(lowercase);
-    }
-    const normalized = lowercase.replace(/\s+/g, "");
-    const singleMatch = /^([0-9]+)(ms|s|m|h)$/i.exec(normalized);
-    if (singleMatch && singleMatch[0].length === normalized.length) {
-        const value = Number(singleMatch[1]);
-        return convertUnit(value, singleMatch[2]);
-    }
-    const multiDuration = /([0-9]+)(ms|h|m|s)/g;
-    let total = 0;
-    let lastIndex = 0;
-    let match = multiDuration.exec(normalized);
-    while (match !== null) {
-        total += convertUnit(Number(match[1]), match[2]);
-        lastIndex = multiDuration.lastIndex;
-        match = multiDuration.exec(normalized);
-    }
-    if (total > 0 && lastIndex === normalized.length) {
-        return total;
-    }
-    return fallback;
-}
-function convertUnit(value, unitRaw) {
-    const unit = unitRaw?.toLowerCase();
-    switch (unit) {
-        case "ms":
-            return value;
-        case "s":
-            return value * 1000;
-        case "m":
-            return value * 60_000;
-        case "h":
-            return value * 3_600_000;
-        default:
-            return value;
-    }
-}
+export { parseDuration } from "../duration.js";
 export function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/dist/src/browser/zipBundle.js

@@ -0,0 +1,152 @@
+const ZIP_UTF8_FLAG = 0x0800;
+const ZIP_STORE_METHOD = 0;
+const ZIP_VERSION_NEEDED = 20;
+const ZIP_DOS_TIME = 0x0000;
+const ZIP_DOS_DATE = 0x0021;
+const CRC32_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let i = 0; i < table.length; i += 1) {
+        let value = i;
+        for (let bit = 0; bit < 8; bit += 1) {
+            value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+        }
+        table[i] = value >>> 0;
+    }
+    return table;
+})();
+function crc32(buffer) {
+    let crc = 0xffffffff;
+    for (const byte of buffer) {
+        crc = CRC32_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function normalizeZipPath(inputPath, fallback) {
+    const normalized = inputPath
+        .replace(/\\/g, "/")
+        .replace(/^[a-zA-Z]:\//, "")
+        .replace(/^\/+/, "")
+        .split("/")
+        .filter((segment) => segment && segment !== "." && segment !== "..")
+        .join("/");
+    return normalized || fallback;
+}
+function uniqueZipPath(inputPath, index, seen) {
+    const normalized = normalizeZipPath(inputPath, `file-${index + 1}.txt`);
+    const extIndex = normalized.lastIndexOf(".");
+    const base = extIndex > 0 ? normalized.slice(0, extIndex) : normalized;
+    const ext = extIndex > 0 ? normalized.slice(extIndex) : "";
+    let candidate = normalized;
+    let suffix = 2;
+    while (seen.has(candidate)) {
+        candidate = `${base}-${suffix}${ext}`;
+        suffix += 1;
+    }
+    seen.add(candidate);
+    return candidate;
+}
+function assertZip32(value, label) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > 0xffffffff) {
+        throw new Error(`${label} exceeds ZIP32 limits.`);
+    }
+}
+function assertZip16(value, label) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > 0xffff) {
+        throw new Error(`${label} exceeds ZIP16 limits.`);
+    }
+}
+function localFileHeader(entry) {
+    const header = Buffer.alloc(30);
+    header.writeUInt32LE(0x04034b50, 0);
+    header.writeUInt16LE(ZIP_VERSION_NEEDED, 4);
+    header.writeUInt16LE(ZIP_UTF8_FLAG, 6);
+    header.writeUInt16LE(ZIP_STORE_METHOD, 8);
+    header.writeUInt16LE(ZIP_DOS_TIME, 10);
+    header.writeUInt16LE(ZIP_DOS_DATE, 12);
+    header.writeUInt32LE(entry.crc32, 14);
+    header.writeUInt32LE(entry.content.length, 18);
+    header.writeUInt32LE(entry.content.length, 22);
+    header.writeUInt16LE(entry.name.length, 26);
+    header.writeUInt16LE(0, 28);
+    return header;
+}
+function centralDirectoryHeader(entry) {
+    const header = Buffer.alloc(46);
+    header.writeUInt32LE(0x02014b50, 0);
+    header.writeUInt16LE(ZIP_VERSION_NEEDED, 4);
+    header.writeUInt16LE(ZIP_VERSION_NEEDED, 6);
+    header.writeUInt16LE(ZIP_UTF8_FLAG, 8);
+    header.writeUInt16LE(ZIP_STORE_METHOD, 10);
+    header.writeUInt16LE(ZIP_DOS_TIME, 12);
+    header.writeUInt16LE(ZIP_DOS_DATE, 14);
+    header.writeUInt32LE(entry.crc32, 16);
+    header.writeUInt32LE(entry.content.length, 20);
+    header.writeUInt32LE(entry.content.length, 24);
+    header.writeUInt16LE(entry.name.length, 28);
+    header.writeUInt16LE(0, 30);
+    header.writeUInt16LE(0, 32);
+    header.writeUInt16LE(0, 34);
+    header.writeUInt16LE(0, 36);
+    header.writeUInt32LE(0, 38);
+    header.writeUInt32LE(entry.localHeaderOffset, 42);
+    return header;
+}
+function endOfCentralDirectory(entryCount, centralSize, centralOffset) {
+    const footer = Buffer.alloc(22);
+    footer.writeUInt32LE(0x06054b50, 0);
+    footer.writeUInt16LE(0, 4);
+    footer.writeUInt16LE(0, 6);
+    footer.writeUInt16LE(entryCount, 8);
+    footer.writeUInt16LE(entryCount, 10);
+    footer.writeUInt32LE(centralSize, 12);
+    footer.writeUInt32LE(centralOffset, 16);
+    footer.writeUInt16LE(0, 20);
+    return footer;
+}
+export function createStoredZip(entries) {
+    if (entries.length > 0xffff) {
+        throw new Error("Too many files for a ZIP32 browser bundle.");
+    }
+    assertZip16(entries.length, "ZIP entry count");
+    const seen = new Set();
+    const prepared = [];
+    const localParts = [];
+    let offset = 0;
+    entries.forEach((entry, index) => {
+        const name = Buffer.from(uniqueZipPath(entry.path, index, seen), "utf8");
+        const content = Buffer.isBuffer(entry.content)
+            ? entry.content
+            : Buffer.from(entry.content, "utf8");
+        assertZip16(name.length, "ZIP file name");
+        assertZip32(content.length, "ZIP entry size");
+        assertZip32(offset, "ZIP local header offset");
+        const preparedEntry = {
+            name,
+            content,
+            crc32: crc32(content),
+            localHeaderOffset: offset,
+        };
+        prepared.push(preparedEntry);
+        const header = localFileHeader(preparedEntry);
+        localParts.push(header, name, content);
+        offset += header.length + name.length + content.length;
+        assertZip32(offset, "ZIP local data size");
+    });
+    const centralOffset = offset;
+    const centralParts = [];
+    for (const entry of prepared) {
+        const header = centralDirectoryHeader(entry);
+        centralParts.push(header, entry.name);
+        offset += header.length + entry.name.length;
+        assertZip32(offset, "ZIP central directory size");
+    }
+    const centralSize = offset - centralOffset;
+    assertZip32(centralOffset, "ZIP central directory offset");
+    assertZip32(centralSize, "ZIP central directory size");
+    const footer = endOfCentralDirectory(prepared.length, centralSize, centralOffset);
+    return Buffer.concat([...localParts, ...centralParts, footer]);
+}
+export const __test__ = {
+    crc32,
+    normalizeZipPath,
+};

package/dist/src/cli/browserConfig.js

@@ -1,6 +1,8 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET, normalizeChatgptUrl, parseDuration, } from "../browserMode.js";
+import { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from "../browser/constants.js";
+import { normalizeChatgptUrl } from "../browser/utils.js";
+import { parseDuration } from "../duration.js";
 import { normalizeBrowserModelStrategy } from "../browser/modelStrategy.js";
 import { getOracleHomeDir } from "../oracleHome.js";
 const DEFAULT_BROWSER_TIMEOUT_MS = 1_200_000;
@@ -12,14 +14,14 @@ const DEFAULT_CHROME_PROFILE = "Default";
 // The browser label is passed to the model picker which fuzzy-matches against ChatGPT's UI.
 const BROWSER_MODEL_LABELS = [
     // Most specific first (e.g., "gpt-5.2-thinking" before "gpt-5.2")
-    ["gpt-5.5-pro", "GPT-5.5 Pro"],
+    ["gpt-5.5-pro", "Pro"],
     ["gpt-5.5", "Thinking 5.5"],
-    ["gpt-5.4-pro", "GPT-5.4 Pro"],
+    ["gpt-5.4-pro", "Pro"],
     ["gpt-5.2-thinking", "GPT-5.2 Thinking"],
     ["gpt-5.2-instant", "GPT-5.2 Instant"],
-    ["gpt-5.2-pro", "GPT-5.5 Pro"],
-    ["gpt-5.1-pro", "GPT-5.5 Pro"],
-    ["gpt-5-pro", "GPT-5.5 Pro"],
+    ["gpt-5.2-pro", "Pro"],
+    ["gpt-5.1-pro", "Pro"],
+    ["gpt-5-pro", "Pro"],
     // Base models last (least specific)
     ["gpt-5.4", "Thinking 5.4"],
     ["gpt-5.2", "GPT-5.2"], // Selects "Auto" in ChatGPT UI
@@ -32,14 +34,14 @@ export function normalizeChatGptModelForBrowser(model) {
     if (!normalized.startsWith("gpt-") || normalized.includes("codex")) {
         return model;
     }
-    if (normalized === "gpt-5.5-pro" ||
-        normalized === "gpt-5.5" ||
-        normalized === "gpt-5.4-pro" ||
-        normalized === "gpt-5.4") {
+    if (normalized === "gpt-5.5-pro" || normalized === "gpt-5.5" || normalized === "gpt-5.4") {
         return normalized;
     }
     // Pro variants: resolve to the latest Pro model in ChatGPT.
-    if (normalized === "gpt-5-pro" || normalized === "gpt-5.1-pro" || normalized === "gpt-5.2-pro") {
+    if (normalized === "gpt-5-pro" ||
+        normalized === "gpt-5.1-pro" ||
+        normalized === "gpt-5.2-pro" ||
+        normalized === "gpt-5.4-pro") {
         return "gpt-5.5-pro";
     }
     // Explicit model variants: keep as-is (they have their own browser labels)

package/dist/src/cli/browserDefaults.js

@@ -1,4 +1,5 @@
-import { normalizeChatgptUrl, CHATGPT_URL } from "../browserMode.js";
+import { CHATGPT_URL } from "../browser/constants.js";
+import { normalizeChatgptUrl } from "../browser/utils.js";
 export function applyBrowserDefaultsFromConfig(options, config, getSource) {
     const browser = config.browser;
     if (!browser)