@steipete/oracle 0.17.3 → 0.19.0

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;
@@ -13,6 +14,12 @@ const DEFAULT_BROWSER_ATTACHMENT_TIMEOUT_MS = 45_000;
 const DEFAULT_BROWSER_RECHECK_TIMEOUT_MS = 120_000;
 const DEFAULT_BROWSER_AUTO_REATTACH_TIMEOUT_MS = 120_000;
 const DEFAULT_CHROME_PROFILE = "Default";
+const CURRENT_CHATGPT_PRO_ALIASES = new Set([
+    "gpt-5-pro",
+    "gpt-5.1-pro",
+    "gpt-5.2-pro",
+    "gpt-5.4-pro",
+]);
 // Ordered array: most specific models first to ensure correct selection.
 // The browser label is passed to the model picker which fuzzy-matches against ChatGPT's UI.
 const BROWSER_MODEL_LABELS = [
@@ -52,11 +59,8 @@ export function normalizeChatGptModelForBrowser(model) {
         return normalized;
     }
     // Pro variants: resolve to the latest Pro model in ChatGPT.
-    if (normalized === "gpt-5-pro" ||
-        normalized === "gpt-5.1-pro" ||
-        normalized === "gpt-5.2-pro" ||
-        normalized === "gpt-5.4-pro") {
-        return "gpt-5.5-pro";
+    if (isCurrentChatGptProAlias(normalized)) {
+        return "gpt-5.6-sol";
     }
     // Explicit model variants: keep as-is (they have their own browser labels)
     if (normalized === "gpt-5.2-thinking" || normalized === "gpt-5.2-instant") {
@@ -68,6 +72,18 @@ export function normalizeChatGptModelForBrowser(model) {
     }
     return model;
 }
+export function isCurrentChatGptProAlias(model) {
+    return CURRENT_CHATGPT_PRO_ALIASES.has(model?.trim().toLowerCase() ?? "");
+}
+export function resolveDefaultBrowserThinkingTime({ model, requestedModel, modelStrategy, }) {
+    const strategy = normalizeBrowserModelStrategy(modelStrategy) ?? DEFAULT_MODEL_STRATEGY;
+    if (strategy !== "select")
+        return undefined;
+    const normalizedModel = normalizeChatGptModelForBrowser(model);
+    return isCurrentChatGptProAlias(requestedModel ?? model) || normalizedModel === "gpt-5.5-pro"
+        ? "pro"
+        : undefined;
+}
 export async function buildBrowserConfig(options) {
     if (options.copyProfile && options.browserKeepBrowser) {
         throw new Error("--copy-profile cannot be combined with --browser-keep-browser: the copied profile is a throwaway that is deleted after the run, so it must not be retained.");
@@ -85,11 +101,14 @@ export async function buildBrowserConfig(options) {
     const normalizedOverride = desiredModelOverride?.toLowerCase() ?? "";
     const baseModel = options.model.toLowerCase();
     const isChatGptModel = baseModel.startsWith("gpt-") && !baseModel.includes("codex");
-    const normalizedBrowserModel = normalizeChatGptModelForBrowser(options.model);
     const shouldUseOverride = !isChatGptModel && normalizedOverride.length > 0 && normalizedOverride !== baseModel;
     const modelStrategy = normalizeBrowserModelStrategy(options.browserModelStrategy) ?? DEFAULT_MODEL_STRATEGY;
     const thinkingTime = normalizeThinkingTimeLevel(options.browserThinkingTime) ??
-        (modelStrategy === "select" && normalizedBrowserModel === "gpt-5.5-pro" ? "pro" : undefined);
+        resolveDefaultBrowserThinkingTime({
+            model: options.model,
+            requestedModel: options.browserRequestedModel,
+            modelStrategy,
+        });
     assertBrowserModelAvailable(options.model, modelStrategy);
     const cookieNames = parseCookieNames(options.browserCookieNames ?? process.env.ORACLE_BROWSER_COOKIE_NAMES);
     let inline = await resolveInlineCookies({
@@ -99,7 +118,9 @@ export async function buildBrowserConfig(options) {
         envFile: process.env.ORACLE_BROWSER_COOKIES_FILE,
         cwd: process.cwd(),
     });
-    if (inline?.source?.startsWith("home:") && options.browserNoCookieSync !== true) {
+    const chromeCookieSyncRequested = options.browserNoCookieSync !== true &&
+        (options.browserCookieSync === true || options.browserManualLoginCookieSync === true);
+    if (inline?.source?.startsWith("home:") && chromeCookieSyncRequested) {
         inline = undefined;
     }
     let remoteChrome;
@@ -133,6 +154,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,
@@ -161,11 +183,13 @@ export async function buildBrowserConfig(options) {
         cookieSyncWaitMs: options.browserCookieWait
             ? parseBrowserDuration(options.browserCookieWait, "--browser-cookie-wait", 0)
             : undefined,
-        cookieSync: options.browserNoCookieSync
-            ? false
-            : options.browserManualLoginCookieSync === true
-                ? true
-                : undefined,
+        cookieSync: inline?.cookies?.length
+            ? true
+            : options.browserNoCookieSync
+                ? false
+                : options.browserCookieSync === true || options.browserManualLoginCookieSync === true
+                    ? true
+                    : undefined,
         cookieNames,
         inlineCookies: inline?.cookies,
         inlineCookiesSource: inline?.source ?? null,
@@ -173,7 +197,7 @@ export async function buildBrowserConfig(options) {
         keepBrowser: options.browserKeepBrowser ? true : undefined,
         manualLogin: options.browserManualLogin === undefined ? undefined : options.browserManualLogin,
         manualLoginProfileDir: options.browserManualLoginProfileDir ?? undefined,
-        manualLoginCookieSync: options.browserManualLoginCookieSync,
+        manualLoginCookieSync: inline?.cookies?.length ? true : options.browserManualLoginCookieSync,
         copyProfileSource: options.copyProfile ?? undefined,
         hideWindow: options.browserHideWindow ? true : undefined,
         desiredModel,
@@ -206,6 +230,7 @@ function validateAttachRunningOptions(options, { attachRunning, hasInlineCookies
     const conflicts = [
         options.browserChromeProfile ? "--browser-chrome-profile" : null,
         options.browserCookiePath ? "--browser-cookie-path" : null,
+        options.browserCookieSync ? "--browser-cookie-sync" : null,
         options.browserNoCookieSync ? "--browser-no-cookie-sync" : null,
         options.browserHeadless ? "--browser-headless" : null,
         options.browserHideWindow ? "--browser-hide-window" : null,
@@ -268,7 +293,7 @@ export function resolveBrowserModelLabel(input, 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);
     }
@@ -76,6 +86,9 @@ export function applyBrowserDefaultsFromConfig(options, config, getSource) {
     if (isUnset("browserCookieWait") && typeof browser.cookieSyncWaitMs === "number") {
         options.browserCookieWait = String(browser.cookieSyncWaitMs);
     }
+    if (!attachRunningRequested && isUnset("browserCookieSync") && browser.cookieSync !== undefined) {
+        options.browserCookieSync = browser.cookieSync;
+    }
     if (!attachRunningRequested && isUnset("browserHeadless") && browser.headless !== undefined) {
         options.browserHeadless = browser.headless;
     }

package/dist/src/cli/browserTabs.js

@@ -2,9 +2,10 @@ 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";
 const LIVE_POLL_MS = 2000;
 const DEFAULT_STALL_THRESHOLD_MS = 60_000;
 function isRecoverableMissingTabError(message) {
@@ -85,35 +86,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 +190,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);
@@ -287,8 +270,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 +287,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);

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,41 +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");
-    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/projectSources.js

@@ -74,9 +74,11 @@ export async function buildProjectSourcesBrowserConfig({ options, projectUrl, co
     const manualLoginCookieSync = flagConfig.manualLoginCookieSync ?? configuredBrowser.manualLoginCookieSync;
     const cookieSync = flagConfig.cookieSync === false
         ? false
-        : manualLogin
-            ? manualLoginCookieSync === true
-            : configuredBrowser.cookieSync;
+        : flagConfig.cookieSync === true
+            ? true
+            : manualLogin
+                ? manualLoginCookieSync === true
+                : configuredBrowser.cookieSync === true;
     return {
         ...configuredBrowser,
         ...flagConfig,

package/dist/src/cli/serveBrowserConfig.js

@@ -0,0 +1,24 @@
+import { resolveBrowserApprovalWait } from "../browser/config.js";
+import { parseRemoteChromeTarget } from "./browserConfig.js";
+import { applyBrowserDefaultsFromConfig } from "./browserDefaults.js";
+export function buildServeBrowserConfig(options, config) {
+    const flags = {
+        browserAttachRunning: options.browserAttachRunning,
+        remoteChrome: options.remoteChrome,
+        browserApprovalWait: options.browserApprovalWait ??
+            (process.env.ORACLE_BROWSER_APPROVAL_WAIT?.trim() || undefined),
+    };
+    const browser = config.browser;
+    applyBrowserDefaultsFromConfig(flags, {
+        browser: {
+            attachRunning: browser?.attachRunning,
+            remoteChrome: browser?.remoteChrome,
+            approvalWaitMs: browser?.approvalWaitMs,
+        },
+    }, (key) => (flags[key] === undefined ? undefined : "cli"));
+    return {
+        attachRunning: flags.browserAttachRunning ?? false,
+        remoteChrome: flags.remoteChrome ? parseRemoteChromeTarget(flags.remoteChrome) : null,
+        approvalWaitMs: resolveBrowserApprovalWait(flags.browserApprovalWait),
+    };
+}