@steipete/oracle 0.19.0 → 0.20.0

package/dist/src/browser/recoveryTarget.js

@@ -0,0 +1,131 @@
+import { randomUUID } from "node:crypto";
+import { sessionStore } from "../sessionStore.js";
+import { connectToRemoteChromeTarget } from "./chromeLifecycle.js";
+import { resolveBrowserApprovalWait } from "./config.js";
+import { extractConversationIdFromUrl } from "./reattachHelpers.js";
+import { STOP_BUTTON_SELECTORS } from "./constants.js";
+import { hasActiveBrowserTargetLease } from "./tabLeaseRegistry.js";
+import { buildTargetRetirementExpression, buildTargetRetirementRollbackExpression, normalizeChromeHost, } from "./targetClaim.js";
+function processMayBeAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== "ESRCH";
+    }
+}
+export function hasOtherLiveBrowserController(metadata) {
+    for (const pid of [metadata.browser?.runtime?.controllerPid, metadata.lifecycle?.workerPid]) {
+        if (!pid || pid === process.pid)
+            continue;
+        if (processMayBeAlive(pid))
+            return true;
+    }
+    return false;
+}
+async function targetHasActiveController(metadata, capture) {
+    for (const other of await sessionStore.listSessions()) {
+        if (other.id === metadata.id)
+            continue;
+        const runtime = other.browser?.runtime;
+        if (runtime?.chromeTargetId !== capture.targetId ||
+            runtime.chromePort !== capture.port ||
+            normalizeChromeHost(runtime.chromeHost ?? "127.0.0.1") !== normalizeChromeHost(capture.host))
+            continue;
+        if ([runtime.controllerPid, other.lifecycle?.workerPid].some((pid) => pid && processMayBeAlive(pid)))
+            return true;
+    }
+    const runtime = metadata.browser?.runtime;
+    const profileDirs = new Set([
+        runtime?.userDataDir,
+        runtime?.chromeProfileRoot,
+        metadata.browser?.config?.manualLoginProfileDir,
+    ].filter((dir) => Boolean(dir)));
+    for (const dir of profileDirs) {
+        if (await hasActiveBrowserTargetLease(dir, capture))
+            return true;
+    }
+    return false;
+}
+export function matchesOwnedRecoveryTarget(metadata, capture) {
+    const runtime = metadata.browser?.runtime;
+    const owned = runtime?.ownedRecoveryTarget;
+    const conversationId = runtime?.conversationId ?? extractConversationIdFromUrl(runtime?.tabUrl ?? "");
+    return Boolean(owned &&
+        capture &&
+        conversationId &&
+        capture.conversationId === conversationId &&
+        owned.targetId === capture.targetId &&
+        normalizeChromeHost(owned.host) === normalizeChromeHost(capture.host) &&
+        owned.port === capture.port &&
+        owned.browserWSEndpoint === capture.browserWSEndpoint);
+}
+/** Call only after the full recovered answer and completed session have been saved. */
+export async function retireRecoveredBrowserTarget(sessionId, capture, logger, deps = {}) {
+    if (!capture)
+        return;
+    let connection;
+    let lockedClaim;
+    const reservationId = randomUUID();
+    let retired = false;
+    try {
+        const metadata = await sessionStore.readSession(sessionId);
+        if (!metadata ||
+            metadata.status !== "completed" ||
+            hasOtherLiveBrowserController(metadata) ||
+            !matchesOwnedRecoveryTarget(metadata, capture))
+            return;
+        const claimId = metadata.browser?.runtime?.ownedRecoveryTarget?.claimId;
+        if (!claimId)
+            return;
+        const connect = deps.connect ?? connectToRemoteChromeTarget;
+        connection = await connect(capture.host, capture.port, logger, {
+            targetId: capture.targetId,
+            browserWSEndpoint: capture.browserWSEndpoint,
+            closeTargetOnDispose: false,
+            approvalWaitMs: resolveBrowserApprovalWait(metadata.browser?.config?.approvalWaitMs),
+        });
+        const { Runtime, Target } = connection.client;
+        const state = await Runtime.evaluate({
+            expression: `(() => ({ url: location.href, generating: Array.from(document.querySelectorAll(${JSON.stringify(STOP_BUTTON_SELECTORS.join(","))})).some(node => node.getBoundingClientRect().width > 0 && node.getBoundingClientRect().height > 0) }))()`,
+            returnByValue: true,
+        });
+        const value = state.result?.value;
+        if (!value ||
+            value.generating !== false ||
+            extractConversationIdFromUrl(value.url ?? "") !== capture.conversationId)
+            return;
+        const { targetInfos } = await Target.getTargets();
+        if (!targetInfos.some((target) => target.type === "page" && target.targetId !== capture.targetId)) {
+            const replacement = await Target.createTarget({ url: "about:blank" });
+            if (!replacement.targetId)
+                return;
+        }
+        if (await targetHasActiveController(metadata, capture))
+            return;
+        lockedClaim = claimId;
+        const locked = await Runtime.evaluate({
+            expression: buildTargetRetirementExpression(claimId, capture.conversationId, reservationId),
+            returnByValue: true,
+        });
+        if (locked.exceptionDetails || locked.result?.value !== true)
+            return;
+        const result = await Target.closeTarget({ targetId: capture.targetId });
+        if (!result.success)
+            throw new Error("Chrome refused target retirement");
+        retired = true;
+        logger("Retired Oracle-owned browser tab after saving the recovered answer.");
+    }
+    catch (error) {
+        logger(`Recovered answer is saved; browser tab cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    finally {
+        if (connection && lockedClaim && !retired) {
+            await connection.client.Runtime.evaluate({
+                expression: buildTargetRetirementRollbackExpression(lockedClaim, reservationId),
+            }).catch(() => undefined);
+        }
+        await connection?.close().catch(() => undefined);
+    }
+}

package/dist/src/browser/sessionRunner.js

@@ -135,7 +135,7 @@ async function executeAssembledBrowserSession({ runOptions, browserConfig, log,
         if (typeof message !== "string")
             return;
         const shouldAlwaysPrint = message.startsWith("[browser] ") &&
-            /archive|fallback|follow-up|retry|thinking|waiting for chatgpt|remote debugging approval|browser slot|browser control|browser guidance|model selection|model picker/i.test(message);
+            /archive|fallback|follow-up|retry|thinking|research|waiting for chatgpt|remote debugging approval|browser slot|browser control|browser guidance|model selection|model picker/i.test(message);
         if (!runOptions.verbose && !shouldAlwaysPrint)
             return;
         log(message);
@@ -278,9 +278,11 @@ async function executeAssembledBrowserSession({ runOptions, browserConfig, log,
             chromeProfileRoot: browserResult.chromeProfileRoot,
             userDataDir: browserResult.userDataDir,
             chromeTargetId: browserResult.chromeTargetId,
+            ownedRecoveryTarget: browserResult.ownedRecoveryTarget,
             tabUrl: browserResult.tabUrl,
             conversationId: browserResult.conversationId,
             promptSubmitted: browserResult.promptSubmitted,
+            researchPlan: browserResult.researchPlan,
             controllerPid: browserResult.controllerPid ?? process.pid,
         },
         archive: browserResult.archive,

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) {
+    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) 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/browserTabs.js

@@ -6,6 +6,7 @@ import { collectChatGptTabs, DEFAULT_REMOTE_CHROME_HOST, DEFAULT_REMOTE_CHROME_P
 import { isRecoveredConversationHarvestReady, recoverConversationTab, } from "../browser/recoverConversation.js";
 import { resolveOutputPath } from "./writeOutputPath.js";
 import { persistBrowserHarvest } from "./harvestIntegrity.js";
+import { completeOwnedBrowserHarvest } from "./recoveredBrowserHarvest.js";
 const LIVE_POLL_MS = 2000;
 const DEFAULT_STALL_THRESHOLD_MS = 60_000;
 function isRecoverableMissingTabError(message) {
@@ -199,6 +200,7 @@ export async function harvestSessionBrowserOutput(sessionId, options = {}) {
         if (!options.quietOutput && output) {
             process.stdout.write(`${output}${output.endsWith("\n") ? "" : "\n"}`);
         }
+        await completeOwnedBrowserHarvest(sessionId, harvested, integrity, (line) => console.log(line));
         return harvested;
     }
     finally {
@@ -296,6 +298,7 @@ export async function liveTailSessionBrowserOutput(sessionId, options = {}) {
                 if (output) {
                     process.stdout.write(`${output}${output.endsWith("\n") ? "" : "\n"}`);
                 }
+                await completeOwnedBrowserHarvest(sessionId, finalHarvest, integrity, (line) => console.log(line));
                 return finalHarvest;
             }
             await new Promise((resolve) => setTimeout(resolve, LIVE_POLL_MS));

package/dist/src/cli/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) {

package/dist/src/cli/sessionRunner.js

@@ -22,6 +22,7 @@ import { sanitizeOscProgress } from "./oscUtils.js";
 import { readFiles } from "../oracle/files.js";
 import { cwd as getCwd } from "node:process";
 import { resumeBrowserSession } from "../browser/reattach.js";
+import { retireRecoveredBrowserTarget } from "../browser/recoveryTarget.js";
 import { hasRecoverableChatGptConversation } from "../browser/reattachability.js";
 import { estimateTokenCount } from "../browser/utils.js";
 import { computeFileSha256, sanitizeArtifactFilename } from "../browser/artifacts.js";
@@ -1039,11 +1040,8 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                 existingArtifacts: sessionMeta.artifacts,
                 logger,
             });
-            const logWriter = sessionStore.createLogWriter(sessionMeta.id);
-            logWriter.logLine(`[auto-reattach] captured assistant response on attempt ${attempt}`);
-            logWriter.logLine("Answer:");
-            logWriter.logLine(answerText);
-            logWriter.stream.end();
+            const paths = await sessionStore.getPaths(sessionMeta.id);
+            await fs.appendFile(paths.log, `[auto-reattach] captured assistant response on attempt ${attempt}\nAnswer:\n${answerText}\n`, "utf8");
             if (modelForStatus) {
                 await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
                     status: "completed",
@@ -1089,6 +1087,7 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                 transport: undefined,
             });
             log(kleur.green("Auto-reattach succeeded; session marked completed."));
+            await retireRecoveredBrowserTarget(sessionMeta.id, result.captureTarget, logger);
             return true;
         }
         catch (error) {

package/dist/src/mcp/tools/consult.js

@@ -74,9 +74,9 @@ const consultInputShape = {
         .optional()
         .describe("Browser-only: model picker strategy. Mirrors the CLI --browser-model-strategy flag."),
     browserResearchMode: z
-        .enum(["deep"])
+        .enum(["search", "deep"])
         .optional()
-        .describe("Browser-only: activate ChatGPT Deep Research mode for broad web research."),
+        .describe("Browser-only: explicitly select ChatGPT Web Search or Deep Research."),
     browserArchive: z
         .enum(["auto", "always", "never"])
         .optional()

package/dist/src/mcp/types.js

@@ -23,7 +23,7 @@ export const consultInputSchema = z
     browserBundleFormat: z.enum(["auto", "text", "zip"]).optional(),
     browserThinkingTime: browserThinkingTimeInputSchema.optional(),
     browserModelStrategy: z.enum(["select", "current", "ignore"]).optional(),
-    browserResearchMode: z.enum(["deep"]).optional(),
+    browserResearchMode: z.enum(["search", "deep"]).optional(),
     browserArchive: z.enum(["auto", "always", "never"]).optional(),
     browserFollowUps: z.array(z.string()).optional(),
     browserKeepBrowser: z.boolean().optional(),

package/dist/src/oracle/config.js

@@ -30,6 +30,20 @@ const countTokensAnthropic = (input) => {
 // supported limit at the base-rate boundary until cost estimation supports tiers.
 const GPT_5_6_BASE_RATE_INPUT_LIMIT = 272_000;
 export const MODEL_CONFIGS = {
+    "gpt-6-astra": {
+        model: "gpt-6-astra",
+        provider: "openai",
+        tokenizer: countTokensGpt5,
+        // Conservative base-rate budget, not Astra's maximum context window.
+        // https://developers.openai.com/api/docs/models/gpt-6-astra
+        inputLimit: 272_000,
+        pricing: {
+            inputPerToken: 10 / 1_000_000,
+            outputPerToken: 50 / 1_000_000,
+        },
+        reasoning: { effort: "xhigh" },
+        searchToolType: "web_search",
+    },
     "gpt-5.6": {
         model: "gpt-5.6",
         provider: "openai",

package/dist/src/oracle/geminiModels.js

@@ -1,4 +1,5 @@
 const MODEL_ID_MAP = {
+    "gpt-6-astra": "gpt-6-astra",
     "gemini-3.1-flash-lite": "gemini-3.1-flash-lite",
     "gemini-3.1-pro": "gemini-3.1-pro-preview",
     "gemini-3.5-flash": "gemini-3.5-flash",