@steipete/oracle 0.10.0 → 0.11.1

package/dist/src/cli/browserTabs.js

@@ -0,0 +1,228 @@
+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 { resolveOutputPath } from "./writeOutputPath.js";
+const LIVE_POLL_MS = 2000;
+const DEFAULT_STALL_THRESHOLD_MS = 60_000;
+function sessionBrowserEndpoint(meta) {
+    const runtime = meta?.browser?.runtime ?? {};
+    const remote = meta?.browser?.config?.remoteChrome ?? {};
+    const host = runtime.chromeHost ?? remote.host;
+    const port = runtime.chromePort ?? remote.port;
+    if (!host || !port) {
+        return null;
+    }
+    return { host, port };
+}
+function collectUniqueEndpoints(metas) {
+    const entries = new Map();
+    entries.set(`${DEFAULT_REMOTE_CHROME_HOST}:${DEFAULT_REMOTE_CHROME_PORT}`, {
+        host: DEFAULT_REMOTE_CHROME_HOST,
+        port: DEFAULT_REMOTE_CHROME_PORT,
+    });
+    for (const meta of metas) {
+        const endpoint = sessionBrowserEndpoint(meta);
+        if (!endpoint) {
+            continue;
+        }
+        entries.set(`${endpoint.host}:${endpoint.port}`, endpoint);
+    }
+    return Array.from(entries.values());
+}
+function buildSessionIndex(metas) {
+    return metas
+        .filter((meta) => meta?.mode === "browser")
+        .sort((left, right) => String(right.createdAt ?? "").localeCompare(String(left.createdAt ?? "")));
+}
+function resolveLinkedSession(tab, metas) {
+    return buildSessionIndex(metas).find((meta) => sessionMatchesTab(meta, tab)) ?? null;
+}
+function snippet(text, max = 120) {
+    const normalized = String(text ?? "")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (normalized.length <= max) {
+        return normalized;
+    }
+    return `${normalized.slice(0, Math.max(0, max - 1)).trimEnd()}…`;
+}
+function resolveSessionTabRef(meta) {
+    const runtime = meta?.browser?.runtime ?? {};
+    const harvest = meta?.browser?.harvest ?? {};
+    return (harvest.url ??
+        runtime.tabUrl ??
+        harvest.conversationId ??
+        runtime.conversationId ??
+        harvest.targetId ??
+        runtime.chromeTargetId ??
+        "current");
+}
+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) {
+    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(`Signals: stop=${harvested.stopExists ? "yes" : "no"} send=${harvested.sendExists ? "yes" : "no"}`);
+    if (harvested.lastUserSnippet) {
+        console.log(`Last user: ${harvested.lastUserSnippet}`);
+    }
+    console.log(chalk.dim("---"));
+}
+async function maybeWriteHarvestOutput(pathInput, cwd, content) {
+    const resolved = resolveOutputPath(pathInput, cwd);
+    if (!resolved) {
+        return;
+    }
+    const payload = content ?? "";
+    if (resolved === "-" || resolved === "/dev/stdout") {
+        process.stdout.write(`${payload}${payload.endsWith("\n") ? "" : "\n"}`);
+        return;
+    }
+    await fs.writeFile(resolved, payload, "utf8");
+    console.log(chalk.dim(`Wrote harvested assistant output to ${resolved}`));
+}
+export async function showBrowserTabsStatus() {
+    const metas = await sessionStore.listSessions().catch(() => []);
+    const endpoints = collectUniqueEndpoints(metas);
+    let printedAny = false;
+    for (const endpoint of endpoints) {
+        let tabs;
+        try {
+            tabs = await collectChatGptTabs(endpoint);
+        }
+        catch {
+            continue;
+        }
+        if (tabs.length === 0) {
+            continue;
+        }
+        printedAny = true;
+        console.log(chalk.bold(`Browser Tabs ${endpoint.host}:${endpoint.port}`));
+        for (const tab of tabs) {
+            const linkedSession = resolveLinkedSession({ ...tab, host: endpoint.host, port: endpoint.port }, metas);
+            console.log(`- ${tab.targetId} ${formatBrowserTabState(tab)} model=${tab.currentModelLabel || "(unknown)"} turns=${tab.assistantCount} stop=${tab.stopExists ? "yes" : "no"} send=${tab.sendExists ? "yes" : "no"}`);
+            console.log(`  title=${tab.title || "(untitled)"}`);
+            console.log(`  url=${tab.url}`);
+            if (linkedSession) {
+                console.log(`  session=${linkedSession.id}`);
+            }
+            if (tab.lastAssistantSnippet) {
+                console.log(`  last=${snippet(tab.lastAssistantSnippet)}`);
+            }
+        }
+    }
+    if (!printedAny) {
+        console.log("No live ChatGPT tabs found on known Chrome DevTools endpoints.");
+    }
+}
+export async function harvestSessionBrowserOutput(sessionId, options = {}) {
+    const meta = await sessionStore.readSession(sessionId);
+    if (!meta) {
+        throw new Error(`No session found with ID ${sessionId}.`);
+    }
+    const endpoint = sessionBrowserEndpoint(meta) ?? {
+        host: DEFAULT_REMOTE_CHROME_HOST,
+        port: DEFAULT_REMOTE_CHROME_PORT,
+    };
+    const harvested = await harvestChatGptTab({
+        host: endpoint.host,
+        port: endpoint.port,
+        ref: options.browserTabRef ?? resolveSessionTabRef(meta),
+        stallWindowMs: options.stallWindowMs,
+    });
+    await persistHarvest(sessionId, meta, harvested);
+    printHarvestSummary(sessionId, harvested);
+    const output = harvested.lastAssistantMarkdown ?? harvested.lastAssistantText ?? "";
+    if (options.writeOutputPath) {
+        await maybeWriteHarvestOutput(options.writeOutputPath, meta.cwd ?? process.cwd(), output);
+    }
+    if (!options.quietOutput && output) {
+        process.stdout.write(`${output}${output.endsWith("\n") ? "" : "\n"}`);
+    }
+    return harvested;
+}
+export async function liveTailSessionBrowserOutput(sessionId, options = {}) {
+    const meta = await sessionStore.readSession(sessionId);
+    if (!meta) {
+        throw new Error(`No session found with ID ${sessionId}.`);
+    }
+    const endpoint = sessionBrowserEndpoint(meta) ?? {
+        host: DEFAULT_REMOTE_CHROME_HOST,
+        port: DEFAULT_REMOTE_CHROME_PORT,
+    };
+    const browserTabRef = options.browserTabRef ?? resolveSessionTabRef(meta);
+    const stallThresholdMs = options.stallThresholdMs ?? DEFAULT_STALL_THRESHOLD_MS;
+    let lastHash = null;
+    let unchangedSince = Date.now();
+    while (true) {
+        const harvested = await harvestChatGptTab({
+            host: endpoint.host,
+            port: endpoint.port,
+            ref: browserTabRef,
+        });
+        const fullText = harvested.lastAssistantMarkdown ?? harvested.lastAssistantText ?? "";
+        const hash = createHash("sha1").update(fullText).digest("hex");
+        if (hash !== lastHash) {
+            lastHash = hash;
+            unchangedSince = Date.now();
+            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)}`;
+            console.log(statusLine);
+            await persistHarvest(sessionId, meta, harvested);
+        }
+        const derivedState = harvested.stopExists
+            ? Date.now() - unchangedSince >= stallThresholdMs
+                ? "stalled"
+                : "running"
+            : harvested.authenticated
+                ? "completed"
+                : "detached";
+        if (derivedState === "completed" || derivedState === "stalled" || derivedState === "detached") {
+            const finalHarvest = {
+                ...harvested,
+                state: derivedState,
+            };
+            await persistHarvest(sessionId, meta, finalHarvest);
+            printHarvestSummary(sessionId, finalHarvest);
+            const output = finalHarvest.lastAssistantMarkdown ?? finalHarvest.lastAssistantText ?? "";
+            if (options.writeOutputPath) {
+                await maybeWriteHarvestOutput(options.writeOutputPath, meta.cwd ?? process.cwd(), output);
+            }
+            if (output) {
+                process.stdout.write(`${output}${output.endsWith("\n") ? "" : "\n"}`);
+            }
+            return finalHarvest;
+        }
+        await new Promise((resolve) => setTimeout(resolve, LIVE_POLL_MS));
+    }
+}

package/dist/src/cli/dryRun.js

@@ -4,6 +4,7 @@ import { isKnownModel } from "../oracle/modelResolver.js";
 import { assembleBrowserPrompt } from "../browser/prompt.js";
 import { buildTokenEstimateSuffix, formatAttachmentLabel } from "../browser/promptSummary.js";
 import { buildCookiePlan } from "../browser/policies.js";
+import { describeBrowserControlPlan, formatBrowserControlPlan } from "../browser/controlPlan.js";
 export async function runDryRunSummary({ engine, runOptions, cwd, version, log, browserConfig, }, deps = {}) {
     if (engine === "browser") {
         await runBrowserDryRun({ runOptions, cwd, version, log, browserConfig }, deps);
@@ -40,20 +41,34 @@ async function runApiDryRun({ runOptions, cwd, version, log, }, deps) {
     printFileTokenStats(stats, { inputTokenBudget: inputBudget, log });
 }
 async function runBrowserDryRun({ runOptions, cwd, version, log, browserConfig, }, deps) {
+    validateBrowserFollowUps(runOptions, browserConfig);
     const assemblePromptImpl = deps.assembleBrowserPromptImpl ?? assembleBrowserPrompt;
     const artifacts = await assemblePromptImpl(runOptions, { cwd });
     const suffix = buildTokenEstimateSuffix(artifacts);
     const headerLine = `[dry-run] Oracle (${version}) would launch browser mode (${runOptions.model}) 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");
 }
+function logBrowserControlPlan(browserConfig, log, label) {
+    const plan = describeBrowserControlPlan(browserConfig);
+    for (const line of formatBrowserControlPlan(plan, label)) {
+        log(chalk.dim(line));
+    }
+}
 function logBrowserCookieStrategy(browserConfig, log, label) {
     if (!browserConfig)
         return;
     const plan = buildCookiePlan(browserConfig);
     log(chalk.bold(`[${label}] ${plan.description}`));
 }
+function logBrowserArchivePolicy(browserConfig, log, label) {
+    const mode = browserConfig?.archiveConversations ?? "auto";
+    log(chalk.dim(`[${label}] ChatGPT archive policy: ${mode}.`));
+}
 function logBrowserFileSummary(artifacts, log, label) {
     if (artifacts.attachments.length > 0) {
         const prefix = artifacts.bundled
@@ -75,12 +90,15 @@ function logBrowserFileSummary(artifacts, log, label) {
     }
     log(chalk.dim(`[${label}] No files attached.`));
 }
-export async function runBrowserPreview({ runOptions, cwd, version, previewMode, log, }, deps = {}) {
+export async function runBrowserPreview({ runOptions, cwd, version, previewMode, log, browserConfig, }, deps = {}) {
+    validateBrowserFollowUps(runOptions, browserConfig);
     const assemblePromptImpl = deps.assembleBrowserPromptImpl ?? assembleBrowserPrompt;
     const artifacts = await assemblePromptImpl(runOptions, { cwd });
     const suffix = buildTokenEstimateSuffix(artifacts);
     const headerLine = `[preview] Oracle (${version}) browser mode (${runOptions.model}) with ~${artifacts.estimatedInputTokens.toLocaleString()} tokens${suffix}.`;
     log(chalk.cyan(headerLine));
+    logBrowserControlPlan(browserConfig, log, "preview");
+    logBrowserFollowUpSummary(runOptions.browserFollowUps, log, "preview");
     logBrowserFileSummary(artifacts, log, "preview");
     if (previewMode === "json" || previewMode === "full") {
         const attachmentSummary = artifacts.attachments.map((attachment) => ({
@@ -96,6 +114,7 @@ export async function runBrowserPreview({ runOptions, cwd, version, previewMode,
             inlineFileCount: artifacts.inlineFileCount,
             bundled: artifacts.bundled,
             tokenEstimate: artifacts.estimatedInputTokens,
+            browserFollowUps: runOptions.browserFollowUps ?? [],
         };
         log("");
         log(chalk.bold("Preview JSON"));
@@ -107,3 +126,16 @@ export async function runBrowserPreview({ runOptions, cwd, version, previewMode,
         log(artifacts.composerText || chalk.dim("(empty prompt)"));
     }
 }
+function logBrowserFollowUpSummary(followUps, log, label) {
+    const count = followUps?.filter((entry) => entry.trim().length > 0).length ?? 0;
+    if (count > 0) {
+        log(chalk.bold(`[${label}] Browser follow-ups: ${count} additional prompt(s).`));
+        log(chalk.dim(`[${label}] Multi-turn is explicit only: Oracle will send these prompts in order, but it never invents follow-ups automatically.`));
+    }
+}
+function validateBrowserFollowUps(runOptions, browserConfig) {
+    const followUpCount = runOptions.browserFollowUps?.filter((entry) => entry.trim().length > 0).length ?? 0;
+    if (followUpCount > 0 && browserConfig?.researchMode === "deep") {
+        throw new Error("Browser follow-ups are not supported with Deep Research mode. Put the full research plan into the initial prompt or run a normal browser consult for multi-turn review.");
+    }
+}

package/dist/src/cli/duplicatePromptGuard.js

@@ -1,12 +1,20 @@
 import chalk from "chalk";
-export async function shouldBlockDuplicatePrompt({ prompt, force, sessionStore, log = console.log, }) {
+function normalizeRunSignature(prompt, browserFollowUps) {
+    const followUps = (browserFollowUps ?? [])
+        .map((entry) => entry.trim())
+        .filter(Boolean)
+        .join("\n\n--- browser follow-up ---\n\n");
+    return [prompt.trim(), followUps].filter(Boolean).join("\n\n--- browser follow-ups ---\n\n");
+}
+export async function shouldBlockDuplicatePrompt({ prompt, browserFollowUps, force, sessionStore, log = console.log, }) {
     if (force)
         return false;
     const normalized = prompt?.trim();
     if (!normalized)
         return false;
+    const signature = normalizeRunSignature(normalized, browserFollowUps);
     const running = (await sessionStore.listSessions()).filter((entry) => entry.status === "running");
-    const duplicate = running.find((entry) => (entry.options?.prompt?.trim?.() ?? "") === normalized);
+    const duplicate = running.find((entry) => normalizeRunSignature(entry.options?.prompt?.trim?.() ?? "", entry.options?.browserFollowUps) === signature);
     if (!duplicate)
         return false;
     log(chalk.yellow(`A session with the same prompt is already running (${duplicate.id}). Reattach with "oracle session ${duplicate.id}" or rerun with --force to start another run.`));

package/dist/src/cli/help.js

@@ -49,7 +49,7 @@ function renderHelpFooter(program, colors) {
         `${colors.bullet("•")} Spell out the project + platform + version requirements (repo name, target OS/toolchain versions, API dependencies) so Oracle doesn’t guess defaults.`,
         `${colors.bullet("•")} When comparing multiple repos/files, spell out each repo + path + role (e.g., “Project A SettingsView → apps/project-a/Sources/SettingsView.swift; Project B SettingsView → ../project-b/mac/...”) so the model knows exactly which file is which.`,
         `${colors.bullet("•")} Best results: 6–30 sentences plus key source files; very short prompts often yield generic answers.`,
-        `${colors.bullet("•")} Oracle is one-shot by default. For OpenAI/Azure API runs, you can chain follow-ups by passing ${colors.accent("--followup <sessionId|responseId>")} (continues via Responses API previous_response_id).`,
+        `${colors.bullet("•")} Oracle is one-shot by default. API runs can continue with ${colors.accent("--followup <sessionId|responseId>")}; browser runs can ask sequential ChatGPT turns with repeated ${colors.accent("--browser-follow-up")}.`,
         `${colors.bullet("•")} Run ${colors.accent("--files-report")} to inspect token spend before hitting the API.`,
         `${colors.bullet("•")} Non-preview runs spawn detached sessions (especially gpt-5.5-pro API). If the CLI times out, do not re-run — reattach with ${colors.accent("oracle session <slug>")} to resume/inspect the existing run.`,
         `${colors.bullet("•")} Set a memorable 3–5 word slug via ${colors.accent('--slug "<words>"')} to keep session IDs tidy.`,

package/dist/src/cli/options.js

@@ -58,6 +58,10 @@ export function collectModelList(value, previous = []) {
         .filter((entry) => entry.length > 0);
     return previous.concat(entries);
 }
+export function collectTextValues(value, previous = []) {
+    const trimmed = value.trim();
+    return trimmed ? previous.concat(trimmed) : previous;
+}
 export function parseFloatOption(value) {
     const parsed = Number.parseFloat(value);
     if (Number.isNaN(parsed)) {

package/dist/src/cli/projectSources.js

@@ -0,0 +1,116 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import chalk from "chalk";
+import { buildBrowserConfig } from "./browserConfig.js";
+import { readFiles } from "../oracle/files.js";
+import { loadUserConfig } from "../config.js";
+import { resolveConfiguredMaxFileSizeBytes } from "./fileSize.js";
+import { runBrowserProjectSources } from "../browser/projectSourcesRunner.js";
+import { normalizeProjectSourcesUrl } from "../projectSources/url.js";
+export async function runProjectSourcesCliCommand(operation, options) {
+    const { config: userConfig } = await loadUserConfig();
+    const configuredUrl = userConfig.browser?.chatgptUrl ?? userConfig.browser?.url;
+    const projectUrl = normalizeProjectSourcesUrl(options.chatgptUrl ?? configuredUrl ?? "");
+    const maxFileSizeBytes = options.maxFileSizeBytes ?? resolveConfiguredMaxFileSizeBytes(userConfig, process.env);
+    const files = operation === "add"
+        ? await resolveProjectSourceFiles(options.file ?? [], {
+            cwd: process.cwd(),
+            maxFileSizeBytes,
+        })
+        : [];
+    if (operation === "add" && files.length === 0) {
+        throw new Error("project-sources add requires at least one --file.");
+    }
+    const browserConfig = await buildProjectSourcesBrowserConfig({
+        options,
+        projectUrl,
+        configuredBrowser: userConfig.browser ?? {},
+    });
+    const result = await runBrowserProjectSources({
+        operation,
+        chatgptUrl: projectUrl,
+        files,
+        dryRun: options.dryRun,
+        config: browserConfig,
+        log: (message) => {
+            if (options.verbose || !message.startsWith("[debug]")) {
+                console.log(chalk.dim(message));
+            }
+        },
+    });
+    printProjectSourcesResult(result, Boolean(options.json));
+}
+export async function resolveProjectSourceFiles(fileInputs, options) {
+    const files = await readFiles(fileInputs, {
+        cwd: options.cwd,
+        maxFileSizeBytes: options.maxFileSizeBytes,
+        readContents: false,
+    });
+    const attachments = [];
+    for (const file of files) {
+        const stats = await fs.stat(file.path);
+        attachments.push({
+            path: file.path,
+            displayPath: path.relative(options.cwd, file.path) || path.basename(file.path),
+            sizeBytes: stats.size,
+        });
+    }
+    return attachments;
+}
+export async function buildProjectSourcesBrowserConfig({ options, projectUrl, configuredBrowser, }) {
+    const flagConfig = removeUndefined(await buildBrowserConfig({
+        ...options,
+        model: "gpt-5.5-pro",
+        chatgptUrl: projectUrl,
+    }));
+    const envProfileDir = process.env.ORACLE_BROWSER_PROFILE_DIR?.trim();
+    const manualLogin = flagConfig.manualLogin ?? configuredBrowser.manualLogin ?? (envProfileDir ? true : undefined);
+    const manualLoginProfileDir = manualLogin === true
+        ? (flagConfig.manualLoginProfileDir ??
+            configuredBrowser.manualLoginProfileDir ??
+            envProfileDir ??
+            null)
+        : null;
+    return {
+        ...configuredBrowser,
+        ...flagConfig,
+        url: projectUrl,
+        chatgptUrl: projectUrl,
+        cookieSync: manualLogin ? false : (flagConfig.cookieSync ?? configuredBrowser.cookieSync),
+        manualLogin,
+        manualLoginProfileDir,
+        desiredModel: null,
+        modelStrategy: "ignore",
+        researchMode: "off",
+    };
+}
+function removeUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+function printProjectSourcesResult(result, json) {
+    if (json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (result.status === "dry-run") {
+        console.log(chalk.bold(`Project Sources ${result.operation} dry run`));
+        console.log(`Project: ${result.projectUrl}`);
+        const plan = result.plannedUploads ?? [];
+        if (plan.length > 0) {
+            console.log(`Planned uploads: ${plan.length}`);
+            for (const upload of plan) {
+                console.log(`  batch ${upload.batch}: ${upload.displayPath}`);
+            }
+        }
+        return;
+    }
+    console.log(chalk.bold(`Project Sources ${result.operation} completed`));
+    console.log(`Project: ${result.projectUrl}`);
+    const before = result.sourcesBefore?.length ?? 0;
+    const after = result.sourcesAfter?.length ?? 0;
+    console.log(`Before: ${before}`);
+    console.log(`After: ${after}`);
+    if (result.added && result.added.length > 0) {
+        console.log(`Added: ${result.added.map((source) => source.name).join(", ")}`);
+    }
+}

package/dist/src/cli/sessionCommand.js

@@ -1,10 +1,13 @@
 import chalk from "chalk";
 import { usesDefaultStatusFilters } from "./options.js";
 import { attachSession, showStatus, } from "./sessionDisplay.js";
+import { harvestSessionBrowserOutput, liveTailSessionBrowserOutput, } from "./browserTabs.js";
 import { sessionStore } from "../sessionStore.js";
 const defaultDependencies = {
     showStatus,
     attachSession,
+    harvestSessionBrowserOutput,
+    liveTailSessionBrowserOutput,
     usesDefaultStatusFilters,
     deleteSessionsOlderThan: (options) => sessionStore.deleteOlderThan(options),
     getSessionPaths: (sessionId) => sessionStore.getPaths(sessionId),
@@ -19,9 +22,26 @@ const SESSION_OPTION_KEYS = new Set([
     "renderMarkdown",
     "path",
     "model",
+    "harvest",
+    "live",
+    "writeOutput",
+    "browserTab",
 ]);
 export async function handleSessionCommand(sessionId, command, deps = defaultDependencies) {
     const sessionOptions = command.opts();
+    const allOptions = command.optsWithGlobals?.() ?? sessionOptions;
+    const writeOutputPath = sessionOptions.writeOutput ??
+        sessionOptions.writeOutputPath ??
+        allOptions.writeOutput ??
+        allOptions.writeOutputPath ??
+        command.getOptionValue?.("writeOutput") ??
+        command.getOptionValue?.("writeOutputPath");
+    const browserTabRef = sessionOptions.browserTab ??
+        sessionOptions.browserTabRef ??
+        allOptions.browserTab ??
+        allOptions.browserTabRef ??
+        command.getOptionValue?.("browserTab") ??
+        command.getOptionValue?.("browserTabRef");
     if (sessionOptions.verboseRender) {
         process.env.ORACLE_VERBOSE_RENDER = "1";
     }
@@ -71,6 +91,37 @@ export async function handleSessionCommand(sessionId, command, deps = defaultDep
         }
         return;
     }
+    const harvestRequested = Boolean(sessionOptions.harvest);
+    const liveRequested = Boolean(sessionOptions.live);
+    if (harvestRequested && liveRequested) {
+        console.error("Cannot combine --harvest and --live. Choose one.");
+        process.exitCode = 1;
+        return;
+    }
+    if (writeOutputPath && !harvestRequested && !liveRequested) {
+        console.error("The --write-output flag requires --harvest or --live.");
+        process.exitCode = 1;
+        return;
+    }
+    if (harvestRequested || liveRequested) {
+        if (!sessionId) {
+            console.error(`The ${harvestRequested ? "--harvest" : "--live"} flag requires a session ID.`);
+            process.exitCode = 1;
+            return;
+        }
+        if (harvestRequested) {
+            await deps.harvestSessionBrowserOutput(sessionId, {
+                writeOutputPath,
+                browserTabRef,
+            });
+            return;
+        }
+        await deps.liveTailSessionBrowserOutput(sessionId, {
+            writeOutputPath,
+            browserTabRef,
+        });
+        return;
+    }
     if (!sessionId) {
         const showExamples = deps.usesDefaultStatusFilters(command);
         await deps.showStatus({