@steipete/oracle 0.19.0 → 0.20.1

package/dist/src/browser/tabLeaseRegistry.js

@@ -4,6 +4,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { lstat, mkdir, readFile, realpath, rename, rm, rmdir, stat, writeFile, } from "node:fs/promises";
 import { isProcessAlive, readProcessStartTimeMs } from "./profileState.js";
 import { delay } from "./utils.js";
+import { normalizeChromeHost } from "./targetClaim.js";
 export const DEFAULT_MAX_CONCURRENT_CHATGPT_TABS = 3;
 const REGISTRY_FILENAME = "oracle-tab-leases.json";
 const REGISTRY_LOCK_DIRNAME = "oracle-tab-leases.lock";
@@ -187,6 +188,25 @@ export async function hasOtherActiveBrowserTabLeases(profileDir, leaseId, option
         return active.some((lease) => lease.id !== leaseId);
     });
 }
+export async function hasActiveBrowserTargetLease(profileDir, target) {
+    let raw;
+    try {
+        raw = await readFile(path.join(profileDir, REGISTRY_FILENAME), "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+    const registry = JSON.parse(raw);
+    if (registry.version !== 1 || !Array.isArray(registry.leases))
+        throw new Error("Unknown browser lease registry");
+    return registry.leases.some((lease) => lease.chromeTargetId === target.targetId &&
+        (!lease.chromeHost ||
+            normalizeChromeHost(lease.chromeHost) === normalizeChromeHost(target.host)) &&
+        (!lease.chromePort || lease.chromePort === target.port) &&
+        isProcessAlive(lease.pid));
+}
 async function withRegistryLock(profileDir, callback, signal) {
     const lockDir = path.join(profileDir, REGISTRY_LOCK_DIRNAME);
     const lockId = randomUUID();

package/dist/src/browser/targetClaim.js

@@ -0,0 +1,54 @@
+import { isIP } from "node:net";
+import { STOP_BUTTON_SELECTORS } from "./constants.js";
+export function normalizeChromeHost(host) {
+    const value = host
+        .trim()
+        .toLowerCase()
+        .replace(/^\[|\]$/g, "");
+    return value === "localhost" || value === "::1" || (isIP(value) === 4 && value.startsWith("127."))
+        ? "loopback"
+        : value;
+}
+export function buildTargetClaimExpression(claimId) {
+    return `(() => {
+    if (window !== window.top) return true;
+    try {
+      const claim = JSON.parse(sessionStorage.getItem('oracle:target-claim') || 'null');
+      if (claim?.retiring) return false;
+      sessionStorage.setItem('oracle:target-claim', JSON.stringify({ id: ${JSON.stringify(claimId)}, retiring: false }));
+      return true;
+    } catch { return false; }
+  })()`;
+}
+export function buildTargetRetirementExpression(claimId, conversationId, reservationId, options = {}) {
+    return `(() => {
+    let claim;
+    try { claim = JSON.parse(sessionStorage.getItem('oracle:target-claim') || 'null'); } catch { return false; }
+    if (!claim || claim.id !== ${JSON.stringify(claimId)} || claim.retiring) return false;
+    const id = location.pathname.match(/\\/c\\/([^/]+)/)?.[1];
+    if (id !== ${JSON.stringify(conversationId)}) return false;
+    const generating = Array.from(document.querySelectorAll(${JSON.stringify(STOP_BUTTON_SELECTORS.join(","))})).some(node => node.getBoundingClientRect().width > 0 && node.getBoundingClientRect().height > 0);
+    if (generating && !${JSON.stringify(options.allowGenerating === true)}) return false;
+    claim.retiring = true;
+    claim.retirementId = ${JSON.stringify(reservationId)};
+    try { sessionStorage.setItem('oracle:target-claim', JSON.stringify(claim)); } catch { return false; }
+    return true;
+  })()`;
+}
+export function buildTargetRetirementRollbackExpression(claimId, reservationId) {
+    return `(() => { try {
+    const claim = JSON.parse(sessionStorage.getItem('oracle:target-claim') || 'null');
+    if (claim?.id === ${JSON.stringify(claimId)} && claim.retirementId === ${JSON.stringify(reservationId)}) {
+      claim.retiring = false;
+      delete claim.retirementId;
+      sessionStorage.setItem('oracle:target-claim', JSON.stringify(claim));
+    }
+  } catch {} })()`;
+}
+/** Per-tab storage survives document replacement and serializes acquisition with retirement. */
+export async function claimBrowserTarget(runtime, claimId) {
+    const source = buildTargetClaimExpression(claimId);
+    const claim = await runtime.evaluate({ expression: source, returnByValue: true });
+    if (claim.exceptionDetails || claim.result?.value !== true)
+        throw new Error("This Oracle tab is being retired after recovery; choose another browser tab.");
+}

package/dist/src/cli/browserConfig.js

@@ -24,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"],
@@ -47,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;
     }
@@ -72,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() ?? "");
 }
@@ -80,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;
 }
@@ -208,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,
     };
 }
@@ -288,7 +316,9 @@ 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;

package/dist/src/cli/browserDefaults.js

@@ -1,6 +1,7 @@
 import { CHATGPT_URL } from "../browser/constants.js";
 import { normalizeChatgptUrl } from "../browser/utils.js";
 import { normalizeThinkingTimeLevel } from "../oracle/thinkingTime.js";
+import { isGpt6ProAlias } from "./browserConfig.js";
 export function applyBrowserDefaultsFromConfig(options, config, getSource) {
     const browser = config.browser;
     if (!browser)
@@ -12,6 +13,7 @@ export function applyBrowserDefaultsFromConfig(options, config, getSource) {
     const attachRunningRequested = options.browserAttachRunning === true ||
         (isUnset("browserAttachRunning") && browser.attachRunning === true);
     const currentModelRequestedByCli = options.browserModelStrategy === "current" && getSource("browserModelStrategy") === "cli";
+    const gpt6ProRequestedByCli = getSource("model") === "cli" && isGpt6ProAlias(options.model);
     if (!options.copyProfile &&
         isUnset("remoteChrome") &&
         options.remoteChrome === undefined &&
@@ -104,6 +106,7 @@ export function applyBrowserDefaultsFromConfig(options, config, getSource) {
         options.browserModelStrategy = browser.modelStrategy;
     }
     if (!currentModelRequestedByCli &&
+        !gpt6ProRequestedByCli &&
         isUnset("browserThinkingTime") &&
         browser.thinkingTime !== undefined) {
         options.browserThinkingTime = normalizeThinkingTimeLevel(browser.thinkingTime) ?? undefined;

package/dist/src/cli/browserTabs.js

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

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

package/dist/src/cli/detachedSession.js

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

package/dist/src/cli/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";
     }

package/dist/src/cli/recoveredBrowserHarvest.js

@@ -0,0 +1,50 @@
+import fs from "node:fs/promises";
+import { sessionStore } from "../sessionStore.js";
+import { isRecoveredConversationHarvestReady } from "../browser/recoverConversation.js";
+import { hasOtherLiveBrowserController, matchesOwnedRecoveryTarget, retireRecoveredBrowserTarget, } from "../browser/recoveryTarget.js";
+import { extractConversationIdFromUrl } from "../browser/reattachHelpers.js";
+import { estimateTokenCount } from "../browser/utils.js";
+export async function completeOwnedBrowserHarvest(sessionId, harvested, integrity, logger) {
+    if (harvested.state !== "completed" ||
+        harvested.stopExists ||
+        integrity.status !== "matched" ||
+        integrity.explicitTarget)
+        return;
+    const metadata = await sessionStore.readSession(sessionId);
+    if (!metadata?.browser?.runtime?.ownedRecoveryTarget ||
+        !isRecoveredConversationHarvestReady(harvested))
+        return;
+    const runtime = metadata.browser?.runtime;
+    const capture = {
+        host: harvested.host ?? "",
+        port: harvested.port ?? 0,
+        targetId: harvested.targetId,
+        browserWSEndpoint: runtime?.chromeBrowserWSEndpoint,
+        conversationId: harvested.conversationId ?? extractConversationIdFromUrl(harvested.url),
+    };
+    if (hasOtherLiveBrowserController(metadata) || !matchesOwnedRecoveryTarget(metadata, capture))
+        return;
+    // Harvest previously persisted only a snippet/hash. Save the full answer before retirement.
+    const answer = harvested.lastAssistantMarkdown || harvested.lastAssistantText;
+    const paths = await sessionStore.getPaths(sessionId);
+    await fs.appendFile(paths.log, `[reattach] harvested assistant response from existing Chrome tab\nAnswer:\n${answer}\n`, "utf8");
+    const outputTokens = estimateTokenCount(answer);
+    const usage = { inputTokens: 0, outputTokens, reasoningTokens: 0, totalTokens: outputTokens };
+    if (metadata.model) {
+        await sessionStore.updateModelRun(sessionId, metadata.model, {
+            status: "completed",
+            completedAt: new Date().toISOString(),
+            usage,
+        });
+    }
+    await sessionStore.updateSession(sessionId, {
+        status: "completed",
+        completedAt: new Date().toISOString(),
+        usage,
+        errorMessage: undefined,
+        error: undefined,
+        transport: undefined,
+        response: { status: "completed" },
+    });
+    await retireRecoveredBrowserTarget(sessionId, capture, logger);
+}

package/dist/src/cli/runOptions.js

@@ -4,7 +4,7 @@ import { normalizeModelOption, inferModelFromLabel, resolveApiModel, normalizeBa
 import { resolveGeminiModelId } from "../oracle/gemini.js";
 import { resolveOverriddenApiModel } from "../oracle/modelResolver.js";
 import { PromptValidationError } from "../oracle/errors.js";
-import { normalizeChatGptModelForBrowser } from "./browserConfig.js";
+import { normalizeChatGptModelForBrowser, isGpt6ProAlias } from "./browserConfig.js";
 import { resolveConfiguredMaxFileSizeBytes } from "./fileSize.js";
 import { isAzureOpenAICandidateModel } from "../oracle/providerRouting.js";
 export function resolveRunOptionsFromConfig({ prompt, files = [], model, models, engine, userConfig, env = process.env, }) {
@@ -24,7 +24,10 @@ export function resolveRunOptionsFromConfig({ prompt, files = [], model, models,
         .map((entry) => normalizeModelOption(entry))
         .filter(Boolean);
     const cliModelArg = normalizeModelOption(model ?? userConfig?.model) || DEFAULT_MODEL;
-    const apiModel = resolveApiModel(cliModelArg);
+    const isGpt6Pro = isGpt6ProAlias(cliModelArg);
+    const apiModel = isGpt6Pro && (resolvedEngine === "browser" || browserEngineRequested)
+        ? "gpt-6-pro"
+        : resolveApiModel(cliModelArg);
     // Browser label inference is intentionally engine-scoped: API model ids such as
     // gpt-5.6-luna must remain provider values even though browser mode rejects
     // unrecognized GPT-5.6 picker variants.
@@ -36,9 +39,11 @@ export function resolveRunOptionsFromConfig({ prompt, files = [], model, models,
     const isGrok = apiModel.startsWith("grok");
     const engineWasBrowser = resolvedEngine === "browser";
     const allModels = normalizedRequestedModels.length > 0
-        ? Array.from(new Set(normalizedRequestedModels.map((entry) => resolveApiModel(entry))))
+        ? Array.from(new Set(normalizedRequestedModels.map((entry) => isGpt6ProAlias(entry) && (resolvedEngine === "browser" || browserEngineRequested)
+            ? "gpt-6-pro"
+            : resolveApiModel(entry))))
         : [apiModel];
-    const browserCompatibilityModels = normalizedRequestedModels.length > 0 ? allModels : [browserModel];
+    const browserCompatibilityModels = normalizedRequestedModels.length > 0 ? allModels : [browserModel ?? apiModel];
     const isBrowserCompatible = (m) => m.startsWith("gpt-") || m.startsWith("gemini");
     const hasNonBrowserCompatibleTarget = browserEngineRequested && browserCompatibilityModels.some((m) => !isBrowserCompatible(m));
     if (hasNonBrowserCompatibleTarget) {
@@ -52,6 +57,16 @@ export function resolveRunOptionsFromConfig({ prompt, files = [], model, models,
     const fixedEngine = isCodex || isClaude || isGrok || azureAutoApi || normalizedRequestedModels.length > 0
         ? "api"
         : resolvedEngine;
+    if (fixedEngine === "api") {
+        if (isGpt6ProAlias(cliModelArg)) {
+            resolveApiModel(cliModelArg);
+        }
+        for (const entry of normalizedRequestedModels) {
+            if (isGpt6ProAlias(entry)) {
+                resolveApiModel(entry);
+            }
+        }
+    }
     // Browser runs use ChatGPT picker labels/aliases; API runs must keep API model ids intact.
     const resolvedModel = fixedEngine === "browser" ? browserModel : apiModel;
     const promptWithSuffix = userConfig?.promptSuffix && userConfig.promptSuffix.trim().length > 0

package/dist/src/cli/sessionDisplay.js

@@ -6,6 +6,7 @@ import { formatFinishLine } from "../oracle/finishLine.js";
 import { sessionStore, wait } from "../sessionStore.js";
 import { formatTokenCount, formatTokenValue } from "../oracle/runUtils.js";
 import { resumeBrowserSession } from "../browser/reattach.js";
+import { retireRecoveredBrowserTarget } from "../browser/recoveryTarget.js";
 import { hasRecoverableChatGptConversation } from "../browser/reattachability.js";
 import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportArtifact, } from "../browser/artifacts.js";
 import { estimateTokenCount } from "../browser/utils.js";
@@ -88,11 +89,8 @@ async function writeReattachAnswer(sessionId, result, replaceExistingLog) {
         await fs.writeFile(paths.log, `[reattach] replaced incomplete Deep Research capture from existing Chrome tab\nAnswer:\n${body}\n`, "utf8");
         return;
     }
-    const logWriter = sessionStore.createLogWriter(sessionId);
-    logWriter.logLine("[reattach] captured assistant response from existing Chrome tab");
-    logWriter.logLine("Answer:");
-    logWriter.logLine(body);
-    logWriter.stream.end();
+    const paths = await sessionStore.getPaths(sessionId);
+    await fs.appendFile(paths.log, `[reattach] captured assistant response from existing Chrome tab\nAnswer:\n${body}\n`, "utf8");
 }
 async function saveReattachBrowserArtifacts(sessionId, metadata, result) {
     const body = result.answerMarkdown || result.answerText;
@@ -264,6 +262,7 @@ export async function attachSession(sessionId, options) {
                 transport: undefined,
             });
             console.log(chalk.green("Reattach succeeded; session marked completed."));
+            await retireRecoveredBrowserTarget(sessionId, result.captureTarget, (line) => console.log(dim(line)));
             metadata = (await sessionStore.readSession(sessionId)) ?? metadata;
         }
         catch (error) {
@@ -360,7 +359,10 @@ export async function attachSession(sessionId, options) {
             console.log(dim(`User error: ${userErrorSummary}`));
         }
     }
-    const shouldTrimIntro = initialStatus === "completed" || initialStatus === "partial" || initialStatus === "error";
+    const shouldTrimIntro = initialStatus === "completed" ||
+        initialStatus === "partial" ||
+        initialStatus === "error" ||
+        initialStatus === "cancelled";
     if (options?.renderPrompt !== false) {
         const prompt = await readStoredPrompt(sessionId);
         if (prompt) {
@@ -486,7 +488,10 @@ export async function attachSession(sessionId, options) {
         if (!latest) {
             break;
         }
-        if (latest.status === "completed" || latest.status === "partial" || latest.status === "error") {
+        if (latest.status === "completed" ||
+            latest.status === "partial" ||
+            latest.status === "error" ||
+            latest.status === "cancelled") {
             await printNew();
             flushRemainder();
             if (!options?.suppressMetadata) {
@@ -517,7 +522,9 @@ export async function attachSession(sessionId, options) {
             if (!settled) {
                 break;
             }
-            if (settled.status === "completed" || settled.status === "partial") {
+            if (settled.status === "completed" ||
+                settled.status === "partial" ||
+                settled.status === "cancelled") {
                 continue;
             }
             await printNew();