@steipete/oracle 0.7.2 → 0.7.4

package/README.md

@@ -64,6 +64,12 @@ Engine auto-picks API when `OPENAI_API_KEY` is set, otherwise browser; browser i
   ```
 - Tip: set `browser.chatgptUrl` in config (or `--chatgpt-url`) to a dedicated ChatGPT project folder so browser runs don’t clutter your main history.
 
+**Codex skill**
+- Copy the bundled skill from this repo to your Codex skills folder:
+  - `mkdir -p ~/.codex/skills`
+  - `cp -R skills/oracle ~/.codex/skills/oracle`
+- Then reference it in your `AGENTS.md`/`CLAUDE.md` so Codex loads it.
+
 **MCP**
 - Run the stdio server via `oracle-mcp`.
 - Configure clients via [steipete/mcporter](https://github.com/steipete/mcporter) or `.mcp.json`; see [docs/mcp.md](docs/mcp.md) for connection examples.

package/dist/bin/oracle-cli.js

@@ -174,7 +174,9 @@ program
     .addOption(new Option('--browser-headless', 'Launch Chrome in headless mode.').hideHelp())
     .addOption(new Option('--browser-hide-window', 'Hide the Chrome window after launch (macOS headful only).').hideHelp())
     .addOption(new Option('--browser-keep-browser', 'Keep Chrome running after completion.').hideHelp())
-    .addOption(new Option('--browser-extended-thinking', 'Select Extended thinking time for GPT-5.2 Thinking model.').hideHelp())
+    .addOption(new Option('--browser-thinking-time <level>', 'Thinking time intensity for Thinking/Pro models: light, standard, extended, heavy.')
+    .choices(['light', 'standard', 'extended', 'heavy'])
+    .hideHelp())
     .addOption(new Option('--browser-allow-cookie-errors', 'Continue even if Chrome cookies cannot be copied.').hideHelp())
     .addOption(new Option('--browser-attachments <mode>', 'How to deliver --file inputs in browser mode: auto (default) pastes inline up to ~60k chars then uploads; never always paste inline; always always upload.')
     .choices(['auto', 'never', 'always'])

package/dist/src/browser/actions/attachments.js

@@ -177,12 +177,15 @@ export async function uploadAttachmentFile(deps, attachment, logger) {
         }
         await dom.setFileInputFiles({ nodeId: resultNode.nodeId, files: [attachment.path] });
         await runtime.evaluate({ expression: dispatchEventsFor(idx), returnByValue: true }).catch(() => undefined);
-        const probeDeadline = Date.now() + 4000;
+        await delay(350);
+        const probeDeadline = Date.now() + 6500;
+        const pokeIntervalMs = 1200;
         let lastPoke = 0;
+        let seenInputHasFile = false;
         while (Date.now() < probeDeadline) {
             // ChatGPT's composer can take a moment to hydrate the file-input onChange handler after navigation/model switches.
             // If the UI hasn't reacted yet, poke the input a few times to ensure the handler fires once it's mounted.
-            if (Date.now() - lastPoke > 650) {
+            if (!seenInputHasFile && Date.now() - lastPoke > pokeIntervalMs) {
                 lastPoke = Date.now();
                 await runtime.evaluate({ expression: dispatchEventsFor(idx), returnByValue: true }).catch(() => undefined);
             }
@@ -198,6 +201,7 @@ export async function uploadAttachmentFile(deps, attachment, logger) {
                     composerText: typeof snapshot.composerText === 'string' ? snapshot.composerText : '',
                 };
                 const inputHasFile = finalSnapshot.inputNames.some((name) => name.toLowerCase().includes(expectedName.toLowerCase()));
+                seenInputHasFile = seenInputHasFile || inputHasFile;
                 const expectedLower = expectedName.toLowerCase();
                 const expectedNoExt = expectedLower.replace(/\.[a-z0-9]{1,10}$/i, '');
                 const uiAcknowledged = finalSnapshot.chipCount > baselineChipCount ||
@@ -209,7 +213,7 @@ export async function uploadAttachmentFile(deps, attachment, logger) {
                     break;
                 }
             }
-            await delay(200);
+            await delay(250);
         }
         const inputHasFile = finalSnapshot?.inputNames?.some((name) => name.toLowerCase().includes(expectedName.toLowerCase())) ?? false;
         const uiAcknowledged = (finalSnapshot?.chipCount ?? 0) > baselineChipCount;

package/dist/src/browser/actions/modelSelection.js

@@ -97,6 +97,10 @@ function buildModelSelectionExpression(targetModel) {
       if (wantsPro && !normalizedLabel.includes(' pro')) return false;
       if (wantsInstant && !normalizedLabel.includes('instant')) return false;
       if (wantsThinking && !normalizedLabel.includes('thinking')) return false;
+      // Also reject if button has variants we DON'T want
+      if (!wantsPro && normalizedLabel.includes(' pro')) return false;
+      if (!wantsInstant && normalizedLabel.includes('instant')) return false;
+      if (!wantsThinking && normalizedLabel.includes('thinking')) return false;
       return true;
     };
 
@@ -172,14 +176,21 @@ function buildModelSelectionExpression(targetModel) {
             return 0;
           }
         }
-        const matches = TEST_IDS.filter((id) => id && normalizedTestId.includes(id));
-        if (matches.length > 0) {
-          // Prefer the most specific match (longest token) instead of treating any hit as equal.
-          // This prevents generic tokens (e.g. "pro") from outweighing version-specific targets.
-          const best = matches.reduce((acc, token) => (token.length > acc.length ? token : acc), '');
-          score += 200 + Math.min(900, best.length * 25);
-          if (best.startsWith('model-switcher-')) score += 120;
-          if (best.includes('gpt-')) score += 60;
+        // Exact testid matches take priority over substring matches
+        const exactMatch = TEST_IDS.find((id) => id && normalizedTestId === id);
+        if (exactMatch) {
+          score += 1500;
+          if (exactMatch.startsWith('model-switcher-')) score += 200;
+        } else {
+          const matches = TEST_IDS.filter((id) => id && normalizedTestId.includes(id));
+          if (matches.length > 0) {
+            // Prefer the most specific match (longest token) instead of treating any hit as equal.
+            // This prevents generic tokens (e.g. "pro") from outweighing version-specific targets.
+            const best = matches.reduce((acc, token) => (token.length > acc.length ? token : acc), '');
+            score += 200 + Math.min(900, best.length * 25);
+            if (best.startsWith('model-switcher-')) score += 120;
+            if (best.includes('gpt-')) score += 60;
+          }
         }
       }
       if (normalizedText && normalizedTarget) {
@@ -215,6 +226,22 @@ function buildModelSelectionExpression(targetModel) {
       } else if (normalizedText.includes(' pro')) {
         score -= 40;
       }
+      // Similarly for Thinking variant
+      if (wantsThinking) {
+        if (!normalizedText.includes('thinking') && !normalizedTestId.includes('thinking')) {
+          score -= 80;
+        }
+      } else if (normalizedText.includes('thinking') || normalizedTestId.includes('thinking')) {
+        score -= 40;
+      }
+      // Similarly for Instant variant
+      if (wantsInstant) {
+        if (!normalizedText.includes('instant') && !normalizedTestId.includes('instant')) {
+          score -= 80;
+        }
+      } else if (normalizedText.includes('instant') || normalizedTestId.includes('instant')) {
+        score -= 40;
+      }
       return Math.max(score, 0);
     };
 
@@ -377,10 +404,24 @@ function buildModelMatchersLiteral(targetModel) {
         push('gpt5-2', labelTokens);
         push('gpt52', labelTokens);
         push('chatgpt 5.2', labelTokens);
-        if (base.includes('thinking'))
+        // Thinking variant: explicit testid for "Thinking" picker option
+        if (base.includes('thinking')) {
             push('thinking', labelTokens);
-        if (base.includes('instant'))
+            testIdTokens.add('model-switcher-gpt-5-2-thinking');
+            testIdTokens.add('gpt-5-2-thinking');
+            testIdTokens.add('gpt-5.2-thinking');
+        }
+        // Instant variant: explicit testid for "Instant" picker option
+        if (base.includes('instant')) {
             push('instant', labelTokens);
+            testIdTokens.add('model-switcher-gpt-5-2-instant');
+            testIdTokens.add('gpt-5-2-instant');
+            testIdTokens.add('gpt-5.2-instant');
+        }
+        // Base 5.2 testids (for "Auto" mode when no suffix specified)
+        if (!base.includes('thinking') && !base.includes('instant') && !base.includes('pro')) {
+            testIdTokens.add('model-switcher-gpt-5-2');
+        }
         testIdTokens.add('gpt-5-2');
         testIdTokens.add('gpt5-2');
         testIdTokens.add('gpt52');

package/dist/src/browser/actions/thinkingTime.js

@@ -1,14 +1,19 @@
 import { MENU_CONTAINER_SELECTOR, MENU_ITEM_SELECTOR } from '../constants.js';
 import { logDomFailure } from '../domDebug.js';
 import { buildClickDispatcher } from './domEvents.js';
-export async function ensureExtendedThinking(Runtime, logger) {
-    const result = await evaluateThinkingTimeSelection(Runtime);
+/**
+ * Selects a specific thinking time level in ChatGPT's composer pill menu.
+ * @param level - The thinking time intensity: 'light', 'standard', 'extended', or 'heavy'
+ */
+export async function ensureThinkingTime(Runtime, level, logger) {
+    const result = await evaluateThinkingTimeSelection(Runtime, level);
+    const capitalizedLevel = level.charAt(0).toUpperCase() + level.slice(1);
     switch (result?.status) {
-        case 'already-extended':
-            logger(`Thinking time: ${result.label ?? 'Extended'} (already selected)`);
+        case 'already-selected':
+            logger(`Thinking time: ${result.label ?? capitalizedLevel} (already selected)`);
             return;
         case 'switched':
-            logger(`Thinking time: ${result.label ?? 'Extended'}`);
+            logger(`Thinking time: ${result.label ?? capitalizedLevel}`);
             return;
         case 'chip-not-found': {
             await logDomFailure(Runtime, logger, 'thinking-chip');
@@ -18,33 +23,35 @@ export async function ensureExtendedThinking(Runtime, logger) {
             await logDomFailure(Runtime, logger, 'thinking-time-menu');
             throw new Error('Unable to find the Thinking time dropdown menu.');
         }
-        case 'extended-not-found': {
-            await logDomFailure(Runtime, logger, 'extended-option');
-            throw new Error('Unable to find the Extended option in the Thinking time menu.');
+        case 'option-not-found': {
+            await logDomFailure(Runtime, logger, `${level}-option`);
+            throw new Error(`Unable to find the ${capitalizedLevel} option in the Thinking time menu.`);
         }
         default: {
             await logDomFailure(Runtime, logger, 'thinking-time-unknown');
-            throw new Error('Unknown error selecting Extended thinking time.');
+            throw new Error(`Unknown error selecting ${capitalizedLevel} thinking time.`);
         }
     }
 }
 /**
- * Best-effort selection of the "Extended" thinking-time option in ChatGPT's composer pill menu.
+ * Best-effort selection of a thinking time level in ChatGPT's composer pill menu.
  * Safe by default: if the pill/menu/option isn't present, we continue without throwing.
+ * @param level - The thinking time intensity: 'light', 'standard', 'extended', or 'heavy'
  */
-export async function ensureExtendedThinkingIfAvailable(Runtime, logger) {
+export async function ensureThinkingTimeIfAvailable(Runtime, level, logger) {
     try {
-        const result = await evaluateThinkingTimeSelection(Runtime);
+        const result = await evaluateThinkingTimeSelection(Runtime, level);
+        const capitalizedLevel = level.charAt(0).toUpperCase() + level.slice(1);
         switch (result?.status) {
-            case 'already-extended':
-                logger(`Thinking time: ${result.label ?? 'Extended'} (already selected)`);
+            case 'already-selected':
+                logger(`Thinking time: ${result.label ?? capitalizedLevel} (already selected)`);
                 return true;
             case 'switched':
-                logger(`Thinking time: ${result.label ?? 'Extended'}`);
+                logger(`Thinking time: ${result.label ?? capitalizedLevel}`);
                 return true;
             case 'chip-not-found':
             case 'menu-not-found':
-            case 'extended-not-found':
+            case 'option-not-found':
                 if (logger.verbose) {
                     logger(`Thinking time: ${result.status.replaceAll('-', ' ')}; continuing with default.`);
                 }
@@ -65,22 +72,24 @@ export async function ensureExtendedThinkingIfAvailable(Runtime, logger) {
         return false;
     }
 }
-async function evaluateThinkingTimeSelection(Runtime) {
+async function evaluateThinkingTimeSelection(Runtime, level) {
     const outcome = await Runtime.evaluate({
-        expression: buildThinkingTimeExpression(),
+        expression: buildThinkingTimeExpression(level),
         awaitPromise: true,
         returnByValue: true,
     });
     return outcome.result?.value;
 }
-function buildThinkingTimeExpression() {
+function buildThinkingTimeExpression(level) {
     const menuContainerLiteral = JSON.stringify(MENU_CONTAINER_SELECTOR);
     const menuItemLiteral = JSON.stringify(MENU_ITEM_SELECTOR);
+    const targetLevelLiteral = JSON.stringify(level.toLowerCase());
     return `(async () => {
     ${buildClickDispatcher()}
 
     const MENU_CONTAINER_SELECTOR = ${menuContainerLiteral};
     const MENU_ITEM_SELECTOR = ${menuItemLiteral};
+    const TARGET_LEVEL = ${targetLevelLiteral};
 
     const CHIP_SELECTORS = [
       '[data-testid="composer-footer-actions"] button[aria-haspopup="menu"]',
@@ -136,11 +145,11 @@ function buildThinkingTimeExpression() {
         return null;
       };
 
-      const findExtendedOption = (menu) => {
+      const findTargetOption = (menu) => {
         const items = menu.querySelectorAll(MENU_ITEM_SELECTOR);
         for (const item of items) {
           const text = normalize(item.textContent ?? '');
-          if (text.includes('extended')) {
+          if (text.includes(TARGET_LEVEL)) {
             return item;
           }
         }
@@ -167,24 +176,24 @@ function buildThinkingTimeExpression() {
           return;
         }
 
-        const extendedOption = findExtendedOption(menu);
-        if (!extendedOption) {
-          resolve({ status: 'extended-not-found' });
+        const targetOption = findTargetOption(menu);
+        if (!targetOption) {
+          resolve({ status: 'option-not-found' });
           return;
         }
 
         const alreadySelected =
-          optionIsSelected(extendedOption) ||
-          optionIsSelected(extendedOption.querySelector?.('[aria-checked="true"], [data-state="checked"], [data-state="selected"]'));
-        const label = extendedOption.textContent?.trim?.() || null;
-        dispatchClickSequence(extendedOption);
-        resolve({ status: alreadySelected ? 'already-extended' : 'switched', label });
+          optionIsSelected(targetOption) ||
+          optionIsSelected(targetOption.querySelector?.('[aria-checked="true"], [data-state="checked"], [data-state="selected"]'));
+        const label = targetOption.textContent?.trim?.() || null;
+        dispatchClickSequence(targetOption);
+        resolve({ status: alreadySelected ? 'already-selected' : 'switched', label });
       };
 
       setTimeout(attempt, INITIAL_WAIT_MS);
     });
   })()`;
 }
-export function buildThinkingTimeExpressionForTest() {
-    return buildThinkingTimeExpression();
+export function buildThinkingTimeExpressionForTest(level = 'extended') {
+    return buildThinkingTimeExpression(level);
 }

package/dist/src/browser/chromeLifecycle.js

@@ -25,6 +25,7 @@ export async function launchChrome(config, userDataDir, logger) {
             chromePath: config.chromePath ?? undefined,
             chromeFlags,
             userDataDir,
+            handleSIGINT: false,
             port: debugPort ?? undefined,
         });
     const pidLabel = typeof launcher.pid === 'number' ? ` (pid ${launcher.pid})` : '';
@@ -216,6 +217,7 @@ async function launchWithCustomHost({ chromeFlags, chromePath, userDataDir, host
         chromePath: chromePath ?? undefined,
         chromeFlags,
         userDataDir,
+        handleSIGINT: false,
         port: requestedPort ?? undefined,
     });
     if (host) {

package/dist/src/browser/config.js

@@ -24,7 +24,6 @@ export const DEFAULT_BROWSER_CONFIG = {
     remoteChrome: null,
     manualLogin: false,
     manualLoginProfileDir: null,
-    extendedThinking: false,
 };
 export function resolveBrowserConfig(config) {
     const debugPortEnv = parseDebugPort(process.env.ORACLE_BROWSER_PORT ?? process.env.ORACLE_BROWSER_DEBUG_PORT);
@@ -64,6 +63,7 @@ export function resolveBrowserConfig(config) {
         chromeCookiePath: config?.chromeCookiePath ?? DEFAULT_BROWSER_CONFIG.chromeCookiePath,
         debug: config?.debug ?? DEFAULT_BROWSER_CONFIG.debug,
         allowCookieErrors: config?.allowCookieErrors ?? envAllowCookieErrors ?? DEFAULT_BROWSER_CONFIG.allowCookieErrors,
+        thinkingTime: config?.thinkingTime,
         manualLogin,
         manualLoginProfileDir: manualLogin ? resolvedProfileDir : null,
     };

package/dist/src/browser/index.js

@@ -7,7 +7,7 @@ import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToChro
 import { syncCookies } from './cookies.js';
 import { navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, ensureModelSelection, submitPrompt, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from './pageActions.js';
 import { uploadAttachmentViaDataTransfer } from './actions/remoteFileTransfer.js';
-import { ensureExtendedThinking } from './actions/thinkingTime.js';
+import { ensureThinkingTime } from './actions/thinkingTime.js';
 import { estimateTokenCount, withRetries, delay } from './utils.js';
 import { formatElapsed } from '../oracle/format.js';
 import { CHATGPT_URL } from './constants.js';
@@ -37,12 +37,14 @@ export async function runBrowserMode(options) {
         if (!runtimeHintCb || !chrome?.port) {
             return;
         }
+        const conversationId = lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined;
         const hint = {
             chromePid: chrome.pid,
             chromePort: chrome.port,
             chromeHost,
             chromeTargetId: lastTargetId,
             tabUrl: lastUrl,
+            conversationId,
             userDataDir,
             controllerPid: process.pid,
         };
@@ -264,13 +266,15 @@ export async function runBrowserMode(options) {
             await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
         }
-        if (config.extendedThinking) {
-            await raceWithDisconnect(withRetries(() => ensureExtendedThinking(Runtime, logger), {
+        // Handle thinking time selection if specified
+        const thinkingTime = config.thinkingTime;
+        if (thinkingTime) {
+            await raceWithDisconnect(withRetries(() => ensureThinkingTime(Runtime, thinkingTime, logger), {
                 retries: 2,
                 delayMs: 300,
                 onRetry: (attempt, error) => {
                     if (options.verbose) {
-                        logger(`[retry] Extended thinking attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                        logger(`[retry] Thinking time (${thinkingTime}) attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
                     }
                 },
             }));
@@ -284,6 +288,7 @@ export async function runBrowserMode(options) {
                 for (const attachment of submissionAttachments) {
                     logger(`Uploading attachment: ${attachment.displayPath}`);
                     await uploadAttachmentFile({ runtime: Runtime, dom: DOM }, attachment, logger);
+                    await delay(500);
                 }
                 // Scale timeout based on number of files: base 30s + 15s per additional file
                 const baseTimeout = config.inputTimeoutMs ?? 30_000;
@@ -315,7 +320,7 @@ export async function runBrowserMode(options) {
             }
         }
         stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, options.verbose ?? false);
-        const answer = await raceWithDisconnect(waitForAssistantResponse(Runtime, config.timeoutMs, logger));
+        const answer = await raceWithDisconnect(waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger));
         answerText = answer.text;
         answerHtml = answer.html ?? '';
         const copiedMarkdown = await raceWithDisconnect(withRetries(async () => {
@@ -661,13 +666,15 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
         }
-        if (config.extendedThinking) {
-            await withRetries(() => ensureExtendedThinking(Runtime, logger), {
+        // Handle thinking time selection if specified
+        const thinkingTime = config.thinkingTime;
+        if (thinkingTime) {
+            await withRetries(() => ensureThinkingTime(Runtime, thinkingTime, logger), {
                 retries: 2,
                 delayMs: 300,
                 onRetry: (attempt, error) => {
                     if (options.verbose) {
-                        logger(`[retry] Extended thinking attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                        logger(`[retry] Thinking time (${thinkingTime}) attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
                     }
                 },
             });
@@ -682,6 +689,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 for (const attachment of submissionAttachments) {
                     logger(`Uploading attachment: ${attachment.displayPath}`);
                     await uploadAttachmentViaDataTransfer({ runtime: Runtime, dom: DOM }, attachment, logger);
+                    await delay(500);
                 }
                 // Scale timeout based on number of files: base 30s + 15s per additional file
                 const baseTimeout = config.inputTimeoutMs ?? 30_000;
@@ -709,7 +717,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             }
         }
         stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, options.verbose ?? false);
-        const answer = await waitForAssistantResponse(Runtime, config.timeoutMs, logger);
+        const answer = await waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger);
         answerText = answer.text;
         answerHtml = answer.html ?? '';
         const copiedMarkdown = await withRetries(async () => {
@@ -859,6 +867,42 @@ export function formatThinkingLog(startedAt, now, message, locatorSuffix) {
     const statusLabel = message ? ` — ${message}` : '';
     return `${pct}% [${elapsedText} / ~10m]${statusLabel}${locatorSuffix}`;
 }
+async function waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger) {
+    try {
+        return await waitForAssistantResponse(Runtime, timeoutMs, logger);
+    }
+    catch (error) {
+        if (!shouldReloadAfterAssistantError(error)) {
+            throw error;
+        }
+        const conversationUrl = await readConversationUrl(Runtime);
+        if (!conversationUrl || !isConversationUrl(conversationUrl)) {
+            throw error;
+        }
+        logger('Assistant response stalled; reloading conversation and retrying once');
+        await Page.navigate({ url: conversationUrl });
+        await delay(1000);
+        return await waitForAssistantResponse(Runtime, timeoutMs, logger);
+    }
+}
+function shouldReloadAfterAssistantError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.toLowerCase();
+    return message.includes('assistant-response') || message.includes('watchdog') || message.includes('timeout');
+}
+async function readConversationUrl(Runtime) {
+    try {
+        const currentUrl = await Runtime.evaluate({ expression: 'location.href', returnByValue: true });
+        return typeof currentUrl.result?.value === 'string' ? currentUrl.result.value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isConversationUrl(url) {
+    return /\/c\/[a-z0-9-]+/i.test(url);
+}
 function startThinkingStatusMonitor(Runtime, logger, includeDiagnostics = false) {
     let stopped = false;
     let pending = false;
@@ -947,6 +991,10 @@ function isWsl() {
         return true;
     return os.release().toLowerCase().includes('microsoft');
 }
+function extractConversationIdFromUrl(url) {
+    const match = url.match(/\/c\/([a-zA-Z0-9-]+)/);
+    return match?.[1];
+}
 async function resolveUserDataBaseDir() {
     // On WSL, Chrome launched via Windows can choke on UNC paths; prefer a Windows-backed temp folder.
     if (isWsl()) {