@steipete/oracle 0.18.0 → 0.20.0

package/dist/src/browser/utils.js

@@ -1,6 +1,22 @@
 export { parseDuration } from "../duration.js";
-export function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+import { currentBrowserAbortSignal } from "./cancellation.js";
+export function delay(ms, signal = currentBrowserAbortSignal()) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            reject(signal?.reason);
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
 }
 export function estimateTokenCount(text) {
     if (!text) {
@@ -18,6 +34,8 @@ export async function withRetries(task, options = {}) {
             return await task();
         }
         catch (error) {
+            if (error instanceof Error && ["AbortError", "BrowserRunCancelledError"].includes(error.name))
+                throw error;
             if (attempt === retries) {
                 throw error;
             }

package/dist/src/cli/browserConfig.js

@@ -5,6 +5,7 @@ import { normalizeThinkingTimeLevel } from "../oracle/thinkingTime.js";
 import { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from "../browser/constants.js";
 import { normalizeChatgptUrl } from "../browser/utils.js";
 import { parseDuration } from "../duration.js";
+import { resolveBrowserApprovalWait } from "../browser/config.js";
 import { normalizeBrowserModelStrategy } from "../browser/modelStrategy.js";
 import { getOracleHomeDir } from "../oracleHome.js";
 const DEFAULT_BROWSER_TIMEOUT_MS = 1_200_000;
@@ -23,6 +24,10 @@ const CURRENT_CHATGPT_PRO_ALIASES = new Set([
 // The browser label is passed to the model picker which fuzzy-matches against ChatGPT's UI.
 const BROWSER_MODEL_LABELS = [
     // Most specific first (e.g., "gpt-5.2-thinking" before "gpt-5.2")
+    // GPT-6 (Astra) has no entry of its own in the ChatGPT picker: it is the "Latest" radio of the
+    // advanced view, and "GPT-6 Pro" is that radio with the power slider at Pro (composer pill "6 Pro").
+    ["gpt-6-pro", "Latest"],
+    ["gpt-6-astra", "Latest"],
     ["gpt-5.6-sol", "GPT-5.6 Sol"],
     ["gpt-5.6", "GPT-5.6 Sol"],
     ["gpt-5.5-pro", "GPT-5.5"],
@@ -46,6 +51,13 @@ const BROWSER_MODEL_LABELS = [
 ];
 export function normalizeChatGptModelForBrowser(model) {
     const normalized = model.toLowerCase();
+    // Browser-only alias: gpt-6-pro keeps its name so the Pro tier default survives (label "Latest").
+    if (isGpt6ProAlias(normalized)) {
+        return "gpt-6-pro";
+    }
+    if (isGpt6Alias(normalized)) {
+        return "gpt-6-astra";
+    }
     if (!normalized.startsWith("gpt-") || normalized.includes("codex")) {
         return model;
     }
@@ -71,6 +83,18 @@ export function normalizeChatGptModelForBrowser(model) {
     }
     return model;
 }
+// Documented spellings only: gpt-6, gpt-6-astra, gpt-6-pro (plus their label forms such as
+// "GPT-6 Pro") and "latest" map to ChatGPT's "Latest" model. Any other gpt-6-* id (gpt-6-codex,
+// gpt-6-custom, ...) is not an alias and must pass through unchanged for custom/OpenRouter use.
+const GPT6_ALIAS_PATTERN = /^gpt[-_ ]?6(?:[-_ ](?:astra|pro))?$/;
+const GPT6_PRO_ALIAS_PATTERN = /^gpt[-_ ]?6[-_ ]pro$/;
+export function isGpt6Alias(model) {
+    const normalized = model?.trim().toLowerCase() ?? "";
+    return normalized === "latest" || GPT6_ALIAS_PATTERN.test(normalized);
+}
+export function isGpt6ProAlias(model) {
+    return GPT6_PRO_ALIAS_PATTERN.test(model?.trim().toLowerCase() ?? "");
+}
 export function isCurrentChatGptProAlias(model) {
     return CURRENT_CHATGPT_PRO_ALIASES.has(model?.trim().toLowerCase() ?? "");
 }
@@ -79,7 +103,10 @@ export function resolveDefaultBrowserThinkingTime({ model, requestedModel, model
     if (strategy !== "select")
         return undefined;
     const normalizedModel = normalizeChatGptModelForBrowser(model);
-    return isCurrentChatGptProAlias(requestedModel ?? model) || normalizedModel === "gpt-5.5-pro"
+    return isCurrentChatGptProAlias(requestedModel ?? model) ||
+        isGpt6ProAlias(requestedModel ?? model) ||
+        normalizedModel === "gpt-6-pro" ||
+        normalizedModel === "gpt-5.5-pro"
         ? "pro"
         : undefined;
 }
@@ -153,6 +180,7 @@ export async function buildBrowserConfig(options) {
         inputTimeoutMs: options.browserInputTimeout
             ? parseBrowserDuration(options.browserInputTimeout, "--browser-input-timeout", DEFAULT_BROWSER_INPUT_TIMEOUT_MS)
             : undefined,
+        approvalWaitMs: resolveBrowserApprovalWait(options.browserApprovalWait),
         attachmentTimeoutMs: options.browserAttachmentTimeout
             ? parseBrowserDuration(options.browserAttachmentTimeout, "--browser-attachment-timeout", DEFAULT_BROWSER_ATTACHMENT_TIMEOUT_MS)
             : undefined,
@@ -206,7 +234,9 @@ export async function buildBrowserConfig(options) {
         remoteChrome,
         browserTabRef: options.browserTab ?? undefined,
         thinkingTime,
-        researchMode: options.browserResearch === "deep" ? "deep" : "off",
+        researchMode: options.browserResearch === "deep" || options.browserResearch === "search"
+            ? options.browserResearch
+            : "off",
         archiveConversations: options.browserArchive,
     };
 }
@@ -286,12 +316,14 @@ export function resolveBrowserModelLabel(input, model) {
         return mapModelToBrowserLabel(model);
     }
     const normalizedInput = trimmed.toLowerCase();
-    if (normalizedInput === model.toLowerCase()) {
+    if (normalizedInput === model.toLowerCase() ||
+        (isGpt6Alias(normalizedInput) && (model === "gpt-6-astra" || model === "gpt-6-pro")) ||
+        (isGpt6ProAlias(normalizedInput) && model === "gpt-6-pro")) {
         return mapModelToBrowserLabel(model);
     }
     return trimmed;
 }
-function parseRemoteChromeTarget(raw) {
+export function parseRemoteChromeTarget(raw) {
     const target = raw.trim();
     if (!target) {
         throw new Error("Invalid remote-chrome value: expected host:port but received an empty string.");

package/dist/src/cli/browserDefaults.js

@@ -12,6 +12,13 @@ export function applyBrowserDefaultsFromConfig(options, config, getSource) {
     const attachRunningRequested = options.browserAttachRunning === true ||
         (isUnset("browserAttachRunning") && browser.attachRunning === true);
     const currentModelRequestedByCli = options.browserModelStrategy === "current" && getSource("browserModelStrategy") === "cli";
+    if (!options.copyProfile &&
+        isUnset("remoteChrome") &&
+        options.remoteChrome === undefined &&
+        browser.remoteChrome) {
+        const { host, port } = browser.remoteChrome;
+        options.remoteChrome = `${host.includes(":") && !host.startsWith("[") ? `[${host}]` : host}:${port}`;
+    }
     const configuredChatgptUrl = browser.chatgptUrl ?? browser.url;
     const cliChatgptSet = options.chatgptUrl !== undefined || options.browserUrl !== undefined;
     if (isUnset("chatgptUrl") && !cliChatgptSet && configuredChatgptUrl !== undefined) {
@@ -45,6 +52,9 @@ export function applyBrowserDefaultsFromConfig(options, config, getSource) {
     if (isUnset("browserInputTimeout") && typeof browser.inputTimeoutMs === "number") {
         options.browserInputTimeout = String(browser.inputTimeoutMs);
     }
+    if (isUnset("browserApprovalWait") && typeof browser.approvalWaitMs === "number") {
+        options.browserApprovalWait = String(browser.approvalWaitMs);
+    }
     if (isUnset("browserAttachmentTimeout") && typeof browser.attachmentTimeoutMs === "number") {
         options.browserAttachmentTimeout = String(browser.attachmentTimeoutMs);
     }

package/dist/src/cli/browserTabs.js

@@ -2,9 +2,11 @@ import fs from "node:fs/promises";
 import { createHash } from "node:crypto";
 import chalk from "chalk";
 import { sessionStore } from "../sessionStore.js";
-import { collectChatGptTabs, DEFAULT_REMOTE_CHROME_HOST, DEFAULT_REMOTE_CHROME_PORT, extractConversationIdFromUrl, formatBrowserTabState, harvestChatGptTab, sessionMatchesTab, } from "../browser/liveTabs.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";
+import { persistBrowserHarvest } from "./harvestIntegrity.js";
+import { completeOwnedBrowserHarvest } from "./recoveredBrowserHarvest.js";
 const LIVE_POLL_MS = 2000;
 const DEFAULT_STALL_THRESHOLD_MS = 60_000;
 function isRecoverableMissingTabError(message) {
@@ -85,35 +87,17 @@ function resolveSessionTabRef(meta) {
 export function resolveSessionTabRefForTest(meta) {
     return resolveSessionTabRef(meta);
 }
-async function persistHarvest(sessionId, meta, harvested) {
-    const hash = createHash("sha1")
-        .update(harvested.lastAssistantMarkdown ?? harvested.lastAssistantText ?? "")
-        .digest("hex");
-    const browser = {
-        ...(meta.browser ?? {}),
-        harvest: {
-            targetId: harvested.targetId,
-            url: harvested.url,
-            conversationId: harvested.conversationId ?? extractConversationIdFromUrl(harvested.url),
-            harvestedAt: new Date().toISOString(),
-            assistantHash: hash,
-            state: harvested.state,
-            stopExists: harvested.stopExists,
-            sendExists: harvested.sendExists,
-            assistantCount: harvested.assistantCount,
-            currentModelLabel: harvested.currentModelLabel,
-            lastAssistantSnippet: harvested.lastAssistantSnippet,
-        },
-    };
-    await sessionStore.updateSession(sessionId, { browser });
-}
-function printHarvestSummary(sessionId, harvested) {
+function printHarvestSummary(sessionId, harvested, integrity) {
     console.log(chalk.bold(`Session: ${sessionId}`));
     console.log(`Target: ${harvested.targetId}`);
     console.log(`State: ${formatBrowserTabState(harvested)}`);
     console.log(`Model: ${harvested.currentModelLabel || "(unknown)"}`);
     console.log(`URL: ${harvested.url}`);
     console.log(`Assistant turns: ${harvested.assistantCount}`);
+    console.log(`Capture identity: ${integrity.status}${integrity.explicitTarget ? " (explicit target)" : ""}`);
+    if (integrity.status === "mismatch") {
+        console.log(chalk.yellow("Explicit harvest target differs from the saved capture; original artifacts are unchanged."));
+    }
     console.log(`Signals: stop=${harvested.stopExists ? "yes" : "no"} send=${harvested.sendExists ? "yes" : "no"}`);
     if (harvested.lastUserSnippet) {
         console.log(`Last user: ${harvested.lastUserSnippet}`);
@@ -207,8 +191,8 @@ export async function harvestSessionBrowserOutput(sessionId, options = {}) {
                 stallWindowMs: options.stallWindowMs,
             });
         }
-        await persistHarvest(sessionId, meta, harvested);
-        printHarvestSummary(sessionId, harvested);
+        const integrity = await persistBrowserHarvest(sessionId, harvested, Boolean(options.browserTabRef));
+        printHarvestSummary(sessionId, harvested, integrity);
         const output = harvested.lastAssistantMarkdown ?? harvested.lastAssistantText ?? "";
         if (options.writeOutputPath) {
             await maybeWriteHarvestOutput(options.writeOutputPath, meta.cwd ?? process.cwd(), output);
@@ -216,6 +200,7 @@ export async function harvestSessionBrowserOutput(sessionId, options = {}) {
         if (!options.quietOutput && output) {
             process.stdout.write(`${output}${output.endsWith("\n") ? "" : "\n"}`);
         }
+        await completeOwnedBrowserHarvest(sessionId, harvested, integrity, (line) => console.log(line));
         return harvested;
     }
     finally {
@@ -287,8 +272,8 @@ export async function liveTailSessionBrowserOutput(sessionId, options = {}) {
                 const statusLine = `[${new Date().toISOString()}] state=${harvested.state} stop=${harvested.stopExists ? "yes" : "no"} ` +
                     `send=${harvested.sendExists ? "yes" : "no"} model=${harvested.currentModelLabel || "(unknown)"} ` +
                     `snippet=${snippet(harvested.lastAssistantSnippet || fullText, 160)}`;
+                await persistBrowserHarvest(sessionId, harvested, Boolean(options.browserTabRef));
                 console.log(statusLine);
-                await persistHarvest(sessionId, meta, harvested);
             }
             const derivedState = harvested.stopExists
                 ? Date.now() - unchangedSince >= stallThresholdMs
@@ -304,8 +289,8 @@ export async function liveTailSessionBrowserOutput(sessionId, options = {}) {
                     ...harvested,
                     state: derivedState,
                 };
-                await persistHarvest(sessionId, meta, finalHarvest);
-                printHarvestSummary(sessionId, finalHarvest);
+                const integrity = await persistBrowserHarvest(sessionId, finalHarvest, Boolean(options.browserTabRef));
+                printHarvestSummary(sessionId, finalHarvest, integrity);
                 const output = finalHarvest.lastAssistantMarkdown ?? finalHarvest.lastAssistantText ?? "";
                 if (options.writeOutputPath) {
                     await maybeWriteHarvestOutput(options.writeOutputPath, meta.cwd ?? process.cwd(), output);
@@ -313,6 +298,7 @@ export async function liveTailSessionBrowserOutput(sessionId, options = {}) {
                 if (output) {
                     process.stdout.write(`${output}${output.endsWith("\n") ? "" : "\n"}`);
                 }
+                await completeOwnedBrowserHarvest(sessionId, finalHarvest, integrity, (line) => console.log(line));
                 return finalHarvest;
             }
             await new Promise((resolve) => setTimeout(resolve, LIVE_POLL_MS));

package/dist/src/cli/detachedSession.js

@@ -0,0 +1,69 @@
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+export function resolveOracleCliEntrypoint(moduleUrl = import.meta.url) {
+    const extension = fileURLToPath(moduleUrl).endsWith(".ts") ? "ts" : "js";
+    return fileURLToPath(new URL(`../../bin/oracle-cli.${extension}`, moduleUrl));
+}
+export function buildDetachedSessionSpawnSpec({ sessionId, cliEntrypoint = resolveOracleCliEntrypoint(), env = process.env, nodeExecutable = process.execPath, }) {
+    return {
+        command: nodeExecutable,
+        args: ["--", cliEntrypoint, "--exec-session", sessionId],
+        options: {
+            detached: true,
+            stdio: ["pipe", "ignore", "ignore"],
+            env: {
+                ...env,
+                ORACLE_DETACHED_START_GATE: "1",
+            },
+            windowsHide: true,
+        },
+    };
+}
+export function launchDetachedSession({ sessionId, cliEntrypoint, env, nodeExecutable, prepare, spawnProcess = spawn, }) {
+    return new Promise((resolve, reject) => {
+        let child;
+        try {
+            const spec = buildDetachedSessionSpawnSpec({
+                sessionId,
+                cliEntrypoint,
+                env,
+                nodeExecutable,
+            });
+            child = spawnProcess(spec.command, spec.args, spec.options);
+        }
+        catch (error) {
+            reject(error);
+            return;
+        }
+        child.once("error", reject);
+        child.once("spawn", async () => {
+            if (child.pid === undefined) {
+                child.kill();
+                reject(new Error("Detached session worker started without a process ID."));
+                return;
+            }
+            try {
+                await prepare(child.pid);
+                if (!child.stdin) {
+                    throw new Error("Detached session worker started without a writable start gate.");
+                }
+                const startGate = child.stdin;
+                await new Promise((resolveGate, rejectGate) => {
+                    startGate.once("error", rejectGate);
+                    startGate.end("ready\n", (error) => {
+                        if (error)
+                            rejectGate(error);
+                        else
+                            resolveGate();
+                    });
+                });
+                child.unref();
+                resolve(child.pid);
+            }
+            catch (error) {
+                child.kill();
+                reject(error);
+            }
+        });
+    });
+}

package/dist/src/cli/dryRun.js

@@ -1,7 +1,7 @@
 import chalk from "chalk";
 import { MODEL_CONFIGS, TOKENIZER_OPTIONS, DEFAULT_SYSTEM_PROMPT, buildPrompt, readFiles, getFileTokenStats, printFileTokenStats, } from "../oracle.js";
 import { isKnownModel } from "../oracle/modelResolver.js";
-import { assembleBrowserPrompt } from "../browser/prompt.js";
+import { assembleBrowserPrompt, cleanupGeneratedBrowserBundles, } from "../browser/prompt.js";
 import { buildTokenEstimateSuffix, formatAttachmentLabel } from "../browser/promptSummary.js";
 import { buildCookiePlan } from "../browser/policies.js";
 import { describeBrowserControlPlan, formatBrowserControlPlan } from "../browser/controlPlan.js";
@@ -45,19 +45,24 @@ async function runBrowserDryRun({ runOptions, cwd, version, log, browserConfig,
     validateBrowserFollowUps(runOptions, browserConfig);
     const assemblePromptImpl = deps.assembleBrowserPromptImpl ?? assembleBrowserPrompt;
     const artifacts = await assemblePromptImpl(runOptions, { cwd });
-    const suffix = buildTokenEstimateSuffix(artifacts);
-    const displayModel = formatBrowserModelTarget({
-        model: runOptions.model,
-        desiredModel: browserConfig?.desiredModel,
-        modelStrategy: browserConfig?.modelStrategy,
-    });
-    const headerLine = `[dry-run] Oracle (${version}) would launch browser mode (${displayModel}) with ~${artifacts.estimatedInputTokens.toLocaleString()} tokens${suffix}.`;
-    log(chalk.cyan(headerLine));
-    logBrowserControlPlan(browserConfig, log, "dry-run");
-    logBrowserFollowUpSummary(runOptions.browserFollowUps, log, "dry-run");
-    logBrowserCookieStrategy(browserConfig, log, "dry-run");
-    logBrowserArchivePolicy(browserConfig, log, "dry-run");
-    logBrowserFileSummary(artifacts, log, "dry-run");
+    try {
+        const suffix = buildTokenEstimateSuffix(artifacts);
+        const displayModel = formatBrowserModelTarget({
+            model: runOptions.model,
+            desiredModel: browserConfig?.desiredModel,
+            modelStrategy: browserConfig?.modelStrategy,
+        });
+        const headerLine = `[dry-run] Oracle (${version}) would launch browser mode (${displayModel}) with ~${artifacts.estimatedInputTokens.toLocaleString()} tokens${suffix}.`;
+        log(chalk.cyan(headerLine));
+        logBrowserControlPlan(browserConfig, log, "dry-run");
+        logBrowserFollowUpSummary(runOptions.browserFollowUps, log, "dry-run");
+        logBrowserCookieStrategy(browserConfig, log, "dry-run");
+        logBrowserArchivePolicy(browserConfig, log, "dry-run");
+        logBrowserFileSummary(artifacts, log, "dry-run");
+    }
+    finally {
+        await cleanupGeneratedBrowserBundles(artifacts);
+    }
 }
 function logBrowserControlPlan(browserConfig, log, label) {
     const plan = describeBrowserControlPlan(browserConfig);
@@ -100,42 +105,47 @@ export async function runBrowserPreview({ runOptions, cwd, version, previewMode,
     validateBrowserFollowUps(runOptions, browserConfig);
     const assemblePromptImpl = deps.assembleBrowserPromptImpl ?? assembleBrowserPrompt;
     const artifacts = await assemblePromptImpl(runOptions, { cwd });
-    const suffix = buildTokenEstimateSuffix(artifacts);
-    const displayModel = formatBrowserModelTarget({
-        model: runOptions.model,
-        desiredModel: browserConfig?.desiredModel,
-        modelStrategy: browserConfig?.modelStrategy,
-    });
-    const headerLine = `[preview] Oracle (${version}) browser mode (${displayModel}) with ~${artifacts.estimatedInputTokens.toLocaleString()} tokens${suffix}.`;
-    log(chalk.cyan(headerLine));
-    logBrowserControlPlan(browserConfig, log, "preview");
-    logBrowserFollowUpSummary(runOptions.browserFollowUps, log, "preview");
-    logBrowserCookieStrategy(browserConfig, log, "preview");
-    logBrowserFileSummary(artifacts, log, "preview");
-    if (previewMode === "json" || previewMode === "full") {
-        const attachmentSummary = artifacts.attachments.map((attachment) => ({
-            path: attachment.path,
-            displayPath: attachment.displayPath,
-            sizeBytes: attachment.sizeBytes,
-        }));
-        const previewPayload = {
+    try {
+        const suffix = buildTokenEstimateSuffix(artifacts);
+        const displayModel = formatBrowserModelTarget({
             model: runOptions.model,
-            engine: "browser",
-            composerText: artifacts.composerText,
-            attachments: attachmentSummary,
-            inlineFileCount: artifacts.inlineFileCount,
-            bundled: artifacts.bundled,
-            tokenEstimate: artifacts.estimatedInputTokens,
-            browserFollowUps: runOptions.browserFollowUps ?? [],
-        };
-        log("");
-        log(chalk.bold("Preview JSON"));
-        log(JSON.stringify(previewPayload, null, 2));
+            desiredModel: browserConfig?.desiredModel,
+            modelStrategy: browserConfig?.modelStrategy,
+        });
+        const headerLine = `[preview] Oracle (${version}) browser mode (${displayModel}) with ~${artifacts.estimatedInputTokens.toLocaleString()} tokens${suffix}.`;
+        log(chalk.cyan(headerLine));
+        logBrowserControlPlan(browserConfig, log, "preview");
+        logBrowserFollowUpSummary(runOptions.browserFollowUps, log, "preview");
+        logBrowserCookieStrategy(browserConfig, log, "preview");
+        logBrowserFileSummary(artifacts, log, "preview");
+        if (previewMode === "json" || previewMode === "full") {
+            const attachmentSummary = artifacts.attachments.map((attachment) => ({
+                path: attachment.path,
+                displayPath: attachment.displayPath,
+                sizeBytes: attachment.sizeBytes,
+            }));
+            const previewPayload = {
+                model: runOptions.model,
+                engine: "browser",
+                composerText: artifacts.composerText,
+                attachments: attachmentSummary,
+                inlineFileCount: artifacts.inlineFileCount,
+                bundled: artifacts.bundled,
+                tokenEstimate: artifacts.estimatedInputTokens,
+                browserFollowUps: runOptions.browserFollowUps ?? [],
+            };
+            log("");
+            log(chalk.bold("Preview JSON"));
+            log(JSON.stringify(previewPayload, null, 2));
+        }
+        if (previewMode === "full") {
+            log("");
+            log(chalk.bold("Composer Text"));
+            log(artifacts.composerText || chalk.dim("(empty prompt)"));
+        }
     }
-    if (previewMode === "full") {
-        log("");
-        log(chalk.bold("Composer Text"));
-        log(artifacts.composerText || chalk.dim("(empty prompt)"));
+    finally {
+        await cleanupGeneratedBrowserBundles(artifacts);
     }
 }
 function logBrowserFollowUpSummary(followUps, log, label) {

package/dist/src/cli/harvestIntegrity.js

@@ -0,0 +1,140 @@
+import fs from "node:fs/promises";
+import { constants } from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { sessionStore } from "../sessionStore.js";
+import { extractConversationIdFromUrl } from "../browser/liveTabs.js";
+import { BrowserAutomationError } from "../oracle/errors.js";
+const INTEGRITY_WARNING = "browser-harvest-integrity";
+const INTEGRITY_MESSAGE = "Harvest or saved conversation identities conflict. Original artifacts were preserved; inspect browser.harvest.integrity before using the answer.";
+async function readTranscriptConversation(filename) {
+    let file;
+    try {
+        const stat = await fs.lstat(filename);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            return undefined;
+        file = await fs.open(filename, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        if (!(await file.stat()).isFile())
+            return undefined;
+        const buffer = Buffer.alloc(2_048);
+        const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+        const match = buffer
+            .subarray(0, bytesRead)
+            .toString("utf8")
+            .match(/^# Oracle Browser Transcript\r?\n\r?\nConversation: ([^\r\n]+)\r?\n/);
+        return match ? extractConversationIdFromUrl(match[1]) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        await file?.close();
+    }
+}
+export async function persistBrowserHarvest(sessionId, harvested, explicitTarget = false) {
+    // Harvesting can take time; compare against the latest saved capture, not the initial read.
+    const meta = await sessionStore.readSession(sessionId);
+    if (!meta)
+        throw new Error(`No session found with ID ${sessionId}.`);
+    const captured = [];
+    const unverifiedSources = [];
+    const add = (source, id) => {
+        if (id)
+            captured.push({ source, conversationId: id });
+    };
+    const addUrl = (source, url, expectsConversation = true) => {
+        if (!url)
+            return;
+        const id = extractConversationIdFromUrl(url);
+        add(source, id);
+        if (!id && expectsConversation)
+            unverifiedSources.push(source);
+    };
+    add("runtime", meta.browser?.runtime?.conversationId);
+    addUrl("runtime-url", meta.browser?.runtime?.tabUrl);
+    addUrl("archive", meta.browser?.archive?.conversationUrl);
+    for (const [index, artifact] of (meta.artifacts ?? []).entries()) {
+        addUrl(`artifact:${index}`, artifact.sourceUrl, artifact.kind === "transcript" || artifact.kind === "deep-research-report");
+    }
+    const artifactDir = path.join((await sessionStore.getPaths(sessionId)).dir, "artifacts");
+    const directoryStat = await fs.lstat(artifactDir).catch(() => null);
+    if (directoryStat?.isDirectory() && !directoryStat.isSymbolicLink()) {
+        const transcripts = new Map([[path.join(artifactDir, "transcript.md"), false]]);
+        for (const artifact of meta.artifacts ?? []) {
+            if (artifact.kind !== "transcript")
+                continue;
+            const candidate = path.isAbsolute(artifact.path)
+                ? artifact.path
+                : path.resolve(artifactDir, "..", artifact.path);
+            // Stored paths must remain direct children of this session's artifact directory.
+            if (path.dirname(candidate) === artifactDir)
+                transcripts.set(candidate, true);
+            else
+                unverifiedSources.push("external-transcript-path");
+        }
+        for (const [filename, expected] of transcripts) {
+            const source = `transcript:${path.basename(filename)}`;
+            const id = await readTranscriptConversation(filename);
+            add(source, id);
+            if (!id && (expected || (await fs.lstat(filename).catch(() => null)))) {
+                unverifiedSources.push(source);
+            }
+        }
+    }
+    else if (directoryStat || meta.artifacts?.some((artifact) => artifact.kind === "transcript")) {
+        unverifiedSources.push("artifact-directory");
+    }
+    const observedConversationId = harvested.conversationId ?? extractConversationIdFromUrl(harvested.url);
+    const capturedIds = new Set(captured.map((entry) => entry.conversationId));
+    const previousIntegrity = meta.browser?.harvest?.integrity;
+    const mismatch = capturedIds.size > 1 ||
+        (observedConversationId
+            ? captured.some((entry) => entry.conversationId !== observedConversationId)
+            : previousIntegrity?.status === "mismatch");
+    const integrity = {
+        status: mismatch
+            ? "mismatch"
+            : observedConversationId && captured.length && unverifiedSources.length === 0
+                ? "matched"
+                : "unverified",
+        observedConversationId,
+        captured,
+        unverifiedSources,
+        explicitTarget,
+        previousHarvestConversationId: meta.browser?.harvest?.conversationId ?? previousIntegrity?.previousHarvestConversationId,
+    };
+    const warnings = (meta.browser?.warnings ?? []).filter((warning) => warning.code !== INTEGRITY_WARNING);
+    if (mismatch) {
+        warnings.push({ code: INTEGRITY_WARNING, severity: "warning", message: INTEGRITY_MESSAGE });
+    }
+    await sessionStore.updateSession(sessionId, {
+        browser: {
+            ...meta.browser,
+            warnings,
+            harvest: {
+                targetId: harvested.targetId,
+                url: harvested.url,
+                conversationId: observedConversationId,
+                harvestedAt: new Date().toISOString(),
+                assistantHash: createHash("sha1")
+                    .update(harvested.lastAssistantMarkdown ?? harvested.lastAssistantText ?? "")
+                    .digest("hex"),
+                state: harvested.state,
+                stopExists: harvested.stopExists,
+                sendExists: harvested.sendExists,
+                assistantCount: harvested.assistantCount,
+                currentModelLabel: harvested.currentModelLabel,
+                lastAssistantSnippet: harvested.lastAssistantSnippet,
+                integrity,
+            },
+        },
+    });
+    if (mismatch && !explicitTarget) {
+        throw new BrowserAutomationError(INTEGRITY_MESSAGE, {
+            stage: "harvest-integrity",
+            code: "conversation-identity-mismatch",
+            integrity,
+        });
+    }
+    return integrity;
+}

package/dist/src/cli/options.js

@@ -1,3 +1,4 @@
+import { isGpt6Alias, isGpt6ProAlias } from "./browserConfig.js";
 import { InvalidArgumentError } from "commander";
 import { parseDuration } from "../duration.js";
 import path from "node:path";
@@ -187,6 +188,12 @@ export function resolveApiModel(modelValue) {
     if (normalized.includes("/")) {
         return normalized;
     }
+    if (isGpt6ProAlias(normalized)) {
+        throw new InvalidArgumentError("GPT-6 Pro is an API reasoning mode, not a model slug. Use --model gpt-6-astra --reasoning-mode pro (or --engine browser --model gpt-6-pro).");
+    }
+    if (isGpt6Alias(normalized)) {
+        return "gpt-6-astra";
+    }
     const gpt56Label = parseBrowserGpt56Label(normalized);
     if (gpt56Label?.variant.split(" ").includes("pro")) {
         throw new InvalidArgumentError("GPT-5.6 Pro is an API reasoning mode, not a model slug. Use --model gpt-5.6-sol --reasoning-mode pro.");
@@ -284,6 +291,14 @@ export function inferModelFromLabel(modelValue) {
     if (normalized.includes("/")) {
         return normalized;
     }
+    // gpt-6 / gpt-6-pro / latest: ChatGPT's "Latest" model (GPT-6 Astra). The browser-only -pro alias
+    // is passed through so its Pro tier default survives (resolveDefaultBrowserThinkingTime).
+    if (isGpt6ProAlias(normalized)) {
+        return "gpt-6-pro";
+    }
+    if (isGpt6Alias(normalized)) {
+        return "gpt-6-astra";
+    }
     if (normalized.includes("grok")) {
         return "grok-4.1";
     }