@steipete/oracle 0.20.0 → 0.20.1

package/dist/src/cli/browserTabs.js

@@ -2,6 +2,8 @@ import fs from "node:fs/promises";
 import { createHash } from "node:crypto";
 import chalk from "chalk";
 import { sessionStore } from "../sessionStore.js";
+import { resolveBrowserConfig } from "../browser/config.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";
 import { resolveOutputPath } from "./writeOutputPath.js";
@@ -9,6 +11,7 @@ import { persistBrowserHarvest } from "./harvestIntegrity.js";
 import { completeOwnedBrowserHarvest } from "./recoveredBrowserHarvest.js";
 const LIVE_POLL_MS = 2000;
 const DEFAULT_STALL_THRESHOLD_MS = 60_000;
+const HARVEST_FRESHNESS_POLL_MS = 250;
 function isRecoverableMissingTabError(message) {
     return (message.includes("No ChatGPT tab matched") ||
         message.includes("No live ChatGPT tabs found") ||
@@ -31,6 +34,35 @@ function finishRecoveredChrome(recoveredChrome, closeAfterRecover) {
         // best-effort cleanup
     }
 }
+function harvestMatchesSessionPrompt(harvested, fingerprint) {
+    const answer = harvested.lastAssistantMarkdown ?? harvested.lastAssistantText;
+    if (harvested.assistantFollowsLatestUser !== true || !answer?.trim())
+        return false;
+    return (fingerprint === undefined ||
+        (typeof harvested.lastUserMessageId === "string" &&
+            harvested.lastUserMessageId.trim().length > 0 &&
+            browserPromptFingerprint(harvested.lastUserTextRaw ?? harvested.lastUserText, harvested.lastUserMessageId) === fingerprint));
+}
+async function harvestSessionPrompt(meta, options, requireSessionPrompt = true) {
+    const fingerprint = requireSessionPrompt ? meta.browser?.runtime?.submittedPromptHash : undefined;
+    if (fingerprint === null) {
+        throw new Error("This browser session has no confirmed submitted user turn; retry after submission or use --browser-tab to inspect a specific tab.");
+    }
+    if (requireSessionPrompt && fingerprint === undefined) {
+        console.warn("Legacy browser session: submitted-turn identity is unavailable; verifying only latest user/assistant pairing.");
+    }
+    const freshnessTimeoutMs = resolveBrowserConfig(meta.browser?.config).inputTimeoutMs;
+    const deadline = Date.now() + freshnessTimeoutMs;
+    let harvested = await harvestChatGptTab(options);
+    while (!harvestMatchesSessionPrompt(harvested, fingerprint) && Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, HARVEST_FRESHNESS_POLL_MS));
+        harvested = await harvestChatGptTab(options);
+    }
+    if (!harvestMatchesSessionPrompt(harvested, fingerprint)) {
+        throw new Error(`Latest ChatGPT turn did not contain an assistant answer paired with this session prompt after ${Math.ceil(freshnessTimeoutMs / 1000)}s; refusing to harvest stale output.`);
+    }
+    return harvested;
+}
 function sessionBrowserEndpoint(meta) {
     const runtime = meta?.browser?.runtime ?? {};
     const remote = meta?.browser?.config?.remoteChrome ?? {};
@@ -167,12 +199,12 @@ export async function harvestSessionBrowserOutput(sessionId, options = {}) {
     try {
         let harvested;
         try {
-            harvested = await harvestChatGptTab({
+            harvested = await harvestSessionPrompt(meta, {
                 host: initialEndpoint.host,
                 port: initialEndpoint.port,
                 ref,
                 stallWindowMs: options.stallWindowMs,
-            });
+            }, !options.browserTabRef);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -184,7 +216,7 @@ export async function harvestSessionBrowserOutput(sessionId, options = {}) {
                 existingEndpoint: recordedEndpoint ?? undefined,
             });
             recoveredChrome = recovered.chrome;
-            harvested = await harvestChatGptTab({
+            harvested = await harvestSessionPrompt(meta, {
                 host: recovered.host,
                 port: recovered.port,
                 ref: recovered.ref,

package/dist/src/cli/detach.js

@@ -1,4 +1,5 @@
 import { isProModel } from "../oracle/modelResolver.js";
+import { isGpt6ProAlias } from "./browserConfig.js";
 export function shouldDetachSession({ 
 // Params kept for policy tweaks.
 engine, model, reasoningMode, waitPreference, disableDetachEnv, }) {
@@ -7,7 +8,7 @@ engine, model, reasoningMode, waitPreference, disableDetachEnv, }) {
     // Keep long local browser Pro work in a separate process even while the CLI
     // stays attached to its session log. If the foreground stream is interrupted,
     // the worker can still finish the browser run and persist the answer.
-    if (engine === "browser" && isProModel(model))
+    if (engine === "browser" && (isProModel(model) || isGpt6ProAlias(model)))
         return true;
     // For API runs, explicit --wait keeps execution in the foreground.
     if (waitPreference)
@@ -17,6 +18,14 @@ engine, model, reasoningMode, waitPreference, disableDetachEnv, }) {
         return true;
     return false;
 }
+export function shouldExitAfterTopLevelSigint(remainingListenerCount) {
+    return remainingListenerCount === 0;
+}
+export function detachedCancellationExitCode(cancelled, finalStatus, currentExitCode) {
+    if (!cancelled)
+        return currentExitCode;
+    return finalStatus === "completed" || finalStatus === "partial" ? 0 : 130;
+}
 export function stopDetachedWorker(workerPid, kill = process.kill) {
     try {
         kill(workerPid, "SIGTERM");

package/dist/src/cli/detachedSession.js

@@ -1,5 +1,41 @@
 import { spawn } from "node:child_process";
+import { access, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
 import { fileURLToPath } from "node:url";
+const CANCELLATION_MARKER = ".cancel-requested";
+export function detachedSessionCancellationPath(sessionDir, workerPid) {
+    return path.join(sessionDir, `${CANCELLATION_MARKER}-${workerPid}`);
+}
+export async function requestDetachedSessionCancellation(markerPath) {
+    await writeFile(markerPath, "cancel\n", "utf8");
+}
+export async function clearDetachedSessionCancellation(markerPath) {
+    await rm(markerPath, { force: true });
+}
+export async function waitForDetachedSessionCancellation({ markerPath, signal, pollIntervalMs = 100, }) {
+    while (!signal.aborted) {
+        try {
+            await access(markerPath);
+            return true;
+        }
+        catch (error) {
+            if (!(error instanceof Error) || error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+        try {
+            await delay(pollIntervalMs, undefined, { signal });
+        }
+        catch (error) {
+            if (signal.aborted && error instanceof Error && error.name === "AbortError") {
+                return false;
+            }
+            throw error;
+        }
+    }
+    return false;
+}
 export function resolveOracleCliEntrypoint(moduleUrl = import.meta.url) {
     const extension = fileURLToPath(moduleUrl).endsWith(".ts") ? "ts" : "js";
     return fileURLToPath(new URL(`../../bin/oracle-cli.${extension}`, moduleUrl));

package/dist/src/cli/sessionDisplay.js

@@ -359,7 +359,10 @@ export async function attachSession(sessionId, options) {
             console.log(dim(`User error: ${userErrorSummary}`));
         }
     }
-    const shouldTrimIntro = initialStatus === "completed" || initialStatus === "partial" || initialStatus === "error";
+    const shouldTrimIntro = initialStatus === "completed" ||
+        initialStatus === "partial" ||
+        initialStatus === "error" ||
+        initialStatus === "cancelled";
     if (options?.renderPrompt !== false) {
         const prompt = await readStoredPrompt(sessionId);
         if (prompt) {
@@ -485,7 +488,10 @@ export async function attachSession(sessionId, options) {
         if (!latest) {
             break;
         }
-        if (latest.status === "completed" || latest.status === "partial" || latest.status === "error") {
+        if (latest.status === "completed" ||
+            latest.status === "partial" ||
+            latest.status === "error" ||
+            latest.status === "cancelled") {
             await printNew();
             flushRemainder();
             if (!options?.suppressMetadata) {
@@ -516,7 +522,9 @@ export async function attachSession(sessionId, options) {
             if (!settled) {
                 break;
             }
-            if (settled.status === "completed" || settled.status === "partial") {
+            if (settled.status === "completed" ||
+                settled.status === "partial" ||
+                settled.status === "cancelled") {
                 continue;
             }
             await printNew();

package/dist/src/cli/sessionRunner.js

@@ -9,7 +9,6 @@ import { formatResponseMetadata, formatTransportMetadata } from "./sessionDispla
 import { markErrorLogged } from "./errorUtils.js";
 import { sendSessionNotification, deriveNotificationSettingsFromMetadata, } from "./notifier.js";
 import { sessionStore } from "../sessionStore.js";
-import { wait } from "../sessionManager.js";
 import { runMultiModelApiSession } from "../oracle/multiModelRunner.js";
 import { MODEL_CONFIGS, DEFAULT_SYSTEM_PROMPT } from "../oracle/config.js";
 import { isKnownModel } from "../oracle/modelResolver.js";
@@ -22,31 +21,71 @@ import { sanitizeOscProgress } from "./oscUtils.js";
 import { readFiles } from "../oracle/files.js";
 import { cwd as getCwd } from "node:process";
 import { resumeBrowserSession } from "../browser/reattach.js";
-import { retireRecoveredBrowserTarget } from "../browser/recoveryTarget.js";
+import { recoveryCaptureFromRuntime, retireCancelledBrowserTarget, retireRecoveredBrowserTarget, } from "../browser/recoveryTarget.js";
 import { hasRecoverableChatGptConversation } from "../browser/reattachability.js";
-import { estimateTokenCount } from "../browser/utils.js";
+import { delay, estimateTokenCount } from "../browser/utils.js";
 import { computeFileSha256, sanitizeArtifactFilename } from "../browser/artifacts.js";
 import { formatElapsed } from "../oracle/format.js";
 import { formatBrowserReattachGuidance } from "./reattachGuidance.js";
+import { BrowserRunCancelledError } from "../oracle/errors.js";
 const isTty = process.stdout.isTTY;
 const dim = (text) => (isTty ? kleur.dim(text) : text);
-export async function performSessionRun({ sessionMeta, runOptions, mode, browserConfig, cwd, log, write, version, notifications, browserDeps, muteStdout = false, }) {
+export async function performSessionRun({ sessionMeta, runOptions, mode, browserConfig, cwd, log, write, version, notifications, browserDeps, muteStdout = false, signal, }) {
     const writeInline = (chunk) => {
         // Keep session logs intact while still echoing inline output to the user.
         write(chunk);
         return muteStdout ? true : process.stdout.write(chunk);
     };
     let currentBrowser = browserConfig
-        ? { config: browserConfig }
+        ? {
+            config: browserConfig,
+            ...(mode === "browser" && sessionMeta.browser?.runtime?.submittedPromptHash !== undefined
+                ? { runtime: { submittedPromptHash: null } }
+                : {}),
+        }
         : sessionMeta.browser;
     await sessionStore.updateSession(sessionMeta.id, {
         status: "running",
         startedAt: new Date().toISOString(),
         mode,
-        ...(browserConfig ? { browser: { config: browserConfig } } : {}),
+        ...(browserConfig ? { browser: currentBrowser } : {}),
     });
     const notificationSettings = notifications ?? deriveNotificationSettingsFromMetadata(sessionMeta, process.env);
     const modelForStatus = runOptions.model ?? sessionMeta.model;
+    const checkBrowserCancellation = () => {
+        if (mode === "browser" && signal?.aborted)
+            throw new BrowserRunCancelledError();
+    };
+    const finalizeBrowserCancellation = async (cancellationError) => {
+        const completedAt = new Date().toISOString();
+        log("Browser run cancelled.");
+        if (modelForStatus) {
+            await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
+                status: "cancelled",
+                completedAt,
+                response: { status: "cancelled" },
+                error: undefined,
+                transport: undefined,
+            });
+        }
+        await sessionStore.updateSession(sessionMeta.id, {
+            status: "cancelled",
+            completedAt,
+            errorMessage: undefined,
+            mode,
+            browser: browserConfig
+                ? {
+                    ...currentBrowser,
+                    config: browserConfig,
+                }
+                : undefined,
+            response: { status: "cancelled" },
+            error: undefined,
+            transport: undefined,
+        });
+        await retireCancelledBrowserTarget(sessionMeta.id, recoveryCaptureFromRuntime(currentBrowser?.runtime), log);
+        throw cancellationError;
+    };
     try {
         if (mode === "browser") {
             if (!browserConfig) {
@@ -80,13 +119,17 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 browserConfig,
                 cwd,
                 log,
+                signal,
             }, runnerDeps);
+            checkBrowserCancellation();
             const writtenOutputPath = await writeAssistantOutput(runOptions.writeOutputPath, result.answerText ?? "", log);
+            checkBrowserCancellation();
             const outputArtifacts = await copyBrowserOutputArtifacts({
                 outputPath: writtenOutputPath,
                 savedFiles: runOptions.writeArtifacts ? result.savedFiles : undefined,
                 log,
             });
+            checkBrowserCancellation();
             const browserWarnings = [...(result.warnings ?? []), ...outputArtifacts.warnings];
             await sendSessionNotification({
                 sessionId: sessionMeta.id,
@@ -96,13 +139,16 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 usage: result.usage,
                 characters: result.answerText?.length,
             }, notificationSettings, log, result.answerText?.slice(0, 140));
+            checkBrowserCancellation();
             if (modelForStatus) {
                 await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
                     status: "completed",
                     completedAt: new Date().toISOString(),
                     usage: result.usage,
                 });
+                checkBrowserCancellation();
             }
+            checkBrowserCancellation();
             await sessionStore.updateSession(sessionMeta.id, {
                 status: "completed",
                 completedAt: new Date().toISOString(),
@@ -401,6 +447,9 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
         });
     }
     catch (error) {
+        if (error instanceof BrowserRunCancelledError) {
+            return await finalizeBrowserCancellation(error);
+        }
         const message = formatError(error);
         log(`ERROR: ${message}`);
         markErrorLogged(error);
@@ -426,6 +475,11 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             const runtime = userError.details
                 ?.runtime;
             const recoverableRuntime = runtime ?? currentBrowser?.runtime;
+            currentBrowser = {
+                ...currentBrowser,
+                config: browserConfig,
+                runtime: recoverableRuntime,
+            };
             if (!hasRecoverableChatGptConversation(recoverableRuntime) &&
                 recoverableRuntime?.promptSubmitted !== true) {
                 log(dim("Chrome disconnected before a ChatGPT conversation was created; marking session error."));
@@ -495,22 +549,32 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             const connectionLostIntervalMs = configuredIntervalMs > 0
                 ? configuredIntervalMs
                 : Math.max(1_000, Math.min(browserConfig?.timeoutMs ?? 30_000, 30_000));
-            const success = await autoReattachUntilComplete({
-                sessionMeta,
-                runtime: recoverableRuntime ?? undefined,
-                browserConfig: {
-                    ...browserConfig,
-                    autoReattachIntervalMs: connectionLostIntervalMs,
-                    autoReattachDelayMs: browserConfig?.autoReattachDelayMs ?? 0,
-                    autoReattachTimeoutMs: browserConfig?.autoReattachTimeoutMs ?? browserConfig?.timeoutMs ?? 120_000,
-                },
-                browserMetadata: currentBrowser,
-                runOptions,
-                modelForStatus,
-                notificationSettings,
-                log,
-                maxAttempts: configuredIntervalMs > 0 ? undefined : 1,
-            });
+            let success;
+            try {
+                success = await autoReattachUntilComplete({
+                    sessionMeta,
+                    runtime: recoverableRuntime ?? undefined,
+                    browserConfig: {
+                        ...browserConfig,
+                        autoReattachIntervalMs: connectionLostIntervalMs,
+                        autoReattachDelayMs: browserConfig?.autoReattachDelayMs ?? 0,
+                        autoReattachTimeoutMs: browserConfig?.autoReattachTimeoutMs ?? browserConfig?.timeoutMs ?? 120_000,
+                    },
+                    browserMetadata: currentBrowser,
+                    runOptions,
+                    modelForStatus,
+                    notificationSettings,
+                    log,
+                    maxAttempts: configuredIntervalMs > 0 ? undefined : 1,
+                    signal,
+                });
+            }
+            catch (recoveryError) {
+                if (signal?.aborted || recoveryError instanceof BrowserRunCancelledError) {
+                    return await finalizeBrowserCancellation(new BrowserRunCancelledError());
+                }
+                throw recoveryError;
+            }
             if (success) {
                 return;
             }
@@ -531,6 +595,11 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             };
             const autoReattachIntervalMs = browserConfig?.autoReattachIntervalMs ?? 0;
             const autoRuntime = runtime ?? currentBrowser?.runtime;
+            currentBrowser = {
+                ...currentBrowser,
+                config: browserConfig,
+                runtime: autoRuntime,
+            };
             const willAutoReattach = autoReattachIntervalMs > 0 && Boolean(autoRuntime);
             if (willAutoReattach) {
                 if (modelForStatus) {
@@ -554,16 +623,26 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                     response: timeoutResponse,
                     error: timeoutError,
                 });
-                const success = await autoReattachUntilComplete({
-                    sessionMeta,
-                    runtime: autoRuntime,
-                    browserConfig,
-                    browserMetadata: currentBrowser,
-                    runOptions,
-                    modelForStatus,
-                    notificationSettings,
-                    log,
-                });
+                let success;
+                try {
+                    success = await autoReattachUntilComplete({
+                        sessionMeta,
+                        runtime: autoRuntime,
+                        browserConfig,
+                        browserMetadata: currentBrowser,
+                        runOptions,
+                        modelForStatus,
+                        notificationSettings,
+                        log,
+                        signal,
+                    });
+                }
+                catch (recoveryError) {
+                    if (signal?.aborted || recoveryError instanceof BrowserRunCancelledError) {
+                        return await finalizeBrowserCancellation(new BrowserRunCancelledError());
+                    }
+                    throw recoveryError;
+                }
                 if (success) {
                     return;
                 }
@@ -976,7 +1055,7 @@ async function writeAssistantOutput(targetPath, content, log) {
         log(dim(`write-output failed (${reason}); session completed anyway.`));
     }
 }
-async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig, browserMetadata, runOptions, modelForStatus, notificationSettings, log, maxAttempts, }) {
+async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig, browserMetadata, runOptions, modelForStatus, notificationSettings, log, maxAttempts, signal, }) {
     if (!runtime || !browserConfig) {
         log(dim("Auto-reattach disabled: missing runtime or browser config."));
         return false;
@@ -991,12 +1070,16 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
         120_000;
     const maxTotalMs = 2 * 60 * 60 * 1000; // 2h hard cap; avoid infinite polling by default.
     const maxDeadline = Date.now() + maxTotalMs;
+    const checkCancellation = () => {
+        if (signal?.aborted)
+            throw new BrowserRunCancelledError();
+    };
     const attemptLimit = typeof maxAttempts === "number" && maxAttempts > 0
         ? Math.floor(maxAttempts)
         : Number.POSITIVE_INFINITY;
     if (delayMs > 0) {
         log(dim(`Auto-reattach starting in ${formatElapsed(delayMs)}...`));
-        await wait(delayMs);
+        await delay(delayMs, signal);
     }
     if (Number.isFinite(attemptLimit)) {
         log(dim(`Auto-reattach will try up to ${attemptLimit} attempt(s).`));
@@ -1012,6 +1095,7 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
     logger.verbose = true;
     let attempt = 0;
     for (;;) {
+        checkCancellation();
         const remainingBudgetMs = maxDeadline - Date.now();
         if (remainingBudgetMs <= 0) {
             log(dim(`Auto-reattach stopped after ${formatElapsed(maxTotalMs)} without capturing an answer.`));
@@ -1025,9 +1109,11 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                 ...browserConfig,
                 timeoutMs,
             };
-            const result = await resumeBrowserSession(runtime, reattachConfig, logger, {
+            const result = await awaitBrowserCancellation(resumeBrowserSession(runtime, reattachConfig, logger, {
                 promptPreview: sessionMeta.promptPreview,
-            });
+                signal,
+            }), signal);
+            checkCancellation();
             captureSucceeded = true;
             const answerText = result.answerMarkdown || result.answerText || "";
             const outputTokens = estimateTokenCount(answerText);
@@ -1040,8 +1126,11 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                 existingArtifacts: sessionMeta.artifacts,
                 logger,
             });
+            checkCancellation();
             const paths = await sessionStore.getPaths(sessionMeta.id);
+            checkCancellation();
             await fs.appendFile(paths.log, `[auto-reattach] captured assistant response on attempt ${attempt}\nAnswer:\n${answerText}\n`, "utf8");
+            checkCancellation();
             if (modelForStatus) {
                 await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
                     status: "completed",
@@ -1053,8 +1142,10 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                         totalTokens: outputTokens,
                     },
                 });
+                checkCancellation();
             }
             await writeAssistantOutput(runOptions.writeOutputPath, answerText, log);
+            checkCancellation();
             await sendSessionNotification({
                 sessionId: sessionMeta.id,
                 sessionName: sessionMeta.options?.slug ?? sessionMeta.id,
@@ -1066,6 +1157,7 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                 },
                 characters: answerText.length,
             }, notificationSettings, log, answerText.slice(0, 140));
+            checkCancellation();
             await sessionStore.updateSession(sessionMeta.id, {
                 status: "completed",
                 completedAt: new Date().toISOString(),
@@ -1091,6 +1183,9 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
             return true;
         }
         catch (error) {
+            if (signal?.aborted || error instanceof BrowserRunCancelledError) {
+                throw new BrowserRunCancelledError();
+            }
             if (captureSucceeded) {
                 const message = formatError(error);
                 if (modelForStatus) {
@@ -1128,7 +1223,25 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
             log(dim(`Auto-reattach stopped after ${formatElapsed(maxTotalMs)} without capturing an answer.`));
             return false;
         }
-        await wait(Math.min(intervalMs, remainingAfterAttemptMs));
+        await delay(Math.min(intervalMs, remainingAfterAttemptMs), signal);
+    }
+}
+async function awaitBrowserCancellation(task, signal) {
+    if (!signal)
+        return task;
+    if (signal.aborted)
+        throw new BrowserRunCancelledError();
+    let abort;
+    const cancelled = new Promise((_, reject) => {
+        abort = () => reject(new BrowserRunCancelledError());
+        signal.addEventListener("abort", abort, { once: true });
+    });
+    try {
+        return await Promise.race([task, cancelled]);
+    }
+    finally {
+        if (abort)
+            signal.removeEventListener("abort", abort);
     }
 }
 export function deriveModelOutputPath(basePath, model) {

package/dist/src/remote/server.js

@@ -819,6 +819,7 @@ function sanitizeResult(result, warnings = []) {
         tabUrl: result.tabUrl,
         conversationId: result.conversationId,
         promptSubmitted: result.promptSubmitted,
+        submittedPromptHash: result.submittedPromptHash,
         warnings: warnings.length > 0 ? warnings : undefined,
         chromePid: undefined,
         chromePort: undefined,

package/dist/src/sessionManager.js

@@ -304,7 +304,14 @@ export async function initializeSession(options, cwd, notifications, baseSlugOve
         })),
         cwd,
         mode,
-        browser: browserConfig ? { config: browserConfig } : undefined,
+        browser: mode === "browser"
+            ? {
+                ...(browserConfig ? { config: browserConfig } : {}),
+                runtime: { submittedPromptHash: null },
+            }
+            : browserConfig
+                ? { config: browserConfig }
+                : undefined,
         notifications,
         options: {
             prompt: options.prompt,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.20.0",
+  "version": "0.20.1",
   "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",
@@ -70,17 +70,17 @@
     "dotenv": "^17.4.2",
     "fast-glob": "^3.3.3",
     "gpt-tokenizer": "^4.0.0",
-    "inquirer": "14.2.1",
+    "inquirer": "14.2.2",
     "json5": "^2.2.3",
     "kleur": "^4.1.5",
     "markdansi": "0.3.3",
-    "openai": "^7.10.0",
+    "openai": "^7.13.0",
     "osc-progress": "^0.3.3",
     "qs": "^6.16.0",
     "shiki": "^4.4.3",
     "toasted-notifier": "^10.1.0",
-    "tokentally": "^0.1.5",
-    "zod": "^4.5.4"
+    "tokentally": "^0.1.6",
+    "zod": "^4.6.0"
   },
   "devDependencies": {
     "@anthropic-ai/tokenizer": "^0.0.4",
@@ -88,13 +88,13 @@
     "@modelcontextprotocol/sdk": "^1.30.0",
     "@types/chrome-remote-interface": "^0.34.0",
     "@types/inquirer": "^9.0.10",
-    "@types/node": "^26.4.1",
+    "@types/node": "^26.5.1",
     "@vitest/coverage-v8": "5.0.0",
-    "devtools-protocol": "0.0.1692173",
+    "devtools-protocol": "0.0.1694333",
     "es-toolkit": "^1.52.0",
     "esbuild": "^0.28.2",
-    "oxfmt": "0.66.0",
-    "oxlint": "^1.81.0",
+    "oxfmt": "0.67.0",
+    "oxlint": "^1.82.0",
     "puppeteer-core": "^25.10.0",
     "tsx": "^4.23.13",
     "typescript": "^7.0.2",