@steipete/oracle 0.10.0 → 0.11.0

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

@@ -18,13 +18,19 @@ async function readSessionLogTail(sessionId, maxBytes) {
     }
 }
 import { performSessionRun } from "../../cli/sessionRunner.js";
+import { runDryRunSummary } from "../../cli/dryRun.js";
 import { CHATGPT_URL } from "../../browser/constants.js";
-import { consultInputSchema } from "../types.js";
+import { CONSULT_PRESETS, consultInputSchema } from "../types.js";
+import { applyConsultPreset } from "../consultPresets.js";
 import { loadUserConfig } from "../../config.js";
 import { resolveNotificationSettings } from "../../cli/notifier.js";
 import { mapModelToBrowserLabel, resolveBrowserModelLabel } from "../../cli/browserConfig.js";
 // Use raw shapes so the MCP SDK (with its bundled Zod) wraps them and emits valid JSON Schema.
 const consultInputShape = {
+    preset: z
+        .enum(CONSULT_PRESETS)
+        .optional()
+        .describe('Optional MCP convenience preset. "chatgpt-pro-heavy" selects ChatGPT browser mode, the current Pro model alias, and Pro Extended thinking unless overridden.'),
     prompt: z.string().min(1, "Prompt is required.").describe("User prompt to run."),
     files: z
         .array(z.string())
@@ -33,7 +39,7 @@ const consultInputShape = {
     model: z
         .string()
         .optional()
-        .describe("Single model name/label. Prefer setting `engine` explicitly to avoid default surprises."),
+        .describe("Single model name/label. If `engine` is omitted, Oracle follows CLI defaults: config/ORACLE_ENGINE first, then `api` when OPENAI_API_KEY is set, otherwise `browser`. Prefer setting `engine` explicitly to avoid default surprises."),
     models: z
         .array(z.string())
         .optional()
@@ -41,7 +47,7 @@ const consultInputShape = {
     engine: z
         .enum(["api", "browser"])
         .optional()
-        .describe("Execution engine. `api` uses OpenAI/other providers. `browser` automates the ChatGPT web UI (supports attachments and ChatGPT-only model labels)."),
+        .describe("Execution engine. `api` uses OpenAI/other providers. `browser` automates the ChatGPT web UI (supports attachments and ChatGPT-only model labels). When omitted, Oracle follows CLI defaults: config/ORACLE_ENGINE first, then `api` when OPENAI_API_KEY is set, otherwise `browser`."),
     browserModelLabel: z
         .string()
         .optional()
@@ -58,10 +64,30 @@ const consultInputShape = {
         .enum(["light", "standard", "extended", "heavy"])
         .optional()
         .describe("Browser-only: set ChatGPT thinking time when supported by the chosen model."),
+    browserModelStrategy: z
+        .enum(["select", "current", "ignore"])
+        .optional()
+        .describe("Browser-only: model picker strategy. Mirrors the CLI --browser-model-strategy flag."),
+    browserResearchMode: z
+        .enum(["deep"])
+        .optional()
+        .describe("Browser-only: activate ChatGPT Deep Research mode for broad web research."),
+    browserArchive: z
+        .enum(["auto", "always", "never"])
+        .optional()
+        .describe('Browser-only: archive completed ChatGPT conversations after local artifacts are saved. "auto" archives successful non-project one-shots only.'),
+    browserFollowUps: z
+        .array(z.string())
+        .optional()
+        .describe("Browser-only: additional prompts to submit sequentially in the same ChatGPT conversation after the initial answer."),
     browserKeepBrowser: z
         .boolean()
         .optional()
         .describe("Browser-only: keep Chrome running after completion (useful for debugging)."),
+    dryRun: z
+        .boolean()
+        .optional()
+        .describe("Preview the resolved Oracle run without creating a session or touching the browser."),
     search: z
         .boolean()
         .optional()
@@ -100,10 +126,34 @@ const consultModelSummaryShape = z.object({
         .optional(),
     logPath: z.string().optional(),
 });
+const consultDryRunResolvedShape = z.object({
+    resolvedEngine: z.enum(["api", "browser"]),
+    model: z.string(),
+    models: z.array(z.string()).optional(),
+    files: z.array(z.string()),
+    followUpCount: z.number(),
+    browser: z
+        .object({
+        desiredModel: z.string().nullable().optional(),
+        thinkingTime: z.string().nullable().optional(),
+        modelStrategy: z.string().nullable().optional(),
+        researchMode: z.string().nullable().optional(),
+        attachments: z.string().optional(),
+        bundleFiles: z.boolean().optional(),
+        keepBrowser: z.boolean().optional(),
+        manualLogin: z.boolean().optional(),
+        profileDir: z.string().nullable().optional(),
+        chatgptUrl: z.string().nullable().optional(),
+    })
+        .optional(),
+    guidance: z.array(z.string()),
+});
 const consultOutputShape = {
-    sessionId: z.string(),
+    sessionId: z.string().optional(),
     status: z.string(),
     output: z.string(),
+    dryRun: z.boolean().optional(),
+    resolved: consultDryRunResolvedShape.optional(),
     models: z.array(consultModelSummaryShape).optional(),
 };
 export function summarizeModelRunsForConsult(runs) {
@@ -136,7 +186,7 @@ export function summarizeModelRunsForConsult(runs) {
         };
     });
 }
-export function buildConsultBrowserConfig({ userConfig, env, runModel, inputModel, browserModelLabel, browserThinkingTime, browserKeepBrowser, }) {
+export function buildConsultBrowserConfig({ userConfig, env, runModel, inputModel, browserModelLabel, browserThinkingTime, browserModelStrategy, browserResearchMode, browserArchive, browserKeepBrowser, }) {
     const configuredBrowser = userConfig.browser ?? {};
     const envProfileDir = (env.ORACLE_BROWSER_PROFILE_DIR ?? "").trim();
     const hasProfileDir = envProfileDir.length > 0;
@@ -160,19 +210,108 @@ export function buildConsultBrowserConfig({ userConfig, env, runModel, inputMode
             ? ((envProfileDir || configuredBrowser.manualLoginProfileDir) ?? null)
             : null,
         thinkingTime: browserThinkingTime ?? configuredBrowser.thinkingTime,
+        modelStrategy: browserModelStrategy ?? configuredBrowser.modelStrategy,
+        researchMode: browserResearchMode ?? configuredBrowser.researchMode,
+        archiveConversations: browserArchive ?? configuredBrowser.archiveConversations,
         desiredModel: desiredModelLabel || mapModelToBrowserLabel(runModel),
     };
 }
+export function buildConsultDryRunResolved({ resolvedEngine, runOptions, browserConfig, }) {
+    const guidance = [];
+    const followUpCount = runOptions.browserFollowUps?.filter((entry) => entry.trim()).length ?? 0;
+    if (resolvedEngine === "api") {
+        guidance.push('API engine requires provider credentials. If the operator has ChatGPT Pro but no API key, retry with engine:"browser" or preset:"chatgpt-pro-heavy".');
+    }
+    if (resolvedEngine === "browser") {
+        guidance.push("Browser engine uses the signed-in ChatGPT profile; run dryRun:true before live use.");
+    }
+    const desiredModel = browserConfig?.desiredModel ?? null;
+    const thinkingTime = browserConfig?.thinkingTime ?? null;
+    if (runOptions.model === "gpt-5.5-pro" && thinkingTime === "heavy") {
+        guidance.push('gpt-5.5-pro should normally use Pro Extended. Use model:"gpt-5.5" with browserThinkingTime:"heavy" only when you explicitly want Thinking Heavy.');
+    }
+    const chatgptUrl = browserConfig?.chatgptUrl ?? browserConfig?.url ?? null;
+    if (chatgptUrl?.includes("/project")) {
+        guidance.push("This ChatGPT project URL is persistent. Project Sources should be mutated only by the project_sources tool with confirmMutation:true.");
+    }
+    if (followUpCount > 0) {
+        guidance.push("This is a multi-turn browser consult; all follow-ups stay in one ChatGPT conversation.");
+    }
+    return {
+        resolvedEngine,
+        model: runOptions.model,
+        models: runOptions.models,
+        files: runOptions.file ?? [],
+        followUpCount,
+        browser: resolvedEngine === "browser"
+            ? {
+                desiredModel,
+                thinkingTime,
+                modelStrategy: browserConfig?.modelStrategy ?? null,
+                researchMode: browserConfig?.researchMode ?? null,
+                attachments: runOptions.browserAttachments,
+                bundleFiles: runOptions.browserBundleFiles,
+                keepBrowser: browserConfig?.keepBrowser,
+                manualLogin: browserConfig?.manualLogin,
+                profileDir: browserConfig?.manualLoginProfileDir ?? null,
+                chatgptUrl,
+            }
+            : undefined,
+        guidance,
+    };
+}
+export function formatConsultDryRunResolved(details) {
+    const lines = [
+        "[dry-run] MCP resolved request:",
+        `  engine: ${details.resolvedEngine}`,
+        `  model: ${details.model}`,
+    ];
+    if (details.models && details.models.length > 0) {
+        lines.push(`  models: ${details.models.join(", ")}`);
+    }
+    lines.push(`  files: ${details.files.length}`);
+    if (details.browser) {
+        lines.push(`  browser desired model: ${details.browser.desiredModel ?? "(default)"}`);
+        lines.push(`  browser thinking time: ${details.browser.thinkingTime ?? "(default)"}`);
+        lines.push(`  browser model strategy: ${details.browser.modelStrategy ?? "(default)"}`);
+        lines.push(`  browser research mode: ${details.browser.researchMode ?? "off"}`);
+        lines.push(`  browser attachments: ${details.browser.attachments ?? "auto"}`);
+        lines.push(`  browser bundle files: ${details.browser.bundleFiles ? "yes" : "no"}`);
+        lines.push(`  browser keep browser: ${details.browser.keepBrowser ? "yes" : "no"}`);
+        lines.push(`  browser manual login: ${details.browser.manualLogin ? "yes" : "no"}`);
+        if (details.browser.profileDir) {
+            lines.push(`  browser profile: ${details.browser.profileDir}`);
+        }
+        if (details.browser.chatgptUrl) {
+            lines.push(`  ChatGPT URL: ${details.browser.chatgptUrl}`);
+        }
+    }
+    lines.push(`  follow-ups: ${details.followUpCount}`);
+    for (const guidance of details.guidance) {
+        lines.push(`  guidance: ${guidance}`);
+    }
+    return lines;
+}
 export function registerConsultTool(server) {
     server.registerTool("consult", {
         title: "Run an oracle session",
-        description: 'Run a one-shot Oracle session (API or ChatGPT browser automation). Use `files` to attach project context. For browser-based image/file uploads, set `browserAttachments:"always"`. Sessions are stored under `ORACLE_HOME_DIR` (shared with the CLI).',
+        description: 'Run an Oracle session (API or ChatGPT browser automation). Use `files` to attach project context. If `engine` is omitted, Oracle follows CLI defaults: config/ORACLE_ENGINE first, then API when OPENAI_API_KEY is set, otherwise browser. Browser GPT-5.5 Pro consults can take many minutes; use `dryRun:true` first when configuring an agent and inspect `sessions`/`oracle status` before retrying. For browser-based image/file uploads, set `browserAttachments:"always"`. Browser consults can include `browserFollowUps` for a multi-turn ChatGPT review in one conversation. Sessions are stored under `ORACLE_HOME_DIR` (shared with the CLI).',
         // Cast to any to satisfy SDK typings across differing Zod versions.
         inputSchema: consultInputShape,
         outputSchema: consultOutputShape,
     }, async (input) => {
         const textContent = (text) => [{ type: "text", text }];
-        const { prompt, files, model, models, engine, search, browserModelLabel, browserAttachments, browserBundleFiles, browserThinkingTime, browserKeepBrowser, slug, } = consultInputSchema.parse(input);
+        let parsedInput;
+        try {
+            parsedInput = applyConsultPreset(consultInputSchema.parse(input));
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: textContent(error instanceof Error ? error.message : String(error)),
+            };
+        }
+        const { prompt, files, model, models, engine, search, browserModelLabel, browserAttachments, browserBundleFiles, browserThinkingTime, browserModelStrategy, browserResearchMode, browserArchive, browserFollowUps, browserKeepBrowser, dryRun, slug, } = parsedInput;
         const { config: userConfig } = await loadUserConfig();
         const { runOptions, resolvedEngine } = mapConsultToRunOptions({
             prompt,
@@ -183,11 +322,66 @@ export function registerConsultTool(server) {
             search,
             browserAttachments,
             browserBundleFiles,
+            browserFollowUps,
             userConfig,
             env: process.env,
         });
         const cwd = process.cwd();
+        const sendLog = (text, level = "info") => server.server
+            .sendLoggingMessage(LoggingMessageNotificationParamsSchema.parse({
+            level,
+            data: { text, bytes: Buffer.byteLength(text, "utf8") },
+        }))
+            .catch(() => { });
         const resolvedRemote = resolveRemoteServiceConfig({ userConfig, env: process.env });
+        let browserConfig;
+        if (resolvedEngine === "browser") {
+            browserConfig = buildConsultBrowserConfig({
+                userConfig,
+                env: process.env,
+                runModel: runOptions.model,
+                inputModel: model,
+                browserModelLabel,
+                browserThinkingTime,
+                browserModelStrategy,
+                browserResearchMode,
+                browserArchive,
+                browserKeepBrowser,
+            });
+        }
+        if (dryRun) {
+            const lines = [];
+            const log = (line) => {
+                lines.push(line);
+                sendLog(line);
+            };
+            const resolved = buildConsultDryRunResolved({
+                resolvedEngine,
+                runOptions,
+                browserConfig,
+            });
+            await runDryRunSummary({
+                engine: resolvedEngine,
+                runOptions,
+                cwd,
+                version: getCliVersion(),
+                log,
+                browserConfig,
+            });
+            for (const line of formatConsultDryRunResolved(resolved)) {
+                log(line);
+            }
+            const output = lines.join("\n").trim();
+            return {
+                content: textContent(output),
+                structuredContent: {
+                    status: "dry-run",
+                    output,
+                    dryRun: true,
+                    resolved,
+                },
+            };
+        }
         const browserGuard = ensureBrowserAvailable(resolvedEngine, {
             remoteHost: resolvedRemote.host,
         });
@@ -212,18 +406,6 @@ export function registerConsultTool(server) {
                 }),
             };
         }
-        let browserConfig;
-        if (resolvedEngine === "browser") {
-            browserConfig = buildConsultBrowserConfig({
-                userConfig,
-                env: process.env,
-                runModel: runOptions.model,
-                inputModel: model,
-                browserModelLabel,
-                browserThinkingTime,
-                browserKeepBrowser,
-            });
-        }
         const notifications = resolveNotificationSettings({
             cliNotify: undefined,
             cliNotifySound: undefined,
@@ -238,13 +420,6 @@ export function registerConsultTool(server) {
             waitPreference: true,
         }, cwd, notifications);
         const logWriter = sessionStore.createLogWriter(sessionMeta.id);
-        // Best-effort: emit MCP logging notifications for live chunks but never block the run.
-        const sendLog = (text, level = "info") => server.server
-            .sendLoggingMessage(LoggingMessageNotificationParamsSchema.parse({
-            level,
-            data: { text, bytes: Buffer.byteLength(text, "utf8") },
-        }))
-            .catch(() => { });
         // Stream logs to both the session log and MCP logging notifications, but avoid buffering in memory
         const log = (line) => {
             logWriter.logLine(line);

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

@@ -0,0 +1,123 @@
+import { z } from "zod";
+import { loadUserConfig } from "../../config.js";
+import { resolveRemoteServiceConfig } from "../../remote/remoteServiceConfig.js";
+import { runBrowserProjectSources } from "../../browser/projectSourcesRunner.js";
+import { normalizeProjectSourcesUrl } from "../../projectSources/url.js";
+import { buildProjectSourcesBrowserConfig, resolveProjectSourceFiles, } from "../../cli/projectSources.js";
+import { resolveConfiguredMaxFileSizeBytes } from "../../cli/fileSize.js";
+const projectSourceEntryShape = z.object({
+    name: z.string(),
+    index: z.number(),
+    status: z.enum(["ready", "processing", "unknown"]).optional(),
+});
+const projectSourceUploadPlanShape = z.object({
+    path: z.string(),
+    displayPath: z.string(),
+    name: z.string(),
+    sizeBytes: z.number().optional(),
+    batch: z.number(),
+});
+const projectSourcesInputShape = {
+    operation: z
+        .enum(["list", "add"])
+        .describe("Project Sources operation. v1 intentionally supports only non-destructive list/add."),
+    chatgptUrl: z
+        .string()
+        .optional()
+        .describe("ChatGPT project URL ending in /project. Falls back to browser.chatgptUrl config."),
+    files: z
+        .array(z.string())
+        .default([])
+        .describe("Local file paths or globs to add as persistent ChatGPT Project Sources."),
+    dryRun: z
+        .boolean()
+        .optional()
+        .describe("Validate files and return an upload plan without touching the browser."),
+    confirmMutation: z
+        .boolean()
+        .optional()
+        .describe("Required for mutating add operations so agents do not modify project state accidentally."),
+    browserKeepBrowser: z.boolean().optional().describe("Keep Chrome running after completion."),
+};
+const projectSourcesOutputShape = {
+    status: z.enum(["ok", "dry-run"]),
+    operation: z.enum(["list", "add"]),
+    projectUrl: z.string(),
+    dryRun: z.boolean(),
+    sourcesBefore: z.array(projectSourceEntryShape).optional(),
+    sourcesAfter: z.array(projectSourceEntryShape).optional(),
+    plannedUploads: z.array(projectSourceUploadPlanShape).optional(),
+    added: z.array(projectSourceEntryShape).optional(),
+    warnings: z.array(z.string()),
+    tookMs: z.number(),
+};
+const projectSourcesInputSchema = z.object(projectSourcesInputShape);
+export function registerProjectSourcesTool(server) {
+    server.registerTool("project_sources", {
+        title: "Manage ChatGPT Project Sources",
+        description: "List or append files to a ChatGPT Project's persistent Sources tab. This is useful for Developer Mode workflows where chats do not share memory, but explicit project sources provide shared context. Destructive delete/replace/sync operations are intentionally not included in v1.",
+        inputSchema: projectSourcesInputShape,
+        outputSchema: projectSourcesOutputShape,
+    }, async (input) => {
+        const textContent = (text) => [{ type: "text", text }];
+        let parsed;
+        try {
+            parsed = projectSourcesInputSchema.parse(input);
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: textContent(error instanceof Error ? error.message : String(error)),
+            };
+        }
+        const { config: userConfig } = await loadUserConfig();
+        const resolvedRemote = resolveRemoteServiceConfig({ userConfig, env: process.env });
+        if (resolvedRemote.host) {
+            return {
+                isError: true,
+                content: textContent("project_sources v1 must run on the signed-in browser host; remote oracle serve support is not enabled yet."),
+            };
+        }
+        const projectUrl = normalizeProjectSourcesUrl(parsed.chatgptUrl ?? userConfig.browser?.chatgptUrl ?? userConfig.browser?.url ?? "");
+        if (parsed.operation === "add" && !parsed.dryRun && parsed.confirmMutation !== true) {
+            return {
+                isError: true,
+                content: textContent("project_sources add modifies persistent ChatGPT Project Sources. Retry with `confirmMutation: true` or use `dryRun: true` first."),
+            };
+        }
+        const maxFileSizeBytes = resolveConfiguredMaxFileSizeBytes(userConfig, process.env);
+        const files = parsed.operation === "add"
+            ? await resolveProjectSourceFiles(parsed.files ?? [], {
+                cwd: process.cwd(),
+                maxFileSizeBytes,
+            })
+            : [];
+        const browserConfig = await buildProjectSourcesBrowserConfig({
+            options: {
+                chatgptUrl: projectUrl,
+                browserKeepBrowser: parsed.browserKeepBrowser,
+            },
+            projectUrl,
+            configuredBrowser: userConfig.browser ?? {},
+        });
+        const result = await runBrowserProjectSources({
+            operation: parsed.operation,
+            chatgptUrl: projectUrl,
+            files,
+            dryRun: parsed.dryRun,
+            config: browserConfig,
+            log: (message) => {
+                server.server
+                    .sendLoggingMessage({ level: "info", data: { text: message } })
+                    .catch(() => undefined);
+            },
+        });
+        const output = result.status === "dry-run"
+            ? `Project Sources ${result.operation} dry run: ${result.plannedUploads?.length ?? 0} planned upload(s).`
+            : `Project Sources ${result.operation} completed: ${result.sourcesAfter?.length ?? 0} source(s).`;
+        return {
+            content: textContent(output),
+            structuredContent: result,
+        };
+    });
+}

package/dist/src/mcp/types.js

@@ -1,5 +1,7 @@
 import { z } from "zod";
+export const CONSULT_PRESETS = ["chatgpt-pro-heavy"];
 export const consultInputSchema = z.object({
+    preset: z.enum(CONSULT_PRESETS).optional(),
     prompt: z.string().min(1, "Prompt is required."),
     files: z.array(z.string()).default([]),
     model: z.string().optional(),
@@ -9,7 +11,12 @@ export const consultInputSchema = z.object({
     browserAttachments: z.enum(["auto", "never", "always"]).optional(),
     browserBundleFiles: z.boolean().optional(),
     browserThinkingTime: z.enum(["light", "standard", "extended", "heavy"]).optional(),
+    browserModelStrategy: z.enum(["select", "current", "ignore"]).optional(),
+    browserResearchMode: z.enum(["deep"]).optional(),
+    browserArchive: z.enum(["auto", "always", "never"]).optional(),
+    browserFollowUps: z.array(z.string()).optional(),
     browserKeepBrowser: z.boolean().optional(),
+    dryRun: z.boolean().optional(),
     search: z.boolean().optional(),
     slug: z.string().optional(),
 });

package/dist/src/mcp/utils.js

@@ -1,6 +1,6 @@
 import { resolveRunOptionsFromConfig } from "../cli/runOptions.js";
 import { Launcher } from "chrome-launcher";
-export function mapConsultToRunOptions({ prompt, files, model, models, engine, search, browserAttachments, browserBundleFiles, userConfig, env = process.env, }) {
+export function mapConsultToRunOptions({ prompt, files, model, models, engine, search, browserAttachments, browserBundleFiles, browserFollowUps, userConfig, env = process.env, }) {
     // Normalize CLI-style inputs through the shared resolver so config/env defaults apply,
     // then overlay MCP-only overrides such as explicit search toggles.
     const mergedModels = Array.isArray(models) && models.length > 0
@@ -24,6 +24,11 @@ export function mapConsultToRunOptions({ prompt, files, model, models, engine, s
     if (typeof browserBundleFiles === "boolean") {
         result.runOptions.browserBundleFiles = browserBundleFiles;
     }
+    if (Array.isArray(browserFollowUps)) {
+        result.runOptions.browserFollowUps = browserFollowUps
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+    }
     return result;
 }
 export function ensureBrowserAvailable(engine, options) {

package/dist/src/oracle/run.js

@@ -127,7 +127,10 @@ export async function runOracle(options, deps = {}) {
                         : options.model.startsWith("grok")
                             ? "XAI_API_KEY"
                             : "OPENROUTER_API_KEY";
-        throw new PromptValidationError(`Missing ${envVar}. Set it via the environment or a .env file.`, {
+        const browserModeHint = options.model.startsWith("gpt")
+            ? ' If you have a ChatGPT Pro subscription, retry with --engine browser (or MCP engine:"browser" / preset:"chatgpt-pro-heavy"); browser mode uses your signed-in ChatGPT session instead of an API key.'
+            : "";
+        throw new PromptValidationError(`Missing ${envVar}. Set it via the environment or a .env file.${browserModeHint}`, {
             env: envVar,
         });
     }

package/dist/src/projectSources/plan.js

@@ -0,0 +1,27 @@
+import path from "node:path";
+export const PROJECT_SOURCES_MAX_UPLOAD_BATCH = 10;
+export function buildProjectSourcesUploadPlan(files) {
+    return files.map((file, index) => ({
+        path: file.path,
+        displayPath: file.displayPath,
+        name: path.basename(file.path),
+        sizeBytes: file.sizeBytes,
+        batch: Math.floor(index / PROJECT_SOURCES_MAX_UPLOAD_BATCH) + 1,
+    }));
+}
+export function diffAddedProjectSources(before, after) {
+    const remainingBefore = new Map();
+    for (const source of before) {
+        remainingBefore.set(source.name, (remainingBefore.get(source.name) ?? 0) + 1);
+    }
+    const added = [];
+    for (const source of after) {
+        const count = remainingBefore.get(source.name) ?? 0;
+        if (count > 0) {
+            remainingBefore.set(source.name, count - 1);
+            continue;
+        }
+        added.push(source);
+    }
+    return added;
+}

package/dist/src/projectSources/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/projectSources/url.js

@@ -0,0 +1,23 @@
+export function normalizeProjectSourcesUrl(rawUrl) {
+    let url;
+    try {
+        url = new URL(rawUrl);
+    }
+    catch (error) {
+        throw new Error(`Invalid ChatGPT project URL: ${rawUrl} (${error instanceof Error ? error.message : String(error)})`);
+    }
+    const hostname = url.hostname.toLowerCase();
+    if (hostname !== "chatgpt.com" && hostname !== "chat.openai.com") {
+        throw new Error(`Project Sources require a ChatGPT URL, received: ${rawUrl}`);
+    }
+    if (!/\/project\/?$/u.test(url.pathname)) {
+        throw new Error(`Project Sources require a ChatGPT project URL ending in /project, received: ${rawUrl}`);
+    }
+    const existingParams = Array.from(url.searchParams.entries()).filter(([key]) => key !== "tab");
+    url.search = "";
+    url.searchParams.set("tab", "sources");
+    for (const [key, value] of existingParams) {
+        url.searchParams.append(key, value);
+    }
+    return url.toString();
+}

package/dist/src/sessionManager.js

@@ -213,6 +213,7 @@ export async function initializeSession(options, cwd, notifications, baseSlugOve
             generateImage: options.generateImage,
             editImage: options.editImage,
             outputPath: options.outputPath,
+            browserFollowUps: options.browserFollowUps,
             aspectRatio: options.aspectRatio,
             geminiShowThoughts: options.geminiShowThoughts,
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "CLI wrapper around OpenAI Responses API with GPT-5.5 Pro, GPT-5.5, GPT-5.4, GPT-5.2, GPT-5.1, and GPT-5.1 Codex high reasoning modes.",
   "keywords": [],
   "homepage": "https://github.com/steipete/oracle#readme",
@@ -30,6 +30,7 @@
   "main": "dist/bin/oracle-cli.js",
   "scripts": {
     "docs:list": "tsx scripts/docs-list.ts",
+    "docs:site": "node scripts/build-docs-site.mjs",
     "build": "tsgo -p tsconfig.build.json && pnpm run build:vendor",
     "build:vendor": "node -e \"const fs=require('fs'); const path=require('path'); const vendorRoot=path.join('dist','vendor'); fs.rmSync(vendorRoot,{recursive:true,force:true}); const vendors=[['oracle-notifier']]; vendors.forEach(([name])=>{const src=path.join('vendor',name); const dest=path.join(vendorRoot,name); fs.mkdirSync(dest,{recursive:true}); if(fs.existsSync(src)){fs.cpSync(src,dest,{recursive:true,force:true});}});\"",
     "start": "pnpm run build && node ./dist/scripts/run-cli.js",