ask-pro 0.1.71 → 0.2.80

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ask-pro",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Minimal browser-backed ChatGPT Pro escalation workflow for agents via $ask-pro.",
   "author": {
     "name": "Jonathan",

package/README.md

@@ -6,47 +6,35 @@ and owns the result; ask-pro never applies generated code.
 
 ## Install
 
-Both options need Node.js 24+, Chrome, and a ChatGPT account with Pro access.
-Browser login is manual.
-
-### Codex plugin marketplace
-
 ```powershell
-codex plugin marketplace add JJLiebig/ask-pro
-codex plugin add ask-pro@ask-pro
+npx skills add JJLiebig/ask-pro -g
 ```
 
-This route needs Git and npm. The plugin's cached runner downloads pnpm, builds
-outside the plugin cache, and keeps the installed snapshot unchanged. If
-`ask-pro` is not on `PATH`, the skill uses that runner.
+This installs the `ask-pro` skill for Codex, Claude Code, and the other agents
+the [skills CLI](https://github.com/vercel-labs/skills) supports. The skill
+contains ask-pro itself; its first run installs dependencies and builds, so no
+separate CLI install is needed. Update with `npx skills update`.
 
-Update with `codex plugin marketplace upgrade ask-pro`, then restart Codex to
-load the updated skill.
-
-### Skills CLI (Codex and other supported agents)
-
-Install the skill and its standalone CLI separately:
+Codex users can install it as a plugin instead:
 
 ```powershell
-npx skills add JJLiebig/ask-pro
-npm install --global ask-pro
+codex plugin marketplace add JJLiebig/ask-pro
+codex plugin add ask-pro@ask-pro
 ```
 
-The [skills CLI](https://github.com/vercel-labs/skills) installs the skill in
-the current project by default. Add `-g` for a user-wide skill or `-a codex`
-to select Codex; it supports other agents too. The npm CLI runs without Codex's
-plugin cache.
-
-Update both parts:
-
-```powershell
-npx skills update
-npm update --global ask-pro
-```
+Update with `codex plugin marketplace upgrade ask-pro`, then restart Codex.
+Both installs run the same bundled launcher. The `ask-pro` npm package
+(`npm i -g ask-pro`) still works too. All three share the same state.
 
-The browser runtime is developed and tested on Windows. Other operating systems
+You need Node.js 24+, npm, Chrome, and a ChatGPT account with Pro access. The
+browser runtime is developed and tested on Windows; other operating systems
 need validation.
 
+**Upgrading from an earlier version:** nothing to do. On its first run,
+ask-pro moves your signed-in browser profiles from `~/.codex/state/ask-pro` to
+`~/.agents/state/ask-pro`. If Chrome still has the old profile open, ask-pro
+uses it where it is and moves it on a later run.
+
 ## Browser and session state
 
 ask-pro never asks for, types, reads, or logs passwords, MFA codes, recovery
@@ -54,10 +42,9 @@ codes, session cookies, or raw auth tokens. A new browser profile may need one
 manual ChatGPT login. On Windows, ordinary managed Chrome runs start minimized
 and are hidden; login and recovery restore the window for human action.
 
-The persistent profile lives at `$CODEX_HOME/state/ask-pro/browser-profile`, or
-`~/.codex/state/ask-pro/browser-profile` when `CODEX_HOME` is unset. Existing
-legacy profiles are migrated on first use; see [Windows notes](docs/windows-work.md)
-for copy and recovery details.
+ask-pro keeps its state in `~/.agents/state/ask-pro/`: the persistent browser
+profile in `browser-profile/` and the builds of the installed skill in
+`runtimes/`. Set `ASK_PRO_STATE_DIR` to use a different folder.
 
 Project sessions live under `.ask-pro/sessions/<id>/`. Add `.ask-pro/` to your
 project's `.gitignore`. At each invocation, ask-pro deletes entire session
@@ -65,7 +52,9 @@ directories at least seven days old, regardless of state.
 
 ## Use
 
-Ask for a recoverable repo consult:
+Agents run ask-pro through the installed skill, as
+`node <skill-folder>/scripts/ask-pro.mjs`; `ask-pro` below stands for that
+command. Ask for a recoverable repo consult:
 
 ```powershell
 ask-pro --no-temporary --prompt-file question.md --files src --files tests
@@ -86,7 +75,7 @@ ask-pro --harvest <session-id>
 
 Use `ask-pro --help` for the full CLI. For multiline prompts, use
 `--prompt-file`. Prefer `--no-temporary` when recovery matters; `--temporary`
-requires Temporary Chat. The [skill](skills/ask-pro/SKILL.md) has agent guidance.
+requires Temporary Chat. The [skill](SKILL.md) has agent guidance.
 
 When Pro asks native questions, ask-pro returns `awaiting_answers`, prints each
 question and its numbered choices, and saves `QUESTIONS.json`. The calling agent
@@ -154,8 +143,8 @@ pnpm run format:check
 pnpm pack --dry-run
 ```
 
-After changing plugin files, run `pnpm run plugin:refresh` and restart Codex.
-Do not edit the installed plugin cache. Live browser tests are opt-in; see
+To try local changes as an installed skill, run
+`npx skills add <path-to-checkout> -g`. Live browser tests are opt-in; see
 [manual tests](docs/manual-tests.md).
 
 After the build matrix passes on `main`, [CI](.github/workflows/ci.yml) publishes

package/SKILL.md

@@ -0,0 +1,229 @@
+---
+name: ask-pro
+description: Escalate hard engineering questions to ChatGPT Pro through browser automation with focused repo context. Use when an agent needs a stronger external review, architecture plan, migration strategy, production-debugging second opinion, or when the user explicitly asks to use $ask-pro.
+---
+
+# $ask-pro
+
+Use `$ask-pro` to ask ChatGPT Pro for a focused second opinion on hard engineering work.
+
+The calling agent still owns the work. Use Pro for judgment, architecture, risk review, or implementation planning when the decision is consequential enough to justify a browser run.
+
+## Running ask-pro
+
+This skill folder contains ask-pro itself; nothing else needs installing. In
+the commands below, `ask-pro` stands for:
+
+```bash
+node <skill-folder>/scripts/ask-pro.mjs
+```
+
+`<skill-folder>` is the directory containing this `SKILL.md`. Run it from the
+target repo root. The first run after an install or update installs
+dependencies and builds, which can take a few minutes; wait for it. The CLI's
+emitted `resume` and `harvest` commands already contain the full launcher path;
+run them as printed. Node.js 24+, npm, and Chrome are required.
+
+## Trigger
+
+Use this skill when the user explicitly asks for `$ask-pro`, or when a second opinion would materially reduce risk for:
+
+- backend architecture
+- schema or data migrations
+- auth, sessions, permissions, or billing
+- queues, workers, idempotency, caching, scaling, or latency
+- production debugging and observability
+- ambiguous implementation paths where a second opinion would reduce risk
+
+Do not use it for trivial syntax fixes, formatting, obvious dependency updates, or small bugs with a clear cause.
+
+## Critical Reminders
+
+- Long waits are normal. ask-pro can take a super long time to run; do not
+  close or kill the browser window/run until at least 3 hours have passed unless
+  the CLI has completed, failed, or explicitly asks for human action.
+
+## Workflow
+
+When invoked:
+
+1. Inspect the repo and the relevant files.
+2. Identify the exact decision Pro should answer.
+3. For committed code on GitHub, prefer `--github` and give Pro the repository,
+   ref, relevant paths, and question. Let it retrieve the code instead of assembling
+   a source bundle. Add a small `--files` bundle only for uncommitted changes,
+   local-only evidence, or repository content the connection cannot access.
+4. Write the prompt yourself using the Prompt Shape below.
+5. Run the smallest useful command: `ask-pro --github "<prompt>"` for GitHub
+   evidence, or `ask-pro --no-temporary --files "<glob>" "<prompt>"` for a file bundle.
+   For multiline prompts, write a temporary prompt file and use
+   `ask-pro --no-temporary --prompt-file <path> --files "<glob>"`; do not rely
+   on shell multiline quoting.
+6. If auth is required, stop and ask the human to log in in the opened browser.
+7. Read the CLI's compact `ask_pro` record and run the emitted `resume` or
+   `harvest` command when that is the next action.
+8. Treat the answer as advisory; turn it into your own plan before editing code.
+
+`ask-pro` selects `Latest` when available, otherwise the highest numbered available
+GPT model, then `Pro` intelligence. Do not require a
+different dated model label or a separate thinking-effort control in the prompt
+or workflow.
+
+Fresh runs try ChatGPT Temporary Chat by default and automatically fall back to
+normal ChatGPT if the current account/UI does not expose Pro there. For repo
+advisories, large bundles, review rounds, or anything where recovery matters,
+prefer `--no-temporary` from the start. Add `--temporary` only when Temporary
+Chat is required and falling back would be wrong. Temporary Chat is less
+recoverable after browser/tab loss.
+
+On Windows, ordinary managed Chrome runs start minimized. First login,
+resume/recovery, and stale-auth paths stay visible or are restored for human
+action. Local managed Chrome guards browser input while Pro is answering.
+If login, MFA, a browser challenge, or incomplete-answer debugging needs human
+attention, ask-pro should restore or retain the browser and emit the next
+action.
+
+Do not set `ASK_PRO_AGENT_ID` for ordinary or concurrent use; the shared
+`ask-pro` browser profile under `~/.agents/state/ask-pro/` handles concurrent
+agents automatically. Set `ASK_PRO_AGENT_ID` only when explicitly testing an
+isolated profile or when the human requests a separate browser login. Use a
+stable reusable lowercase id like `review-t1`, not a one-off task slug, because
+each new id creates a new Chrome profile and may require the human to log in
+again. Example:
+`ASK_PRO_AGENT_ID=review-t1 ask-pro ...`.
+
+## Prompt Shape
+
+Assume Pro has no caller context or local checkout. Include each material fact and
+instruction once: the goal, current state, hard constraints, evidence, success
+criteria, and required output. Do not rely on the agent's conversation context, repo
+folklore, prior ask-pro runs, branch names, or unstated user preferences.
+Keep advisory design consults as plain answer requests. Start advisory prompts
+with:
+
+```text
+Return final Markdown only, with no preamble or implementation package.
+```
+
+The CLI wrapper already tells Pro to read `CONTEXT.zip` and call out missing or
+conflicting context. Do not repeat that instruction. Add task-specific output
+requirements only when needed. For risk or review work, ask Pro to rank
+findings by severity. For architecture or design consults, ask directly for the
+recommendation and tradeoffs.
+
+Use `--artifacts` only when the standard implementation package is needed. The
+wrapper supplies the zip name, standard files, and markdown fallback; add only
+task-specific deliverables not covered by that package. Keep advisory consults
+inline by default.
+Keep bundles focused: source files under review, focused tests, relevant docs,
+known recent changes, and validation status. Avoid whole-repo bundles unless the
+question is explicitly architectural.
+
+## Connected GitHub (optional)
+
+Prefer `--github` for remote repository evidence. It checks
+the connection before uploading or submitting, and defaults to normal ChatGPT.
+Do not require GitHub for file-based consults. Availability varies by account,
+workspace, model, and ChatGPT experience.
+
+If the CLI returns `needs_github_connection` / `connect_github_then_resume`,
+direct the human to the opened GitHub page in ask-pro's browser. They install the
+plugin if needed, complete sign-in, review permissions, and select repositories;
+organization approval may be needed. Wait for them to finish, then run the
+emitted resume command without adding `--github`. The requirement is saved with
+the session and checked again. Do not start a second session or submit through
+the browser yourself. Never collect GitHub credentials or automate authorization.
+
+If available, GitHub's **Allow read actions** permission can avoid read approval
+prompts. The human chooses that setting. It controls approval behavior, not the
+underlying permissions of a write-capable app; see
+[app permissions](https://help.openai.com/en/articles/20001495-managing-app-permissions-in-chatgpt).
+The live GitHub plugin advertises write capabilities despite the Help Center's
+read-only description. `--github` requests read-only work; it does not restrict
+the provider's permissions or prove that writes are impossible.
+
+If GitHub is already connected, proceed without a setup question or source-file
+bundle. For the consult, name the repository (`owner/repo`), relevant paths, and
+requested branch or commit in the prompt. Explicitly ask Pro
+to answer the specific question. The wrapper requests the connected GitHub app,
+read-only work, citations, the revision inspected, and access gaps. Do not
+infer repository access from ChatGPT login or a successful CLI exit.
+
+Keep `--files` for local/uncommitted changes, non-GitHub evidence, and snapshots
+that the app cannot retrieve. Distinguish
+uploaded evidence from GitHub evidence, and ask Pro to flag revision conflicts.
+If the app or requested revision is unavailable, offer a new consult with a
+focused file bundle and
+disclose that limitation. Do not silently switch away from Pro. The CLI submits
+text; it does not select an app in the composer or handle app approval prompts.
+Until a live run demonstrates retrieval, describe this as an available setup
+path, not a verified connection. Confirm material claims against the repo.
+
+## Output
+
+Normal `ask-pro` stdout is compact TOON-style telemetry. Use `state`, `action`,
+`resume`, and `harvest` to decide the next command. Browser progress may appear
+on stderr and can be ignored unless diagnosing a stuck run.
+
+`AWAITING_ANSWERS` / `answer_questions` means Pro is asking native interactive
+questions. Read the printed questions/options or `QUESTIONS.json`, answer from
+the caller's context, and ask the human only for decisions you cannot infer.
+Write UTF-8 JSON `{"requestId":"<request_id>","answers":[2,3,"free text"]}`
+with one answer per question in order, then run the emitted
+`ask-pro --resume <session-id> --answers <answers.json>` command. Numbers select
+1-based choices; strings enter the native free-text field. `--answers -` accepts
+piped JSON. Do not submit defaults or treat the question preamble as the answer.
+Repeat for further question rounds, then harvest the final answer normally.
+
+When present, use `profile`, `profile_path`, `chrome`, and `language` only as
+diagnostic hints. They tell you whether the run used the shared profile, an
+isolated agent profile, saved DevTools state, and English browser steering.
+When present, `conversation_url` is a recoverable non-temporary ChatGPT
+conversation URL.
+
+`ask-pro --harvest <session-id>` prints the raw markdown answer only for
+answer-bearing states such as `COMPLETED` or `HARVESTED`.
+For pending/incomplete sessions it prints compact status/action instead. For
+sessions run with `--artifacts`, any provided `ask-pro-response.zip` is
+extracted under the session's `pro-output/` directory and described in
+`PRO_OUTPUT_MANIFEST.json`. Inline-default sessions should not expect a zip.
+
+`INCOMPLETE_ANSWER` / `stopped_without_answer` means ChatGPT stopped without
+an answer after ask-pro attempted one automatic `continue`. Present the caller
+with the emitted resume command or a full retry of the original request in a new
+chat, and wait for their choice. Do not automatically resume or retry this state.
+An explicit `--resume` allows one more continuation attempt.
+
+`COMPLETED` means harvest now; the run browser may already be closed. If the
+state is `INCOMPLETE_ANSWER` / `preamble_without_artifacts`, do not treat
+`ANSWER.md` as final. Try resume/harvest if recoverable; otherwise rerun with
+`--no-temporary`, a tighter bundle, and a more direct prompt.
+
+## Commands
+
+```bash
+ask-pro "Review the async billing webhook migration plan and return an implementation plan."
+ask-pro --no-temporary --prompt-file question.md --files src --files tests
+ask-pro --github "In owner/repo at <commit>, inspect src/auth and explain token validation."
+ask-pro --temporary "Review this sensitive migration plan, and fail if Temporary Chat cannot use Pro."
+ask-pro --no-temporary "Review this in normal ChatGPT instead of Temporary Chat."
+ask-pro --prompt-file question.md --files .\src
+ask-pro --artifacts --prompt-file implementation-plan.md --files src
+ask-pro --files "src/api/stripe/**" --files "prisma/**" --files "src/lib/billing/**" \
+  "Review whether this Stripe webhook flow should use a queue or transactional outbox."
+ask-pro --dry-run "Prepare the Pro handoff but do not open the browser."
+ask-pro --resume <session-id>
+ask-pro --harvest <session-id>
+```
+
+`--files` must be inside the target repo. Use repo-relative paths.
+
+## Safety
+
+Never ask for, read, store, type, or log passwords, MFA codes, recovery codes, session cookies, or raw auth tokens.
+
+Browser auth is human-controlled. Continue only after the human says the ChatGPT composer is visible.
+
+After submit, avoid interacting with any retained Chrome run window while Pro is
+thinking. ask-pro guards input after submit, but the safest agent behavior is to
+let the run finish or resume/harvest from CLI telemetry.

package/dist/bin/ask-pro-cli.js

@@ -10,7 +10,8 @@ import { Command, Option } from "commander";
 import { createAskProSession, getAskProSessionPaths, pruneExpiredAskProSessions, readAskProAnswer, readAskProStatus, updateAskProResumeCommand, updateAskProStatus, } from "../src/ask-pro/session.js";
 import { AskProNeedsAuthError, isSuspiciousPreambleAnswer, resumeAskProBrowserSession, runAskProBrowserSession, } from "../src/ask-pro/browserRunner.js";
 import { renderToonRecord } from "../src/ask-pro/toon.js";
-import { askProAgentIdForManagedBrowserProfileDir, defaultAskProBrowserProfileDir, } from "../src/browser/profilePaths.js";
+import { askProAgentIdForLegacyBrowserProfileDir, askProAgentIdForManagedBrowserProfileDir, defaultAskProBrowserProfileDir, isLegacyAskProManagedBrowserProfileDir, } from "../src/browser/profilePaths.js";
+import { migrateLegacyAskProProfiles } from "../src/browser/profileMigration.js";
 import { getCliVersion } from "../src/version.js";
 const program = new Command();
 program
@@ -60,6 +61,10 @@ async function runAskPro(question, options) {
     if (options.answers && question.trim())
         throw new Error("Use --answers with --resume, without a question argument.");
     await pruneExpiredAskProSessions({ cwd });
+    await migrateLegacyAskProProfiles({
+        log: (message) => console.error(message),
+        lockTimeoutMs: 5_000,
+    });
     if (options.status !== undefined) {
         const { status } = await readAskProStatus({ cwd, sessionId: optionSessionId(options.status) });
         printStatusRecord(status, {
@@ -522,9 +527,11 @@ async function readBrowserMetadata(cwd, sessionId) {
 function profileMode(profileDir) {
     if (!profileDir)
         return undefined;
-    if (askProAgentIdForManagedBrowserProfileDir(profileDir))
+    if (askProAgentIdForManagedBrowserProfileDir(profileDir) ||
+        askProAgentIdForLegacyBrowserProfileDir(profileDir))
         return "agent";
-    if (path.resolve(profileDir) === path.resolve(defaultAskProBrowserProfileDir()))
+    if (path.resolve(profileDir) === path.resolve(defaultAskProBrowserProfileDir()) ||
+        isLegacyAskProManagedBrowserProfileDir(profileDir))
         return "shared";
     return undefined;
 }

package/dist/src/ask-pro/browserRunner.js

@@ -5,7 +5,8 @@ import { AssistantStoppedError, BrowserAutomationError } from "../browser/errors
 import { AssistantQuestionsError } from "../browser/actions/questions.js";
 import { readAskProQuestions, parseQuestionAnswers, writeAskProQuestions } from "./questions.js";
 import { GitHubConnectionRequiredError } from "../browser/actions/github.js";
-import { askProAgentIdForLegacyBrowserProfileDir, askProAgentIdForManagedBrowserProfileDir, askProBrowserProfileDirForAgentId, ensureAskProBrowserProfileDir, isLegacyAskProManagedBrowserProfileDir, isAskProManagedBrowserProfileDir, resolveAskProAgentId, } from "../browser/profilePaths.js";
+import { askProAgentIdForLegacyBrowserProfileDir, askProAgentIdForManagedBrowserProfileDir, askProBrowserProfileDirForAgentId, isAskProManagedBrowserProfileDir, isLegacyAskProManagedBrowserProfileDir, resolveAskProAgentId, } from "../browser/profilePaths.js";
+import { prepareAskProBrowserProfile } from "../browser/profileMigration.js";
 import { runBrowserMode } from "../browserMode.js";
 import { closeTab } from "../browser/chromeLifecycle.js";
 import { resumeBrowserSession } from "../browser/reattach.js";
@@ -28,7 +29,7 @@ async function runAskProBrowserSessionWithLease({ cwd, sessionId, temporary: req
     const temporary = requestedTemporary ?? (sessionStatus.github ? false : undefined);
     const artifactsRequested = sessionStatus.artifacts === true;
     const agentId = agentIdOverride !== undefined ? agentIdOverride : resolveAskProAgentId();
-    const browserProfile = browserProfileDir ?? (await ensureAskProBrowserProfileDir(agentId));
+    const browserProfile = browserProfileDir ?? (await prepareAskProBrowserProfile(agentId));
     const metadata = await readBrowserMetadata(paths.browser).catch(() => null);
     const chatgptUrl = chatgptUrlOverride ??
         (temporary === true
@@ -721,36 +722,34 @@ async function resolveResumeBrowserProfile(metadata) {
     const profileDir = metadata.profileDir;
     const profileAgentId = profileDir ? askProAgentIdForManagedBrowserProfileDir(profileDir) : null;
     const legacyAgentId = profileDir ? askProAgentIdForLegacyBrowserProfileDir(profileDir) : null;
-    if (profileAgentId && profileAgentId !== metadata.agentId) {
-        throw new Error("Stored ask-pro agent profile does not match stored agent id.");
-    }
-    if (legacyAgentId && legacyAgentId !== metadata.agentId) {
+    if ((profileAgentId ?? legacyAgentId) && (profileAgentId ?? legacyAgentId) !== metadata.agentId) {
         throw new Error("Stored ask-pro agent profile does not match stored agent id.");
     }
     if (profileAgentId && agentProfile) {
         return profileDir;
     }
+    // Sessions from earlier versions record the old profile location; resume where it is now.
     if (legacyAgentId && agentProfile) {
-        return ensureAskProBrowserProfileDir(metadata.agentId);
+        return prepareAskProBrowserProfile(metadata.agentId);
     }
     if (profileDir &&
         !profileAgentId &&
         !legacyAgentId &&
         !agentProfile &&
         isAskProManagedBrowserProfileDir(profileDir)) {
-        return ensureAskProBrowserProfileDir(null);
+        return askProBrowserProfileDirForAgentId(null);
     }
     if (profileDir &&
         !profileAgentId &&
         !legacyAgentId &&
         !agentProfile &&
         isLegacyAskProManagedBrowserProfileDir(profileDir)) {
-        return ensureAskProBrowserProfileDir(null);
+        return prepareAskProBrowserProfile(null);
     }
     if (profileDir) {
         throw new Error("Stored ask-pro profile path is invalid.");
     }
-    return ensureAskProBrowserProfileDir(metadata.agentId);
+    return prepareAskProBrowserProfile(metadata.agentId);
 }
 function resolveStoredAgentProfile(agentId) {
     if (!agentId)

package/dist/src/browser/chromeLifecycle.js

@@ -8,7 +8,7 @@ import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import CDP from "chrome-remote-interface";
 import { Launcher } from "chrome-launcher";
-import { clearChromeLaunchStarting, cleanupStaleProfileState, hasChromeLaunchStarting, markChromeLaunchStarting, readChromePid, readDevToolsPort, verifyDevToolsReachable, } from "./profileState.js";
+import { clearChromeLaunchStarting, clearIdleBrowserProfileCaches, cleanupStaleProfileState, hasChromeLaunchStarting, markChromeLaunchStarting, readChromePid, readDevToolsPort, verifyDevToolsReachable, } from "./profileState.js";
 import { delay } from "./utils.js";
 import { formatElapsed } from "./format.js";
 import { withTimeout } from "./reattachHelpers.js";
@@ -20,13 +20,14 @@ const CPU_THROTTLING_OVERRIDE_FLAGS = new Set([
     "--disable-ipc-flooding-protection",
 ]);
 const CHROME_STARTUP_HANDOFF_MS = 26_000;
-export async function launchChrome(config, userDataDir, logger) {
+export async function launchChrome(config, userDataDir, logger, options = {}) {
     const connectHost = resolveRemoteDebugHost();
     const debugBindAddress = connectHost && connectHost !== "127.0.0.1" ? "0.0.0.0" : connectHost;
     const debugPort = config.debugPort ?? parseDebugPortEnv();
     const chromeFlags = buildChromeLaunchFlags(buildChromeFlags(config.headless ?? false, debugBindAddress, config.acceptLanguage, {
         startMinimized: shouldLaunchChromeMinimized(config),
     }));
+    await clearIdleBrowserProfileCaches(userDataDir, options);
     await markChromeLaunchStarting(userDataDir);
     try {
         const launcher = await launchManagedChrome({
@@ -581,6 +582,7 @@ export function buildChromeFlags(headless, debugBindAddress, acceptLanguage = "e
     const primaryLanguage = acceptLanguage.split(",", 1)[0]?.trim() || "en-US";
     const flags = [
         "--disable-background-networking",
+        "--disk-cache-size=16777216",
         "--disable-breakpad",
         "--disable-client-side-phishing-detection",
         "--disable-default-apps",

package/dist/src/browser/index.js

@@ -394,7 +394,7 @@ export async function runBrowserMode(options) {
                 (await launchChrome({
                     ...config,
                     remoteChrome: config.remoteChrome,
-                }, userDataDir, logger));
+                }, userDataDir, logger, { ignoreLockId: profileLock?.lockId }));
         // Persist profile state so future manual-login runs can reuse this Chrome.
         if (manualLogin && chrome.port) {
             await writeDevToolsActivePort(userDataDir, chrome.port);