@steipete/oracle 0.15.0 → 0.15.2

package/dist/bin/oracle-cli.js

@@ -15,7 +15,7 @@ import { resolveDashPrompt } from "../src/cli/stdin.js";
 import chalk from "chalk";
 import { sessionStore, pruneOldSessions } from "../src/sessionStore.js";
 import { DEFAULT_MODEL, MODEL_CONFIGS } from "../src/oracle/config.js";
-import { isKnownModel } from "../src/oracle/modelResolver.js";
+import { isKnownModel, resolveOverriddenApiModel } from "../src/oracle/modelResolver.js";
 import { CHATGPT_URL } from "../src/browser/constants.js";
 import { applyHelpStyling } from "../src/cli/help.js";
 import { collectPaths, collectModelList, collectTextValues, parseFloatOption, parseIntOption, parseSearchOption, parseThinkingTimeOption, usesDefaultStatusFilters, resolvePreviewMode, normalizeModelOption, normalizeBaseUrl, resolveApiModel, inferModelFromLabel, parseHeartbeatOption, parseTimeoutOption, parseDurationOption, mergePathLikeOptions, dedupePathInputs, } from "../src/cli/options.js";
@@ -662,6 +662,7 @@ function buildRunOptions(options, overrides = {}) {
         previousResponseId: overrides.previousResponseId ?? options.previousResponseId,
         browserResumeConversationUrl: overrides.browserResumeConversationUrl ?? options.browserResumeConversationUrl,
         effectiveModelId: overrides.effectiveModelId ?? options.effectiveModelId ?? options.model,
+        modelOverrides: overrides.modelOverrides ?? options.modelOverrides,
         file: overrides.file ?? options.file ?? [],
         maxFileSizeBytes: overrides.maxFileSizeBytes ?? options.maxFileSizeBytes,
         slug: overrides.slug ?? options.slug,
@@ -900,6 +901,7 @@ function buildRunOptionsFromMetadata(metadata) {
         previousResponseId: stored.previousResponseId,
         browserResumeConversationUrl: stored.browserResumeConversationUrl,
         effectiveModelId: stored.effectiveModelId ?? stored.model,
+        modelOverrides: stored.modelOverrides,
         file: stored.file ?? [],
         maxFileSizeBytes: stored.maxFileSizeBytes,
         slug: stored.slug,
@@ -1172,11 +1174,16 @@ async function runRootCommand(options) {
         throw new Error("--remote-host does not support --models yet. Use API engine locally instead.");
     }
     const resolvedModel = normalizedMultiModels[0] ?? (isGemini ? resolveApiModel(cliModelArg) : resolvedModelCandidate);
-    const effectiveModelId = resolvedModel.startsWith("gemini")
-        ? resolveGeminiModelId(resolvedModel)
-        : isKnownModel(resolvedModel)
-            ? (MODEL_CONFIGS[resolvedModel].apiModel ?? resolvedModel)
-            : resolvedModel;
+    // A user-config apiModel override (known models only) wins over Gemini alias
+    // remapping and the bundled apiModel, so it becomes the on-wire request id.
+    const apiModelOverrides = engine === "api" ? userConfig.modelOverrides : undefined;
+    const overriddenApiModel = resolveOverriddenApiModel(resolvedModel, apiModelOverrides);
+    const effectiveModelId = overriddenApiModel ??
+        (resolvedModel.startsWith("gemini")
+            ? resolveGeminiModelId(resolvedModel)
+            : isKnownModel(resolvedModel)
+                ? (MODEL_CONFIGS[resolvedModel].apiModel ?? resolvedModel)
+                : resolvedModel);
     const resolvedBaseUrl = normalizeBaseUrl(options.baseUrl ?? (isClaude ? process.env.ANTHROPIC_BASE_URL : process.env.OPENAI_BASE_URL));
     const { models: _rawModels, ...optionsWithoutModels } = options;
     const resolvedOptions = { ...optionsWithoutModels, model: resolvedModel };
@@ -1187,6 +1194,7 @@ async function runRootCommand(options) {
     }
     resolvedOptions.baseUrl = resolvedBaseUrl;
     resolvedOptions.effectiveModelId = effectiveModelId;
+    resolvedOptions.modelOverrides = apiModelOverrides;
     resolvedOptions.provider = providerMode;
     resolvedOptions.writeOutputPath = resolveOutputPath(options.writeOutput, process.cwd());
     if (options.status) {

package/dist/docs-site/bridge.html

@@ -251,6 +251,22 @@ body:not(.home) .doc>h1:first-child{display:none}
 <li><strong>Host (Windows)</strong>: runs <code>oracle bridge host</code> and holds the signed-in ChatGPT session.</li>
 <li><strong>Client (Linux)</strong>: stores the host connection once and routes browser runs (and MCP browser runs) through the host.</li>
 </ul>
+<h2 id="generated-artifact-transfer"><a class="anchor" href="#generated-artifact-transfer" aria-label="Anchor link">#</a>Generated artifact transfer</h2>
+<p>Bridge runs now keep the Windows browser host and Linux client separated while still returning ChatGPT-generated files, such as ZIP, CSV, PDF, wheels, and source distributions, to a cloud-readable path. The host advertises artifact-transfer support from the token-protected <code>GET /health</code> response. The Linux client uses that capability signal in <code>oracle bridge client --test</code> and <code>oracle bridge doctor</code>; older hosts remain usable for text responses, but generated files require manual copy from the Windows browser until both sides are upgraded.</p>
+<p>The transfer protocol is pull-based and keeps secrets local to the host:</p>
+<ol>
+<li>The browser host saves the ChatGPT file to its local session artifacts directory as before.</li>
+<li>The host emits only a redacted artifact descriptor over the existing NDJSON run stream: artifact id, safe filename, MIME type, byte size, SHA-256, validation status, and coarse source kind. It does not expose cookies, bearer tokens, signed ChatGPT download URLs, or Windows filesystem paths.</li>
+<li>The Linux client fetches <code>GET /runs/&lt;runId&gt;/artifacts/&lt;artifactId&gt;</code> with the same bridge bearer token, writes to <code>~/.oracle/sessions/&lt;sessionId&gt;/artifacts/</code>, verifies size and SHA-256, validates ZIP structure when applicable, and only then publishes the final path in session metadata.</li>
+<li>If transfer fails, Oracle keeps the text response and records a warning with manual fallback instructions. Open the ChatGPT browser on the Windows host, use the visible download button/link in the current assistant response, and copy the file to a cloud-readable path yourself.</li>
+</ol>
+<p>Operational notes:</p>
+<ul>
+<li>Run the same patched Oracle version on both Windows host and Linux client before relying on automatic file transfer. Mixed versions remain backward compatible for text-only runs.</li>
+<li><code>oracle bridge doctor</code> reports <code>Artifact transfer: bridge v1</code> when the host supports the protocol, including the advertised maximum artifact size.</li>
+<li>The default bridge transfer size limit is 512 MiB. Larger files stay on the browser host and require manual copy.</li>
+<li>Session inspection prints artifact path, size, SHA-256 prefix, validation status, and transfer status so agents can verify whether the returned path is local to the Linux client.</li>
+</ul>
 <h2 id="1-windows-start-the-host-service-recommended"><a class="anchor" href="#1-windows-start-the-host-service-recommended" aria-label="Anchor link">#</a>1) Windows: start the host service (recommended)</h2>
 <p>Run this on the Windows machine that’s signed into ChatGPT:</p>
 <pre class="shiki github-dark-dimmed" style="background-color:var(--code-bg);color:var(--code-fg)" tabindex="0"><code class="language-powershell"><span class="line"><span style="color:#ADBAC7">oracle bridge host </span><span style="color:#F47067">--</span><span style="color:#ADBAC7">token auto </span><span style="color:#F47067">--</span><span style="color:#ADBAC7">ssh user@your</span><span style="color:#F47067">-</span><span style="color:#ADBAC7">linux</span><span style="color:#F47067">-</span><span style="color:#ADBAC7">host</span></span></code></pre>
@@ -334,7 +350,7 @@ body:not(.home) .doc>h1:first-child{display:none}
 <li>The connection artifact and config file contain secrets; keep them private (Oracle writes them with restrictive permissions on Unix).</li>
 <li>Bridge does <strong>not</strong> extract/decrypt cookies from arbitrary profiles; the Windows machine keeps the authenticated session locally.</li>
 </ul><nav class="page-nav" aria-label="Pager"><a class="page-nav-prev" href="windows-work.html"><small>Previous</small><span>Windows Work</span></a><a class="page-nav-next" href="agents.html"><small>Next</small><span>Coding Agents</span></a></nav></article>
-        <nav class="toc" aria-label="On this page"><h2>On this page</h2><a class="toc-l2" href="#concepts">Concepts</a><a class="toc-l2" href="#1-windows-start-the-host-service-recommended">1) Windows: start the host service (recommended)</a><a class="toc-l2" href="#2-linux-configure-the-client-once">2) Linux: configure the client once</a><a class="toc-l2" href="#2b-linux-desktop-local-manual-login-no-bridge">2b) Linux desktop: local manual-login (no bridge)</a><a class="toc-l2" href="#3-codex-cli-mcp-integration">3) Codex CLI (MCP) integration</a><a class="toc-l2" href="#3b-claude-code-mcp-integration">3b) Claude Code (MCP) integration</a><a class="toc-l3" href="#macos-local-browser-let-them-fight">macOS local browser: Let Them Fight</a><a class="toc-l2" href="#4-troubleshooting">4) Troubleshooting</a><a class="toc-l2" href="#security-notes">Security notes</a></nav>
+        <nav class="toc" aria-label="On this page"><h2>On this page</h2><a class="toc-l2" href="#concepts">Concepts</a><a class="toc-l2" href="#generated-artifact-transfer">Generated artifact transfer</a><a class="toc-l2" href="#1-windows-start-the-host-service-recommended">1) Windows: start the host service (recommended)</a><a class="toc-l2" href="#2-linux-configure-the-client-once">2) Linux: configure the client once</a><a class="toc-l2" href="#2b-linux-desktop-local-manual-login-no-bridge">2b) Linux desktop: local manual-login (no bridge)</a><a class="toc-l2" href="#3-codex-cli-mcp-integration">3) Codex CLI (MCP) integration</a><a class="toc-l2" href="#3b-claude-code-mcp-integration">3b) Claude Code (MCP) integration</a><a class="toc-l3" href="#macos-local-browser-let-them-fight">macOS local browser: Let Them Fight</a><a class="toc-l2" href="#4-troubleshooting">4) Troubleshooting</a><a class="toc-l2" href="#security-notes">Security notes</a></nav>
       </div>
     </main>
   </div>

package/dist/docs-site/browser-mode.html

@@ -362,11 +362,11 @@ body:not(.home) .doc>h1:first-child{display:none}
 <span class="line"><span style="color:#6CB6FF">  --browser-manual-login</span><span style="color:#F47067"> \</span></span>
 <span class="line"><span style="color:#6CB6FF">  --browser-research</span><span style="color:#96D0FF"> deep</span><span style="color:#F47067"> \</span></span>
 <span class="line"><span style="color:#6CB6FF">  -p</span><span style="color:#96D0FF"> "Research the current browser support for WebGPU in enterprise-managed Chrome and cite sources."</span></span></code></pre>
-<p>Oracle activates ChatGPT Deep Research through the composer <code>/Deepresearch</code> command and falls back to the composer tools menu when the slash flow is not available. It waits for the research plan to auto-confirm, logs high-level progress, then captures the final report from the Deep Research report surface instead of trusting the assistant tool-call wrapper.</p>
+<p>Oracle activates ChatGPT Deep Research through the composer tools menu, recognizing both the <code>Deep research</code> label and current <code>Get a detailed report</code> menu variants. It waits for the research plan to auto-confirm, logs high-level progress, then captures the final report from the Deep Research report surface instead of trusting the assistant tool-call wrapper.</p>
 <p>If ChatGPT initially exposes only <code>Called tool</code> / <code>Used tool</code>, Oracle treats that as an incomplete capture for Deep Research rather than a final answer. Reattach the existing session with <code>oracle session &lt;id&gt; --render</code> so Oracle can recover the lazy-loaded report from the existing Chrome tab; do not rerun the research unless the browser session is unrecoverable.</p>
 <p>Deep Research is browser-only. It does not use connected apps in v1; give it public-web scope, uploaded files, and any domain/source guidance in the prompt. For deep thinking over code or architecture without web search, prefer a normal browser run with a Pro/Thinking model and <code>--browser-thinking-time heavy</code>.</p>
 <p>Completed browser sessions also save durable artifacts under <code>~/.oracle/sessions/&lt;id&gt;/artifacts/</code>. Deep Research writes the extracted report to <code>deep-research-report.md</code>, and every browser run writes <code>transcript.md</code> with the prompt, final answer, conversation URL, and saved artifact references. Use <code>--write-output &lt;path&gt;</code> when you also need a copy of just the final answer at a specific path.</p>
-<p>When ChatGPT generates downloadable files in the assistant response (for example a ZIP, wheel, source distribution, CSV, or PDF), Oracle saves those files beside the transcript before any archive attempt. The downloader is intentionally narrow: it only follows ChatGPT-owned file/download URLs from the assistant response and uses <code>sandbox:/mnt/data/...</code> links as source metadata and filename hints, not as arbitrary fetch targets. External links in the response are left in the transcript but are not downloaded.</p>
+<p>When ChatGPT generates downloadable files in the assistant response (for example a ZIP, wheel, source distribution, CSV, or PDF), Oracle saves those files beside the transcript before any archive attempt. The downloader is intentionally narrow: it only follows ChatGPT-owned file/download URLs from the assistant response and uses <code>sandbox:/mnt/data/...</code> links as source metadata and filename hints, not as arbitrary fetch targets. External links in the response are left in the transcript but are not downloaded. In bridge mode, a patched Windows host advertises artifact-transfer capability through <code>/health</code>; the Linux client then pulls each saved file over the authenticated bridge endpoint, stores it under the Linux session <code>artifacts/</code> directory, and verifies safe filename, byte size, SHA-256, and ZIP structure where applicable. If either side is older or transfer validation fails, the text response still completes and Oracle prints a manual-copy fallback instead of leaking host paths or signed download URLs.</p>
 <h3 id="conversation-archiving"><a class="anchor" href="#conversation-archiving" aria-label="Anchor link">#</a>Conversation archiving</h3>
 <p>Browser mode keeps the local session as the source of truth, so Oracle can optionally archive the ChatGPT conversation after a successful run. The default <code>--browser-archive auto</code> archives only successful non-project, non-Deep-Research, non-multi-turn one-shot chats after <code>transcript.md</code>, generated artifacts, the final answer, and the conversation URL are saved locally.</p>
 <p>Oracle does not auto-archive failed, incomplete, running, project, Deep Research, or multi-turn sessions. Use <code>--browser-archive never</code> to disable archiving, or <code>--browser-archive always</code> when you explicitly want a successful browser conversation archived even outside the default one-shot policy. Archived chats are still visible and manageable from ChatGPT&#39;s own archive UI.</p>

package/dist/docs-site/configuration.html

@@ -307,6 +307,15 @@ body:not(.home) .doc>h1:first-child{display:none}
 <span class="line"><span style="color:#96D0FF">  sessionRetentionHours</span><span style="color:#ADBAC7">: </span><span style="color:#6CB6FF">72</span><span style="color:#ADBAC7">, </span><span style="color:#768390">// prune cached sessions older than 72h before each run (0 disables)</span></span>
 <span class="line"><span style="color:#96D0FF">  promptSuffix</span><span style="color:#ADBAC7">: </span><span style="color:#96D0FF">"// signed-off by me"</span><span style="color:#ADBAC7">, </span><span style="color:#768390">// appended to every prompt</span></span>
 <span class="line"><span style="color:#96D0FF">  apiBaseUrl</span><span style="color:#ADBAC7">: </span><span style="color:#96D0FF">"https://api.openai.com/v1"</span><span style="color:#ADBAC7">, </span><span style="color:#768390">// override for LiteLLM / custom gateways</span></span>
+<span class="line"><span style="color:#768390">  // API-only, user-config-only overrides for known model keys.</span></span>
+<span class="line"><span style="color:#96D0FF">  modelOverrides</span><span style="color:#ADBAC7">: {</span></span>
+<span class="line"><span style="color:#96D0FF">    "gpt-5.5"</span><span style="color:#ADBAC7">: {</span></span>
+<span class="line"><span style="color:#96D0FF">      apiModel</span><span style="color:#ADBAC7">: </span><span style="color:#96D0FF">"gateway-model"</span><span style="color:#ADBAC7">, </span><span style="color:#768390">// on-wire id exposed by the gateway</span></span>
+<span class="line"><span style="color:#96D0FF">      reasoning</span><span style="color:#ADBAC7">: { </span><span style="color:#96D0FF">effort</span><span style="color:#ADBAC7">: </span><span style="color:#96D0FF">"xhigh"</span><span style="color:#ADBAC7"> }, </span><span style="color:#768390">// or null to clear the bundled effort</span></span>
+<span class="line"><span style="color:#96D0FF">      inputLimit</span><span style="color:#ADBAC7">: </span><span style="color:#6CB6FF">1050000</span><span style="color:#ADBAC7">,</span></span>
+<span class="line"><span style="color:#96D0FF">      pricing</span><span style="color:#ADBAC7">: { </span><span style="color:#96D0FF">inputPerToken</span><span style="color:#ADBAC7">: </span><span style="color:#6CB6FF">0.000005</span><span style="color:#ADBAC7">, </span><span style="color:#96D0FF">outputPerToken</span><span style="color:#ADBAC7">: </span><span style="color:#6CB6FF">0.00003</span><span style="color:#ADBAC7"> },</span></span>
+<span class="line"><span style="color:#ADBAC7">    },</span></span>
+<span class="line"><span style="color:#ADBAC7">  },</span></span>
 <span class="line"><span style="color:#ADBAC7">}</span></span></code></pre>
 <h2 id="project-configs"><a class="anchor" href="#project-configs" aria-label="Anchor link">#</a>Project configs</h2>
 <p>Put a project-level config at <code>.oracle/config.json</code> inside any project folder:</p>
@@ -320,17 +329,18 @@ body:not(.home) .doc>h1:first-child{display:none}
 <span class="line"><span style="color:#ADBAC7">  },</span></span>
 <span class="line"><span style="color:#ADBAC7">}</span></span></code></pre>
 <p>Oracle discovers every <code>.oracle/config.json</code> from the current directory upward until your home directory, then applies them from parent to child after the user config. Nested objects are merged, while scalars and arrays replace earlier values. This lets a parent folder set broad defaults and override a specific ChatGPT Project URL in a package subdirectory.</p>
-<p>Project configs intentionally support only workflow defaults. They cannot set provider routing or secret/executable fields such as <code>apiBaseUrl</code>, <code>azure</code>, <code>browser.remoteHost</code>, <code>browser.remoteToken</code>, <code>browser.chromePath</code>, or <code>browser.chromeCookiePath</code>. Keep tokens and machine-local executable/profile paths in <code>~/.oracle/config.json</code>, environment variables, or explicit CLI flags.</p>
+<p>Project configs intentionally support only workflow defaults. They cannot set provider routing or secret/executable fields such as <code>apiBaseUrl</code>, <code>modelOverrides</code>, <code>azure</code>, <code>browser.remoteHost</code>, <code>browser.remoteToken</code>, <code>browser.chromePath</code>, or <code>browser.chromeCookiePath</code>. Keep tokens and machine-local executable/profile paths in <code>~/.oracle/config.json</code>, environment variables, or explicit CLI flags.</p>
 <h2 id="precedence"><a class="anchor" href="#precedence" aria-label="Anchor link">#</a>Precedence</h2>
 <p>CLI flags and explicit override environment variables → effective config (project <code>.oracle/config.json</code> files over <code>~/.oracle/config.json</code>) → auto-detected environment → built-in defaults.</p>
 <ul>
 <li>The effective config starts with <code>~/.oracle/config.json</code>, then layers project <code>.oracle/config.json</code> files from parent to child. <code>engine</code>, <code>model</code>, <code>search</code>, <code>filesReport</code>, <code>heartbeatSeconds</code>, <code>maxFileSizeBytes</code>, and <code>apiBaseUrl</code> in the effective config override auto-detected values unless explicitly set on the CLI or through a supported override environment variable.</li>
 <li>Project <code>.oracle/config.json</code> files can override safe workflow defaults such as <code>engine</code>, <code>model</code>, <code>search</code>, <code>filesReport</code>, <code>heartbeatSeconds</code>, <code>maxFileSizeBytes</code>, <code>promptSuffix</code>, and allowed <code>browser.*</code> workflow settings.</li>
-<li>Provider routing and machine-local fields (<code>apiBaseUrl</code>, <code>azure</code>, remote browser host/token defaults, Chrome binary/profile paths, cookie DB paths, and session retention cleanup) are ignored in project configs and are read only from the user config, environment variables, or explicit CLI flags.</li>
+<li>Provider routing and machine-local fields (<code>apiBaseUrl</code>, <code>modelOverrides</code>, <code>azure</code>, remote browser host/token defaults, Chrome binary/profile paths, cookie DB paths, and session retention cleanup) are ignored in project configs and are read only from the user config, environment variables, or explicit CLI flags.</li>
 <li><code>ORACLE_ENGINE=api|browser</code> is a global override for engine selection (useful for MCP/Codex setups); it wins over <code>config.json</code>.</li>
 <li>If <code>azure.endpoint</code> (or <code>--azure-endpoint</code>) is set, Oracle reads <code>AZURE_OPENAI_API_KEY</code> first and falls back to <code>OPENAI_API_KEY</code> for GPT models.</li>
 <li>Remote browser defaults follow the same order: <code>--remote-host/--remote-token</code> win, then <code>browser.remoteHost</code> / <code>browser.remoteToken</code> in the config, then <code>ORACLE_REMOTE_HOST</code> / <code>ORACLE_REMOTE_TOKEN</code> if still unset.</li>
 <li><code>OPENAI_API_KEY</code> only influences engine selection when neither the CLI nor <code>config.json</code> specify an engine (API when present, otherwise browser).</li>
+<li><code>modelOverrides</code> applies only to API runs and existing built-in model keys. It can replace the on-wire <code>apiModel</code>, reasoning effort, input limit, and per-token pricing; unspecified fields and the bundled tokenizer remain unchanged. Invalid override values are ignored. Project configs cannot set this field.</li>
 <li><code>ORACLE_NOTIFY*</code> env vars still layer on top of the config’s <code>notify</code> block.</li>
 <li><code>sessionRetentionHours</code> controls the default value for <code>--retain-hours</code>. When unset, <code>ORACLE_RETAIN_HOURS</code> (if present) becomes the fallback, and the CLI flag still wins over both.</li>
 <li><code>ORACLE_MAX_FILE_SIZE_BYTES</code> overrides <code>maxFileSizeBytes</code> when set. Oracle validates it as a positive integer number of bytes before reading any <code>--file</code> inputs.</li>

package/dist/docs-site/openai-endpoints.html

@@ -292,6 +292,18 @@ body:not(.home) .doc>h1:first-child{display:none}
 <pre class="shiki github-dark-dimmed" style="background-color:var(--code-bg);color:var(--code-fg)" tabindex="0"><code class="language-json"><span class="line"><span style="color:#ADBAC7">{</span></span>
 <span class="line"><span style="color:#8DDB8C">  "apiBaseUrl"</span><span style="color:#ADBAC7">: </span><span style="color:#96D0FF">"http://localhost:4000"</span></span>
 <span class="line"><span style="color:#ADBAC7">}</span></span></code></pre>
+<p>If a gateway exposes a different on-wire model id, add an API-only override to the user config at <code>~/.oracle/config.json</code>:</p>
+<pre class="shiki github-dark-dimmed" style="background-color:var(--code-bg);color:var(--code-fg)" tabindex="0"><code class="language-json5"><span class="line"><span style="color:#ADBAC7">{</span></span>
+<span class="line"><span style="color:#96D0FF">  apiBaseUrl</span><span style="color:#ADBAC7">: </span><span style="color:#96D0FF">"http://localhost:4000"</span><span style="color:#ADBAC7">,</span></span>
+<span class="line"><span style="color:#96D0FF">  model</span><span style="color:#ADBAC7">: </span><span style="color:#96D0FF">"gpt-5.5"</span><span style="color:#ADBAC7">,</span></span>
+<span class="line"><span style="color:#96D0FF">  modelOverrides</span><span style="color:#ADBAC7">: {</span></span>
+<span class="line"><span style="color:#96D0FF">    "gpt-5.5"</span><span style="color:#ADBAC7">: {</span></span>
+<span class="line"><span style="color:#96D0FF">      apiModel</span><span style="color:#ADBAC7">: </span><span style="color:#96D0FF">"gateway-model"</span><span style="color:#ADBAC7">,</span></span>
+<span class="line"><span style="color:#96D0FF">      reasoning</span><span style="color:#ADBAC7">: { </span><span style="color:#96D0FF">effort</span><span style="color:#ADBAC7">: </span><span style="color:#96D0FF">"high"</span><span style="color:#ADBAC7"> },</span></span>
+<span class="line"><span style="color:#ADBAC7">    },</span></span>
+<span class="line"><span style="color:#ADBAC7">  },</span></span>
+<span class="line"><span style="color:#ADBAC7">}</span></span></code></pre>
+<p>Overrides accept existing built-in model keys only and are ignored in project <code>.oracle/config.json</code> files. See <a href="configuration.html">Local configuration</a> for the full field list and precedence.</p>
 <h2 id="model-aliases"><a class="anchor" href="#model-aliases" aria-label="Anchor link">#</a>Model aliases</h2>
 <p>Oracle keeps a stable CLI-facing model set, but some names are aliases for the concrete API model ids it sends:</p>
 <ul>

package/dist/scripts/test-browser.js

@@ -58,9 +58,9 @@ function firewallHint(host, devtoolsPort) {
         "Re-run ./runner pnpm test:browser after adding the rule.",
     ].join("\n");
 }
-async function fetchVersion(host, devtoolsPort) {
+async function fetchVersion(host, devtoolsPort, timeoutMs = 5000) {
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 5000);
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
     try {
         const res = await fetch(`http://${host}:${devtoolsPort}/json/version`, {
             signal: controller.signal,
@@ -77,6 +77,16 @@ async function fetchVersion(host, devtoolsPort) {
         clearTimeout(timer);
     }
 }
+async function waitForDevToolsShutdown(host, devtoolsPort) {
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline) {
+        if (!(await fetchVersion(host, devtoolsPort, 250))) {
+            return;
+        }
+        await sleep(100);
+    }
+    throw new Error(`DevTools did not stop listening at ${host}:${devtoolsPort}`);
+}
 async function main() {
     console.log(`[browser-test] launching Chrome on ${targetHost}:${port} (headful)…`);
     const chrome = await launch({
@@ -89,6 +99,7 @@ async function main() {
         ok = await fetchVersion(targetHost, chrome.port);
     }
     await chrome.kill();
+    await waitForDevToolsShutdown(targetHost, chrome.port);
     if (ok) {
         console.log(`[browser-test] PASS: DevTools responding on ${targetHost}:${chrome.port}`);
         process.exit(0);

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

@@ -1,8 +1,20 @@
-import { ANSWER_SELECTORS, ASSISTANT_ROLE_SELECTOR, CONVERSATION_TURN_SELECTOR, COPY_BUTTON_SELECTOR, FINISHED_ACTIONS_SELECTOR, STOP_BUTTON_SELECTOR, } from "../constants.js";
+import { ANSWER_SELECTORS, ASSISTANT_ROLE_SELECTOR, CONVERSATION_TURN_SELECTOR, COPY_BUTTON_SELECTOR, FINISHED_ACTIONS_SELECTOR, STOP_BUTTON_SELECTORS, } from "../constants.js";
+import { buildConversationTurnListExpression } from "../conversationTurns.js";
 import { delay } from "../utils.js";
 import { logDomFailure, logConversationSnapshot, buildConversationDebugExpression, } from "../domDebug.js";
 import { buildClickDispatcher } from "./domEvents.js";
 const ASSISTANT_POLL_TIMEOUT_ERROR = "assistant-response-watchdog-timeout";
+const STOP_CONTROL_SELECTOR = STOP_BUTTON_SELECTORS.join(", ");
+const MIN_CONFIDENT_ANSWER_LENGTH = 16;
+function isImplausiblyShortAnswer(candidateLength) {
+    return candidateLength > 0 && candidateLength < MIN_CONFIDENT_ANSWER_LENGTH;
+}
+export function shouldConfirmAssistantCompletion(args) {
+    if (args.stopVisible || args.completionVisible) {
+        return true;
+    }
+    return isImplausiblyShortAnswer(args.candidateLength);
+}
 const THINKING_STATUS_LABELS = [
     "thinking",
     "pro thinking",
@@ -44,8 +56,8 @@ function isAnswerNowPlaceholderText(normalized) {
 }
 function buildActiveThinkingStatusPredicateJs(fnName) {
     const labelsLiteral = JSON.stringify(THINKING_STATUS_LABELS);
-    const stopSelectorLiteral = JSON.stringify(STOP_BUTTON_SELECTOR);
-    return `const ${fnName} = (snapshot) => {
+    return `${buildStopButtonVisibilityPredicateJs("isStopControlVisible")}
+  const ${fnName} = (snapshot) => {
     const normalized = String(snapshot?.text ?? '').toLowerCase().replace(/\\s+/g, ' ').trim();
     if (!normalized) return false;
     const labels = ${labelsLiteral};
@@ -53,7 +65,7 @@ function buildActiveThinkingStatusPredicateJs(fnName) {
       labels.includes(normalized) ||
       (normalized.startsWith('thought for ') && normalized.length <= 40) ||
       (normalized.startsWith('pro thinking') && normalized.length <= 40);
-    return matches && Boolean(document.querySelector(${stopSelectorLiteral}));
+    return matches && isStopControlVisible();
   };`;
 }
 export function matchesThinkingStatusLabelForTest(text) {
@@ -108,7 +120,9 @@ export async function waitForAssistantResponse(Runtime, timeoutMs, logger, minTu
             if (source === "poll" &&
                 error instanceof Error &&
                 error.message === ASSISTANT_POLL_TIMEOUT_ERROR) {
-                evaluation = await evaluationPromise;
+                evaluationPromise.catch(() => undefined);
+                await terminateRuntimeExecution(Runtime);
+                throw error;
             }
             else if (source === "poll") {
                 throw error;
@@ -161,21 +175,34 @@ export async function waitForAssistantResponse(Runtime, timeoutMs, logger, minTu
     // The evaluation path can race ahead of completion. If ChatGPT is still streaming, wait for the watchdog poller.
     const elapsedMs = Date.now() - start;
     const remainingMs = Math.max(0, timeoutMs - elapsedMs);
+    const candidateText = String(candidate?.text ?? "").trim();
+    const suspiciouslyShort = isImplausiblyShortAnswer(candidateText.length);
     if (remainingMs > 0) {
         const [stopVisible, completionVisible] = await Promise.all([
             isStopButtonVisible(Runtime),
             isCompletionVisible(Runtime),
         ]);
-        if (stopVisible) {
-            logger("Assistant still generating; waiting for completion");
+        // Completion controls can appear briefly while Pro is still replacing its thinking UI.
+        // Confirm every capture from that transition with the stability-based watchdog; a
+        // partial first paragraph can be arbitrarily long.
+        if (shouldConfirmAssistantCompletion({
+            candidateLength: candidateText.length,
+            stopVisible,
+            completionVisible,
+        })) {
+            logger(stopVisible
+                ? "Assistant still generating; waiting for completion"
+                : completionVisible
+                    ? "Completion controls surfaced; confirming stable assistant response"
+                    : "Captured an implausibly short response; confirming it is not a mid-stream capture");
             const completed = await pollAssistantCompletion(Runtime, remainingMs, minTurnIndex, expectedConversationId);
-            if (completed) {
+            if (completed && String(completed.text ?? "").trim().length >= candidateText.length) {
                 return completed;
             }
         }
-        else if (completionVisible) {
-            // No-op: completion UI surfaced and stop button is gone.
-        }
+    }
+    if (suspiciouslyShort) {
+        throw new Error("assistant-response short capture could not be confirmed before timeout; refusing to finalize it");
     }
     return candidate;
 }
@@ -239,11 +266,17 @@ async function recoverAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex
     if (recoveryTimeoutMs === 0) {
         return null;
     }
+    const recoveryStartedAt = Date.now();
     const recovered = await waitForCondition(async () => {
         const snapshot = await readAssistantSnapshot(Runtime, minTurnIndex, expectedConversationId);
         return normalizeAssistantSnapshot(snapshot);
     }, recoveryTimeoutMs, 400);
     if (recovered) {
+        if (isImplausiblyShortAnswer(recovered.text.length)) {
+            logger("Recovered an implausibly short response; waiting for completion proof");
+            const remainingMs = Math.max(0, recoveryTimeoutMs - (Date.now() - recoveryStartedAt));
+            return pollAssistantCompletion(Runtime, remainingMs, minTurnIndex, expectedConversationId);
+        }
         logger("Recovered assistant response via polling fallback");
         return recovered;
     }
@@ -360,8 +393,8 @@ async function pollAssistantCompletion(Runtime, timeoutMs, minTurnIndex, expecte
             if (isGeneratedImageAssistantAnswer(normalized)) {
                 return normalized;
             }
-            const shortAnswer = currentLength > 0 && currentLength < 16;
-            const mediumAnswer = currentLength >= 16 && currentLength < 40;
+            const shortAnswer = isImplausiblyShortAnswer(currentLength);
+            const mediumAnswer = currentLength >= MIN_CONFIDENT_ANSWER_LENGTH && currentLength < 40;
             const longAnswer = currentLength >= 40 && currentLength < 500;
             // Learned: short answers need a longer stability window or they truncate.
             // Learned: long streaming responses (esp. thinking models) can pause mid-stream;
@@ -374,7 +407,7 @@ async function pollAssistantCompletion(Runtime, timeoutMs, minTurnIndex, expecte
             if (!stopVisible) {
                 const stableEnough = stableCycles >= requiredStableCycles && stableMs >= minStableMs;
                 const completionEnough = completionVisible && stableCycles >= completionStableTarget && stableMs >= minStableMs;
-                if (completionEnough || stableEnough) {
+                if (completionEnough || (!shortAnswer && stableEnough)) {
                     return normalized;
                 }
             }
@@ -390,7 +423,7 @@ async function pollAssistantCompletion(Runtime, timeoutMs, minTurnIndex, expecte
 async function isStopButtonVisible(Runtime) {
     try {
         const { result } = await Runtime.evaluate({
-            expression: `Boolean(document.querySelector('${STOP_BUTTON_SELECTOR}'))`,
+            expression: buildStopButtonVisibilityExpression(),
             returnByValue: true,
         });
         return Boolean(result?.value);
@@ -399,6 +432,30 @@ async function isStopButtonVisible(Runtime) {
         return false;
     }
 }
+function buildStopButtonVisibilityExpression() {
+    return `(() => {
+    ${buildStopButtonVisibilityPredicateJs("isStopControlVisible")}
+    return isStopControlVisible();
+  })()`;
+}
+function buildStopButtonVisibilityPredicateJs(fnName) {
+    const selectorLiteral = JSON.stringify(STOP_CONTROL_SELECTOR);
+    return `const ${fnName} = () => {
+    const isVisible = (node) => {
+      if (!(node instanceof HTMLElement)) return false;
+      const rect = node.getBoundingClientRect();
+      if (!rect || rect.width <= 0 || rect.height <= 0) return false;
+      const style = window.getComputedStyle(node);
+      return !(
+        style.display === 'none' ||
+        style.visibility === 'hidden' ||
+        (style.opacity !== '' && Number(style.opacity) === 0)
+      );
+    };
+    return Array.from(document.querySelectorAll(${selectorLiteral})).some((node) => isVisible(node));
+  };`;
+}
+export const buildStopButtonVisibilityExpressionForTest = buildStopButtonVisibilityExpression;
 async function isCompletionVisible(Runtime) {
     try {
         const { result } = await Runtime.evaluate({
@@ -417,7 +474,7 @@ async function isCompletionVisible(Runtime) {
           return Boolean(node.querySelector(ASSISTANT_SELECTOR) || node.querySelector('[data-testid*="assistant"]'));
         };
 
-        const turns = Array.from(document.querySelectorAll('${CONVERSATION_TURN_SELECTOR}'));
+        const turns = ${buildConversationTurnListExpression()};
         let lastAssistantTurn = null;
         for (let i = turns.length - 1; i >= 0; i--) {
           if (isAssistantTurn(turns[i])) {
@@ -529,7 +586,6 @@ function buildAssistantSnapshotExpression(minTurnIndex, expectedConversationId)
 }
 function buildResponseObserverExpression(timeoutMs, minTurnIndex, expectedConversationId) {
     const selectorsLiteral = JSON.stringify(ANSWER_SELECTORS);
-    const conversationLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
     const assistantLiteral = JSON.stringify(ASSISTANT_ROLE_SELECTOR);
     const minTurnLiteral = typeof minTurnIndex === "number" && Number.isFinite(minTurnIndex) && minTurnIndex >= 0
         ? Math.floor(minTurnIndex)
@@ -540,9 +596,8 @@ function buildResponseObserverExpression(timeoutMs, minTurnIndex, expectedConver
     return `(() => {
     ${buildClickDispatcher()}
     const SELECTORS = ${selectorsLiteral};
-    const STOP_SELECTOR = '${STOP_BUTTON_SELECTOR}';
+    const STOP_SELECTOR = ${JSON.stringify(STOP_CONTROL_SELECTOR)};
     const FINISHED_SELECTOR = '${FINISHED_ACTIONS_SELECTOR}';
-    const CONVERSATION_SELECTOR = ${conversationLiteral};
     const ASSISTANT_SELECTOR = ${assistantLiteral};
     const EXPECTED_CONVERSATION_ID = ${expectedConversationLiteral};
     // Learned: settling avoids capturing mid-stream HTML; keep short.
@@ -598,7 +653,6 @@ function buildResponseObserverExpression(timeoutMs, minTurnIndex, expectedConver
     const captureViaObserver = () =>
       new Promise((resolve, reject) => {
         const deadline = Date.now() + ${timeoutMs};
-        let stopInterval = null;
         let timeoutId = null;
         let cleanedUp = false;
         let observer = null;
@@ -607,10 +661,6 @@ function buildResponseObserverExpression(timeoutMs, minTurnIndex, expectedConver
         const cleanup = () => {
           if (cleanedUp) return;
           cleanedUp = true;
-          if (stopInterval) {
-            clearInterval(stopInterval);
-            stopInterval = null;
-          }
           if (timeoutId) {
             clearTimeout(timeoutId);
             timeoutId = null;
@@ -662,20 +712,6 @@ function buildResponseObserverExpression(timeoutMs, minTurnIndex, expectedConver
         observer = new MutationObserver(observerCallback);
         observer.observe(document.body, { childList: true, subtree: true, characterData: true });
 
-        stopInterval = setInterval(() => {
-          if (cleanedUp) return;
-          const stop = document.querySelector(STOP_SELECTOR);
-          if (!stop) {
-            return;
-          }
-          const isStopButton =
-            stop.getAttribute('data-testid') === 'stop-button' || stop.getAttribute('aria-label')?.toLowerCase()?.includes('stop');
-          if (isStopButton) {
-            return;
-          }
-          dispatchClickSequence(stop);
-        }, 500);
-
         timeoutId = setTimeout(() => {
           cleanup();
           reject(new Error('Response timeout'));
@@ -684,7 +720,7 @@ function buildResponseObserverExpression(timeoutMs, minTurnIndex, expectedConver
 
     // Check if the last assistant turn has finished (scoped to avoid detecting old turns).
     const isLastAssistantTurnFinished = () => {
-      const turns = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+      const turns = ${buildConversationTurnListExpression()};
       let lastAssistantTurn = null;
       for (let i = turns.length - 1; i >= 0; i--) {
         if (isAssistantTurn(turns[i])) {
@@ -708,8 +744,8 @@ function buildResponseObserverExpression(timeoutMs, minTurnIndex, expectedConver
       // Learned: long streaming responses (esp. thinking models) can pause mid-stream;
       // use progressively longer windows to avoid truncation (#71).
       const initialLength = snapshot?.text?.length ?? 0;
-      const shortAnswer = initialLength > 0 && initialLength < 16;
-      const mediumAnswer = initialLength >= 16 && initialLength < 40;
+      const shortAnswer = initialLength > 0 && initialLength < ${MIN_CONFIDENT_ANSWER_LENGTH};
+      const mediumAnswer = initialLength >= ${MIN_CONFIDENT_ANSWER_LENGTH} && initialLength < 40;
       const longAnswer = initialLength >= 40 && initialLength < 500;
       const settleWindowMs = shortAnswer ? 12_000 : mediumAnswer ? 5_000 : longAnswer ? 8_000 : 10_000;
       const settleIntervalMs = 400;
@@ -783,11 +819,9 @@ function buildResponseObserverExpression(timeoutMs, minTurnIndex, expectedConver
   })()`;
 }
 function buildAssistantExtractor(functionName) {
-    const conversationLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
     const assistantLiteral = JSON.stringify(ASSISTANT_ROLE_SELECTOR);
     return `const ${functionName} = () => {
     ${buildClickDispatcher()}
-    const CONVERSATION_SELECTOR = ${conversationLiteral};
     const ASSISTANT_SELECTOR = ${assistantLiteral};
     const isAssistantTurn = (node) => {
       if (!(node instanceof HTMLElement)) return false;
@@ -823,7 +857,7 @@ function buildAssistantExtractor(functionName) {
       }
     };
 
-    const turns = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+    const turns = ${buildConversationTurnListExpression()};
     for (let index = turns.length - 1; index >= 0; index -= 1) {
       const turn = turns[index];
       if (!isAssistantTurn(turn)) {
@@ -907,13 +941,10 @@ function buildMarkdownFallbackExtractor(minTurnLiteral) {
       }
     }
     if (!root) return null;
-    const CONVERSATION_SELECTOR = '${CONVERSATION_TURN_SELECTOR}';
-    const turnNodes = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+    const turnNodes = ${buildConversationTurnListExpression()};
     const hasTurns = turnNodes.length > 0;
     const resolveTurnIndex = (node) => {
-      const turn = node?.closest?.(CONVERSATION_SELECTOR);
-      if (!turn) return null;
-      const idx = turnNodes.indexOf(turn);
+      const idx = turnNodes.findIndex((turn) => turn === node || turn.contains?.(node));
       return idx >= 0 ? idx : null;
     };
     const isAfterMinTurn = (node) => {
@@ -1041,7 +1072,7 @@ function buildCopyExpression(meta) {
         if (testId.includes('assistant')) return true;
         return Boolean(node.querySelector(ASSISTANT_SELECTOR) || node.querySelector('[data-testid*="assistant"]'));
       };
-      const turns = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+      const turns = ${buildConversationTurnListExpression()};
       for (let i = turns.length - 1; i >= 0; i -= 1) {
         const turn = turns[i];
         if (!isAssistantTurn(turn)) continue;

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

@@ -1,5 +1,6 @@
 import path from "node:path";
-import { CONVERSATION_TURN_SELECTOR, INPUT_SELECTORS, SEND_BUTTON_SELECTORS, UPLOAD_STATUS_SELECTORS, } from "../constants.js";
+import { INPUT_SELECTORS, SEND_BUTTON_SELECTORS, UPLOAD_STATUS_SELECTORS } from "../constants.js";
+import { buildConversationTurnListExpression } from "../conversationTurns.js";
 import { delay } from "../utils.js";
 import { logDomFailure } from "../domDebug.js";
 import { transferAttachmentViaDataTransfer } from "./attachmentDataTransfer.js";
@@ -1173,7 +1174,14 @@ export async function clearComposerAttachments(Runtime, timeoutMs, logger) {
 export async function waitForAttachmentCompletion(Runtime, timeoutMs, expectedNames = [], logger) {
     const deadline = Date.now() + timeoutMs;
     const expectedNormalized = expectedNames.map((name) => name.toLowerCase());
+    const expectedInputBasenames = expectedNormalized
+        .map((name) => name.split("/").pop()?.split("\\").pop() ?? name)
+        .map((name) => name.toLowerCase().replace(/\s+/g, " ").trim())
+        .filter(Boolean);
+    const expectedInputSignature = expectedInputBasenames.slice().sort().join("\0");
     let inputMatchSince = null;
+    let inputOnlyReadySince = null;
+    let inputOnlySignature = "";
     let sawInputMatch = false;
     let attachmentMatchSince = null;
     let lastVerboseLog = 0;
@@ -1466,6 +1474,26 @@ export async function waitForAttachmentCompletion(Runtime, timeoutMs, expectedNa
             else {
                 attachmentMatchSince = null;
             }
+            const inputOnlySignatureNow = inputNames.slice().sort().join("\0");
+            const inputOnlyNamesSatisfied = expectedInputBasenames.length > 0 && inputOnlySignatureNow === expectedInputSignature;
+            const inputOnlyReady = inputOnlyNamesSatisfied &&
+                value.state === "ready" &&
+                value.uploading === false &&
+                !value.filesAttached &&
+                fileCount === 0;
+            if (inputOnlyReady) {
+                if (inputOnlyReadySince === null || inputOnlySignature !== inputOnlySignatureNow) {
+                    inputOnlyReadySince = Date.now();
+                    inputOnlySignature = inputOnlySignatureNow;
+                }
+                if (Date.now() - inputOnlyReadySince > 1500) {
+                    return;
+                }
+            }
+            else {
+                inputOnlyReadySince = null;
+                inputOnlySignature = "";
+            }
             // Fallback: if the file input has the expected names, allow progress once that condition is stable.
             // Some ChatGPT surfaces only render the filename after sending the message.
             const inputMissing = expectedNormalized.filter((expected) => {
@@ -1478,7 +1506,7 @@ export async function waitForAttachmentCompletion(Runtime, timeoutMs, expectedNa
             // Don't include 'disabled' - a disabled button likely means upload is still in progress.
             const inputStateOk = value.state === "ready" || value.state === "missing";
             const inputSeenNow = inputMissing.length === 0 || fileCountSatisfied;
-            const inputEvidenceOk = Boolean(value.filesAttached) || Boolean(value.uploading) || fileCountSatisfied;
+            const inputEvidenceOk = Boolean(value.filesAttached) || fileCountSatisfied;
             const stableThresholdMs = value.uploading ? 3000 : 1500;
             if (inputSeenNow && inputStateOk && inputEvidenceOk) {
                 if (inputMatchSince === null) {
@@ -1567,14 +1595,12 @@ export async function waitForUserTurnAttachments(Runtime, expectedNames, timeout
     throw new Error("Attachment was not present on the sent user message.");
 }
 function buildUserTurnAttachmentExpression(options) {
-    const conversationSelectorLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
     const minTurnLiteral = options.minTurnIndex === null ? "null" : String(options.minTurnIndex);
     const expectedPromptLiteral = JSON.stringify(options.expectedPromptPrefix);
     const expectedConversationLiteral = options.expectedConversationId
         ? JSON.stringify(options.expectedConversationId)
         : "null";
     return `(() => {
-    const CONVERSATION_SELECTOR = ${conversationSelectorLiteral};
     const MIN_TURN_INDEX = ${minTurnLiteral};
     const EXPECTED_PROMPT_PREFIX = ${expectedPromptLiteral};
     const EXPECTED_CONVERSATION_ID = ${expectedConversationLiteral};
@@ -1587,7 +1613,7 @@ function buildUserTurnAttachmentExpression(options) {
     ) {
       return { ok: false, conversationMismatch: true };
     }
-    const turns = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+    const turns = ${buildConversationTurnListExpression()};
     const userTurns = turns.map((node, index) => ({ node, index })).filter(({ node }) => {
       const attr = (node.getAttribute('data-message-author-role') || node.getAttribute('data-turn') || node.dataset?.turn || '').toLowerCase();
       if (attr === 'user') return true;