@steipete/oracle 0.20.1 → 0.20.2

package/dist/bin/oracle-cli.js

@@ -25,7 +25,7 @@ import { warnIfOversizeBundle } from "../src/cli/bundleWarnings.js";
 import { formatRenderedMarkdown } from "../src/cli/renderOutput.js";
 import { resolveRenderFlag, resolveRenderPlain } from "../src/cli/renderFlags.js";
 import { resolveGeminiModelId } from "../src/oracle/geminiModels.js";
-import { isErrorLogged } from "../src/cli/errorUtils.js";
+import { formatCliError, isErrorLogged } from "../src/cli/errorUtils.js";
 import { resolveOutputPath } from "../src/cli/writeOutputPath.js";
 import { getCliVersion } from "../src/version.js";
 import { resolveNotificationSettings, deriveNotificationSettingsFromMetadata, } from "../src/cli/notifier.js";
@@ -1358,6 +1358,8 @@ async function runRootCommand(options) {
             browserRequestedModel: cliModelArg,
             browserModelLabel: resolveBrowserModelLabel(cliModelArg, activeModel),
         });
+        config.modelIsImplicitDefault =
+            optionUsesDefault("model") && !userConfig.model && !options.browserModelLabel;
         return resolvedOptions.browserResumeConversationUrl
             ? { ...config, resumeConversationUrl: resolvedOptions.browserResumeConversationUrl }
             : config;
@@ -2106,13 +2108,7 @@ async function main() {
     }
 }
 void main().catch((error) => {
-    if (error instanceof Error) {
-        if (!isErrorLogged(error)) {
-            console.error(chalk.red("✖"), error.message);
-        }
-    }
-    else {
-        console.error(chalk.red("✖"), error);
-    }
+    if (!isErrorLogged(error))
+        console.error(chalk.red("✖"), formatCliError(error));
     process.exitCode = 1;
 });

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

@@ -15,10 +15,28 @@ const MODEL_BUTTON_POLL_MS = 250;
 export async function ensureModelSelection(Runtime, desiredModel, logger, strategy = "select", options = {}) {
     const buttonWaitMs = options.buttonWaitMs ?? MODEL_BUTTON_WAIT_MS;
     const buttonPollMs = options.buttonPollMs ?? MODEL_BUTTON_POLL_MS;
-    const deadline = Date.now() + Math.max(0, buttonWaitMs);
+    const probeDeadline = Date.now() + Math.max(0, buttonWaitMs);
+    let deadline;
     let result;
     let announcedWait = false;
     for (;;) {
+        if (options.implicitDefault && strategy === "select") {
+            // Wait for observable selection before a default-driven switch, just as selection waits for the picker.
+            const observed = await Runtime.evaluate({
+                expression: buildModelSelectionExpression(desiredModel, "current"),
+                awaitPromise: true,
+                returnByValue: true,
+            }).catch(() => null);
+            const label = observed?.result?.value?.label;
+            if ((typeof label !== "string" || !label.trim()) && Date.now() < probeDeadline) {
+                await delay(buttonPollMs);
+                continue;
+            }
+            if (typeof label === "string" && isNewerModelLabel(label, desiredModel)) {
+                logger(`[browser] Model selection warning: no model was specified, so Oracle's default will switch ChatGPT from "${label}" to "${desiredModel}" before submission. Pass --model explicitly or --browser-model-strategy current to keep the selected model.`);
+            }
+        }
+        deadline ??= Date.now() + Math.max(0, buttonWaitMs);
         const outcome = await Runtime.evaluate({
             expression: buildModelSelectionExpression(desiredModel, strategy),
             awaitPromise: true,
@@ -76,6 +94,18 @@ export async function ensureModelSelection(Runtime, desiredModel, logger, strate
         }
     }
 }
+function isNewerModelLabel(current, target) {
+    const latest = /^(?:Latest|最新|최신)$/i;
+    if (latest.test(current.trim()))
+        return !latest.test(target.trim());
+    const version = (label) => {
+        const match = label.match(/(?:^|gpt[- ]*|thinking\s+)(\d+)(?:\.(\d+))?/i);
+        return match ? [Number(match[1]), Number(match[2] ?? 0)] : null;
+    };
+    const from = version(current);
+    const to = version(target);
+    return Boolean(from && to && (from[0] > to[0] || (from[0] === to[0] && from[1] > to[1])));
+}
 function assertResolvedModelSelection(desiredModel, resolvedLabel) {
     const desired = desiredModel.toLowerCase();
     const resolved = resolvedLabel.toLowerCase();
@@ -85,7 +115,8 @@ function assertResolvedModelSelection(desiredModel, resolvedLabel) {
         // The advanced radio is localized, but only the documented exact labels are
         // evidence of GPT-6 Astra. Do not let a generic picker result verify Latest.
         if (resolvedLabel.normalize("NFC").trim() === "Latest" ||
-            resolvedLabel.normalize("NFC").trim() === "最新") {
+            resolvedLabel.normalize("NFC").trim() === "最新" ||
+            resolvedLabel.normalize("NFC").trim() === "최신") {
             return;
         }
         throw new Error(`Model picker selected "${resolvedLabel}" while "${desiredModel}" requires GPT-6 Astra (Latest).`);
@@ -187,7 +218,7 @@ function buildModelSelectionExpression(targetModel, strategy) {
     // Sol or an arbitrary localized menu row can never satisfy a Latest request.
     const isLatestModelLabel = (value) => {
       const label = String(value ?? '').normalize('NFC').trim();
-      return label === 'Latest' || label === '最新';
+      return label === 'Latest' || label === '最新' || label === '최신';
     };
     const normalizedTokens = Array.from(new Set([normalizedTarget, ...LABEL_TOKENS]))
       .map((token) => normalizeText(token))
@@ -1442,8 +1473,9 @@ function buildModelMatchersLiteral(targetModel) {
         testIdTokens.add("gpt56");
     }
     if (base === "latest") {
-        // ChatGPT's Japanese advanced-model radio is named exactly "最新".
+        // Exact Japanese and Korean labels for the advanced-model Latest radio.
         push("最新", labelTokens);
+        push("최신", labelTokens);
     }
     // Numeric variations (5.5 <-> 55 <-> gpt-5-5)
     if (base.includes("5.5") || base.includes("5-5") || base.includes("55")) {

package/dist/src/browser/browserConnection.js

@@ -0,0 +1,59 @@
+import { withoutBrowserCancellation } from "./cancellation.js";
+const connections = new Map();
+// CRI exposes no ref API. Retain approval while idle without keeping a CLI alive.
+function refTransport(client, active) {
+    const socket = client._ws?._socket;
+    if (active)
+        socket?.ref();
+    else
+        socket?.unref();
+}
+export async function acquireBrowserConnection(endpoint, connect) {
+    let pending = connections.get(endpoint);
+    if (!pending) {
+        pending = Promise.resolve().then(async () => {
+            const client = await withoutBrowserCancellation(connect);
+            const connection = { client, users: 0 };
+            client.on?.("disconnect", () => {
+                if (connections.get(endpoint) === pending)
+                    connections.delete(endpoint);
+            });
+            return connection;
+        });
+        connections.set(endpoint, pending);
+    }
+    let connection;
+    try {
+        connection = await pending;
+    }
+    catch (error) {
+        if (connections.get(endpoint) === pending)
+            connections.delete(endpoint);
+        throw error;
+    }
+    connection.users += 1;
+    refTransport(connection.client, true);
+    let released = false;
+    return new Proxy({}, {
+        ownKeys: () => Reflect.ownKeys(connection.client),
+        getOwnPropertyDescriptor: (_target, key) => {
+            const descriptor = Object.getOwnPropertyDescriptor(connection.client, key);
+            return descriptor ? { ...descriptor, configurable: true } : undefined;
+        },
+        get(_target, key) {
+            const target = connection.client;
+            if (key === "close") {
+                return async () => {
+                    if (released)
+                        return;
+                    released = true;
+                    connection.users -= 1;
+                    if (connection.users === 0)
+                        refTransport(target, false);
+                };
+            }
+            const value = Reflect.get(target, key, target);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+}

package/dist/src/browser/chatgptImages.js

@@ -209,7 +209,7 @@ function detectImageFile(buffer) {
     }
     return null;
 }
-function resolveSiblingImagePath(basePath, index, extension) {
+export function resolveSiblingImagePath(basePath, index, extension) {
     const ext = path.extname(basePath);
     const dir = path.dirname(basePath);
     const stem = ext ? path.basename(basePath, ext) : path.basename(basePath);

package/dist/src/browser/chromeLifecycle.js

@@ -1,4 +1,5 @@
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { EventEmitter } from "node:events";
 import * as childProcess from "node:child_process";
 import net from "node:net";
 import path from "node:path";
@@ -8,6 +9,7 @@ import { cleanupStaleProfileState } from "./profileState.js";
 import { delay } from "./utils.js";
 import { isWsl, resolveWslChromeLaunchRoute } from "./wslHost.js";
 import { BrowserCancellation } from "./cancellation.js";
+import { acquireBrowserConnection } from "./browserConnection.js";
 export async function launchChrome(config, userDataDir, logger) {
     const { connectHost, debugBindAddress, usePatchedLauncher } = resolveWslChromeLaunchRoute();
     const debugPort = config.debugPort ?? parseDebugPortEnv();
@@ -405,6 +407,7 @@ export async function listRemoteChromeTargets(options) {
                     targetId: target.targetId,
                     type: target.type,
                     url: target.url,
+                    title: target.title,
                 }));
             }
             finally {
@@ -429,37 +432,43 @@ export async function connectToRemoteChromeTarget(host, port, logger, options) {
     }
     const browser = await connectToBrowserWebSocket(host, port, options.browserWSEndpoint, logger, options.approvalWaitMs);
     let targetId = options.targetId;
+    let createdTargetId;
     try {
         if (!targetId) {
             const created = await browser.Target.createTarget({
                 url: options.targetUrl ?? "about:blank",
             });
             targetId = created.targetId;
+            createdTargetId = targetId;
             logger(`Opened dedicated remote Chrome tab targeting ${options.targetUrl ?? "about:blank"}`);
         }
         const attached = await browser.Target.attachToTarget({ targetId, flatten: true });
         const client = createSessionBoundChromeClient(browser, attached.sessionId);
+        let closing;
         return {
             client,
             targetId,
             browserWSEndpoint: options.browserWSEndpoint,
-            close: async (closeOptions) => {
-                await browser.Target.detachFromTarget({ sessionId: attached.sessionId }).catch(() => undefined);
+            close: (closeOptions) => (closing ??= (async () => {
                 if (options.closeTargetOnDispose && targetId && !closeOptions?.preserveTarget) {
                     await browser.Target.closeTarget({ targetId }).catch(() => undefined);
                 }
-                await browser.close().catch(() => undefined);
-            },
+                await client.close();
+            })()),
         };
     }
     catch (error) {
+        if (createdTargetId) {
+            await browser.Target.closeTarget({ targetId: createdTargetId }).catch(() => undefined);
+        }
         await browser.close().catch(() => undefined);
         throw error;
     }
 }
 async function connectToBrowserWebSocket(host, port, browserWSEndpoint, logger, approvalWaitMs) {
+    const acquire = () => acquireBrowserConnection(browserWSEndpoint, async () => (await CDP({ target: browserWSEndpoint, local: true })));
     if (!approvalWaitMs || approvalWaitMs <= 0) {
-        return (await CDP({ target: browserWSEndpoint, local: true }));
+        return acquire();
     }
     logger(`[browser] Waiting for Chrome remote debugging approval for ${host}:${port}...`);
     const startedAt = Date.now();
@@ -474,8 +483,8 @@ async function connectToBrowserWebSocket(host, port, browserWSEndpoint, logger,
             let timeout;
             let expired = false;
             try {
-                const connecting = CDP({ target: browserWSEndpoint, local: true }).then(async (client) => {
-                    // An approval arriving after our deadline must not leak a connection.
+                const connecting = acquire().then(async (client) => {
+                    // Release this waiter; another request may still be awaiting the same approval.
                     if (expired)
                         await client.close().catch(() => undefined);
                     return client;
@@ -554,6 +563,37 @@ async function connectToNewTarget(host, port, url, logger, messages) {
 }
 function createSessionBoundChromeClient(browser, sessionId) {
     const browserWithEvents = browser;
+    const events = new EventEmitter();
+    const bridges = new Map();
+    let closing;
+    const remove = (name, listener) => {
+        events.removeListener(name, listener);
+        if (events.listenerCount(name) === 0) {
+            const bridge = bridges.get(name);
+            if (bridge)
+                browserWithEvents.removeListener(name, bridge);
+            bridges.delete(name);
+        }
+    };
+    const listen = (name, listener, once = false) => {
+        if (closing)
+            return () => { };
+        if (!bridges.has(name)) {
+            const bridge = (...args) => events.emit(name, ...args);
+            bridges.set(name, bridge);
+            browserWithEvents.on(name, bridge);
+        }
+        if (once)
+            events.once(name, listener);
+        else
+            events.on(name, listener);
+        return () => remove(name, listener);
+    };
+    const onDetached = (event) => {
+        if (event.sessionId === sessionId)
+            events.emit("disconnect");
+    };
+    browserWithEvents.on("Target.detachedFromTarget", onDetached);
     const bindDomain = (domainName) => {
         const domain = browser[domainName];
         const eventName = (name) => `${domainName}.${name}.${sessionId}`;
@@ -561,25 +601,34 @@ function createSessionBoundChromeClient(browser, sessionId) {
             get(target, prop, receiver) {
                 if (prop === "on") {
                     return (name, listener) => {
-                        const domainEvent = target[name];
-                        if (typeof domainEvent === "function") {
-                            return domainEvent(sessionId, listener);
-                        }
-                        browserWithEvents.on(eventName(name), listener);
-                        return () => browserWithEvents.removeListener(eventName(name), listener);
+                        return listen(eventName(name), listener);
                     };
                 }
                 if (prop === "off" || prop === "removeListener") {
                     return (name, listener) => {
-                        const off = browserWithEvents.off ?? browserWithEvents.removeListener.bind(browserWithEvents);
-                        off(eventName(name), listener);
+                        remove(eventName(name), listener);
                     };
                 }
                 const value = Reflect.get(target, prop, receiver);
                 if (typeof value !== "function") {
                     return value;
                 }
-                return (...args) => value(...args, sessionId);
+                if (value.category === "event") {
+                    return (listener) => listener
+                        ? listen(eventName(String(prop)), listener)
+                        : new Promise((resolve) => listen(eventName(String(prop)), resolve, true));
+                }
+                return (...args) => {
+                    if (closing)
+                        return Promise.reject(new Error("Chrome page session is closed."));
+                    if (typeof args[0] === "function") {
+                        return value({}, sessionId, args[0]);
+                    }
+                    if (typeof args[1] === "function") {
+                        return value(args[0], sessionId, args[1]);
+                    }
+                    return value(...args, sessionId);
+                };
             },
         });
     };
@@ -598,14 +647,23 @@ function createSessionBoundChromeClient(browser, sessionId) {
         Input: bindDomain("Input"),
         DOM: bindDomain("DOM"),
         Emulation: bindDomain("Emulation"),
-        on: browserWithEvents.on.bind(browserWithEvents),
-        once: browserWithEvents.once.bind(browserWithEvents),
-        off: browserWithEvents.off?.bind(browserWithEvents) ??
-            browserWithEvents.removeListener.bind(browserWithEvents),
-        removeListener: browserWithEvents.removeListener.bind(browserWithEvents),
-        close: async () => {
-            await browser.Target.detachFromTarget({ sessionId }).catch(() => undefined);
-        },
+        on: (name, listener) => listen(name, listener),
+        once: (name, listener) => listen(name, listener, true),
+        off: remove,
+        removeListener: remove,
+        close: () => (closing ??= (async () => {
+            for (const [name, bridge] of bridges)
+                browserWithEvents.removeListener(name, bridge);
+            bridges.clear();
+            events.removeAllListeners();
+            browserWithEvents.removeListener("Target.detachedFromTarget", onDetached);
+            try {
+                await browser.Target.detachFromTarget({ sessionId }).catch(() => undefined);
+            }
+            finally {
+                await browser.close();
+            }
+        })()),
     };
 }
 export async function connectWithNewTab(port, logger, initialUrl, host, options) {

package/dist/src/browser/index.js

@@ -1210,7 +1210,9 @@ async function runBrowserModeInternal(options, cancellation) {
         await captureRuntimeSnapshot();
         const modelStrategy = config.modelStrategy ?? DEFAULT_MODEL_STRATEGY;
         if (config.desiredModel && modelStrategy !== "ignore" && !isResumingConversation) {
-            modelSelectionEvidence = await raceWithDisconnect(withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger, modelStrategy), {
+            modelSelectionEvidence = await raceWithDisconnect(withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger, modelStrategy, {
+                implicitDefault: config.modelIsImplicitDefault,
+            }), {
                 retries: 2,
                 delayMs: 300,
                 onRetry: (attempt, error) => {
@@ -2490,6 +2492,8 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             const attached = await cancellation.acquire(() => connectToExistingChatGptTab({
                 host,
                 port,
+                browserWSEndpoint,
+                approvalWaitMs: config.approvalWaitMs,
                 ref: tabRef,
             }), (attached) => attached.client.close());
             client = cancellation.client(attached.client);
@@ -2605,7 +2609,9 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         }
         const modelStrategy = config.modelStrategy ?? DEFAULT_MODEL_STRATEGY;
         if (config.desiredModel && modelStrategy !== "ignore" && !config.resumeConversationUrl) {
-            modelSelectionEvidence = await withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger, modelStrategy), {
+            modelSelectionEvidence = await withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger, modelStrategy, {
+                implicitDefault: config.modelIsImplicitDefault,
+            }), {
                 retries: 2,
                 delayMs: 300,
                 onRetry: (attempt, error) => {

package/dist/src/browser/liveTabs.js

@@ -5,6 +5,7 @@ import { captureAssistantMarkdown, readAssistantSnapshot } from "./actions/assis
 import { buildConversationTurnListExpression } from "./conversationTurns.js";
 import { extractStableConversationIdFromUrl } from "./conversationUrl.js";
 import { delay } from "./utils.js";
+import { connectToRemoteChromeTarget, listRemoteChromeTargets } from "./chromeLifecycle.js";
 export const DEFAULT_REMOTE_CHROME_HOST = "127.0.0.1";
 export const DEFAULT_REMOTE_CHROME_PORT = 9222;
 const LOGIN_CTA_PATTERN = /\b(log in|login|sign up|sign in|continue with google|continue with microsoft)\b/i;
@@ -22,8 +23,15 @@ function normalizeHostPort(input = {}) {
     return {
         host: input.host ?? DEFAULT_REMOTE_CHROME_HOST,
         port: input.port ?? DEFAULT_REMOTE_CHROME_PORT,
+        ...(input.browserWSEndpoint
+            ? { browserWSEndpoint: input.browserWSEndpoint, approvalWaitMs: input.approvalWaitMs }
+            : {}),
     };
 }
+function chromeTransportError(operation, endpoint, error) {
+    const detail = error instanceof Error ? error.message.trim() : String(error ?? "").trim();
+    return new Error(`Unable to ${operation} on Chrome at ${endpoint.host}:${endpoint.port}. ${detail || "Chrome returned no error details."} Check that Chrome is running and remote debugging is enabled, then retry and allow the connection prompt.`, { cause: error });
+}
 function normalizeUrl(value) {
     return String(value ?? "").trim();
 }
@@ -164,6 +172,7 @@ function buildTabInspectionExpression() {
       const lastUserText = normalize(lastUserTurn?.textContent);
       const lastUserMessage = lastUserTurn?.matches?.('[data-message-author-role="user"]')
         ? lastUserTurn : lastUserTurn?.querySelector?.('[data-message-author-role="user"]');
+      const userContent = lastUserMessage?.querySelectorAll?.('[class~="whitespace-pre-wrap"]');
       const authenticated = !loginButtonExists && (promptReady || sendExists || stopExists || assistantCount > 0);
       return {
         title: normalize(document.title),
@@ -181,6 +190,7 @@ function buildTabInspectionExpression() {
         lastUserTurnIndex,
         lastUserText,
         lastUserTextRaw: lastUserMessage?.textContent,
+        lastUserContentText: userContent?.length === 1 ? userContent[0].textContent : undefined,
         lastUserMessageId: lastUserMessage?.getAttribute?.('data-message-id'),
         visibilityState: document.visibilityState,
         focused: Boolean(document.hasFocus?.()),
@@ -191,26 +201,67 @@ export function buildTabInspectionExpressionForTest() {
     return buildTabInspectionExpression();
 }
 export async function listChatGptTargets(options = {}) {
-    const { host, port } = normalizeHostPort(options);
-    const targets = (await CDP.List({ host, port }));
-    return targets.filter(isChatGptTarget);
+    const endpoint = normalizeHostPort(options);
+    try {
+        const targets = await listRemoteChromeTargets(endpoint);
+        return targets.filter(isChatGptTarget);
+    }
+    catch (error) {
+        throw chromeTransportError("list ChatGPT tabs", endpoint, error);
+    }
 }
 export async function openChatGptTarget(options = {}) {
-    const { host, port } = normalizeHostPort(options);
+    const endpoint = normalizeHostPort(options);
+    const { host, port } = endpoint;
     const url = options.url ?? "https://chatgpt.com/";
-    const target = await CDP.New({ host, port, url });
-    return target.id;
+    try {
+        if (endpoint.browserWSEndpoint) {
+            const connection = await connectToRemoteChromeTarget(host, port, noopLogger, {
+                ...endpoint,
+                targetUrl: url,
+            });
+            try {
+                if (!connection.targetId)
+                    throw new Error("Chrome did not return a target ID.");
+                return connection.targetId;
+            }
+            finally {
+                await connection.close();
+            }
+        }
+        const target = await CDP.New({ host, port, url });
+        return target.id;
+    }
+    catch (error) {
+        throw chromeTransportError("open saved ChatGPT conversation", endpoint, error);
+    }
 }
-async function connectToTarget(host, port, targetId) {
-    const client = await CDP({ host, port, target: targetId });
+async function connectToTarget(options, targetId) {
+    const endpoint = normalizeHostPort(options);
+    const { host, port } = endpoint;
+    const connection = await connectToRemoteChromeTarget(host, port, noopLogger, {
+        ...endpoint,
+        targetId,
+    }).catch((error) => {
+        throw chromeTransportError("inspect ChatGPT tab", endpoint, error);
+    });
+    const client = Object.create(connection.client);
+    // Session-bound clients detach only; the owning connection also closes its browser socket.
+    client.close = connection.close;
     const { Runtime, DOM } = client;
-    if (Runtime?.enable) {
-        await Runtime.enable();
+    try {
+        if (Runtime?.enable) {
+            await Runtime.enable();
+        }
+        if (DOM?.enable) {
+            await DOM.enable();
+        }
+        return client;
     }
-    if (DOM?.enable) {
-        await DOM.enable();
+    catch (error) {
+        await connection.close().catch(() => undefined);
+        throw error;
     }
-    return client;
 }
 export async function inspectChatGptTab(options) {
     const { host, port } = normalizeHostPort(options);
@@ -219,7 +270,7 @@ export async function inspectChatGptTab(options) {
     if (!targetId) {
         throw new Error("inspectChatGptTab requires a target with targetId.");
     }
-    const client = await connectToTarget(host, port, targetId);
+    const client = await connectToTarget(options, targetId);
     try {
         const { Runtime } = client;
         const evaluation = await Runtime.evaluate({
@@ -268,6 +319,7 @@ export async function inspectChatGptTab(options) {
             lastAssistantSnippet: trimToSnippet(lastAssistantText),
             lastUserText,
             lastUserTextRaw: info.lastUserTextRaw,
+            lastUserContentText: info.lastUserContentText,
             lastUserMessageId: info.lastUserMessageId,
             lastUserSnippet: trimToSnippet(lastUserText),
             focused: Boolean(info.focused),
@@ -305,11 +357,11 @@ export function classifyTabState(summary) {
 }
 export async function collectChatGptTabs(options = {}) {
     const { host, port } = normalizeHostPort(options);
-    const targets = await listChatGptTargets({ host, port });
+    const targets = await listChatGptTargets(options);
     const summaries = [];
     for (const target of targets) {
         try {
-            const summary = await inspectChatGptTab({ host, port, target });
+            const summary = await inspectChatGptTab({ ...options, target });
             summaries.push(summary);
         }
         catch (error) {
@@ -383,28 +435,33 @@ export function resolveChatGptTabFromSummariesForTest(summaries, ref) {
     return resolveChatGptTabFromSummaries(summaries, ref);
 }
 export async function resolveChatGptTab(options = {}) {
-    const { host, port } = normalizeHostPort(options);
-    const summaries = await collectChatGptTabs({ host, port });
+    const ref = options.ref?.trim();
+    if (ref && ref.toLowerCase() !== "current") {
+        const targets = await listChatGptTargets(options);
+        const exact = targets.find((target) => extractTargetId(target) === ref ||
+            target.url === ref ||
+            extractConversationIdFromUrl(target.url ?? "") === ref);
+        if (exact)
+            return inspectChatGptTab({ ...options, target: exact });
+    }
+    const summaries = await collectChatGptTabs(options);
     return resolveChatGptTabFromSummaries(summaries, options.ref);
 }
 export async function connectToExistingChatGptTab(options = {}) {
-    const { host, port } = normalizeHostPort(options);
-    const tab = await resolveChatGptTab({ host, port, ref: options.ref });
-    const client = await connectToTarget(host, port, tab.targetId);
+    const tab = await resolveChatGptTab(options);
+    const client = await connectToTarget(options, tab.targetId);
     return { client, targetId: tab.targetId, tab };
 }
 export async function harvestChatGptTab(options = {}) {
-    const { host, port } = normalizeHostPort(options);
     const resolved = options.target
-        ? await inspectChatGptTab({ host, port, target: options.target })
-        : await resolveChatGptTab({ host, port, ref: options.ref });
-    const client = await connectToTarget(host, port, resolved.targetId);
+        ? await inspectChatGptTab({ ...options, target: options.target })
+        : await resolveChatGptTab(options);
+    const client = await connectToTarget(options, resolved.targetId);
     try {
         const { Runtime } = client;
         const snapshot = await readAssistantSnapshot(Runtime).catch(() => null);
         const nowSummary = await inspectChatGptTab({
-            host,
-            port,
+            ...options,
             target: {
                 targetId: resolved.targetId,
                 title: resolved.title,
@@ -448,8 +505,7 @@ export async function harvestChatGptTab(options = {}) {
             const firstFingerprint = harvested.fingerprint;
             await delay(options.stallWindowMs);
             const followup = await inspectChatGptTab({
-                host,
-                port,
+                ...options,
                 target: {
                     targetId: harvested.targetId,
                     title: harvested.title,
@@ -468,6 +524,7 @@ export async function harvestChatGptTab(options = {}) {
             harvested.loginButtonExists = followup.loginButtonExists;
             harvested.lastUserText = followup.lastUserText;
             harvested.lastUserTextRaw = followup.lastUserTextRaw;
+            harvested.lastUserContentText = followup.lastUserContentText;
             harvested.lastUserMessageId = followup.lastUserMessageId;
             harvested.lastUserSnippet = followup.lastUserSnippet;
             harvested.assistantFollowsLatestUser = followup.assistantFollowsLatestUser;

package/dist/src/cli/browserTabs.js

@@ -3,6 +3,7 @@ import { createHash } from "node:crypto";
 import chalk from "chalk";
 import { sessionStore } from "../sessionStore.js";
 import { resolveBrowserConfig } from "../browser/config.js";
+import { formatWebSocketHost, readDevToolsActivePortInfo } from "../browser/detect.js";
 import { browserPromptFingerprint } from "../browser/promptFingerprint.js";
 import { collectChatGptTabs, DEFAULT_REMOTE_CHROME_HOST, DEFAULT_REMOTE_CHROME_PORT, formatBrowserTabState, harvestChatGptTab, sessionMatchesTab, } from "../browser/liveTabs.js";
 import { isRecoveredConversationHarvestReady, recoverConversationTab, } from "../browser/recoverConversation.js";
@@ -41,7 +42,10 @@ function harvestMatchesSessionPrompt(harvested, fingerprint) {
     return (fingerprint === undefined ||
         (typeof harvested.lastUserMessageId === "string" &&
             harvested.lastUserMessageId.trim().length > 0 &&
-            browserPromptFingerprint(harvested.lastUserTextRaw ?? harvested.lastUserText, harvested.lastUserMessageId) === fingerprint));
+            // ChatGPT can append transient status text outside the user's content after submission.
+            // Keep legacy full-container hashes valid and require an exact match for either form.
+            [harvested.lastUserTextRaw ?? harvested.lastUserText, harvested.lastUserContentText].some((text) => typeof text === "string" &&
+                browserPromptFingerprint(text, harvested.lastUserMessageId) === fingerprint)));
 }
 async function harvestSessionPrompt(meta, options, requireSessionPrompt = true) {
     const fingerprint = requireSessionPrompt ? meta.browser?.runtime?.submittedPromptHash : undefined;
@@ -63,7 +67,7 @@ async function harvestSessionPrompt(meta, options, requireSessionPrompt = true)
     }
     return harvested;
 }
-function sessionBrowserEndpoint(meta) {
+async function sessionBrowserEndpoint(meta) {
     const runtime = meta?.browser?.runtime ?? {};
     const remote = meta?.browser?.config?.remoteChrome ?? {};
     const host = runtime.chromeHost ?? remote.host;
@@ -71,20 +75,65 @@ function sessionBrowserEndpoint(meta) {
     if (!host || !port) {
         return null;
     }
-    return { host, port };
+    let browserWSEndpoint = runtime.chromeBrowserWSEndpoint;
+    let livePort = port;
+    if (browserWSEndpoint) {
+        const active = runtime.chromeProfileRoot
+            ? await readDevToolsActivePortInfo(runtime.chromeProfileRoot, { host }).catch(() => null)
+            : null;
+        if (active) {
+            browserWSEndpoint = active.browserWSEndpoint;
+            livePort = active.port;
+        }
+        else {
+            // A restarted Chrome can keep its port while changing its browser socket ID.
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 1000);
+            try {
+                const response = await fetch(`http://${formatWebSocketHost(host)}:${port}/json/version`, {
+                    signal: controller.signal,
+                });
+                if (response.ok) {
+                    const version = (await response.json());
+                    const advertised = new URL(version.webSocketDebuggerUrl ?? "");
+                    if (advertised.pathname.startsWith("/devtools/browser/")) {
+                        const refreshed = new URL(browserWSEndpoint);
+                        refreshed.pathname = advertised.pathname;
+                        browserWSEndpoint = refreshed.toString();
+                    }
+                }
+            }
+            catch {
+                // Attach-running Chrome may disable HTTP discovery; keep its saved socket.
+            }
+            finally {
+                clearTimeout(timeout);
+                controller.abort();
+            }
+        }
+    }
+    return {
+        host,
+        port: livePort,
+        ...(browserWSEndpoint
+            ? {
+                browserWSEndpoint,
+                approvalWaitMs: resolveBrowserConfig(meta?.browser?.config).approvalWaitMs,
+            }
+            : {}),
+    };
 }
-function collectUniqueEndpoints(metas) {
+async function collectUniqueEndpoints(metas) {
     const entries = new Map();
-    entries.set(`${DEFAULT_REMOTE_CHROME_HOST}:${DEFAULT_REMOTE_CHROME_PORT}`, {
+    entries.set(`${DEFAULT_REMOTE_CHROME_HOST}:${DEFAULT_REMOTE_CHROME_PORT}:http`, {
         host: DEFAULT_REMOTE_CHROME_HOST,
         port: DEFAULT_REMOTE_CHROME_PORT,
     });
-    for (const meta of metas) {
-        const endpoint = sessionBrowserEndpoint(meta);
+    for (const endpoint of await Promise.all(metas.map(sessionBrowserEndpoint))) {
         if (!endpoint) {
             continue;
         }
-        entries.set(`${endpoint.host}:${endpoint.port}`, endpoint);
+        entries.set(`${endpoint.host}:${endpoint.port}:${endpoint.browserWSEndpoint ?? "http"}`, endpoint);
     }
     return Array.from(entries.values());
 }
@@ -151,7 +200,7 @@ async function maybeWriteHarvestOutput(pathInput, cwd, content) {
 }
 export async function showBrowserTabsStatus() {
     const metas = await sessionStore.listSessions().catch(() => []);
-    const endpoints = collectUniqueEndpoints(metas);
+    const endpoints = await collectUniqueEndpoints(metas);
     let printedAny = false;
     for (const endpoint of endpoints) {
         let tabs;
@@ -188,7 +237,7 @@ export async function harvestSessionBrowserOutput(sessionId, options = {}) {
     if (!meta) {
         throw new Error(`No session found with ID ${sessionId}.`);
     }
-    const recordedEndpoint = sessionBrowserEndpoint(meta);
+    const recordedEndpoint = await sessionBrowserEndpoint(meta);
     const initialEndpoint = recordedEndpoint ?? {
         host: DEFAULT_REMOTE_CHROME_HOST,
         port: DEFAULT_REMOTE_CHROME_PORT,
@@ -200,8 +249,7 @@ export async function harvestSessionBrowserOutput(sessionId, options = {}) {
         let harvested;
         try {
             harvested = await harvestSessionPrompt(meta, {
-                host: initialEndpoint.host,
-                port: initialEndpoint.port,
+                ...initialEndpoint,
                 ref,
                 stallWindowMs: options.stallWindowMs,
             }, !options.browserTabRef);
@@ -219,6 +267,8 @@ export async function harvestSessionBrowserOutput(sessionId, options = {}) {
             harvested = await harvestSessionPrompt(meta, {
                 host: recovered.host,
                 port: recovered.port,
+                browserWSEndpoint: recovered.browserWSEndpoint,
+                approvalWaitMs: recovered.approvalWaitMs,
                 ref: recovered.ref,
                 stallWindowMs: options.stallWindowMs,
             });
@@ -244,7 +294,7 @@ export async function liveTailSessionBrowserOutput(sessionId, options = {}) {
     if (!meta) {
         throw new Error(`No session found with ID ${sessionId}.`);
     }
-    const recordedEndpoint = sessionBrowserEndpoint(meta);
+    const recordedEndpoint = await sessionBrowserEndpoint(meta);
     let endpoint = recordedEndpoint ?? {
         host: DEFAULT_REMOTE_CHROME_HOST,
         port: DEFAULT_REMOTE_CHROME_PORT,
@@ -261,8 +311,7 @@ export async function liveTailSessionBrowserOutput(sessionId, options = {}) {
         // Probe once to see if the live tab is still alive; recover if not.
         try {
             await harvestChatGptTab({
-                host: endpoint.host,
-                port: endpoint.port,
+                ...endpoint,
                 ref: browserTabRef,
             });
         }
@@ -277,15 +326,19 @@ export async function liveTailSessionBrowserOutput(sessionId, options = {}) {
                 waitForReady: false,
             });
             recoveredChrome = recovered.chrome;
-            endpoint = { host: recovered.host, port: recovered.port };
+            endpoint = {
+                host: recovered.host,
+                port: recovered.port,
+                browserWSEndpoint: recovered.browserWSEndpoint,
+                approvalWaitMs: recovered.approvalWaitMs,
+            };
             browserTabRef = recovered.ref;
             requireRecoveredContent = true;
             recoveredContentDeadlineMs = Date.now() + stallThresholdMs;
         }
         while (true) {
             const harvested = await harvestChatGptTab({
-                host: endpoint.host,
-                port: endpoint.port,
+                ...endpoint,
                 ref: browserTabRef,
             });
             const fullText = harvested.lastAssistantMarkdown ?? harvested.lastAssistantText ?? "";

package/dist/src/cli/errorUtils.js

@@ -1,4 +1,13 @@
 const LOGGED_SYMBOL = Symbol("oracle.alreadyLogged");
+export function formatCliError(error) {
+    const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+    if (message.trim())
+        return message;
+    const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
+    if (typeof code === "string" && code.trim())
+        return `Operation failed (${code}).`;
+    return "An unexpected error occurred. Retry with --verbose for more details.";
+}
 export function markErrorLogged(error) {
     if (error instanceof Error) {
         error[LOGGED_SYMBOL] = true;

package/dist/src/mcp/tools/consult.js

@@ -299,6 +299,7 @@ export function buildConsultBrowserConfig({ userConfig, env, runModel, inputMode
         researchMode: browserResearchMode ?? configuredBrowser.researchMode,
         archiveConversations: browserArchive ?? configuredBrowser.archiveConversations,
         desiredModel: desiredModelLabel || mapModelToBrowserLabel(runModel),
+        modelIsImplicitDefault: !inputModel && !userConfig.model && !browserModelLabel,
     };
 }
 export function buildConsultDryRunResolved({ resolvedEngine, runOptions, browserConfig, }) {
@@ -436,13 +437,6 @@ export async function runConsultTool(input, { log: requestLog, launchDetached =
     const cwd = process.cwd();
     const sendLog = (text, level = "info") => requestLog(level, { text, bytes: Buffer.byteLength(text, "utf8") }).catch(() => { });
     const resolvedRemote = resolveRemoteServiceConfig({ userConfig, env: process.env });
-    const imageOutputPath = runOptions.generateImage ?? runOptions.outputPath;
-    if (resolvedEngine === "browser" && resolvedRemote.host && imageOutputPath) {
-        return {
-            isError: true,
-            content: textContent("ChatGPT image output is not supported with a remote browser service: generated files are not transferred back to the MCP caller. Unset ORACLE_REMOTE_HOST to generate images locally, or omit generateImage/outputPath."),
-        };
-    }
     let browserConfig;
     if (resolvedEngine === "browser") {
         browserConfig = buildConsultBrowserConfig({

package/dist/src/remote/client.js

@@ -5,11 +5,12 @@ import { pipeline } from "node:stream/promises";
 import path from "node:path";
 import { mkdir, readFile, rename, rm, stat } from "node:fs/promises";
 import { appendArtifacts, computeFileSha256, resolveSessionArtifactsDir, resolveUniqueArtifactPath, sanitizeArtifactFilename, sanitizeArtifactMimeType, validateArtifactFile, } from "../browser/artifacts.js";
-import { MAX_REMOTE_ARTIFACT_BYTES, } from "./types.js";
+import { MAX_REMOTE_ARTIFACT_BYTES, pickRemoteImageMetadata, } from "./types.js";
 import { materializeStagedFallbackBundle } from "../browser/prompt.js";
 import { checkRemoteHealth } from "./health.js";
 import { parseHostPort } from "../bridge/connection.js";
 import { BrowserRunCancelledError } from "../oracle/errors.js";
+import { resolveSiblingImagePath } from "../browser/chatgptImages.js";
 export function createRemoteBrowserExecutor({ host, token }) {
     // Return a drop-in replacement for runBrowserMode so the browser session runner can stay unchanged.
     return async function remoteBrowserExecutor(options) {
@@ -17,13 +18,20 @@ export function createRemoteBrowserExecutor({ host, token }) {
             throw new Error("Web Search is a local browser pilot; --remote-host does not negotiate this capability yet. Use local Chrome or --browser-attach-running.");
         }
         const callerSignal = options.signal;
+        const imageOutputRequested = Boolean(options.generateImagePath || options.outputPath);
         if (callerSignal?.aborted)
             throw new BrowserRunCancelledError("Browser run cancelled before the request was sent.");
-        if (callerSignal) {
+        if (callerSignal || imageOutputRequested) {
             const health = await checkRemoteHealth({ host, token, signal: callerSignal });
-            if (callerSignal.aborted)
+            if (callerSignal?.aborted)
                 throw new BrowserRunCancelledError();
-            if (health.capabilities?.runCancellation !== true)
+            if (imageOutputRequested &&
+                (!health.ok ||
+                    health.capabilities?.generatedImages !== true ||
+                    health.capabilities.artifactProtocolVersion !== 1)) {
+                throw new Error("Remote host cannot capture and transfer generated images; upgrade Oracle on the host and retry. The image request was not sent.");
+            }
+            if (callerSignal && health.capabilities?.runCancellation !== true)
                 throw new Error("Remote host does not support run cancellation; upgrade the host before using an AbortSignal.");
         }
         const payload = {
@@ -37,6 +45,7 @@ export function createRemoteBrowserExecutor({ host, token }) {
                 sessionId: options.sessionId,
                 followUpPrompts: options.followUpPrompts,
                 cancelOnDisconnect: callerSignal ? true : undefined,
+                imageOutputRequested,
             },
         };
         const body = Buffer.from(JSON.stringify(payload));
@@ -46,10 +55,12 @@ export function createRemoteBrowserExecutor({ host, token }) {
                 reject(new Error("Browser run cancelled before the request was sent."));
                 return;
             }
-            const transferredFiles = [];
+            const transferredArtifacts = [];
             const transferFailures = [];
             const transferPromises = [];
             let artifactTransferQueue = Promise.resolve();
+            const preferredImagePath = options.generateImagePath ?? options.outputPath;
+            let preferredImageIndex = 0;
             let settled = false;
             let resolved = null;
             const fail = (error) => {
@@ -95,7 +106,7 @@ export function createRemoteBrowserExecutor({ host, token }) {
                                     resolved = result;
                                 },
                                 onArtifact: (artifact) => {
-                                    transferredFiles.push(artifact);
+                                    transferredArtifacts.push(artifact);
                                 },
                                 onArtifactFailure: (message) => {
                                     transferFailures.push(message);
@@ -105,6 +116,12 @@ export function createRemoteBrowserExecutor({ host, token }) {
                                     artifactTransferQueue = queued.catch(() => undefined);
                                     return queued;
                                 },
+                                resolvePreferredImagePath: (descriptor) => {
+                                    if (!preferredImagePath)
+                                        return undefined;
+                                    const extension = path.extname(descriptor.filename).slice(1) || "png";
+                                    return resolveSiblingImagePath(path.resolve(preferredImagePath), preferredImageIndex++, extension);
+                                },
                                 onError: fail,
                             });
                             if (transferPromise) {
@@ -123,9 +140,18 @@ export function createRemoteBrowserExecutor({ host, token }) {
                             fail(new Error("Remote browser run completed without a result."));
                             return;
                         }
+                        if (preferredImagePath) {
+                            const images = transferredArtifacts.filter((artifact) => artifact.kind === "image");
+                            if (images.length === 0 ||
+                                images.length !== preferredImageIndex ||
+                                resolved.warnings?.some((warning) => warning.code === "remote-image-registration-failed")) {
+                                fail(new Error("Remote image output was not fully delivered. Inspect the bridge host's generated images and the artifact transfer diagnostics before retrying."));
+                                return;
+                            }
+                        }
                         settled = true;
                         callerSignal?.removeEventListener("abort", onCallerAbort);
-                        resolve(mergeTransferredArtifacts(resolved, transferredFiles, transferFailures));
+                        resolve(mergeTransferredArtifacts(resolved, transferredArtifacts, transferFailures));
                     })().catch(fail);
                 });
                 res.on("error", fail);
@@ -222,12 +248,16 @@ function handleEvent(params) {
     }
     if (event.type === "artifact-ready") {
         const displayFilename = sanitizeArtifactFilename(String(event.artifact?.filename ?? ""), "artifact.bin");
+        const preferredPath = event.artifact.kind === "image"
+            ? params.resolvePreferredImagePath(event.artifact)
+            : undefined;
         const transfer = params.enqueueArtifactTransfer(() => transferRemoteArtifact({
             hostname: params.hostname,
             port: params.port,
             token: params.token,
             descriptor: event.artifact,
             sessionId: params.options.sessionId,
+            preferredPath,
             signal: params.options.signal,
             log: params.options.log,
         })
@@ -256,9 +286,11 @@ async function transferRemoteArtifact(params) {
     validateRemoteArtifactDescriptor(params.descriptor);
     const sessionId = params.sessionId ?? params.descriptor.runId;
     const artifactsDir = resolveSessionArtifactsDir(sessionId);
-    await mkdir(artifactsDir, { recursive: true });
     const filename = sanitizeArtifactFilename(params.descriptor.filename, `artifact-${params.descriptor.artifactId}.bin`);
-    const finalPath = await resolveUniqueArtifactPath(path.join(artifactsDir, filename));
+    const finalPath = params.preferredPath
+        ? path.resolve(params.preferredPath)
+        : await resolveUniqueArtifactPath(path.join(artifactsDir, filename));
+    await mkdir(path.dirname(finalPath), { recursive: true });
     const partPath = `${finalPath}.part-${params.descriptor.artifactId}`;
     const artifactPath = `/runs/${encodeURIComponent(params.descriptor.runId)}/artifacts/${encodeURIComponent(params.descriptor.artifactId)}`;
     params.log?.(`[browser] Transferring artifact ${filename} from bridge host...`);
@@ -300,8 +332,7 @@ async function transferRemoteArtifact(params) {
     await rename(partPath, finalPath);
     params.log?.(`[browser] Transferred artifact to ${finalPath}`);
     const publishedFilename = path.basename(finalPath);
-    return {
-        kind: "file",
+    const baseArtifact = {
         path: finalPath,
         label: publishedFilename,
         mimeType: sanitizeArtifactMimeType(params.descriptor.mimeType),
@@ -313,6 +344,17 @@ async function transferRemoteArtifact(params) {
         origin: { mode: "bridge" },
         url: "bridge-artifact",
         finalUrl: "bridge-artifact",
+    };
+    if (params.descriptor.kind === "image") {
+        return {
+            ...baseArtifact,
+            kind: "image",
+            ...pickRemoteImageMetadata(params.descriptor.image),
+        };
+    }
+    return {
+        ...baseArtifact,
+        kind: "file",
         filename: publishedFilename,
     };
 }
@@ -371,7 +413,7 @@ async function downloadArtifactToFile(params) {
 function validateRemoteArtifactDescriptor(descriptor) {
     if (!descriptor ||
         typeof descriptor !== "object" ||
-        descriptor.kind !== "file" ||
+        (descriptor.kind !== "file" && descriptor.kind !== "image") ||
         typeof descriptor.runId !== "string" ||
         !/^[a-zA-Z0-9_-]{1,128}$/.test(descriptor.runId) ||
         typeof descriptor.artifactId !== "string" ||
@@ -385,9 +427,12 @@ function validateRemoteArtifactDescriptor(descriptor) {
         throw new Error("invalid bridge artifact descriptor");
     }
 }
-function mergeTransferredArtifacts(result, transferredFiles, transferFailures) {
-    const artifacts = appendArtifacts(result.artifacts, transferredFiles);
+function mergeTransferredArtifacts(result, transferredArtifacts, transferFailures) {
+    const transferredFiles = transferredArtifacts.filter((artifact) => artifact.kind === "file");
+    const transferredImages = transferredArtifacts.filter((artifact) => artifact.kind === "image");
+    const artifacts = appendArtifacts(result.artifacts, transferredArtifacts);
     const savedFiles = appendSavedFiles(result.savedFiles, transferredFiles);
+    const savedImages = appendSavedImages(result.savedImages, transferredImages);
     const warnings = [
         ...(result.warnings ?? []),
         ...transferFailures.map((message) => ({
@@ -400,9 +445,21 @@ function mergeTransferredArtifacts(result, transferredFiles, transferFailures) {
         ...result,
         artifacts,
         savedFiles,
+        savedImages,
         warnings: warnings.length > 0 ? warnings : undefined,
     };
 }
+function appendSavedImages(existing, additions) {
+    const merged = new Map();
+    for (const artifact of existing ?? []) {
+        merged.set(artifact.path, artifact);
+    }
+    for (const artifact of additions) {
+        merged.set(artifact.path, artifact);
+    }
+    const values = Array.from(merged.values());
+    return values.length > 0 ? values : undefined;
+}
 function appendSavedFiles(existing, additions) {
     const merged = new Map();
     for (const artifact of existing ?? []) {

package/dist/src/remote/health.js

@@ -93,6 +93,7 @@ function parseCapabilities(value) {
     return {
         ...(raw.deferredFallbackBundling === true ? { deferredFallbackBundling: true } : {}),
         ...(raw.runCancellation === true ? { runCancellation: true } : {}),
+        ...(raw.generatedImages === true ? { generatedImages: true } : {}),
         artifactTransfer: true,
         artifactProtocolVersion,
         maxArtifactBytes: Math.min(maxArtifactBytes, MAX_REMOTE_ARTIFACT_BYTES),

package/dist/src/remote/server.js

@@ -14,20 +14,21 @@ import { resolveBrowserConfig } from "../browser/config.js";
 import { RunSlots } from "./runSlots.js";
 export { RunSlots } from "./runSlots.js";
 import { loadUserConfig } from "../config.js";
-import { MAX_REMOTE_ARTIFACT_BYTES } from "./types.js";
+import { MAX_REMOTE_ARTIFACT_BYTES, pickRemoteImageMetadata } from "./types.js";
 import { getCookies } from "@steipete/sweet-cookie";
 import { CHATGPT_URL } from "../browser/constants.js";
 import { getCliVersion } from "../version.js";
 import { getOracleHomeDir } from "../oracleHome.js";
 import { cleanupStaleProfileState, readDevToolsPort, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from "../browser/profileState.js";
 import { normalizeChatgptUrl } from "../browser/utils.js";
-import { computeFileSha256, sanitizeArtifactFilename, sanitizeArtifactMimeType, validateArtifactFile, } from "../browser/artifacts.js";
+import { computeFileSha256, resolveSessionArtifactsDir, sanitizeArtifactFilename, sanitizeArtifactMimeType, validateArtifactFile, } from "../browser/artifacts.js";
 const ARTIFACT_PROTOCOL_VERSION = 1;
 const REMOTE_ARTIFACT_TTL_MS = 30 * 60 * 1000;
 const ARTIFACT_CAPABILITIES = {
     runCancellation: true,
     deferredFallbackBundling: true,
     artifactTransfer: true,
+    generatedImages: true,
     artifactProtocolVersion: ARTIFACT_PROTOCOL_VERSION,
     maxArtifactBytes: MAX_REMOTE_ARTIFACT_BYTES,
 };
@@ -334,6 +335,9 @@ export async function createRemoteServer(options = {}, deps = {}) {
                 ? payload.options.sessionId.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 32)
                 : "remote";
             payload.options.sessionId = `${clientSession || "remote"}-${runId}`;
+            const hostImageOutputPath = payload.options.imageOutputRequested === true
+                ? path.join(resolveSessionArtifactsDir(payload.options.sessionId), "generated.png")
+                : undefined;
             if (browserTabCap !== undefined)
                 payload.browserConfig.maxConcurrentTabs = browserTabCap;
             signal?.throwIfAborted();
@@ -362,6 +366,7 @@ export async function createRemoteServer(options = {}, deps = {}) {
                 heartbeatIntervalMs: payload.options.heartbeatIntervalMs,
                 verbose: payload.options.verbose,
                 sessionId: payload.options.sessionId,
+                generateImagePath: hostImageOutputPath,
                 followUpPrompts: payload.options.followUpPrompts,
             });
             signal?.throwIfAborted();
@@ -615,13 +620,14 @@ function remoteArtifactKey(runId, artifactId) {
 async function registerRemoteArtifacts(params) {
     pruneExpiredArtifacts(params.artifactRegistry);
     const seen = new Set();
-    const fileArtifacts = [
+    const transferableArtifacts = [
         ...(params.result.savedFiles ?? []),
-        ...(params.result.artifacts ?? []).filter((artifact) => artifact.kind === "file"),
+        ...(params.result.savedImages ?? []),
+        ...(params.result.artifacts ?? []).filter((artifact) => artifact.kind === "file" || artifact.kind === "image"),
     ];
     const descriptors = [];
     const warnings = [];
-    for (const artifact of fileArtifacts) {
+    for (const artifact of transferableArtifacts) {
         if (!artifact?.path || seen.has(artifact.path)) {
             continue;
         }
@@ -630,7 +636,9 @@ async function registerRemoteArtifacts(params) {
             const filename = sanitizeArtifactFilename(path.basename(artifact.path), "artifact.bin");
             params.logger(`[serve] Skipping remote artifact descriptor: ${error instanceof Error ? error.message : String(error)}`);
             warnings.push({
-                code: "remote-artifact-registration-failed",
+                code: artifact.kind === "image"
+                    ? "remote-image-registration-failed"
+                    : "remote-artifact-registration-failed",
                 severity: "warning",
                 message: `Oracle captured the browser text response, but the bridge host could not prepare ${filename} for transfer. ` +
                     "Open the ChatGPT browser on the bridge host, download the ZIP/file shown in the current response, and copy it to a cloud-readable path.",
@@ -675,7 +683,12 @@ async function buildRemoteArtifactRegistration(runId, artifact) {
         descriptor: {
             artifactId: randomUUID(),
             runId,
-            kind: "file",
+            kind: artifact.kind === "image" ? "image" : "file",
+            ...(artifact.kind === "image"
+                ? {
+                    image: pickRemoteImageMetadata(artifact),
+                }
+                : {}),
             filename,
             mimeType,
             byteSize: fileStat.size,
@@ -740,6 +753,7 @@ const CLIENT_BROWSER_CONFIG_FIELDS = [
     "chatgptUrl",
     "url",
     "desiredModel",
+    "modelIsImplicitDefault",
     "modelStrategy",
     "thinkingTime",
     "researchMode",
@@ -805,10 +819,37 @@ async function stageRemoteAttachments(payload, directory, defaultPrefix) {
 }
 // Return conversation identity and observed selection; keep process/profile details on the host.
 function sanitizeResult(result, warnings = []) {
+    const hostArtifactPaths = [
+        ...(result.savedFiles ?? []),
+        ...(result.savedImages ?? []),
+        ...(result.artifacts ?? []),
+    ]
+        .map((artifact) => artifact.path)
+        .filter((artifactPath) => Boolean(artifactPath));
+    const savedImagePaths = [
+        ...(result.savedImages ?? []),
+        ...(result.artifacts ?? []).filter((artifact) => artifact.kind === "image"),
+    ].map((artifact) => artifact.path);
+    const imageCount = new Set(savedImagePaths).size;
+    const sanitizeAnswer = (value) => {
+        let sanitized = value;
+        // Local save notices describe the host filesystem, not the client's transferred files.
+        for (const imagePath of savedImagePaths) {
+            sanitized = sanitized
+                ?.split(` Saved to: ${imagePath}`)
+                .join("")
+                .split(` Saved ${imageCount} file(s) starting at: ${imagePath}`)
+                .join("");
+        }
+        for (const artifactPath of hostArtifactPaths) {
+            sanitized = sanitized?.split(artifactPath).join(path.basename(artifactPath));
+        }
+        return sanitized;
+    };
     return {
-        answerText: result.answerText,
-        answerMarkdown: result.answerMarkdown,
-        answerHtml: result.answerHtml,
+        answerText: sanitizeAnswer(result.answerText) ?? "",
+        answerMarkdown: sanitizeAnswer(result.answerMarkdown) ?? "",
+        answerHtml: sanitizeAnswer(result.answerHtml),
         tookMs: result.tookMs,
         answerTokens: result.answerTokens,
         answerChars: result.answerChars,

package/dist/src/remote/types.js

@@ -1 +1,14 @@
 export const MAX_REMOTE_ARTIFACT_BYTES = 512 * 1024 * 1024;
+export function pickRemoteImageMetadata(image = {}) {
+    return {
+        ...(Number.isSafeInteger(image.width) && Number(image.width) > 0
+            ? { width: Number(image.width) }
+            : {}),
+        ...(Number.isSafeInteger(image.height) && Number(image.height) > 0
+            ? { height: Number(image.height) }
+            : {}),
+        ...(typeof image.fileId === "string" && /^file[-_][a-z0-9_-]{1,200}$/i.test(image.fileId)
+            ? { fileId: image.fileId }
+            : {}),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.20.1",
+  "version": "0.20.2",
   "description": "CLI wrapper around OpenAI Responses API with GPT-5.6 Sol, GPT-5.6, GPT-5.5 Pro, GPT-5.5, GPT-5.4, GPT-5.2, GPT-5.1, and GPT-5.1 Codex high reasoning modes.",
   "keywords": [],
   "homepage": "https://askoracle.sh",
@@ -80,7 +80,7 @@
     "shiki": "^4.4.3",
     "toasted-notifier": "^10.1.0",
     "tokentally": "^0.1.6",
-    "zod": "^4.6.0"
+    "zod": "^4.6.1"
   },
   "devDependencies": {
     "@anthropic-ai/tokenizer": "^0.0.4",