@steipete/oracle 0.18.0 → 0.19.0

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,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/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),
+    };
+}

package/dist/src/cli/sessionDisplay.js

@@ -12,7 +12,7 @@ import { estimateTokenCount } from "../browser/utils.js";
 import { formatSessionTableHeader, formatSessionTableRow, resolveSessionCost, } from "./sessionTable.js";
 import { abbreviateResponseId, buildResponseOwnerIndex, resolveSessionLineage, } from "./sessionLineage.js";
 import { formatSessionExecutionLabel } from "./sessionLifecycle.js";
-import { formatBrowserModelSelectionEvidence, formatSessionBrowserModelWithRequestedKey, resolveSessionBrowserModelDisplayName, } from "../browser/modelDisplay.js";
+import { formatBrowserModelSelectionEvidence, formatBrowserThinkingSelectionEvidence, formatSessionBrowserModelWithRequestedKey, resolveSessionBrowserModelDisplayName, } from "../browser/modelDisplay.js";
 const isTty = () => Boolean(process.stdout.isTTY);
 const dim = (text) => (isTty() ? kleur.dim(text) : text);
 export const MAX_RENDER_BYTES = 200_000;
@@ -255,6 +255,7 @@ export async function attachSession(sessionId, options) {
                     config: metadata.browser?.config,
                     runtime,
                     modelSelection: metadata.browser?.modelSelection,
+                    thinkingSelection: metadata.browser?.thinkingSelection,
                     warnings: metadata.browser?.warnings,
                 },
                 artifacts,
@@ -603,7 +604,9 @@ export function formatUserErrorMetadata(metadata) {
 }
 export function formatBrowserEvidence(metadata) {
     const browser = metadata.browser;
-    if (!browser?.modelSelection && (!browser?.warnings || browser.warnings.length === 0)) {
+    if (!browser?.modelSelection &&
+        !browser?.thinkingSelection &&
+        (!browser?.warnings || browser.warnings.length === 0)) {
         return null;
     }
     const lines = [];
@@ -611,6 +614,10 @@ export function formatBrowserEvidence(metadata) {
     if (evidence) {
         lines.push(`model ${formatBrowserModelSelectionEvidence(evidence, metadata.model)}`);
     }
+    const thinkingEvidence = browser.thinkingSelection;
+    if (thinkingEvidence) {
+        lines.push(`effort ${formatBrowserThinkingSelectionEvidence(thinkingEvidence)}`);
+    }
     for (const warning of browser.warnings ?? []) {
         lines.push(`warning ${warning.code}: ${warning.message}`);
     }

package/dist/src/cli/sessionRunner.js

@@ -1,4 +1,5 @@
 import kleur from "kleur";
+import { constants as fsConstants } from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { runOracle, OracleResponseError, OracleTransportError, extractResponseMetadata, asOracleUserError, extractTextOutput, classifyProviderFailure, } from "../oracle.js";
@@ -23,6 +24,7 @@ import { cwd as getCwd } from "node:process";
 import { resumeBrowserSession } from "../browser/reattach.js";
 import { hasRecoverableChatGptConversation } from "../browser/reattachability.js";
 import { estimateTokenCount } from "../browser/utils.js";
+import { computeFileSha256, sanitizeArtifactFilename } from "../browser/artifacts.js";
 import { formatElapsed } from "../oracle/format.js";
 import { formatBrowserReattachGuidance } from "./reattachGuidance.js";
 const isTty = process.stdout.isTTY;
@@ -78,7 +80,13 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 cwd,
                 log,
             }, runnerDeps);
-            await writeAssistantOutput(runOptions.writeOutputPath, result.answerText ?? "", log);
+            const writtenOutputPath = await writeAssistantOutput(runOptions.writeOutputPath, result.answerText ?? "", log);
+            const outputArtifacts = await copyBrowserOutputArtifacts({
+                outputPath: writtenOutputPath,
+                savedFiles: runOptions.writeArtifacts ? result.savedFiles : undefined,
+                log,
+            });
+            const browserWarnings = [...(result.warnings ?? []), ...outputArtifacts.warnings];
             await sendSessionNotification({
                 sessionId: sessionMeta.id,
                 sessionName: sessionMeta.options?.slug ?? sessionMeta.id,
@@ -105,9 +113,10 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                     runtime: result.runtime,
                     archive: result.archive,
                     modelSelection: result.modelSelection,
-                    warnings: result.warnings,
+                    thinkingSelection: result.thinkingSelection,
+                    warnings: browserWarnings.length > 0 ? browserWarnings : undefined,
                 },
-                artifacts: mergeArtifacts(sessionMeta.artifacts, result.artifacts),
+                artifacts: mergeArtifacts(sessionMeta.artifacts, mergeArtifacts(result.artifacts, outputArtifacts.artifacts)),
                 response: undefined,
                 transport: undefined,
                 error: undefined,
@@ -848,6 +857,81 @@ function resolveSessionPath(sessionDir, targetPath) {
     }
     return path.join(sessionDir, targetPath);
 }
+async function copyBrowserOutputArtifacts(params) {
+    const artifacts = [];
+    const warnings = [];
+    if (!params.outputPath || !params.savedFiles?.length) {
+        return { artifacts, warnings };
+    }
+    const outputDir = path.dirname(params.outputPath);
+    for (const savedFile of params.savedFiles) {
+        const filename = sanitizeArtifactFilename(savedFile.filename ?? path.basename(savedFile.path), "artifact.bin");
+        let copied;
+        try {
+            copied = await copyFileWithoutOverwrite(savedFile.path, path.join(outputDir, filename));
+            const [stat, sha256] = await Promise.all([fs.stat(copied), computeFileSha256(copied)]);
+            if (savedFile.sizeBytes != null && stat.size !== savedFile.sizeBytes) {
+                throw new Error(`size mismatch (expected ${savedFile.sizeBytes}, received ${stat.size})`);
+            }
+            if (savedFile.sha256 && sha256 !== savedFile.sha256) {
+                throw new Error(`sha256 mismatch (expected ${savedFile.sha256}, received ${sha256})`);
+            }
+            const artifact = {
+                kind: "file",
+                path: copied,
+                label: `${savedFile.label ?? filename} (write-output)`,
+                mimeType: savedFile.mimeType,
+                sizeBytes: stat.size,
+                sourceUrl: savedFile.sourceUrl,
+                sha256,
+                validation: savedFile.validation,
+                transfer: { status: "not-needed" },
+                origin: { mode: "local" },
+            };
+            artifacts.push(artifact);
+            params.log(dim(`[browser] Saved write-output file artifact to ${copied} sha256=${sha256}`));
+        }
+        catch (error) {
+            if (copied) {
+                await fs.unlink(copied).catch(() => undefined);
+            }
+            const reason = error instanceof Error ? error.message : String(error);
+            const message = `Failed to copy saved file artifact ${savedFile.path} beside ${params.outputPath}: ${reason}`;
+            params.log(dim(`[browser] ${message}`));
+            warnings.push({
+                code: "browser-output-artifact-copy-failed",
+                severity: "warning",
+                message,
+                details: {
+                    sourcePath: savedFile.path,
+                    outputPath: params.outputPath,
+                    sha256: savedFile.sha256,
+                },
+            });
+        }
+    }
+    return { artifacts, warnings };
+}
+async function copyFileWithoutOverwrite(sourcePath, baseTargetPath) {
+    const ext = path.extname(baseTargetPath);
+    const stem = ext ? path.basename(baseTargetPath, ext) : path.basename(baseTargetPath);
+    const dir = path.dirname(baseTargetPath);
+    let suffix = 1;
+    for (;;) {
+        const targetPath = suffix === 1 ? baseTargetPath : path.join(dir, `${stem}-${suffix}${ext}`);
+        try {
+            await fs.copyFile(sourcePath, targetPath, fsConstants.COPYFILE_EXCL);
+            return targetPath;
+        }
+        catch (error) {
+            if (isErrorCode(error, "EEXIST")) {
+                suffix += 1;
+                continue;
+            }
+            throw error;
+        }
+    }
+}
 async function writeAssistantOutput(targetPath, content, log) {
     if (!targetPath)
         return;
@@ -1057,11 +1141,11 @@ export function deriveModelOutputPath(basePath, model) {
     const suffix = ext.length > 0 ? `${stem}.${model}${ext}` : `${stem}.${model}`;
     return path.join(dir, suffix);
 }
+function isErrorCode(error, expected) {
+    return error instanceof Error && error.code === expected;
+}
 function isPermissionError(error) {
-    if (!(error instanceof Error))
-        return false;
-    const code = error.code;
-    return code === "EACCES" || code === "EPERM";
+    return isErrorCode(error, "EACCES") || isErrorCode(error, "EPERM");
 }
 function buildFallbackPath(original) {
     const ext = path.extname(original);

package/dist/src/config.js

@@ -135,6 +135,7 @@ function sanitizeProjectConfig(config) {
             "attachRunning",
             "timeoutMs",
             "inputTimeoutMs",
+            "approvalWaitMs",
             "attachmentTimeoutMs",
             "assistantRecheckDelayMs",
             "assistantRecheckTimeoutMs",