@youdie006/prodex 0.2.0

package/dist/cli.js

@@ -0,0 +1,3502 @@
+#!/usr/bin/env node
+import { execFile } from "node:child_process";
+import { realpathSync, statSync } from "node:fs";
+import { lstat, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { renderBanner, shouldColorize } from "./banner.js";
+import { buildDryRunBundle } from "./bundle.js";
+import { chatGptVisibilityBlocker, defaultChatGptProfileDir, getChatGptBrowserStatus, normalizeChatGptTargetUrl, openChatGptBrowser, sendChatGptPrompt } from "./chatgpt-browser.js";
+import { getTokenExpiryStatus, loadLocalConfig, writeLocalConfig } from "./config.js";
+import { startHttpMcpServer } from "./http-mcp.js";
+import { createMcpToolHandlers } from "./mcp-tools.js";
+import { runMcpServer } from "./mcp.js";
+import { readVerifiedUtf8File, writeVerifiedUtf8File } from "./safe-file.js";
+import { ReceiptKindSchema, TaskStatusSchema } from "./schema.js";
+import { BridgeStore, MAX_FETCHABLE_RESULT_ARTIFACT_BYTES } from "./store.js";
+const execFileAsync = promisify(execFile);
+const requirePackageJson = createRequire(import.meta.url);
+const packageJson = requirePackageJson("../package.json");
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const CLI_VERSION = packageJson.version ?? "0.0.0";
+const RESERVED_PACKAGE_NAMES = new Set(["node_modules", "favicon.ico"]);
+const PRO_BROWSER_SMOKE_TOKEN = "PRODEX_PRO_SMOKE_OK";
+const TOKEN_BEARING_MCP_URL_AUTHORITY_WARNING = "Token-bearing MCP URL authorizes all enabled bridge tools, including repo_read_file, repo_search, repo_write_file_dry_run, repo_write_file_apply, and repo_stage_reviewed_paths. Paste it only into your own trusted private MCP client.";
+const TOP_LEVEL_COMMANDS = [
+    "help",
+    "version",
+    "init",
+    "setup",
+    "start",
+    "status",
+    "tunnel",
+    "doctor",
+    "onboard",
+    "project",
+    "claude",
+    "tasks",
+    "results",
+    "receipts",
+    "sessions",
+    "pro",
+    "release",
+    "mcp"
+];
+const DOCTOR_REQUIRED_MCP_TOOLS = [
+    "bridge_create_task",
+    "bridge_list_tasks",
+    "bridge_get_task",
+    "bridge_claim_task",
+    "bridge_complete_task",
+    "bridge_block_task",
+    "bridge_list_results",
+    "bridge_fetch_result",
+    "bridge_fetch_result_artifact",
+    "bridge_list_receipts",
+    "bridge_get_receipt",
+    "bridge_list_sessions",
+    "bridge_get_session",
+    "repo_read_file",
+    "repo_search",
+    "repo_write_file_dry_run",
+    "repo_write_file_apply",
+    "repo_stage_reviewed_paths"
+];
+export async function runCli(args, io = defaultIo()) {
+    const [command, ...rest] = args;
+    const store = new BridgeStore(io.cwd);
+    if (command === "--version" || command === "-v" || command === "version") {
+        io.stdout(CLI_VERSION);
+        return 0;
+    }
+    if (!command || command === "help" || command === "--help" || command === "-h") {
+        if (shouldColorize())
+            io.stdout(renderBanner({ color: true }));
+        printHelp(io.stdout);
+        return 0;
+    }
+    if (command === "init") {
+        if (printHelpIfRequested(rest, "init", io.stdout, printInitHelp, { valueFlags: ["--cwd"] }))
+            return 0;
+        assertOnlyOptions(rest, "init", ["--cwd"]);
+        const targetCwd = resolveCwdFlag(io.cwd, rest);
+        const targetStore = new BridgeStore(targetCwd);
+        await targetStore.ensure();
+        await ensureBridgeGitignore(targetCwd);
+        io.stdout("Initialized .bridge receipt ledger.");
+        return 0;
+    }
+    if (command === "setup") {
+        if (printHelpIfRequested(rest, "setup", io.stdout, printSetupHelp, { valueFlags: ["--cwd", "--host", "--port", "--token", "--token-ttl-hours"] }))
+            return 0;
+        assertOnlyOptions(rest, "setup", ["--cwd", "--host", "--port", "--token", "--token-ttl-hours"]);
+        const targetCwd = resolveCwdFlag(io.cwd, rest);
+        const config = await writeLocalConfig(targetCwd, {
+            host: readFlag(rest, "--host") ?? "127.0.0.1",
+            port: readPortFlag(rest, "--port") ?? 8787,
+            token: readFlag(rest, "--token"),
+            tokenTtlHours: readPositiveNumberFlag(rest, "--token-ttl-hours")
+        });
+        io.stdout("Saved local ChatGPT Developer Mode MCP profile.");
+        io.stdout(`Server URL: ${redactServerUrl(config.server_url)}`);
+        io.stdout(formatTokenExpiryLine(config));
+        io.stdout("Full URL is stored in .bridge/config.local.json.");
+        return 0;
+    }
+    if (command === "start") {
+        if (printHelpIfRequested(rest, "start", io.stdout, printStartHelp, { valueFlags: ["--cwd", "--source-cli"] }))
+            return 0;
+        assertOnlyOptions(rest, "start", ["--cwd", "--source-cli"]);
+        const targetCwd = resolveCwdFlag(io.cwd, rest);
+        const sourceCli = resolveOptionalFileFlag(io.cwd, rest, "--source-cli");
+        const setupHintCwd = readFlag(rest, "--cwd") ? targetCwd : undefined;
+        const config = await loadLocalConfigForCommand(targetCwd, "start", sourceCli, setupHintCwd);
+        assertTokenNotExpiredForCommand(config, sourceCli, setupHintCwd);
+        const running = await startHttpMcpServer({
+            cwd: targetCwd,
+            host: config.host,
+            port: config.port,
+            token: config.token,
+            tokenExpiresAt: config.token_expires_at
+        });
+        io.stdout(`prodex HTTP MCP listening on ${redactServerUrl(running.mcp_url)}`);
+        io.stdout(formatTokenExpiryLine(config));
+        await waitForShutdown(async () => running.close());
+        return 0;
+    }
+    if (command === "status") {
+        if (printHelpIfRequested(rest, "status", io.stdout, printStatusHelp, {
+            valueFlags: ["--cwd", "--source-cli"],
+            booleanFlags: ["--show-token", "--url-only", "--unsafe-show-non-expiring-token"]
+        })) {
+            return 0;
+        }
+        assertOnlyOptions(rest, "status", ["--cwd", "--source-cli"], ["--show-token", "--url-only", "--unsafe-show-non-expiring-token"]);
+        const targetCwd = resolveCwdFlag(io.cwd, rest);
+        const sourceCli = resolveOptionalFileFlag(io.cwd, rest, "--source-cli");
+        const setupHintCwd = readFlag(rest, "--cwd") ? targetCwd : undefined;
+        const config = await loadLocalConfigForCommand(targetCwd, "status", sourceCli, setupHintCwd);
+        const showToken = rest.includes("--show-token");
+        const allowNonExpiringTokenReveal = rest.includes("--unsafe-show-non-expiring-token");
+        const tokenStatus = getTokenExpiryStatus(config);
+        if (showToken && tokenStatus.status === "non_expiring" && !allowNonExpiringTokenReveal) {
+            throw new Error(sourceAwareSetupMessage("status --show-token requires a token with expiry. Run `prodex setup --token-ttl-hours <hours>` first, or pass --unsafe-show-non-expiring-token for local-only debugging.", sourceCli, { cwd: setupHintCwd }));
+        }
+        if (showToken && tokenStatus.status === "expired") {
+            throw new Error(sourceAwareSetupMessage(`token expired at ${tokenStatus.token_expires_at}. Run \`prodex setup --token-ttl-hours <hours>\`.`, sourceCli, {
+                cwd: setupHintCwd
+            }));
+        }
+        const nonExpiringRevealWarning = showToken && allowNonExpiringTokenReveal && tokenStatus.status === "non_expiring"
+            ? sourceAwareSetupMessage("Showing a non-expiring token. Keep this local-only and rotate it with `prodex setup --token-ttl-hours <hours>` before any tunnel or ChatGPT Project use.", sourceCli, { cwd: setupHintCwd })
+            : undefined;
+        const serverUrl = formatServerUrlForOutput(config.server_url, { showToken });
+        if (rest.includes("--url-only")) {
+            if (showToken)
+                io.stderr(TOKEN_BEARING_MCP_URL_AUTHORITY_WARNING);
+            if (nonExpiringRevealWarning)
+                io.stderr(nonExpiringRevealWarning);
+            io.stdout(serverUrl);
+            return 0;
+        }
+        const warnings = tokenStatus.warning ? [sourceAwareSetupMessage(tokenStatus.warning, sourceCli, { cwd: setupHintCwd })] : [];
+        if (showToken)
+            warnings.push(TOKEN_BEARING_MCP_URL_AUTHORITY_WARNING);
+        if (nonExpiringRevealWarning)
+            warnings.push(nonExpiringRevealWarning);
+        io.stdout(JSON.stringify({
+            server_url: serverUrl,
+            config_path: ".bridge/config.local.json",
+            token_status: tokenStatus.status,
+            token_expires_at: tokenStatus.token_expires_at ?? null,
+            warnings
+        }, null, 2));
+        return 0;
+    }
+    if (command === "tunnel") {
+        const [subcommand, ...tunnelArgs] = rest;
+        if (!subcommand || isHelpSubcommand(subcommand)) {
+            assertNoExtraArgs(tunnelArgs, "tunnel help", 0);
+            printTunnelHelp(io.stdout);
+            return 0;
+        }
+        if (subcommand !== "url")
+            throw unknownSubcommandError("tunnel", subcommand, ["url"]);
+        if (printHelpIfRequested(tunnelArgs, "tunnel url", io.stdout, printTunnelUrlHelp, {
+            valueFlags: ["--cwd", "--public-url", "--source-cli"],
+            booleanFlags: ["--show-token", "--url-only"]
+        })) {
+            return 0;
+        }
+        assertOnlyOptions(tunnelArgs, "tunnel url", ["--cwd", "--public-url", "--source-cli"], ["--show-token", "--url-only"]);
+        const targetCwd = resolveCwdFlag(io.cwd, tunnelArgs);
+        const sourceCli = resolveOptionalFileFlag(io.cwd, tunnelArgs, "--source-cli");
+        const setupHintCwd = readFlag(tunnelArgs, "--cwd") ? targetCwd : undefined;
+        const publicUrl = readFlag(tunnelArgs, "--public-url");
+        if (!publicUrl)
+            throw new Error("tunnel url requires --public-url <https-url>");
+        parseTunnelPublicUrl(publicUrl);
+        const config = await loadLocalConfigForCommand(targetCwd, "tunnel url", sourceCli, setupHintCwd);
+        const tokenStatus = getTokenExpiryStatus(config);
+        if (tokenStatus.status === "non_expiring") {
+            throw new Error(sourceAwareSetupMessage("tunnel url requires a short-lived token. Run `prodex setup --token-ttl-hours <hours>` first.", sourceCli, {
+                cwd: setupHintCwd
+            }));
+        }
+        if (tokenStatus.status === "expired") {
+            throw new Error(sourceAwareSetupMessage(`token expired at ${tokenStatus.token_expires_at}. Run \`prodex setup --token-ttl-hours <hours>\`.`, sourceCli, {
+                cwd: setupHintCwd
+            }));
+        }
+        const mcpUrl = makeTunnelMcpUrl(publicUrl, config.token);
+        const showToken = tunnelArgs.includes("--show-token");
+        const outputUrl = showToken ? mcpUrl : redactServerUrl(mcpUrl);
+        if (tunnelArgs.includes("--url-only")) {
+            if (showToken)
+                io.stderr(TOKEN_BEARING_MCP_URL_AUTHORITY_WARNING);
+            io.stdout(outputUrl);
+            return 0;
+        }
+        const warnings = [
+            "This command does not create a tunnel. Keep `prodex start` running behind your own tunnel.",
+            "Only paste the token-bearing URL into a trusted private MCP client."
+        ];
+        if (showToken)
+            warnings.push(TOKEN_BEARING_MCP_URL_AUTHORITY_WARNING);
+        io.stdout(JSON.stringify({
+            mcp_url: outputUrl,
+            token_status: tokenStatus.status,
+            token_expires_at: tokenStatus.token_expires_at,
+            warnings
+        }, null, 2));
+        return 0;
+    }
+    if (command === "doctor") {
+        if (printHelpIfRequested(rest, "doctor", io.stdout, printDoctorHelp, { valueFlags: ["--cwd", "--source-cli"] }))
+            return 0;
+        assertOnlyOptions(rest, "doctor", ["--cwd", "--source-cli"]);
+        const targetCwd = resolveCwdFlag(io.cwd, rest);
+        const sourceCli = resolveOptionalFileFlag(io.cwd, rest, "--source-cli");
+        return runDoctor(new BridgeStore(targetCwd), { ...io, cwd: targetCwd }, sourceCli, readFlag(rest, "--cwd") ? targetCwd : undefined);
+    }
+    if (command === "release") {
+        const [subcommand, ...releaseArgs] = rest;
+        if (!subcommand || isHelpSubcommand(subcommand)) {
+            assertNoExtraArgs(releaseArgs, "release help", 0);
+            printReleaseHelp(io.stdout);
+            return 0;
+        }
+        if (subcommand === "status") {
+            if (printHelpIfRequested(releaseArgs, "release status", io.stdout, printReleaseHelp, { valueFlags: ["--cwd", "--source-cli"] }))
+                return 0;
+            assertOnlyOptions(releaseArgs, "release status", ["--cwd", "--source-cli"]);
+            const targetCwd = resolveCwdFlag(io.cwd, releaseArgs);
+            const sourceCli = resolveOptionalFileFlag(io.cwd, releaseArgs, "--source-cli");
+            io.stdout(await formatReleaseStatus(targetCwd, sourceCli, readFlag(releaseArgs, "--cwd") ? targetCwd : undefined));
+            return 0;
+        }
+        if (subcommand === "pack") {
+            if (printHelpIfRequested(releaseArgs, "release pack", io.stdout, printReleaseHelp, {
+                valueFlags: ["--cwd", "--pack-destination", "--source-cli"],
+                booleanFlags: ["--keep-workdir"]
+            })) {
+                return 0;
+            }
+            assertOnlyOptions(releaseArgs, "release pack", ["--cwd", "--pack-destination", "--source-cli"], ["--keep-workdir"]);
+            const targetCwd = resolveCwdFlag(io.cwd, releaseArgs);
+            const sourceCli = resolveOptionalFileFlag(io.cwd, releaseArgs, "--source-cli");
+            const packDestination = readFlag(releaseArgs, "--pack-destination");
+            if (!packDestination)
+                throw new Error("release pack requires --pack-destination <dir>");
+            await runReleasePackCommand({
+                cwd: io.cwd,
+                packageRoot: targetCwd,
+                packDestination: path.resolve(io.cwd, packDestination),
+                keepWorkdir: releaseArgs.includes("--keep-workdir"),
+                sourceCli,
+                releaseStatusCwd: readFlag(releaseArgs, "--cwd") ? targetCwd : undefined,
+                stdout: io.stdout,
+                stderr: io.stderr
+            });
+            return 0;
+        }
+        throw unknownSubcommandError("release", subcommand, ["status", "pack"]);
+    }
+    if (command === "onboard") {
+        if (printHelpIfRequested(rest, "onboard", io.stdout, printOnboardHelp, { valueFlags: ["--cwd", "--source-cli"] }))
+            return 0;
+        assertOnlyOptions(rest, "onboard", ["--cwd", "--source-cli"]);
+        const targetCwd = resolveCwdFlag(io.cwd, rest);
+        if (shouldColorize())
+            io.stdout(renderBanner({ color: true }));
+        io.stdout(formatOnboardingGuide(targetCwd, await hasOnboardingReadme(targetCwd), resolveOptionalFileFlag(io.cwd, rest, "--source-cli")));
+        return 0;
+    }
+    if (command === "project") {
+        const [subcommand, ...projectArgs] = rest;
+        if (!subcommand || isHelpSubcommand(subcommand)) {
+            assertNoExtraArgs(projectArgs, "project help", 0);
+            printProjectHelp(io.stdout);
+            return 0;
+        }
+        if (subcommand !== "prompt")
+            throw unknownSubcommandError("project", subcommand, ["prompt"]);
+        if (printHelpIfRequested(projectArgs, "project prompt", io.stdout, printProjectHelp, { valueFlags: ["--cwd", "--source-cli"] }))
+            return 0;
+        assertOnlyOptions(projectArgs, "project prompt", ["--cwd", "--source-cli"]);
+        io.stdout(formatProjectVerificationPrompt(resolveCwdFlag(io.cwd, projectArgs), resolveOptionalFileFlag(io.cwd, projectArgs, "--source-cli")));
+        return 0;
+    }
+    if (command === "claude") {
+        const [subcommand, ...claudeArgs] = rest;
+        if (!subcommand || isHelpSubcommand(subcommand)) {
+            assertNoExtraArgs(claudeArgs, "claude help", 0);
+            printClaudeHelp(io.stdout);
+            return 0;
+        }
+        if (subcommand === "prompt") {
+            if (printHelpIfRequested(claudeArgs, "claude prompt", io.stdout, printClaudeHelp, { valueFlags: ["--cwd", "--source-cli"] }))
+                return 0;
+            assertOnlyOptions(claudeArgs, "claude prompt", ["--cwd", "--source-cli"]);
+            io.stdout(formatClaudeVerificationPrompt(resolveCwdFlag(io.cwd, claudeArgs), resolveOptionalFileFlag(io.cwd, claudeArgs, "--source-cli")));
+            return 0;
+        }
+        if (subcommand === "config") {
+            if (printHelpIfRequested(claudeArgs, "claude config", io.stdout, printClaudeHelp, { valueFlags: ["--cwd", "--source-cli"] }))
+                return 0;
+            assertOnlyOptions(claudeArgs, "claude config", ["--cwd", "--source-cli"]);
+            io.stdout(formatClaudeConfig(resolveCwdFlag(io.cwd, claudeArgs), resolveOptionalFileFlag(io.cwd, claudeArgs, "--source-cli")));
+            return 0;
+        }
+        throw unknownSubcommandError("claude", subcommand, ["prompt", "config"]);
+    }
+    if (command === "chatgpt") {
+        const [subcommand, ...chatgptArgs] = rest;
+        if (!subcommand || isHelpSubcommand(subcommand)) {
+            throw legacyChatGptNamespaceError();
+        }
+        if (subcommand === "open") {
+            assertOnlyOptions(chatgptArgs, "chatgpt open", ["--port", "--profile-dir", "--url"]);
+            const opened = openChatGptBrowser({
+                port: readPortFlag(chatgptArgs, "--port") ?? 9333,
+                profileDir: readFlag(chatgptArgs, "--profile-dir"),
+                url: readChatGptBrowserUrlFlag(chatgptArgs)
+            });
+            await assertBrowserLaunchStayedAlive(opened);
+            io.stdout(`Opened ChatGPT browser via ${opened.command}.`);
+            io.stdout(`Profile: ${opened.profileDir}`);
+            io.stdout(`Debug: http://127.0.0.1:${opened.port}`);
+            return 0;
+        }
+        if (subcommand === "status") {
+            assertOnlyOptions(chatgptArgs, "chatgpt status", ["--port"]);
+            const status = await getChatGptBrowserStatus({ port: readPortFlag(chatgptArgs, "--port") ?? 9333 });
+            io.stdout(JSON.stringify(status, null, 2));
+            return 0;
+        }
+        if (subcommand === "smoke") {
+            assertOnlyOptions(chatgptArgs, "chatgpt smoke", ["--cwd", "--port", "--timeout-ms", "--source-cli"]);
+            const targetCwd = resolveCwdFlag(io.cwd, chatgptArgs);
+            const targetStore = new BridgeStore(targetCwd);
+            const sourceCli = resolveOptionalFileFlag(io.cwd, chatgptArgs, "--source-cli");
+            const port = readPortFlag(chatgptArgs, "--port") ?? 9333;
+            const timeoutMs = readPositiveNumberFlag(chatgptArgs, "--timeout-ms") ?? 90000;
+            const commandOptions = {
+                ...(readFlag(chatgptArgs, "--cwd") ? { cwd: targetCwd } : {}),
+                ...(readFlag(chatgptArgs, "--port") ? { port } : {})
+            };
+            const smokePrompt = `This is a one-time prodex smoke test. Reply exactly: ${PRO_BROWSER_SMOKE_TOKEN}`;
+            const recordBlockedSmoke = async (summary, blocker, thread) => {
+                const bundle = await buildDryRunBundle(targetCwd, { prompt: smokePrompt, files: [] });
+                const task = await targetStore.createTask({
+                    source: "codex",
+                    title: "GPT Pro smoke",
+                    prompt: bundle.text,
+                    repo_id: "default",
+                    provenance: {
+                        adapter: "chatgpt-control",
+                        session_id: bundle.id,
+                        thread,
+                        warnings: []
+                    }
+                });
+                await targetStore.claimTask(task.id, "chatgpt-pro");
+                await targetStore.completeTask(task.id, {
+                    status: "blocked",
+                    summary,
+                    commands: ["visible ChatGPT browser smoke"],
+                    blocker
+                });
+                await writeSessionBestEffort(targetStore, {
+                    id: bundle.id,
+                    direction: "codex_to_chatgpt",
+                    backend: "chatgpt-control",
+                    task_id: task.id,
+                    thread,
+                    status: "blocked",
+                    blocker,
+                    warnings: []
+                }, io);
+                return task.id;
+            };
+            let result;
+            try {
+                result = await sendChatGptPrompt({
+                    port,
+                    prompt: smokePrompt,
+                    timeoutMs
+                });
+            }
+            catch (error) {
+                const blocker = sourceAwareBrowserBlocker(browserSendBlockerFromError(error), sourceCli, commandOptions);
+                const message = blocker.next_step ? `${blocker.message} Next: ${blocker.next_step}` : errorMessage(error);
+                let taskId;
+                try {
+                    taskId = await recordBlockedSmoke(message, blocker);
+                }
+                catch (recordError) {
+                    throw new Error(`${message} (also failed to record blocked smoke: ${errorMessage(recordError)})`);
+                }
+                throw new Error(formatBlockedConsultRecordedMessage(message, taskId, sourceCli, { cwd: targetCwd }));
+            }
+            if (result.answer.trim() !== PRO_BROWSER_SMOKE_TOKEN) {
+                const message = `Pro browser smoke returned an unexpected answer. Expected exactly ${PRO_BROWSER_SMOKE_TOKEN}. Actual: ${firstLine(result.answer)}`;
+                const blocker = {
+                    code: "smoke_token_mismatch",
+                    message,
+                    retryable: true,
+                    next_step: `Retry \`${formatBrowserSmokeCommand(sourceCli, commandOptions)}\` after selecting the intended Pro model, or inspect the visible ChatGPT answer.`
+                };
+                let taskId;
+                try {
+                    taskId = await recordBlockedSmoke(message, blocker, result.url);
+                }
+                catch (recordError) {
+                    throw new Error(`${message} (also failed to record blocked smoke: ${errorMessage(recordError)})`);
+                }
+                throw new Error(formatBlockedConsultRecordedMessage(message, taskId, sourceCli, { cwd: targetCwd }));
+            }
+            io.stdout(JSON.stringify(result, null, 2));
+            return 0;
+        }
+        throw legacyChatGptNamespaceError(subcommand);
+    }
+    if (command === "tasks") {
+        const [subcommand, ...taskArgs] = rest;
+        if (!subcommand || isHelpSubcommand(subcommand)) {
+            assertNoExtraArgs(taskArgs, "tasks help", 0);
+            printTasksHelp(io.stdout);
+            return 0;
+        }
+        if (subcommand === "create") {
+            if (printHelpIfRequested(taskArgs, "tasks create", io.stdout, printTasksHelp, { valueFlags: ["--cwd", "--title", "--prompt", "--repo-id", "--file"] }))
+                return 0;
+            assertOnlyOptions(taskArgs, "tasks create", ["--cwd", "--title", "--prompt", "--repo-id", "--file"]);
+            const title = readFlag(taskArgs, "--title");
+            const prompt = readFlag(taskArgs, "--prompt");
+            if (!title || !prompt)
+                throw new Error("tasks create requires --title and --prompt");
+            const targetStore = new BridgeStore(resolveCwdFlag(io.cwd, taskArgs));
+            const task = await targetStore.createTask({
+                source: "codex",
+                title,
+                prompt,
+                repo_id: readFlag(taskArgs, "--repo-id") ?? "default",
+                files: readRepeatedFlag(taskArgs, "--file").map((file) => ({ path: file, role: "context" })),
+                provenance: { adapter: "cli", warnings: [] }
+            });
+            io.stdout(`${task.id}\t${task.status}\t${task.title}`);
+            return 0;
+        }
+        if (subcommand === "list") {
+            if (printHelpIfRequested(taskArgs, "tasks list", io.stdout, printTasksHelp, { valueFlags: ["--cwd", "--status"] }))
+                return 0;
+            assertOnlyOptions(taskArgs, "tasks list", ["--cwd", "--status"]);
+            const targetStore = new BridgeStore(resolveCwdFlag(io.cwd, taskArgs));
+            const status = readTaskStatusFlag(taskArgs);
+            const tasks = await listTasksForInspection(targetStore, status);
+            for (const task of tasks) {
+                io.stdout(`${task.id}\t${task.status}\t${task.title}`);
+            }
+            return 0;
+        }
+        if (subcommand === "show") {
+            if (printHelpIfRequested(taskArgs, "tasks show", io.stdout, printTasksHelp, { valueFlags: ["--cwd"], maxPositionals: 1 }))
+                return 0;
+            const [taskId] = readPositionalsWithOptions(taskArgs, "tasks show", 1, ["--cwd"]);
+            if (!taskId)
+                throw new Error("tasks show requires <task-id|latest>");
+            const targetStore = new BridgeStore(resolveCwdFlag(io.cwd, taskArgs));
+            const task = taskId === "latest" ? await latestTask(targetStore, { readOnly: true }) : await targetStore.getTaskReadOnly(taskId);
+            if (!task)
+                throw new Error(taskId === "latest" ? "No tasks found" : `Task not found: ${taskId}`);
+            io.stdout(JSON.stringify(task, null, 2));
+            return 0;
+        }
+        if (subcommand === "claim") {
+            if (printHelpIfRequested(taskArgs, "tasks claim", io.stdout, printTasksHelp, { valueFlags: ["--cwd", "--by"], maxPositionals: 1 }))
+                return 0;
+            const [taskId] = readPositionalsWithOptions(taskArgs, "tasks claim", 1, ["--cwd", "--by"]);
+            if (!taskId)
+                throw new Error("tasks claim requires <task-id>");
+            const targetStore = new BridgeStore(resolveCwdFlag(io.cwd, taskArgs));
+            const task = await targetStore.claimTask(taskId, readFlag(taskArgs, "--by") ?? "codex");
+            io.stdout(`${task.id}\t${task.status}\t${task.claimed_by ?? ""}`);
+            return 0;
+        }
+        if (subcommand === "complete") {
+            if (printHelpIfRequested(taskArgs, "tasks complete", io.stdout, printTasksHelp, {
+                valueFlags: ["--cwd", "--summary", "--command", "--artifact"],
+                maxPositionals: 1
+            })) {
+                return 0;
+            }
+            const [taskId] = readPositionalsWithOptions(taskArgs, "tasks complete", 1, ["--cwd", "--summary", "--command", "--artifact"]);
+            if (!taskId)
+                throw new Error("tasks complete requires <task-id> --summary");
+            const summary = readFlag(taskArgs, "--summary");
+            if (!summary)
+                throw new Error("tasks complete requires <task-id> --summary");
+            const targetStore = new BridgeStore(resolveCwdFlag(io.cwd, taskArgs));
+            const result = await targetStore.completeTask(taskId, {
+                status: "done",
+                summary,
+                commands: readRepeatedFlag(taskArgs, "--command"),
+                artifacts: await writeTaskCompleteArtifacts(targetStore, readRepeatedFlag(taskArgs, "--artifact"))
+            });
+            io.stdout(`${result.task_id}\t${result.status}\t${result.summary}`);
+            return 0;
+        }
+        if (subcommand === "block") {
+            if (printHelpIfRequested(taskArgs, "tasks block", io.stdout, printTasksHelp, {
+                valueFlags: ["--cwd", "--summary", "--code", "--next-step", "--command"],
+                booleanFlags: ["--retryable"],
+                maxPositionals: 1
+            })) {
+                return 0;
+            }
+            const [taskId] = readPositionalsWithOptions(taskArgs, "tasks block", 1, ["--cwd", "--summary", "--code", "--next-step", "--command"], ["--retryable"]);
+            if (!taskId)
+                throw new Error("tasks block requires <task-id> --summary");
+            const summary = readFlag(taskArgs, "--summary");
+            if (!summary)
+                throw new Error("tasks block requires <task-id> --summary");
+            const targetStore = new BridgeStore(resolveCwdFlag(io.cwd, taskArgs));
+            const result = await targetStore.completeTask(taskId, {
+                status: "blocked",
+                summary,
+                blocker: {
+                    code: readFlag(taskArgs, "--code") ?? "manual_blocker",
+                    message: summary,
+                    retryable: taskArgs.includes("--retryable"),
+                    next_step: readFlag(taskArgs, "--next-step")
+                },
+                commands: readRepeatedFlag(taskArgs, "--command")
+            });
+            io.stdout(`${result.task_id}\t${result.status}\t${result.summary}`);
+            return 0;
+        }
+        throw unknownSubcommandError("tasks", subcommand, ["create", "list", "show", "claim", "complete", "block"]);
+    }
+    if (command === "results") {
+        const [subcommand, ...resultArgs] = rest;
+        if (!subcommand || isHelpSubcommand(subcommand)) {
+            assertNoExtraArgs(resultArgs, "results help", 0);
+            printResultsHelp(io.stdout);
+            return 0;
+        }
+        if (subcommand === "show") {
+            if (printHelpIfRequested(resultArgs, "results show", io.stdout, printResultsHelp, { valueFlags: ["--cwd"], maxPositionals: 1 }))
+                return 0;
+            const [taskId] = readPositionalsWithOptions(resultArgs, "results show", 1, ["--cwd"]);
+            if (!taskId)
+                throw new Error("results show requires <task-id|latest>");
+            const targetCwd = resolveCwdFlag(io.cwd, resultArgs);
+            const targetStore = new BridgeStore(targetCwd);
+            const resultOptions = { cwd: readFlag(resultArgs, "--cwd") ? targetCwd : undefined };
+            try {
+                const resolvedTaskId = taskId === "latest" ? await latestResultTaskId(targetStore, { readOnly: true }) : taskId;
+                io.stdout(JSON.stringify(await targetStore.getFinalizedResultReadOnly(resolvedTaskId), null, 2));
+            }
+            catch (error) {
+                throw sourceAwareResultError(error, undefined, resultOptions);
+            }
+            return 0;
+        }
+        if (subcommand === "artifact") {
+            if (printHelpIfRequested(resultArgs, "results artifact", io.stdout, printResultsHelp, { valueFlags: ["--cwd"], maxPositionals: 2 }))
+                return 0;
+            const [taskId, artifactPath] = readPositionalsWithOptions(resultArgs, "results artifact", 2, ["--cwd"]);
+            if (!taskId)
+                throw new Error("results artifact requires <task-id> [artifact-path]");
+            const targetCwd = resolveCwdFlag(io.cwd, resultArgs);
+            const targetStore = new BridgeStore(targetCwd);
+            const resultOptions = { cwd: readFlag(resultArgs, "--cwd") ? targetCwd : undefined };
+            try {
+                const resolvedTaskId = taskId === "latest" ? await latestResultTaskId(targetStore, { readOnly: true }) : taskId;
+                const artifact = await targetStore.readFinalizedResultArtifactText(resolvedTaskId, artifactPath);
+                io.stdout(artifact.content);
+            }
+            catch (error) {
+                throw sourceAwareResultError(error, undefined, resultOptions);
+            }
+            return 0;
+        }
+        if (subcommand === "reseal") {
+            if (printHelpIfRequested(resultArgs, "results reseal", io.stdout, printResultsHelp, {
+                valueFlags: ["--cwd"],
+                booleanFlags: ["--confirm-current-result"],
+                maxPositionals: 1
+            })) {
+                return 0;
+            }
+            const [taskId] = readPositionalsWithOptions(resultArgs, "results reseal", 1, ["--cwd"], ["--confirm-current-result"]);
+            if (!taskId)
+                throw new Error("results reseal requires <task-id|latest> --confirm-current-result");
+            if (!resultArgs.includes("--confirm-current-result")) {
+                throw new Error("results reseal requires --confirm-current-result after you review the current .bridge/results/<task-id>.json payload locally.");
+            }
+            const targetStore = new BridgeStore(resolveCwdFlag(io.cwd, resultArgs));
+            const resolvedTaskId = taskId === "latest" ? await latestRawResultTaskId(targetStore) : taskId;
+            const resealed = await targetStore.resealResult(resolvedTaskId);
+            io.stdout(`${resealed.result.task_id}\tresealed\t${resealed.receipt.id}\tresult_sha256=${resealed.receipt.metadata.result_sha256}`);
+            return 0;
+        }
+        throw unknownSubcommandError("results", subcommand, ["show", "artifact", "reseal"]);
+    }
+    if (command === "receipts") {
+        const [subcommand, ...receiptArgs] = rest;
+        if (!subcommand || isHelpSubcommand(subcommand)) {
+            assertNoExtraArgs(receiptArgs, "receipts help", 0);
+            printReceiptsHelp(io.stdout);
+            return 0;
+        }
+        if (subcommand === "list") {
+            if (printHelpIfRequested(receiptArgs, "receipts list", io.stdout, printReceiptsHelp, { valueFlags: ["--cwd", "--kind", "--task-id"] }))
+                return 0;
+            assertOnlyOptions(receiptArgs, "receipts list", ["--cwd", "--kind", "--task-id"]);
+            const targetStore = new BridgeStore(resolveCwdFlag(io.cwd, receiptArgs));
+            const receipts = await listReceiptsForInspection(targetStore, {
+                kind: readReceiptKindFlag(receiptArgs),
+                task_id: readFlag(receiptArgs, "--task-id")
+            });
+            for (const receipt of receipts) {
+                io.stdout(`${receipt.id}\t${receipt.kind}\t${receipt.summary}${receiptInspectionListSuffix(receipt)}`);
+            }
+            return 0;
+        }
+        if (subcommand === "show") {
+            if (printHelpIfRequested(receiptArgs, "receipts show", io.stdout, printReceiptsHelp, { valueFlags: ["--cwd"], maxPositionals: 1 }))
+                return 0;
+            const [receiptId] = readPositionalsWithOptions(receiptArgs, "receipts show", 1, ["--cwd"]);
+            if (!receiptId)
+                throw new Error("receipts show requires <receipt-id|latest>");
+            const targetStore = new BridgeStore(resolveCwdFlag(io.cwd, receiptArgs));
+            const receipt = receiptId === "latest" ? (await listReceiptsForInspection(targetStore))[0] : await targetStore.getReceiptForDisplayReadOnly(receiptId);
+            if (!receipt)
+                throw new Error(receiptId === "latest" ? "No receipts found" : `Receipt not found: ${receiptId}`);
+            io.stdout(JSON.stringify(receipt, null, 2));
+            return 0;
+        }
+        throw unknownSubcommandError("receipts", subcommand, ["list", "show"]);
+    }
+    if (command === "sessions") {
+        const [subcommand, ...sessionArgs] = rest;
+        if (!subcommand || isHelpSubcommand(subcommand)) {
+            assertNoExtraArgs(sessionArgs, "sessions help", 0);
+            printSessionsHelp(io.stdout);
+            return 0;
+        }
+        if (subcommand === "list") {
+            if (printHelpIfRequested(sessionArgs, "sessions list", io.stdout, printSessionsHelp, { valueFlags: ["--cwd", "--status"] }))
+                return 0;
+            assertOnlyOptions(sessionArgs, "sessions list", ["--cwd", "--status"]);
+            const targetStore = new BridgeStore(resolveCwdFlag(io.cwd, sessionArgs));
+            const status = readSessionStatusFlag(sessionArgs);
+            const sessions = await listSessionsForInspection(targetStore, status);
+            for (const session of sessions) {
+                io.stdout(`${session.id}\t${session.status}\t${session.backend}\t${session.direction}`);
+            }
+            return 0;
+        }
+        if (subcommand === "show") {
+            if (printHelpIfRequested(sessionArgs, "sessions show", io.stdout, printSessionsHelp, { valueFlags: ["--cwd"], maxPositionals: 1 }))
+                return 0;
+            const [sessionId] = readPositionalsWithOptions(sessionArgs, "sessions show", 1, ["--cwd"]);
+            if (!sessionId)
+                throw new Error("sessions show requires <session-id|latest>");
+            const targetStore = new BridgeStore(resolveCwdFlag(io.cwd, sessionArgs));
+            const session = sessionId === "latest" ? (await listSessionsForInspection(targetStore))[0] : await targetStore.getSessionReadOnly(sessionId);
+            if (!session)
+                throw new Error(sessionId === "latest" ? "No sessions found" : `Session not found: ${sessionId}`);
+            io.stdout(formatSession(session));
+            return 0;
+        }
+        throw unknownSubcommandError("sessions", subcommand, ["list", "show"]);
+    }
+    if (command === "pro") {
+        const [subcommand, ...proArgs] = rest;
+        if (!subcommand || isHelpSubcommand(subcommand)) {
+            assertNoExtraArgs(proArgs, "pro help", 0);
+            printProHelp(io.stdout);
+            return 0;
+        }
+        if (subcommand === "ask") {
+            if (printHelpIfRequested(proArgs, "pro ask", io.stdout, printProHelp, {
+                valueFlags: [...ASK_PRO_PREVIEW_VALUE_FLAGS],
+                booleanFlags: [...ASK_PRO_BOOLEAN_FLAGS]
+            })) {
+                return 0;
+            }
+            parseAskProArgs(proArgs, ASK_PRO_PREVIEW_VALUE_FLAGS);
+            if (hasAskProSendMode(proArgs)) {
+                throw new Error("prodex pro ask is a dry-run preview. Use `prodex pro browser ask` for visible-browser sends.");
+            }
+            const hasDryRun = hasAskProDryRunMode(proArgs);
+            return runCli(["ask-pro", ...(hasDryRun ? [] : ["--dry-run"]), ...proArgs], io);
+        }
+        if (subcommand === "browser") {
+            const [browserSubcommand, ...browserArgs] = proArgs;
+            if (!browserSubcommand || isHelpSubcommand(browserSubcommand)) {
+                assertOnlyOptions(browserArgs, "pro browser help", ["--source-cli"]);
+                const sourceCli = resolveOptionalFileFlag(io.cwd, browserArgs, "--source-cli");
+                printProBrowserHelp(io.stdout, sourceCli);
+                return 0;
+            }
+            if (browserSubcommand === "login") {
+                if (printProBrowserHelpIfRequested(browserArgs, "pro browser login", io, {
+                    valueFlags: ["--cwd", "--profile-dir", "--port", "--url", "--source-cli", "--launch-timeout-ms"],
+                    booleanFlags: ["--dry-run"]
+                })) {
+                    return 0;
+                }
+                assertOnlyOptions(browserArgs, "pro browser login", ["--cwd", "--profile-dir", "--port", "--url", "--source-cli", "--launch-timeout-ms"], ["--dry-run"]);
+                const loginUrl = readChatGptBrowserUrlFlag(browserArgs);
+                const sourceCli = resolveOptionalFileFlag(io.cwd, browserArgs, "--source-cli");
+                const targetCwd = readFlag(browserArgs, "--cwd") ? resolveCwdFlag(io.cwd, browserArgs) : undefined;
+                const profileDir = readFlag(browserArgs, "--profile-dir");
+                const port = readPortFlag(browserArgs, "--port") ?? 9333;
+                const launchTimeoutMs = readPositiveNumberFlag(browserArgs, "--launch-timeout-ms");
+                const commandOptions = {
+                    ...(targetCwd ? { cwd: targetCwd } : {}),
+                    ...(profileDir ? { profileDir } : {}),
+                    ...(port !== 9333 ? { port } : {}),
+                    ...(readFlag(browserArgs, "--url") ? { url: loginUrl } : {}),
+                    ...(launchTimeoutMs !== undefined ? { launchTimeoutMs } : {})
+                };
+                if (browserArgs.includes("--dry-run")) {
+                    printBrowserLoginGuide(io.stdout, {
+                        opened: false,
+                        loginUrl,
+                        profileDir: profileDir ?? defaultChatGptProfileDir(),
+                        port,
+                        sourceCli,
+                        commandOptions
+                    });
+                    return 0;
+                }
+                const opened = openChatGptBrowser({
+                    port,
+                    profileDir,
+                    url: loginUrl
+                });
+                await assertBrowserLaunchStayedAlive(opened, launchTimeoutMs);
+                printBrowserLoginGuide(io.stdout, {
+                    opened: true,
+                    loginUrl,
+                    profileDir: opened.profileDir,
+                    port: opened.port,
+                    sourceCli,
+                    commandOptions
+                });
+                return 0;
+            }
+            if (browserSubcommand === "ask") {
+                if (printProBrowserHelpIfRequested(browserArgs, "pro browser ask", io, {
+                    valueFlags: [...ASK_PRO_VALUE_FLAGS],
+                    booleanFlags: [...ASK_PRO_BOOLEAN_FLAGS]
+                })) {
+                    return 0;
+                }
+                if (hasAskProDryRunMode(browserArgs) && hasAskProSendMode(browserArgs)) {
+                    throw new Error("ask-pro cannot combine --dry-run and --send");
+                }
+                if (hasAskProDryRunMode(browserArgs)) {
+                    throw new Error("prodex pro browser ask is an explicit visible-browser send. Use `prodex pro ask` for dry-run previews.");
+                }
+                const hasMode = hasAskProMode(browserArgs);
+                return runCli(["ask-pro", ...(hasMode ? [] : ["--send"]), ...browserArgs], { ...io, allowAskProBrowserSend: true });
+            }
+            if (browserSubcommand === "open" || browserSubcommand === "status" || browserSubcommand === "doctor") {
+                const replacement = browserSubcommand === "open" ? "login" : "check";
+                throw new Error(`Use \`prodex pro browser ${replacement}\` for explicit browser automation.`);
+            }
+            if (browserSubcommand === "smoke") {
+                if (printProBrowserHelpIfRequested(browserArgs, "pro browser smoke", io, { valueFlags: ["--cwd", "--port", "--timeout-ms", "--source-cli"] }))
+                    return 0;
+                return runCli(["chatgpt", browserSubcommand, ...browserArgs], io);
+            }
+            if (browserSubcommand === "check") {
+                if (printProBrowserHelpIfRequested(browserArgs, "pro browser check", io, { valueFlags: ["--cwd", "--port", "--timeout-ms", "--source-cli"] }))
+                    return 0;
+                assertOnlyOptions(browserArgs, "pro browser check", ["--cwd", "--port", "--timeout-ms", "--source-cli"]);
+                const targetCwd = resolveCwdFlag(io.cwd, browserArgs);
+                readPortFlag(browserArgs, "--port");
+                readPositiveNumberFlag(browserArgs, "--timeout-ms");
+                const healthy = await printProductCheck(new BridgeStore(targetCwd), io, browserArgs, targetCwd);
+                return healthy ? 0 : 1;
+            }
+            throw unknownSubcommandError("pro browser", browserSubcommand, ["login", "ask", "smoke", "check"]);
+        }
+        if (subcommand === "open" || subcommand === "status" || subcommand === "smoke" || subcommand === "check" || subcommand === "doctor") {
+            throw new Error(`Use \`prodex pro browser ${subcommand === "doctor" ? "check" : subcommand}\` for explicit browser automation.`);
+        }
+        if (subcommand === "list") {
+            if (printHelpIfRequested(proArgs, "pro list", io.stdout, printProHelp, { valueFlags: ["--cwd", "--source-cli"] }))
+                return 0;
+            assertOnlyOptions(proArgs, "pro list", ["--cwd", "--source-cli"]);
+            const targetCwd = resolveCwdFlag(io.cwd, proArgs);
+            const targetStore = new BridgeStore(targetCwd);
+            const sourceCli = resolveOptionalFileFlag(io.cwd, proArgs, "--source-cli");
+            const answerOptions = { cwd: readFlag(proArgs, "--cwd") ? targetCwd : undefined };
+            const consults = await listConsultListEntries(targetStore);
+            for (const entry of consults) {
+                if (entry.kind === "untrusted") {
+                    io.stdout(`${entry.task.id}\tuntrusted\t${sourceAwareResultMessage(errorMessage(entry.error), sourceCli, answerOptions)}`);
+                }
+                else {
+                    io.stdout(`${entry.consult.task.id}\t${entry.consult.result.status}\t${formatProListSummary(entry.consult, sourceCli, answerOptions)}`);
+                }
+            }
+            return 0;
+        }
+        if (subcommand === "latest") {
+            if (printHelpIfRequested(proArgs, "pro latest", io.stdout, printProHelp, { valueFlags: ["--cwd", "--source-cli"] }))
+                return 0;
+            assertOnlyOptions(proArgs, "pro latest", ["--cwd", "--source-cli"]);
+            const targetCwd = resolveCwdFlag(io.cwd, proArgs);
+            const targetStore = new BridgeStore(targetCwd);
+            const sourceCli = resolveOptionalFileFlag(io.cwd, proArgs, "--source-cli");
+            const answerOptions = { cwd: readFlag(proArgs, "--cwd") ? targetCwd : undefined };
+            let consult;
+            try {
+                consult = await latestTrustedConsult(targetStore);
+            }
+            catch (error) {
+                throw sourceAwareResultError(error, sourceCli, answerOptions);
+            }
+            if (!consult)
+                throw new Error("No GPT Pro answers found");
+            io.stdout(formatProAnswer(consult, sourceCli, answerOptions));
+            return 0;
+        }
+        if (subcommand === "show") {
+            if (printHelpIfRequested(proArgs, "pro show", io.stdout, printProHelp, { valueFlags: ["--cwd", "--source-cli"], maxPositionals: 1 }))
+                return 0;
+            const [taskId] = readPositionalsWithOptions(proArgs, "pro show", 1, ["--cwd", "--source-cli"]);
+            if (!taskId)
+                throw new Error("pro show requires <task-id|latest>");
+            const targetCwd = resolveCwdFlag(io.cwd, proArgs);
+            const targetStore = new BridgeStore(targetCwd);
+            const sourceCli = resolveOptionalFileFlag(io.cwd, proArgs, "--source-cli");
+            const answerOptions = { cwd: readFlag(proArgs, "--cwd") ? targetCwd : undefined };
+            let consult;
+            try {
+                consult = taskId === "latest" ? await latestTrustedConsult(targetStore) : await getConsult(targetStore, taskId, { readOnly: true });
+            }
+            catch (error) {
+                throw sourceAwareResultError(error, sourceCli, answerOptions);
+            }
+            if (!consult)
+                throw new Error(taskId === "latest" ? "No GPT Pro answers found" : `GPT Pro answer not found: ${taskId}`);
+            io.stdout(formatProAnswer(consult, sourceCli, answerOptions));
+            return 0;
+        }
+        throw unknownSubcommandError("pro", subcommand, ["ask", "browser", "list", "latest", "show"]);
+    }
+    if (command === "consults") {
+        throw new Error("The legacy `consults` alias is retired. Use `prodex pro list`, `prodex pro latest`, or `prodex pro show <task-id|latest>`.");
+    }
+    if (command === "ask-pro") {
+        const parsedAskPro = parseAskProArgs(rest);
+        const hasDryRunMode = parsedAskPro.optionArgs.includes("--dry-run");
+        const hasSendMode = parsedAskPro.optionArgs.includes("--send");
+        if (!hasDryRunMode && !hasSendMode) {
+            throw new Error("ask-pro requires --dry-run or --send");
+        }
+        if (hasDryRunMode && hasSendMode) {
+            throw new Error("ask-pro cannot combine --dry-run and --send");
+        }
+        if (hasSendMode && !io.allowAskProBrowserSend) {
+            throw new Error("Direct ask-pro --send is disabled. Use `prodex pro browser ask` for explicit visible-browser sends.");
+        }
+        const targetCwd = resolveCwdFlag(io.cwd, parsedAskPro.optionArgs);
+        const targetStore = new BridgeStore(targetCwd);
+        const files = readRepeatedFlag(parsedAskPro.optionArgs, "--file");
+        const targetUrl = readFlag(parsedAskPro.optionArgs, "--target-url");
+        const normalizedTargetUrl = targetUrl ? normalizeChatGptTargetUrl(targetUrl) : undefined;
+        if (!normalizedTargetUrl && parsedAskPro.optionArgs.includes("--confirm-target")) {
+            throw new Error("--confirm-target requires --target-url so the visible browser target is explicit.");
+        }
+        if (normalizedTargetUrl && hasSendMode && !parsedAskPro.optionArgs.includes("--confirm-target")) {
+            throw new Error("--target-url requires --confirm-target after you manually verify the visible ChatGPT tab is the intended Project/thread.");
+        }
+        const prompt = parsedAskPro.promptParts.join(" ").trim();
+        if (!prompt)
+            throw new Error("ask-pro requires a prompt");
+        const browserPort = hasSendMode ? (readPortFlag(parsedAskPro.optionArgs, "--port") ?? 9333) : undefined;
+        const browserTimeoutMs = hasSendMode ? (readPositiveNumberFlag(parsedAskPro.optionArgs, "--timeout-ms") ?? 90000) : undefined;
+        const sourceCli = resolveOptionalFileFlag(io.cwd, parsedAskPro.optionArgs, "--source-cli");
+        const bundle = await buildDryRunBundle(targetCwd, { prompt, files });
+        if (hasSendMode) {
+            const browserCommandOptions = {
+                cwd: targetCwd,
+                port: parsedAskPro.optionArgs.includes("--port") ? browserPort : undefined
+            };
+            const task = await targetStore.createTask({
+                source: "codex",
+                title: "GPT Pro consult",
+                prompt: bundle.text,
+                repo_id: "default",
+                files: files.map((file) => ({ path: file, role: "context" })),
+                provenance: {
+                    adapter: "chatgpt-control",
+                    session_id: bundle.id,
+                    thread: normalizedTargetUrl,
+                    warnings: []
+                }
+            });
+            await targetStore.claimTask(task.id, "chatgpt-pro");
+            try {
+                await writeSessionBeforeBrowserSend(targetStore, {
+                    id: bundle.id,
+                    direction: "codex_to_chatgpt",
+                    backend: "chatgpt-control",
+                    task_id: task.id,
+                    thread: normalizedTargetUrl,
+                    status: "running",
+                    warnings: []
+                });
+            }
+            catch (error) {
+                const blocker = {
+                    code: "session_record_failed",
+                    message: `Could not record ChatGPT browser session before send: ${errorMessage(error)}`,
+                    retryable: true,
+                    next_step: "Fix local .bridge write permissions, then rerun the consult."
+                };
+                try {
+                    await targetStore.completeTask(task.id, {
+                        status: "blocked",
+                        summary: blocker.message,
+                        commands: ["visible ChatGPT browser consult"],
+                        blocker
+                    });
+                }
+                catch (recordError) {
+                    throw new Error(`${blocker.message} (also failed to record blocked consult: ${errorMessage(recordError)})`);
+                }
+                throw new Error(formatBlockedConsultRecordedMessage(blocker.message, task.id, sourceCli, { cwd: targetCwd }));
+            }
+            let consult;
+            try {
+                consult = await sendChatGptPrompt({
+                    port: browserPort,
+                    prompt: bundle.text,
+                    targetUrl: normalizedTargetUrl,
+                    timeoutMs: browserTimeoutMs
+                });
+            }
+            catch (error) {
+                const blocker = sourceAwareBrowserBlocker(browserSendBlockerFromError(error), sourceCli, browserCommandOptions);
+                const message = blocker.next_step ? `${blocker.message} Next: ${blocker.next_step}` : errorMessage(error);
+                try {
+                    await targetStore.completeTask(task.id, {
+                        status: "blocked",
+                        summary: message,
+                        commands: ["visible ChatGPT browser consult"],
+                        blocker
+                    });
+                    await writeSessionBestEffort(targetStore, {
+                        id: bundle.id,
+                        direction: "codex_to_chatgpt",
+                        backend: "chatgpt-control",
+                        task_id: task.id,
+                        thread: normalizedTargetUrl,
+                        status: "blocked",
+                        blocker,
+                        warnings: []
+                    }, io);
+                }
+                catch (recordError) {
+                    throw new Error(`${message} (also failed to record blocked consult: ${errorMessage(recordError)})`);
+                }
+                throw new Error(formatBlockedConsultRecordedMessage(message, task.id, sourceCli, { cwd: targetCwd }));
+            }
+            const answerArtifactText = formatProConsultArtifact(consult);
+            const persistenceWarnings = [...consult.warnings];
+            let answerArtifactPath;
+            const answerArtifactBytes = Buffer.byteLength(answerArtifactText, "utf8");
+            if (answerArtifactBytes > MAX_FETCHABLE_RESULT_ARTIFACT_BYTES) {
+                const warning = `answer_artifact_warning: answer artifact is too large for bridge_fetch_result_artifact (${answerArtifactBytes} bytes > ${MAX_FETCHABLE_RESULT_ARTIFACT_BYTES} bytes); saved answer in result summary only`;
+                persistenceWarnings.push(warning);
+                io.stderr(warning);
+            }
+            else {
+                try {
+                    answerArtifactPath = await targetStore.writeArtifactText(`.bridge/artifacts/pro-consults/${task.id}.md`, answerArtifactText);
+                }
+                catch (error) {
+                    const warning = `answer_artifact_warning: ${errorMessage(error)}`;
+                    persistenceWarnings.push(warning);
+                    io.stderr(warning);
+                }
+            }
+            try {
+                await targetStore.writeReceipt({
+                    kind: "consult_answer_saved",
+                    task_id: task.id,
+                    session_id: bundle.id,
+                    summary: `Recorded ChatGPT answer for ${task.id}`,
+                    metadata: {
+                        ...(answerArtifactPath ? { artifact_path: answerArtifactPath } : {}),
+                        thread: consult.url,
+                        warnings: persistenceWarnings
+                    }
+                });
+            }
+            catch (error) {
+                const warning = `receipt_record_warning: ${errorMessage(error)}`;
+                persistenceWarnings.push(warning);
+                io.stderr(warning);
+            }
+            let result;
+            try {
+                result = await targetStore.completeTask(task.id, {
+                    status: "done",
+                    summary: consult.answer,
+                    artifacts: answerArtifactPath ? [{ path: answerArtifactPath, role: "result", bytes: Buffer.byteLength(answerArtifactText, "utf8") }] : [],
+                    commands: ["visible ChatGPT browser consult"],
+                    warnings: persistenceWarnings,
+                    provenance: {
+                        thread: consult.url,
+                        warnings: persistenceWarnings
+                    }
+                });
+            }
+            catch (error) {
+                io.stdout(`consult_answer_received_but_not_saved: ${task.id} ${consult.url}`);
+                io.stdout("");
+                io.stdout(consult.answer);
+                throw new Error(`ChatGPT answer was received but local persistence failed: ${errorMessage(error)}`);
+            }
+            await writeSessionBestEffort(targetStore, {
+                id: bundle.id,
+                direction: "codex_to_chatgpt",
+                backend: "chatgpt-control",
+                task_id: task.id,
+                thread: consult.url,
+                status: "done",
+                warnings: persistenceWarnings
+            }, io);
+            io.stdout(`${result.task_id}\t${result.status}\t${consult.url}`);
+            io.stdout("");
+            io.stdout(result.summary);
+        }
+        else {
+            await writeSessionBestEffort(targetStore, {
+                id: bundle.id,
+                direction: "codex_to_chatgpt",
+                backend: "manual",
+                status: "preview",
+                warnings: []
+            }, io);
+            await targetStore.writeReceipt({
+                kind: "consult_preview",
+                session_id: bundle.id,
+                summary: `Created dry-run consult preview ${bundle.id}`
+            });
+            io.stdout(`DRY RUN ${bundle.id}`);
+            io.stdout(bundle.text);
+        }
+        return 0;
+    }
+    if (command === "mcp") {
+        if (printHelpIfRequested(rest, "mcp", io.stdout, printMcpHelp, { valueFlags: ["--cwd"] }))
+            return 0;
+        assertOnlyOptions(rest, "mcp", ["--cwd"]);
+        await runMcpServer(resolveCwdFlag(io.cwd, rest));
+        return 0;
+    }
+    throw unknownTopLevelCommandError(command);
+}
+function defaultIo() {
+    return {
+        cwd: process.cwd(),
+        stdout: (line) => console.log(line),
+        stderr: (line) => console.error(line)
+    };
+}
+function printHelp(stdout) {
+    stdout(`prodex v${CLI_VERSION}
+
+Commands:
+  prodex --version
+  prodex init [--cwd /absolute/path/to/repo]
+  prodex doctor [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
+  prodex setup [--cwd /absolute/path/to/repo] [--host 127.0.0.1] [--port 8787] [--token-ttl-hours <hours>]
+  prodex start [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
+  prodex status [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js] [--show-token] [--url-only] [--unsafe-show-non-expiring-token]
+  prodex tunnel url [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js] --public-url https://... [--show-token] [--url-only]
+  prodex release status [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
+  prodex release pack [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js] --pack-destination /absolute/path [--keep-workdir]
+  prodex onboard [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
+  prodex project prompt [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
+  prodex claude prompt [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
+  prodex claude config [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
+  prodex pro ask [--dry-run] [--cwd /absolute/path/to/repo] [--file path] "prompt"  # dry-run preview
+  prodex pro browser login [--cwd /absolute/path/to/repo] [--dry-run] [--source-cli /absolute/path/to/dist/cli.js] [--profile-dir path] [--port 9333] [--url https://chatgpt.com/...] [--launch-timeout-ms 5000]  # preview/open visible browser login
+  prodex pro browser help [--source-cli /absolute/path/to/dist/cli.js]
+  prodex pro browser check [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 1500]
+  prodex pro browser smoke [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 90000]
+  prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 90000] [--target-url url --confirm-target] [--file path] "prompt"  # explicit visible-browser send
+  prodex pro latest [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
+  prodex pro list [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
+  prodex pro show <task-id|latest> [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
+  prodex tasks create [--cwd /absolute/path/to/repo] --title "Title" --prompt "Prompt"
+  prodex tasks list [--status new|claimed|done|blocked] [--cwd /absolute/path/to/repo]
+  prodex tasks show <task-id|latest> [--cwd /absolute/path/to/repo]
+  prodex tasks claim <task-id> [--cwd /absolute/path/to/repo] [--by codex]
+  prodex tasks complete <task-id> [--cwd /absolute/path/to/repo] --summary "Summary" [--command "npm test"] [--artifact .bridge/artifacts/results/name.md=text]
+  prodex tasks block <task-id> [--cwd /absolute/path/to/repo] --summary "Summary" [--code code] [--next-step "Next step"] [--retryable]
+  prodex results show <task-id|latest> [--cwd /absolute/path/to/repo]
+  prodex results artifact <task-id|latest> [artifact-path] [--cwd /absolute/path/to/repo]
+  prodex results reseal <task-id|latest> --confirm-current-result [--cwd /absolute/path/to/repo]
+  prodex receipts list [--kind kind] [--task-id task-id] [--cwd /absolute/path/to/repo]
+  prodex receipts show <receipt-id|latest> [--cwd /absolute/path/to/repo]
+  prodex sessions list [--status preview|running|done|blocked] [--cwd /absolute/path/to/repo]
+  prodex sessions show <session-id|latest> [--cwd /absolute/path/to/repo]
+  prodex mcp [--cwd /absolute/path/to/repo]`);
+}
+function printInitHelp(stdout) {
+    stdout(`prodex init
+
+Commands:
+  prodex init [--cwd /absolute/path/to/repo]
+
+Initialize the local .bridge receipt ledger and bridge .gitignore entries.`);
+}
+function printSetupHelp(stdout) {
+    stdout(`prodex setup
+
+Commands:
+  prodex setup [--cwd /absolute/path/to/repo] [--host 127.0.0.1] [--port 8787] [--token-ttl-hours <hours>]
+
+Save a loopback-only HTTP MCP profile in .bridge/config.local.json. Use --token-ttl-hours before tunnels or ChatGPT Project use.`);
+}
+function printStartHelp(stdout) {
+    stdout(`prodex start
+
+Commands:
+  prodex start [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
+
+Start the local loopback HTTP MCP server from the saved setup profile.`);
+}
+function printStatusHelp(stdout) {
+    stdout(`prodex status
+
+Commands:
+  prodex status [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js] [--show-token] [--url-only] [--unsafe-show-non-expiring-token]
+
+Show the saved local MCP URL with tokens redacted by default.`);
+}
+function printTunnelHelp(stdout) {
+    stdout(`prodex tunnel
+
+Commands:
+  prodex tunnel url [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js] --public-url https://... [--show-token] [--url-only]
+
+Format a public tunnel MCP URL from an existing local setup. This command does not create a tunnel.`);
+}
+function printTunnelUrlHelp(stdout) {
+    stdout(`prodex tunnel url
+
+Commands:
+  prodex tunnel url [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js] --public-url https://... [--show-token] [--url-only]
+
+This command does not create a tunnel. It only formats your supplied public URL with the saved short-lived MCP token.`);
+}
+function printDoctorHelp(stdout) {
+    stdout(`prodex doctor
+
+Commands:
+  prodex doctor [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
+
+Run local bridge, MCP, write/apply/stage, and HTTP MCP smoke checks without opening ChatGPT.`);
+}
+function printOnboardHelp(stdout) {
+    stdout(`prodex onboard
+
+Commands:
+  prodex onboard [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
+
+Print a local-first setup guide for Codex, ChatGPT Projects, Claude, and visible-browser Pro consults.`);
+}
+function printMcpHelp(stdout) {
+    stdout(`prodex mcp
+
+Commands:
+  prodex mcp [--cwd /absolute/path/to/repo]
+
+Run the stdio MCP server for local clients such as Claude. This does not reveal HTTP MCP URL tokens.`);
+}
+function printReleaseHelp(stdout) {
+    stdout(`prodex release
+
+Commands:
+  prodex release status [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
+  prodex release pack [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js] --pack-destination /absolute/path [--keep-workdir]
+
+Release commands are local checks and package preparation helpers; they do not publish or push.`);
+}
+function printProHelp(stdout) {
+    stdout(`prodex pro
+
+Commands:
+  prodex pro ask [--dry-run] [--cwd /absolute/path/to/repo] [--file path] "prompt"
+  prodex pro browser help [--source-cli /absolute/path/to/dist/cli.js]
+  prodex pro browser login [--cwd /absolute/path/to/repo] [--dry-run] [--source-cli /absolute/path/to/dist/cli.js] [--launch-timeout-ms 5000]
+  prodex pro browser check [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
+  prodex pro browser smoke [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
+  prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--target-url url --confirm-target] [--file path] "prompt"
+  prodex pro latest [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
+  prodex pro list [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
+  prodex pro show <task-id|latest> [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
+
+Use \`prodex pro ask\` for dry-run/manual previews.
+Use \`prodex pro browser ask\` only when you want an explicit visible-browser send.`);
+}
+function printProjectHelp(stdout) {
+    stdout(`prodex project
+
+Commands:
+  prodex project prompt [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
+
+Print a ChatGPT Project MCP verification prompt. The prompt asks for read/task handoff verification only.`);
+}
+function printClaudeHelp(stdout) {
+    stdout(`prodex claude
+
+Commands:
+  prodex claude prompt [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
+  prodex claude config [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
+
+Print Claude MCP setup and verification helpers. These commands do not start MCP or reveal HTTP tokens.`);
+}
+function printTasksHelp(stdout) {
+    stdout(`prodex tasks
+
+Commands:
+  prodex tasks create [--cwd /absolute/path/to/repo] --title "Title" --prompt "Prompt"
+  prodex tasks list [--status new|claimed|done|blocked] [--cwd /absolute/path/to/repo]
+  prodex tasks show <task-id|latest> [--cwd /absolute/path/to/repo]
+  prodex tasks claim <task-id> [--cwd /absolute/path/to/repo] [--by codex]
+  prodex tasks complete <task-id> [--cwd /absolute/path/to/repo] --summary "Summary" [--command "npm test"] [--artifact .bridge/artifacts/results/name.md=text]
+  prodex tasks block <task-id> [--cwd /absolute/path/to/repo] --summary "Summary" [--code code] [--next-step "Next step"] [--retryable]`);
+}
+function printResultsHelp(stdout) {
+    stdout(`prodex results
+
+Commands:
+  prodex results show <task-id|latest> [--cwd /absolute/path/to/repo]
+  prodex results artifact <task-id|latest> [artifact-path] [--cwd /absolute/path/to/repo]
+  prodex results reseal <task-id|latest> --confirm-current-result [--cwd /absolute/path/to/repo]`);
+}
+function printReceiptsHelp(stdout) {
+    stdout(`prodex receipts
+
+Commands:
+  prodex receipts list [--kind kind] [--task-id task-id] [--cwd /absolute/path/to/repo]
+  prodex receipts show <receipt-id|latest> [--cwd /absolute/path/to/repo]`);
+}
+function printSessionsHelp(stdout) {
+    stdout(`prodex sessions
+
+Commands:
+  prodex sessions list [--status preview|running|done|blocked] [--cwd /absolute/path/to/repo]
+  prodex sessions show <session-id|latest> [--cwd /absolute/path/to/repo]`);
+}
+function isHelpSubcommand(value) {
+    return value === "help" || value === "--help" || value === "-h";
+}
+function isHelpArgs(args) {
+    return args.length > 0 && isHelpSubcommand(args[0]);
+}
+function printHelpIfRequested(args, command, stdout, printHelp, options = {}) {
+    const helpIndex = findHelpFlagIndexBeforePromptDelimiter(args);
+    if (helpIndex === -1)
+        return false;
+    assertHelpRequestArgs(args, command, options);
+    printHelp(stdout);
+    return true;
+}
+function printProBrowserHelpIfRequested(args, command, io, options) {
+    const helpIndex = findHelpFlagIndexBeforePromptDelimiter(args);
+    if (helpIndex === -1)
+        return false;
+    assertHelpRequestArgs(args, command, options);
+    printProBrowserHelp(io.stdout, resolveOptionalFileFlag(io.cwd, args, "--source-cli"));
+    return true;
+}
+function findHelpFlagIndexBeforePromptDelimiter(args) {
+    const delimiterIndex = args.indexOf("--");
+    const limit = delimiterIndex === -1 ? args.length : delimiterIndex;
+    return args.findIndex((arg, index) => index < limit && isHelpSubcommand(arg));
+}
+function assertHelpRequestArgs(args, command, options) {
+    const delimiterIndex = args.indexOf("--");
+    const commandArgs = delimiterIndex === -1 ? args : args.slice(0, delimiterIndex);
+    const valueFlagSet = new Set(options.valueFlags ?? []);
+    const booleanFlagSet = new Set(options.booleanFlags ?? []);
+    const maxPositionals = options.maxPositionals ?? 0;
+    let positionals = 0;
+    for (let index = 0; index < commandArgs.length; index += 1) {
+        const arg = commandArgs[index];
+        if (isHelpSubcommand(arg))
+            continue;
+        if (valueFlagSet.has(arg)) {
+            const next = commandArgs[index + 1];
+            if (next && !isHelpSubcommand(next)) {
+                readFlagValue(commandArgs, index, arg);
+                index += 1;
+            }
+            continue;
+        }
+        if (booleanFlagSet.has(arg))
+            continue;
+        if (arg.startsWith("-")) {
+            throw unknownOptionError(arg, command, [...valueFlagSet, ...booleanFlagSet]);
+        }
+        if (positionals >= maxPositionals) {
+            throw new Error(`Unexpected argument for ${command}: ${arg}`);
+        }
+        positionals += 1;
+    }
+}
+function unknownSubcommandError(command, subcommand, expected) {
+    const suggestion = closestSuggestion(subcommand, expected);
+    const suggestionText = suggestion ? ` Did you mean \`prodex ${command} ${suggestion}\`?` : "";
+    return new Error(`Unknown ${command} subcommand: ${subcommand}.${suggestionText} Expected one of: ${expected.join(", ")}. Run \`prodex ${command} --help\`.`);
+}
+function unknownTopLevelCommandError(command) {
+    const suggestion = closestSuggestion(command, TOP_LEVEL_COMMANDS);
+    const suggestionText = suggestion ? ` Did you mean \`prodex ${suggestion}\`?` : "";
+    return new Error(`Unknown command: ${command}.${suggestionText} Run \`prodex help\`.`);
+}
+function unknownOptionError(option, command, candidates) {
+    const suggestion = closestSuggestion(option, candidates);
+    const suggestionText = suggestion ? `. Did you mean \`${suggestion}\`?` : "";
+    const context = command ? ` for ${command}` : "";
+    return new Error(`Unknown option${context}: ${option}${suggestionText}`);
+}
+function closestSuggestion(value, candidates) {
+    let best;
+    for (const candidate of candidates) {
+        const distance = editDistance(value, candidate);
+        const prefixMatch = isUsefulPrefixSuggestion(value, candidate);
+        if (!best || (prefixMatch && !best.prefixMatch) || (prefixMatch === best.prefixMatch && distance < best.distance)) {
+            best = { command: candidate, distance, prefixMatch };
+        }
+    }
+    return best && (best.prefixMatch || best.distance <= 2) ? best.command : undefined;
+}
+function isUsefulPrefixSuggestion(value, candidate) {
+    return value.length >= 5 && candidate.startsWith(value);
+}
+function editDistance(left, right) {
+    const previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+    const current = Array.from({ length: right.length + 1 }, () => 0);
+    for (let leftIndex = 1; leftIndex <= left.length; leftIndex += 1) {
+        current[0] = leftIndex;
+        for (let rightIndex = 1; rightIndex <= right.length; rightIndex += 1) {
+            const substitutionCost = left[leftIndex - 1] === right[rightIndex - 1] ? 0 : 1;
+            current[rightIndex] = Math.min(previous[rightIndex] + 1, current[rightIndex - 1] + 1, previous[rightIndex - 1] + substitutionCost);
+        }
+        previous.splice(0, previous.length, ...current);
+    }
+    return previous[right.length];
+}
+function legacyChatGptNamespaceError(subcommand) {
+    const prefix = subcommand ? `Unknown legacy chatgpt subcommand: ${subcommand}.` : "The legacy `chatgpt` namespace is hidden.";
+    return new Error(`${prefix} Use \`prodex pro browser help\` for visible-browser commands.`);
+}
+function formatProjectVerificationPrompt(cwd, sourceCli) {
+    const cli = formatCliCommand(sourceCli);
+    const quotedCwd = shellQuote(cwd);
+    const sourceCliOption = formatSourceCliOption(sourceCli);
+    return `ChatGPT Project MCP verification prompt
+
+Paste this into the ChatGPT Project after adding the prodex MCP server URL.
+${TOKEN_BEARING_MCP_URL_AUTHORITY_WARNING}
+
+Please verify the prodex MCP bridge for this private project:
+
+1. Call the MCP tool \`bridge_create_task\` with:
+
+   {
+     "title": "prodex MCP verification",
+     "prompt": "Verify that this ChatGPT Project can create tasks through the local prodex MCP bridge.",
+     "repo_id": "default"
+   }
+
+2. Call \`bridge_list_tasks\` with:
+
+   { "status": "new" }
+
+3. Call \`bridge_get_task\` with the task_id returned by \`bridge_create_task\`.
+
+4. Reply with the task_id and whether all three MCP calls succeeded. Ask me to run the local completion command below, then wait.
+
+5. After I reply exactly \`local completion done\`, call \`bridge_fetch_result\` with:
+
+   { "task_id": "<task-id>" }
+
+6. If the fetched result lists artifacts, call \`bridge_fetch_result_artifact\` for each listed result artifact path:
+
+   { "task_id": "<task-id>", "path": "<artifact-path>" }
+
+7. Reply with whether \`bridge_fetch_result\` returned the verification result summary and whether every listed result artifact was readable. Do not call repo_write_file_dry_run, repo_write_file_apply, repo_stage_reviewed_paths, or any write/stage tool for this verification.
+
+Local follow-up after ChatGPT replies:
+
+cd ${quotedCwd}
+${cli} tasks list --status new --cwd ${quotedCwd}
+${cli} tasks show <task-id> --cwd ${quotedCwd}
+${cli} tasks complete <task-id> --cwd ${quotedCwd} --summary "prodex MCP verification result" --artifact .bridge/artifacts/results/mcp-verification.md="prodex MCP verification artifact"
+
+Then reply to ChatGPT with:
+
+local completion done
+
+If ChatGPT cannot see or call the MCP tools, keep the server terminal running and check locally:
+
+${cli} status --cwd ${quotedCwd}${sourceCliOption}
+${cli} doctor --cwd ${quotedCwd}${sourceCliOption}`;
+}
+function formatOnboardingGuide(cwd, hasReadme, sourceCli) {
+    const quotedCwd = shellQuote(cwd);
+    const cli = sourceCli ? `node ${shellQuote(sourceCli)}` : "prodex";
+    const sourceCliOption = sourceCli ? ` --source-cli ${shellQuote(sourceCli)}` : "";
+    const proAskCommand = hasReadme ? `${cli} pro ask --cwd ${quotedCwd} --file README.md "Review this repo"` : `${cli} pro ask --cwd ${quotedCwd} "Review this repo"`;
+    const proBrowserAskCommand = hasReadme
+        ? `${cli} pro browser ask${sourceCliOption} --cwd ${quotedCwd} --file README.md "Review this repo"`
+        : `${cli} pro browser ask${sourceCliOption} --cwd ${quotedCwd} "Review this repo"`;
+    return `prodex onboarding
+
+repo: ${cwd}
+
+1. Prepare the local bridge:
+   ${cli} init --cwd ${quotedCwd}
+   ${cli} doctor --cwd ${quotedCwd}${sourceCliOption}
+
+2. Claude stdio MCP:
+   ${cli} claude config --cwd ${quotedCwd}${sourceCliOption}
+   ${cli} claude prompt --cwd ${quotedCwd}${sourceCliOption}
+
+3. ChatGPT Project HTTP MCP:
+   Note: HTTP MCP uses a short-lived token. Paste token-bearing URLs only into your own trusted private MCP client.
+   ${TOKEN_BEARING_MCP_URL_AUTHORITY_WARNING}
+   ${cli} setup --cwd ${quotedCwd} --token-ttl-hours 24
+   ${cli} start --cwd ${quotedCwd}${sourceCliOption}
+   Keep this terminal open while ChatGPT uses the bridge; run the next commands in a second terminal.
+   ${cli} status --cwd ${quotedCwd} --show-token --url-only${sourceCliOption}
+   ${cli} project prompt --cwd ${quotedCwd}${sourceCliOption}
+
+4. Optional ChatGPT Pro consults:
+   cd ${quotedCwd}
+   ${proAskCommand}  # dry-run/manual preview
+   ${cli} pro browser login --dry-run${sourceCliOption}  # preview, no browser opens
+   ${cli} pro browser login${sourceCliOption}  # opens visible browser
+   ${cli} pro browser help${sourceCliOption}
+   ${cli} pro browser check${sourceCliOption} --cwd ${quotedCwd}
+   ${cli} pro browser smoke${sourceCliOption} --cwd ${quotedCwd}
+   ${proBrowserAskCommand}  # visible-browser send
+   ${cli} pro list${sourceCliOption} --cwd ${quotedCwd}
+   ${cli} pro latest${sourceCliOption} --cwd ${quotedCwd}
+   ${cli} results show latest --cwd ${quotedCwd}
+   ${cli} results artifact latest --cwd ${quotedCwd}
+   ${cli} results reseal <task-id> --confirm-current-result --cwd ${quotedCwd}  # only after reviewing .bridge/results/<task-id>.json
+
+Safety notes:
+- This command only prints commands; it does not start servers, open browsers, or write files.
+- Visible-browser sends require a manual, visible browser session and stop on login, captcha, Cloudflare, permission, rate-limit, or usage-limit blockers.`;
+}
+async function hasOnboardingReadme(cwd) {
+    try {
+        const stat = await lstat(path.join(cwd, "README.md"));
+        return stat.isFile();
+    }
+    catch (error) {
+        if (isMissingFileError(error))
+            return false;
+        throw error;
+    }
+}
+function formatClaudeVerificationPrompt(cwd, sourceCli) {
+    const cli = formatCliCommand(sourceCli);
+    const quotedCwd = shellQuote(cwd);
+    const sourceCliOption = sourceCli ? ` --source-cli ${shellQuote(sourceCli)}` : "";
+    return `Claude MCP verification prompt
+
+Paste this into Claude after adding the prodex stdio MCP server.
+
+Please verify the prodex MCP bridge for this private repo:
+
+1. Call the MCP tool \`bridge_create_task\` with:
+
+   {
+     "title": "prodex Claude MCP verification",
+     "prompt": "Verify that Claude can create tasks through the local prodex MCP bridge.",
+     "repo_id": "default"
+   }
+
+2. Call \`bridge_list_tasks\` with:
+
+   { "status": "new" }
+
+3. Call \`bridge_get_task\` with the task_id returned by \`bridge_create_task\`.
+
+4. Reply with the task_id and whether all three MCP calls succeeded. Ask me to run the local completion command below, then wait.
+
+5. After I reply exactly \`local completion done\`, call \`bridge_fetch_result\` with:
+
+   { "task_id": "<task-id>" }
+
+6. If the fetched result lists artifacts, call \`bridge_fetch_result_artifact\` for each listed result artifact path:
+
+   { "task_id": "<task-id>", "path": "<artifact-path>" }
+
+7. Reply with whether \`bridge_fetch_result\` returned the verification result summary and whether every listed result artifact was readable. Do not call repo_write_file_dry_run, repo_write_file_apply, repo_stage_reviewed_paths, or any write/stage tool for this verification.
+
+Local follow-up after Claude replies:
+
+cd ${quotedCwd}
+${cli} tasks list --status new --cwd ${quotedCwd}
+${cli} tasks show <task-id> --cwd ${quotedCwd}
+${cli} tasks complete <task-id> --cwd ${quotedCwd} --summary "prodex Claude MCP verification result" --artifact .bridge/artifacts/results/claude-verification.md="prodex Claude MCP verification artifact"
+
+Then reply to Claude with:
+
+local completion done
+
+If Claude cannot see or call the MCP tools, regenerate the config and run the local health check:
+
+${cli} claude config --cwd ${quotedCwd}${sourceCliOption}
+${cli} doctor --cwd ${quotedCwd}${sourceCliOption}`;
+}
+function formatClaudeConfig(cwd, sourceCli) {
+    return JSON.stringify({
+        mcpServers: {
+            prodex: sourceCli
+                ? { command: "node", args: [sourceCli, "mcp", "--cwd", cwd] }
+                : { command: "prodex", args: ["mcp", "--cwd", cwd] }
+        }
+    }, null, 2);
+}
+function shellQuote(value) {
+    return /^[A-Za-z0-9_./:@=-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
+}
+function formatCliCommand(sourceCli) {
+    return sourceCli ? `node ${shellQuote(sourceCli)}` : "prodex";
+}
+function formatInitCommand(sourceCli, options = {}) {
+    return [`${formatCliCommand(sourceCli)} init`, options.cwd ? `--cwd ${shellQuote(options.cwd)}` : undefined].filter(Boolean).join(" ");
+}
+function formatSetupCommand(sourceCli, options = {}) {
+    return [`${formatCliCommand(sourceCli)} setup`, options.cwd ? `--cwd ${shellQuote(options.cwd)}` : undefined].filter(Boolean).join(" ");
+}
+function formatSourceCliOption(sourceCli) {
+    return sourceCli ? ` --source-cli ${shellQuote(sourceCli)}` : "";
+}
+function formatBrowserLoginCommand(sourceCli, options = {}) {
+    return formatCommandInCwd(formatBrowserLoginCommandBody(sourceCli, options), options.cwd);
+}
+function formatBrowserLoginCommandBody(sourceCli, options = {}) {
+    const command = [
+        `${formatCliCommand(sourceCli)} pro browser login${formatSourceCliOption(sourceCli)}`,
+        options.profileDir ? `--profile-dir ${shellQuote(options.profileDir)}` : undefined,
+        options.port ? `--port ${options.port}` : undefined,
+        options.url ? `--url ${shellQuote(options.url)}` : undefined,
+        options.launchTimeoutMs ? `--launch-timeout-ms ${options.launchTimeoutMs}` : undefined
+    ]
+        .filter(Boolean)
+        .join(" ");
+    return command;
+}
+function formatBrowserSmokeCommand(sourceCli, options = {}) {
+    return formatCommandInCwd(formatBrowserSmokeCommandBody(sourceCli, options), options.cwd);
+}
+function formatBrowserSmokeCommandBody(sourceCli, options = {}) {
+    const command = [`${formatCliCommand(sourceCli)} pro browser smoke${formatSourceCliOption(sourceCli)}`, options.port ? `--port ${options.port}` : undefined]
+        .filter(Boolean)
+        .join(" ");
+    return command;
+}
+// ask retry commands carry their own --target-url/--confirm-target/"prompt" tail, so callers
+// preserve the stored argument tail verbatim and only re-point this bare base at the source CLI.
+function formatBrowserAskCommandBody(sourceCli) {
+    return `${formatCliCommand(sourceCli)} pro browser ask${formatSourceCliOption(sourceCli)}`;
+}
+function formatBrowserCheckCommand(sourceCli, options = {}) {
+    const command = [`${formatCliCommand(sourceCli)} pro browser check${formatSourceCliOption(sourceCli)}`, options.port ? `--port ${options.port}` : undefined]
+        .filter(Boolean)
+        .join(" ");
+    return formatCommandInCwd(command, options.cwd);
+}
+function formatBrowserTargetAskCommand(sourceCli, options = {}) {
+    const command = [
+        `${formatCliCommand(sourceCli)} pro browser ask${formatSourceCliOption(sourceCli)}`,
+        options.port ? `--port ${options.port}` : undefined,
+        `--target-url ${options.targetUrl ? shellQuote(options.targetUrl) : "<chatgpt-url>"} --confirm-target "prompt"`
+    ]
+        .filter(Boolean)
+        .join(" ");
+    return formatCommandInCwd(command, options.cwd);
+}
+function formatCommandInCwd(command, cwd) {
+    return cwd ? `cd ${shellQuote(cwd)} && ${command}` : command;
+}
+function formatProShowCommand(taskId, sourceCli, options = {}) {
+    return [`${formatCliCommand(sourceCli)} pro show ${shellQuote(taskId)}${formatSourceCliOption(sourceCli)}`, options.cwd ? `--cwd ${shellQuote(options.cwd)}` : undefined]
+        .filter(Boolean)
+        .join(" ");
+}
+function formatProLatestCommand(sourceCli, options = {}) {
+    return [`${formatCliCommand(sourceCli)} pro latest${formatSourceCliOption(sourceCli)}`, options.cwd ? `--cwd ${shellQuote(options.cwd)}` : undefined]
+        .filter(Boolean)
+        .join(" ");
+}
+function formatResultResealCommand(taskId, sourceCli, options = {}) {
+    return [
+        `${formatCliCommand(sourceCli)} results reseal ${shellQuote(taskId)} --confirm-current-result`,
+        options.cwd ? `--cwd ${shellQuote(options.cwd)}` : undefined
+    ]
+        .filter(Boolean)
+        .join(" ");
+}
+function sourceAwareResultMessage(message, sourceCli, options = {}) {
+    if (!sourceCli && !options.cwd)
+        return message;
+    return message.replace(/`prodex results reseal ([^`\s]+) --confirm-current-result`/g, (_match, taskId) => `\`${formatResultResealCommand(taskId, sourceCli, options)}\``);
+}
+function sourceAwareResultError(error, sourceCli, options = {}) {
+    if (!isUntrustedResultError(error))
+        return error;
+    return new Error(sourceAwareResultMessage(errorMessage(error), sourceCli, options), { cause: error });
+}
+function formatBlockedConsultRecordedMessage(message, taskId, sourceCli, options = {}) {
+    return `${message}\nblocked consult recorded: ${taskId}; inspect with \`${formatProShowCommand(taskId, sourceCli, options)}\` or \`${formatProLatestCommand(sourceCli, options)}\`.`;
+}
+function formatReleaseStatusCommand(sourceCli, options = {}) {
+    return [`${formatCliCommand(sourceCli)} release status${formatSourceCliOption(sourceCli)}`, options.cwd ? `--cwd ${shellQuote(options.cwd)}` : undefined]
+        .filter(Boolean)
+        .join(" ");
+}
+function formatReleasePackCommand(sourceCli, options = {}) {
+    return [
+        `${formatCliCommand(sourceCli)} release pack${formatSourceCliOption(sourceCli)}`,
+        options.cwd ? `--cwd ${shellQuote(options.cwd)}` : undefined,
+        "--pack-destination <dir>"
+    ]
+        .filter(Boolean)
+        .join(" ");
+}
+function formatGitPushUpstreamCommand(branch) {
+    return `git push -u origin ${shellQuote(branch)}`;
+}
+function sourceAwareBrowserNextStep(nextStep, sourceCli, options = {}) {
+    if (!nextStep)
+        return nextStep;
+    const targetRetry = nextStep.match(/^Open (https:\/\/chatgpt\.com\/\S+) in the (visible|dedicated) browser and retry(\. Current: .+|\.)$/);
+    if (targetRetry) {
+        const [, targetUrl, location, suffix] = targetRetry;
+        return `Open ${targetUrl} in the ${location} browser and run \`${formatBrowserTargetAskCommand(sourceCli, {
+            ...options,
+            targetUrl
+        })}\`${suffix}`;
+    }
+    if (!sourceCli && !options.port && !options.cwd)
+        return nextStep;
+    return nextStep
+        .replace(/`cd (.+?) && prodex pro browser login([^`]*)?`/g, (_match, cwdPrefix, storedArgs) => {
+        return `\`cd ${cwdPrefix} && ${formatBrowserLoginCommandBody(sourceCli, browserOptionsWithStoredPort(options, storedArgs))}\``;
+    })
+        .replace(/`cd (.+?) && prodex pro browser smoke([^`]*)?`/g, (_match, cwdPrefix, storedArgs) => {
+        return `\`cd ${cwdPrefix} && ${formatBrowserSmokeCommandBody(sourceCli, browserOptionsWithStoredPort(options, storedArgs))}\``;
+    })
+        .replace(/`cd (.+?) && prodex pro browser ask([^`]*)?`/g, (_match, cwdPrefix, storedArgs) => {
+        return `\`cd ${cwdPrefix} && ${formatBrowserAskCommandBody(sourceCli)}${storedArgs ?? ""}\``;
+    })
+        .replace(/`prodex pro browser login([^`]*)?`/g, (_match, storedArgs) => {
+        return `\`${formatBrowserLoginCommand(sourceCli, browserOptionsWithStoredPort(options, storedArgs))}\``;
+    })
+        .replace(/`prodex pro browser smoke([^`]*)?`/g, (_match, storedArgs) => {
+        return `\`${formatBrowserSmokeCommand(sourceCli, browserOptionsWithStoredPort(options, storedArgs))}\``;
+    })
+        .replace(/`prodex pro browser ask([^`]*)?`/g, (_match, storedArgs) => {
+        return `\`${formatBrowserAskCommandBody(sourceCli)}${storedArgs ?? ""}\``;
+    })
+        .replaceAll("pass --target-url with --confirm-target", `run \`${formatBrowserTargetAskCommand(sourceCli, options)}\``);
+}
+function browserOptionsWithStoredPort(options, storedArgs) {
+    if (options.port || !storedArgs)
+        return options;
+    const match = storedArgs.match(/(?:^|\s)--port\s+(\d{1,5})(?:\s|$)/);
+    if (!match)
+        return options;
+    const port = Number(match[1]);
+    if (!Number.isInteger(port) || port < 1 || port > 65535)
+        return options;
+    return { ...options, port };
+}
+function productCheckBrowserNextStep(nextStep, sourceCli, options = {}) {
+    const sourceAware = sourceAwareBrowserNextStep(nextStep, sourceCli, options);
+    if (!sourceAware)
+        return sourceAware;
+    if (sourceAware.includes("`"))
+        return sourceAware;
+    if (sourceAware.includes("pass --target-url with --confirm-target")) {
+        return sourceAware.replace("pass --target-url with --confirm-target", `run \`${formatBrowserTargetAskCommand(sourceCli, options)}\``);
+    }
+    return sourceAware.replace(/(?:and|then) retry\.$/, `then run \`${formatBrowserSmokeCommand(sourceCli, options)}\`.`);
+}
+function sourceAwareBrowserBlocker(blocker, sourceCli, options = {}) {
+    const nextStep = sourceAwareBrowserNextStep(blocker.next_step, sourceCli, options);
+    return nextStep === blocker.next_step ? blocker : { ...blocker, next_step: nextStep };
+}
+function sourceAwareSetupMessage(message, sourceCli, options = {}) {
+    if (!sourceCli && !options.cwd)
+        return message;
+    const setupCommand = formatSetupCommand(sourceCli, options);
+    return message
+        .replaceAll("`prodex setup --token-ttl-hours <hours>`", `\`${setupCommand} --token-ttl-hours <hours>\``)
+        .replaceAll("`prodex setup`", `\`${setupCommand}\``);
+}
+function sourceAwareReleaseMessage(message, sourceCli, options = {}) {
+    if (!sourceCli && !options.cwd)
+        return message;
+    return message
+        .replaceAll("`prodex release pack --pack-destination <dir>`", `\`${formatReleasePackCommand(sourceCli, options)}\``)
+        .replaceAll("`prodex release status`", `\`${formatReleaseStatusCommand(sourceCli, options)}\``);
+}
+async function formatReleaseStatus(cwd, sourceCli, releaseHintCwd) {
+    const packageJsonPath = path.join(cwd, "package.json");
+    const raw = await readReleasePackageJson(packageJsonPath).catch(async (error) => {
+        if (!isMissingFileError(error))
+            throw error;
+        return undefined;
+    });
+    if (raw === undefined) {
+        const lines = [formatReleaseStatusCommand(sourceCli, { cwd: releaseHintCwd }), "package: <missing package.json>"];
+        lines.push(`metadata: blocked package.json not found at ${packageJsonPath}`);
+        const gitStatus = await readReleaseGitStatus(cwd);
+        lines.push(gitStatus.line);
+        if (gitStatus.next)
+            lines.push(`git_next: ${gitStatus.next}`);
+        lines.push("next: run this command from a package root or pass `--cwd /absolute/path/to/repo`");
+        lines.push("verification: run `npm run release:verify` anytime without weakening the publish guard");
+        return lines.join("\n");
+    }
+    let packageJson;
+    try {
+        packageJson = JSON.parse(raw);
+    }
+    catch {
+        const lines = [formatReleaseStatusCommand(sourceCli, { cwd: releaseHintCwd }), "package: <invalid package.json>"];
+        lines.push(`metadata: blocked package.json is not valid JSON at ${packageJsonPath}`);
+        const gitStatus = await readReleaseGitStatus(cwd);
+        lines.push(gitStatus.line);
+        if (gitStatus.next)
+            lines.push(`git_next: ${gitStatus.next}`);
+        lines.push("next: fix package.json syntax, then run `npm run release:check`");
+        lines.push("verification: run `npm run release:verify` anytime without weakening the publish guard");
+        return lines.join("\n");
+    }
+    const name = typeof packageJson.name === "string" && packageJson.name.trim() ? packageJson.name : "<unnamed>";
+    const version = typeof packageJson.version === "string" && packageJson.version.trim() ? packageJson.version : "<unversioned>";
+    const lines = [formatReleaseStatusCommand(sourceCli, { cwd: releaseHintCwd }), `package: ${name}@${version}`];
+    const license = typeof packageJson.license === "string" ? packageJson.license.trim() : "";
+    const identityError = packageIdentityError(packageJson);
+    let metadataNext = "run `npm run release:check` before publishing";
+    let metadataReady = false;
+    let packReady = false;
+    const packCheckEligible = !identityError;
+    if (identityError) {
+        lines.push(`metadata: blocked ${identityError.message}`);
+        metadataNext = identityError.next;
+    }
+    else if (packageJson.private === true) {
+        lines.push("metadata: blocked package.json private: true prevents npm publish");
+        metadataNext = "remove `private: true` before public publishing, then run `npm run release:check`";
+    }
+    else {
+        if (!license) {
+            lines.push("metadata: blocked package.json must include an explicit license before publishing");
+            metadataNext = await missingPackageLicenseNextStep(cwd);
+        }
+        else if (license === "UNLICENSED") {
+            lines.push('metadata: blocked license "UNLICENSED" is not publishable');
+            metadataNext = "choose a public license and add LICENSE, then run `npm run release:check`";
+        }
+        else if (license !== "MIT") {
+            lines.push(`metadata: blocked license=${license} package.json license must be MIT before publishing`);
+            metadataNext = "set package.json license to MIT and use the MIT LICENSE text, then run `npm run release:check`";
+        }
+        else {
+            const licenseFile = await readLicenseFileStatus(path.join(cwd, "LICENSE"), license);
+            if (licenseFile.status === "missing") {
+                lines.push(`metadata: blocked license=${license} license_file=missing`);
+                metadataNext = "add LICENSE, then run `npm run release:check`";
+            }
+            else if (licenseFile.status === "invalid") {
+                lines.push(`metadata: blocked license=${license} license_file=invalid - LICENSE must be a regular file and must not be a symlink`);
+                metadataNext = "replace LICENSE with a regular file, then run `npm run release:check`";
+            }
+            else if (licenseFile.status === "hardlinked") {
+                lines.push(`metadata: blocked license=${license} license_file=invalid - LICENSE must not have hard links`);
+                metadataNext = "replace LICENSE with a non-hard-linked regular file, then run `npm run release:check`";
+            }
+            else if (licenseFile.status === "mismatch") {
+                lines.push(`metadata: blocked license=${license} license_file=mismatch - LICENSE content must match package.json license MIT`);
+                metadataNext = "replace LICENSE with the MIT LICENSE text, then run `npm run release:check`";
+            }
+            else {
+                lines.push(`metadata: ok license=${license} license_file=present`);
+                metadataReady = true;
+            }
+        }
+    }
+    if (packCheckEligible) {
+        const packStatus = await readReleasePackStatus(cwd, packageJson, sourceCli, releaseHintCwd);
+        lines.push(packStatus.line);
+        if (packStatus.next) {
+            if (metadataReady) {
+                metadataNext = packStatus.next;
+            }
+            else {
+                lines.push(`pack_next: ${packStatus.next}`);
+            }
+        }
+        else {
+            packReady = true;
+        }
+    }
+    const gitStatus = await readReleaseGitStatus(cwd);
+    lines.push(gitStatus.line);
+    if (gitStatus.next)
+        lines.push(`git_next: ${gitStatus.next}`);
+    if (metadataReady && packReady && !gitStatus.next) {
+        metadataNext = "run `prodex release pack --pack-destination <dir>`, then run the printed release_pack_verify dry-run before npm publish";
+    }
+    lines.push(`next: ${sourceAwareReleaseMessage(metadataNext, sourceCli, { cwd: releaseHintCwd })}`);
+    lines.push("verification: run `npm run release:verify` anytime without weakening the publish guard");
+    return lines.join("\n");
+}
+function packageIdentityError(packageJson) {
+    if (!isNonEmptyPackageString(packageJson.name) || !isNonEmptyPackageString(packageJson.version)) {
+        return {
+            message: "package.json must include non-empty string name and version",
+            next: "set package.json name and version, then run `npm run release:check`"
+        };
+    }
+    if (!isNpmPublishablePackageName(packageJson.name)) {
+        return {
+            message: "package.json name must be npm-publishable",
+            next: "fix package.json name, then run `npm run release:check`"
+        };
+    }
+    if (!isValidSemverVersion(packageJson.version)) {
+        return {
+            message: "package.json version must be valid semver",
+            next: "fix package.json version, then run `npm run release:check`"
+        };
+    }
+    return undefined;
+}
+async function missingPackageLicenseNextStep(cwd) {
+    const licenseFile = await readLicenseFileStatus(path.join(cwd, "LICENSE"));
+    if (licenseFile.status === "present") {
+        return "choose a license and set package.json license, then run `npm run release:check`";
+    }
+    if (licenseFile.status === "invalid") {
+        return "choose a license and replace LICENSE with a regular file, then run `npm run release:check`";
+    }
+    if (licenseFile.status === "hardlinked") {
+        return "choose a license and replace LICENSE with a non-hard-linked regular file, then run `npm run release:check`";
+    }
+    return "choose a license, add LICENSE, then run `npm run release:check`";
+}
+function isNonEmptyPackageString(value) {
+    return typeof value === "string" && value.trim() !== "";
+}
+function isNpmPublishablePackageName(value) {
+    if (!isNonEmptyPackageString(value) || value.length > 214 || value !== value.toLowerCase())
+        return false;
+    if (RESERVED_PACKAGE_NAMES.has(value))
+        return false;
+    if (value.startsWith("@")) {
+        const parts = value.slice(1).split("/");
+        return parts.length === 2 && parts.every(isPackageNameSegment);
+    }
+    return !value.includes("/") && isPackageNameSegment(value);
+}
+function isPackageNameSegment(value) {
+    return /^(?![._])[a-z0-9][a-z0-9._~-]*$/.test(value);
+}
+function isValidSemverVersion(value) {
+    return /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-(?:0|[1-9]\d*|[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*))*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.test(value);
+}
+async function readReleasePackageJson(packageJsonPath) {
+    return readFile(packageJsonPath, "utf8");
+}
+async function readReleasePackStatus(cwd, packageJson, sourceCli, releaseHintCwd) {
+    try {
+        const { stdout } = await execFileAsync(commandForPlatform("npm"), ["pack", "--json", "--dry-run", "--ignore-scripts"], {
+            cwd,
+            timeout: 120_000,
+            maxBuffer: 20 * 1024 * 1024
+        });
+        const files = parsePackedFiles(stdout);
+        const nonRegular = await findNonRegularPackedFiles(cwd, files);
+        if (nonRegular.length > 0) {
+            return {
+                line: `pack: blocked packed files must be regular non-symlink files: ${formatPathList(nonRegular)}`,
+                next: "replace non-regular or symlinked packed files with regular files, then run `npm run release:check`"
+            };
+        }
+        const invalid = findExecutableNonBinPackedFiles(files, packageJson);
+        if (invalid.length > 0) {
+            return {
+                line: `pack: blocked packed files have unexpected executable modes outside package bin entries: ${formatPathList(invalid)}`,
+                next: sourceAwareReleaseMessage("fix file modes or publish from a filesystem that preserves executable bits, then run `npm run release:check`; on WSL/Windows mounts, create a sanitized tarball with `prodex release pack --pack-destination <dir>` after `npm run release:verify`; release pack prints `npm publish --dry-run <tarball>` and warns that tarball publish bypasses prepublishOnly before printing `npm publish <tarball>`", sourceCli, { cwd: releaseHintCwd })
+            };
+        }
+        const hardLinked = await findHardLinkedPackedFiles(cwd, files);
+        if (hardLinked.length > 0) {
+            return {
+                line: `pack: blocked packed files have hard links: ${formatPathList(hardLinked)}`,
+                next: "replace hard-linked packed files with independent files, then run `npm run release:check`"
+            };
+        }
+        return { line: "pack: ok file_modes=ok" };
+    }
+    catch (error) {
+        return {
+            line: `pack: blocked npm pack dry-run failed: ${firstErrorLine(error)}`,
+            next: "fix npm pack dry-run, then run `npm run release:check`"
+        };
+    }
+}
+function parsePackedFiles(stdout) {
+    let entries;
+    try {
+        entries = JSON.parse(stdout);
+    }
+    catch {
+        throw new Error("npm pack dry-run did not return valid JSON");
+    }
+    const files = entries?.[0]?.files;
+    if (!Array.isArray(files)) {
+        throw new Error("npm pack dry-run did not return a file list");
+    }
+    for (const file of files) {
+        if (typeof file?.path !== "string" || file.path.trim() === "") {
+            throw new Error("npm pack dry-run file entry is missing a path");
+        }
+        if (typeof file.mode !== "number") {
+            throw new Error(`npm pack dry-run file entry is missing mode metadata: ${normalizePackagePath(file.path)}`);
+        }
+    }
+    return files;
+}
+function findExecutableNonBinPackedFiles(files, packageJson) {
+    const binPaths = packageBinPaths(packageJson.bin);
+    return files
+        .filter((file) => (file.mode & 0o111) !== 0)
+        .map((file) => normalizePackagePath(file.path))
+        .filter((filePath) => !binPaths.has(filePath));
+}
+async function findNonRegularPackedFiles(cwd, files) {
+    const invalid = [];
+    for (const file of files) {
+        const packagePath = normalizePackagePath(file.path);
+        const filePath = path.join(cwd, packagePath);
+        const relative = path.relative(cwd, filePath);
+        if (relative.startsWith("..") || path.isAbsolute(relative)) {
+            invalid.push(packagePath);
+            continue;
+        }
+        try {
+            const stat = await lstat(filePath);
+            if (stat.isSymbolicLink() || !stat.isFile())
+                invalid.push(packagePath);
+        }
+        catch (error) {
+            if (isMissingFileError(error))
+                invalid.push(packagePath);
+            else
+                throw error;
+        }
+    }
+    return invalid;
+}
+async function findHardLinkedPackedFiles(cwd, files) {
+    const invalid = [];
+    for (const file of files) {
+        const packagePath = normalizePackagePath(file.path);
+        const filePath = path.join(cwd, packagePath);
+        const relative = path.relative(cwd, filePath);
+        if (relative.startsWith("..") || path.isAbsolute(relative)) {
+            invalid.push(packagePath);
+            continue;
+        }
+        try {
+            const stat = await lstat(filePath);
+            if (stat.nlink > 1)
+                invalid.push(packagePath);
+        }
+        catch (error) {
+            if (isMissingFileError(error))
+                invalid.push(packagePath);
+            else
+                throw error;
+        }
+    }
+    return invalid;
+}
+function packageBinPaths(bin) {
+    const paths = new Set();
+    if (typeof bin === "string") {
+        paths.add(normalizePackagePath(bin));
+    }
+    else if (typeof bin === "object" && bin !== null) {
+        for (const value of Object.values(bin)) {
+            if (typeof value === "string")
+                paths.add(normalizePackagePath(value));
+        }
+    }
+    return paths;
+}
+function normalizePackagePath(value) {
+    return value.replaceAll("\\", "/").replace(/^\.\/+/, "");
+}
+function formatPathList(paths) {
+    const shown = paths.slice(0, 8).join(", ");
+    return paths.length > 8 ? `${shown}, ... (${paths.length} files)` : shown;
+}
+async function runReleasePackCommand(input) {
+    const scriptPath = path.join(packageRoot, "scripts", "release-pack.mjs");
+    const args = [scriptPath, "--root", input.packageRoot, "--pack-destination", input.packDestination];
+    if (input.keepWorkdir)
+        args.push("--keep-workdir");
+    try {
+        const { stdout, stderr } = await execFileAsync(process.execPath, args, {
+            cwd: input.cwd,
+            timeout: 120_000,
+            maxBuffer: 20 * 1024 * 1024
+        });
+        writeCommandOutput(sourceAwareReleaseMessage(stdout, input.sourceCli, { cwd: input.releaseStatusCwd }), input.stdout);
+        writeCommandOutput(stderr, input.stderr);
+    }
+    catch (error) {
+        throw new Error(firstErrorLine(error));
+    }
+}
+function writeCommandOutput(output, write) {
+    const trimmed = output.replace(/\r?\n$/, "");
+    if (!trimmed)
+        return;
+    for (const line of trimmed.split(/\r?\n/))
+        write(line);
+}
+function commandForPlatform(command) {
+    return process.platform === "win32" && command === "npm" ? "npm.cmd" : command;
+}
+function firstErrorLine(error) {
+    const failed = typeof error === "object" && error !== null ? error : {};
+    const stderr = firstOutputLine(failed.stderr);
+    if (stderr)
+        return stderr;
+    const stdout = firstOutputLine(failed.stdout);
+    if (stdout)
+        return stdout;
+    if (typeof failed.code === "number")
+        return `exit code ${failed.code}`;
+    if (typeof failed.signal === "string" && failed.signal) {
+        return `signal ${failed.signal}`;
+    }
+    return errorMessage(error).split(/\r?\n/)[0];
+}
+function firstOutputLine(value) {
+    if (typeof value !== "string")
+        return undefined;
+    return value
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean);
+}
+async function readReleaseGitStatus(cwd) {
+    try {
+        const insideWorkTree = (await gitStdout(cwd, ["rev-parse", "--is-inside-work-tree"])).trim();
+        if (insideWorkTree !== "true") {
+            return {
+                line: "git: blocked not a git worktree",
+                next: "initialize a git repo and commit the release state before public release"
+            };
+        }
+    }
+    catch {
+        return {
+            line: "git: blocked not a git worktree",
+            next: "initialize a git repo and commit the release state before public release"
+        };
+    }
+    const [branch, commit, statusOutput, branchStatusOutput, remoteOutput, upstream] = await Promise.all([
+        gitStdout(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]).then((value) => value.trim() || "unknown", () => "unknown"),
+        gitStdout(cwd, ["rev-parse", "--short", "HEAD"]).then((value) => value.trim() || "unknown", () => "unknown"),
+        gitStdout(cwd, ["status", "--porcelain"]).then((value) => value.trim(), () => ""),
+        gitStdout(cwd, ["status", "--porcelain=v1", "--branch"]).then((value) => value.trim(), () => ""),
+        gitStdout(cwd, ["remote"]).then((value) => value.trim(), () => ""),
+        gitStdout(cwd, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]).then((value) => value.trim(), () => "")
+    ]);
+    const dirtyCount = statusOutput ? statusOutput.split(/\r?\n/).filter(Boolean).length : 0;
+    const remotes = remoteOutput ? remoteOutput.split(/\r?\n/).map((remote) => remote.trim()).filter(Boolean) : [];
+    const remoteText = remotes.length > 0 ? remotes.join(",") : "none";
+    const gitContext = `branch=${branch} commit=${commit}`;
+    if (dirtyCount > 0) {
+        return {
+            line: `git: blocked worktree has uncommitted changes files=${dirtyCount} ${gitContext} remote=${remoteText}`,
+            next: "commit or stash local changes before release"
+        };
+    }
+    if (branch === "HEAD") {
+        return {
+            line: `git: blocked detached HEAD commit=${commit} remote=${remoteText}`,
+            next: "check out a release branch before public release"
+        };
+    }
+    if (remotes.length === 0) {
+        return {
+            line: `git: blocked no remote configured ${gitContext}`,
+            next: `add a remote, then push with upstream tracking: git remote add origin <git-url>; ${formatGitPushUpstreamCommand(branch)}`
+        };
+    }
+    const relation = parseGitBranchRelation(branchStatusOutput);
+    const effectiveUpstream = upstream || relation.upstream || "";
+    if (!upstream && relation.gone && relation.upstream) {
+        return {
+            line: `git: blocked upstream is gone ${gitContext} remote=${remoteText} upstream=${relation.upstream}`,
+            next: "restore upstream tracking before public release"
+        };
+    }
+    if (!effectiveUpstream) {
+        return {
+            line: `git: blocked no upstream configured ${gitContext} remote=${remoteText}`,
+            next: `push the branch with upstream tracking: ${formatGitPushUpstreamCommand(branch)}`
+        };
+    }
+    if (relation.gone) {
+        return {
+            line: `git: blocked upstream is gone ${gitContext} remote=${remoteText} upstream=${effectiveUpstream}`,
+            next: "restore upstream tracking before public release"
+        };
+    }
+    if (relation.ahead > 0 && relation.behind > 0) {
+        return {
+            line: `git: blocked branch diverged ahead=${relation.ahead} behind=${relation.behind} ${gitContext} remote=${remoteText} upstream=${effectiveUpstream}`,
+            next: "sync the branch with upstream before public release"
+        };
+    }
+    if (relation.ahead > 0) {
+        return {
+            line: `git: blocked branch has unpushed commits ahead=${relation.ahead} ${gitContext} remote=${remoteText} upstream=${effectiveUpstream}`,
+            next: "push local commits before public release"
+        };
+    }
+    if (relation.behind > 0) {
+        return {
+            line: `git: blocked branch is behind upstream behind=${relation.behind} ${gitContext} remote=${remoteText} upstream=${effectiveUpstream}`,
+            next: "sync the branch with upstream before public release"
+        };
+    }
+    return {
+        line: `git: ok ${gitContext} remote=${remoteText} upstream=${effectiveUpstream}`
+    };
+}
+function parseGitBranchRelation(statusOutput) {
+    const branchLine = statusOutput.split(/\r?\n/).find((line) => line.startsWith("## ")) ?? "";
+    const relationText = /\[([^\]]+)\]/.exec(branchLine)?.[1] ?? "";
+    const upstream = /\.\.\.([^\s\[]+)/.exec(branchLine)?.[1];
+    const ahead = Number(/\bahead (\d+)\b/.exec(relationText)?.[1] ?? 0);
+    const behind = Number(/\bbehind (\d+)\b/.exec(relationText)?.[1] ?? 0);
+    return { ahead, behind, gone: /\bgone\b/.test(relationText), upstream };
+}
+async function gitStdout(cwd, args) {
+    const { stdout } = await execFileAsync("git", args, { cwd });
+    return stdout;
+}
+async function readLicenseFileStatus(filePath, expectedLicense) {
+    try {
+        const stat = await lstat(filePath);
+        if (stat.isSymbolicLink() || !stat.isFile())
+            return { status: "invalid" };
+        if (stat.nlink > 1)
+            return { status: "hardlinked" };
+        const raw = await readFile(filePath, "utf8");
+        if (expectedLicense === "MIT" && !isMitLicenseText(raw))
+            return { status: "mismatch" };
+        return { status: "present" };
+    }
+    catch (error) {
+        if (isMissingFileError(error))
+            return { status: "missing" };
+        throw error;
+    }
+}
+function isMitLicenseText(raw) {
+    return /\bMIT License\b/.test(raw);
+}
+async function runDoctor(store, io, sourceCli, setupHintCwd) {
+    let ok = true;
+    io.stdout("prodex doctor");
+    try {
+        const bridgeReady = await store.hasReadyBridgeStorageReadOnly();
+        io.stdout(bridgeReady
+            ? "bridge: ok (.bridge)"
+            : `bridge: missing/incomplete (.bridge) - run \`${formatInitCommand(sourceCli, { cwd: setupHintCwd })}\` when you need local task/result storage`);
+    }
+    catch (error) {
+        ok = false;
+        io.stdout(`bridge: failed ${errorMessage(error)}`);
+    }
+    try {
+        const config = await loadLocalConfig(io.cwd);
+        const tokenStatus = getTokenExpiryStatus(config);
+        if (tokenStatus.status === "expired") {
+            ok = false;
+            io.stdout(`config: failed token expired at ${tokenStatus.token_expires_at} - run \`${formatSetupCommand(sourceCli, { cwd: setupHintCwd })}\``);
+        }
+        else {
+            io.stdout(`config: ok ${redactServerUrl(config.server_url)} token_status=${tokenStatus.status}`);
+            const warningLine = formatConfigWarningLine(tokenStatus, sourceCli, setupHintCwd);
+            if (warningLine)
+                io.stdout(warningLine);
+        }
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            io.stdout(`config: missing - run \`${formatSetupCommand(sourceCli, { cwd: setupHintCwd })}\``);
+        }
+        else {
+            ok = false;
+            io.stdout(`config: failed ${sourceAwareSetupMessage(errorMessage(error), sourceCli, { cwd: setupHintCwd })}`);
+        }
+    }
+    try {
+        const smoke = await runMcpWriteSmoke();
+        io.stdout(`mcp_write_smoke: ok path=${smoke.path} receipt_payload=${smoke.receipt_payload} staged=${smoke.staged}`);
+    }
+    catch (error) {
+        ok = false;
+        io.stdout(`mcp_write_smoke: failed ${errorMessage(error)}`);
+    }
+    try {
+        const smoke = await runHttpMcpCatalogSmoke();
+        io.stdout(`http_mcp_smoke: ok task_flow=${smoke.taskFlow} finalizers=${smoke.finalizers} search=${smoke.search} tools=${smoke.tools.join(",")}`);
+    }
+    catch (error) {
+        ok = false;
+        io.stdout(`http_mcp_smoke: failed ${errorMessage(error)}`);
+    }
+    return ok ? 0 : 1;
+}
+async function runHttpMcpCatalogSmoke() {
+    const cwd = await mkdtemp(path.join(tmpdir(), "prodex-http-doctor-"));
+    let running;
+    let client;
+    let smokeFailed = false;
+    try {
+        await writeFile(path.join(cwd, "search-smoke.txt"), "before\n--doctor-rg-literal ok\nafter\n", "utf8");
+        running = await startHttpMcpServer({
+            cwd,
+            host: "127.0.0.1",
+            port: 0,
+            token: "doctor-token"
+        });
+        client = new Client({ name: "prodex-doctor", version: CLI_VERSION });
+        await withTimeout(client.connect(new StreamableHTTPClientTransport(new URL(running.mcp_url))), 20_000, "timed out connecting to HTTP MCP server");
+        const result = await withTimeout(client.listTools(), 20_000, "timed out listing HTTP MCP tools");
+        const names = result.tools.map((tool) => tool.name);
+        const missing = DOCTOR_REQUIRED_MCP_TOOLS.filter((tool) => !names.includes(tool));
+        if (missing.length > 0)
+            throw new Error(`missing MCP tools: ${missing.join(",")}`);
+        await runHttpMcpSearchSmoke(client);
+        await runHttpMcpFinalizerSmoke(client);
+        return { tools: [...DOCTOR_REQUIRED_MCP_TOOLS], taskFlow: "ok", finalizers: "ok", search: "ok" };
+    }
+    catch (error) {
+        smokeFailed = true;
+        throw error;
+    }
+    finally {
+        const cleanupErrors = [];
+        if (client) {
+            try {
+                await withTimeout(client.close(), 10_000, "timed out closing HTTP MCP client");
+            }
+            catch (error) {
+                cleanupErrors.push(errorMessage(error));
+            }
+        }
+        if (running) {
+            try {
+                await running.close({ forceAfterMs: 1_000, timeoutMs: 10_000 });
+            }
+            catch (error) {
+                cleanupErrors.push(errorMessage(error));
+            }
+        }
+        try {
+            await rm(cwd, { recursive: true, force: true });
+        }
+        catch (error) {
+            cleanupErrors.push(errorMessage(error));
+        }
+        if (cleanupErrors.length > 0 && !smokeFailed) {
+            throw new Error(`HTTP MCP smoke cleanup failed: ${cleanupErrors.join("; ")}`);
+        }
+    }
+}
+async function runHttpMcpSearchSmoke(client) {
+    const result = await callHttpMcpJsonTool(client, "repo_search", {
+        query: "--doctor-rg-literal"
+    });
+    if (result.matches.length !== 1 ||
+        result.matches[0]?.path !== "search-smoke.txt" ||
+        result.matches[0]?.line !== 2 ||
+        result.matches[0]?.text !== "--doctor-rg-literal ok") {
+        throw new Error(`unexpected HTTP MCP search result: ${JSON.stringify(result)}`);
+    }
+}
+async function runHttpMcpFinalizerSmoke(client) {
+    const doneTask = await callHttpMcpJsonTool(client, "bridge_create_task", {
+        title: "Doctor HTTP complete smoke",
+        prompt: "Complete this task over HTTP MCP"
+    });
+    assertDoctorMcpTask(doneTask.task, {
+        taskId: doneTask.task.id,
+        status: "new",
+        title: "Doctor HTTP complete smoke"
+    });
+    const fetchedTask = await callHttpMcpJsonTool(client, "bridge_get_task", {
+        task_id: doneTask.task.id
+    });
+    const newTasks = await callHttpMcpJsonTool(client, "bridge_list_tasks", {
+        status: "new"
+    });
+    assertDoctorMcpTask(fetchedTask.task, {
+        taskId: doneTask.task.id,
+        status: "new",
+        title: "Doctor HTTP complete smoke"
+    });
+    assertDoctorMcpTaskInList(newTasks.tasks, {
+        taskId: doneTask.task.id,
+        status: "new"
+    });
+    const claimedTask = await callHttpMcpJsonTool(client, "bridge_claim_task", {
+        task_id: doneTask.task.id,
+        claimed_by: "doctor-http-smoke"
+    });
+    const claimedTasks = await callHttpMcpJsonTool(client, "bridge_list_tasks", {
+        status: "claimed"
+    });
+    assertDoctorMcpTask(claimedTask.task, {
+        taskId: doneTask.task.id,
+        status: "claimed",
+        title: "Doctor HTTP complete smoke",
+        claimedBy: "doctor-http-smoke"
+    });
+    assertDoctorMcpTaskInList(claimedTasks.tasks, {
+        taskId: doneTask.task.id,
+        status: "claimed"
+    });
+    const completed = await callHttpMcpJsonTool(client, "bridge_complete_task", {
+        task_id: doneTask.task.id,
+        summary: "Completed by doctor HTTP MCP",
+        commands: ["doctor http finalizer smoke"]
+    });
+    const blockedTask = await callHttpMcpJsonTool(client, "bridge_create_task", {
+        title: "Doctor HTTP block smoke",
+        prompt: "Block this task over HTTP MCP"
+    });
+    const blocked = await callHttpMcpJsonTool(client, "bridge_block_task", {
+        task_id: blockedTask.task.id,
+        summary: "Blocked by doctor HTTP MCP",
+        code: "doctor_http_blocker",
+        retryable: true,
+        next_step: "Inspect doctor output."
+    });
+    const fetchedDone = await callHttpMcpJsonTool(client, "bridge_fetch_result", {
+        task_id: doneTask.task.id
+    });
+    const fetchedBlocked = await callHttpMcpJsonTool(client, "bridge_fetch_result", {
+        task_id: blockedTask.task.id
+    });
+    const doneTasks = await callHttpMcpJsonTool(client, "bridge_list_tasks", {
+        status: "done"
+    });
+    const blockedTasks = await callHttpMcpJsonTool(client, "bridge_list_tasks", {
+        status: "blocked"
+    });
+    const results = await callHttpMcpJsonTool(client, "bridge_list_results", {});
+    assertDoctorMcpResult(completed.result, {
+        taskId: doneTask.task.id,
+        status: "done",
+        summary: "Completed by doctor HTTP MCP",
+        commands: ["doctor http finalizer smoke"]
+    });
+    assertDoctorMcpResult(fetchedDone.result, {
+        taskId: doneTask.task.id,
+        status: "done",
+        summary: "Completed by doctor HTTP MCP",
+        commands: ["doctor http finalizer smoke"]
+    });
+    assertDoctorMcpResult(blocked.result, {
+        taskId: blockedTask.task.id,
+        status: "blocked",
+        summary: "Blocked by doctor HTTP MCP",
+        blockerCode: "doctor_http_blocker",
+        retryable: true,
+        nextStep: "Inspect doctor output."
+    });
+    assertDoctorMcpResult(fetchedBlocked.result, {
+        taskId: blockedTask.task.id,
+        status: "blocked",
+        summary: "Blocked by doctor HTTP MCP",
+        blockerCode: "doctor_http_blocker",
+        retryable: true,
+        nextStep: "Inspect doctor output."
+    });
+    assertDoctorMcpTaskInList(doneTasks.tasks, {
+        taskId: doneTask.task.id,
+        status: "done"
+    });
+    assertDoctorMcpTaskInList(blockedTasks.tasks, {
+        taskId: blockedTask.task.id,
+        status: "blocked"
+    });
+    assertDoctorMcpResultInList(results.results, {
+        taskId: doneTask.task.id,
+        status: "done",
+        summary: "Completed by doctor HTTP MCP"
+    });
+    assertDoctorMcpResultInList(results.results, {
+        taskId: blockedTask.task.id,
+        status: "blocked",
+        summary: "Blocked by doctor HTTP MCP"
+    });
+}
+async function callHttpMcpJsonTool(client, name, args) {
+    const result = await withTimeout(client.callTool({ name, arguments: args }), 20_000, `timed out calling HTTP MCP tool ${name}`);
+    const content = result.content;
+    if (Array.isArray(content)) {
+        for (const item of content) {
+            if (isMcpTextContent(item))
+                return JSON.parse(item.text);
+        }
+    }
+    throw new Error(`HTTP MCP tool ${name} did not return text content`);
+}
+function isMcpTextContent(item) {
+    return (typeof item === "object" &&
+        item !== null &&
+        "type" in item &&
+        "text" in item &&
+        item.type === "text" &&
+        typeof item.text === "string");
+}
+async function withTimeout(promise, timeoutMs, message) {
+    let timeout;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timeout = setTimeout(() => reject(new Error(message)), timeoutMs);
+            })
+        ]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
+function assertDoctorMcpResult(result, expected) {
+    if (result.task_id !== expected.taskId || result.status !== expected.status || result.summary !== expected.summary) {
+        throw new Error(`unexpected HTTP MCP result: ${JSON.stringify(result)} expected ${JSON.stringify(expected)}`);
+    }
+    if (expected.commands && JSON.stringify(result.commands) !== JSON.stringify(expected.commands)) {
+        throw new Error(`unexpected HTTP MCP result commands: ${JSON.stringify(result.commands)} expected ${JSON.stringify(expected.commands)}`);
+    }
+    if (expected.blockerCode && result.blocker?.code !== expected.blockerCode) {
+        throw new Error(`unexpected HTTP MCP blocker: ${JSON.stringify(result.blocker)} expected code ${expected.blockerCode}`);
+    }
+    if (expected.retryable !== undefined && result.blocker?.retryable !== expected.retryable) {
+        throw new Error(`unexpected HTTP MCP blocker retryable: ${JSON.stringify(result.blocker)} expected ${expected.retryable}`);
+    }
+    if (expected.nextStep !== undefined && result.blocker?.next_step !== expected.nextStep) {
+        throw new Error(`unexpected HTTP MCP blocker next_step: ${JSON.stringify(result.blocker)} expected ${expected.nextStep}`);
+    }
+}
+function assertDoctorMcpTask(task, expected) {
+    if (task.id !== expected.taskId || task.status !== expected.status) {
+        throw new Error(`unexpected HTTP MCP task: ${JSON.stringify(task)} expected ${JSON.stringify(expected)}`);
+    }
+    if (expected.title !== undefined && task.title !== expected.title) {
+        throw new Error(`unexpected HTTP MCP task title: ${JSON.stringify(task)} expected ${expected.title}`);
+    }
+    if (expected.claimedBy !== undefined && task.claimed_by !== expected.claimedBy) {
+        throw new Error(`unexpected HTTP MCP task claimer: ${JSON.stringify(task)} expected ${expected.claimedBy}`);
+    }
+}
+function assertDoctorMcpTaskInList(tasks, expected) {
+    if (!Array.isArray(tasks)) {
+        throw new Error(`unexpected HTTP MCP task list: ${JSON.stringify(tasks)}`);
+    }
+    if (!tasks.some((task) => isDoctorMcpTask(task) && task.id === expected.taskId && task.status === expected.status)) {
+        throw new Error(`missing HTTP MCP task in list: ${JSON.stringify(expected)} from ${JSON.stringify(tasks)}`);
+    }
+}
+function assertDoctorMcpResultInList(results, expected) {
+    if (!Array.isArray(results)) {
+        throw new Error(`unexpected HTTP MCP result list: ${JSON.stringify(results)}`);
+    }
+    if (!results.some((result) => isDoctorMcpResult(result) && result.task_id === expected.taskId && result.status === expected.status && result.summary === expected.summary)) {
+        throw new Error(`missing HTTP MCP result in list: ${JSON.stringify(expected)} from ${JSON.stringify(results)}`);
+    }
+}
+function isDoctorMcpTask(task) {
+    return typeof task === "object" && task !== null;
+}
+function isDoctorMcpResult(result) {
+    return typeof result === "object" && result !== null;
+}
+async function runMcpWriteSmoke() {
+    const cwd = await mkdtemp(path.join(tmpdir(), "prodex-doctor-"));
+    let smokeFailed = false;
+    try {
+        await writeFile(path.join(cwd, "notes.md"), "old\n", "utf8");
+        await execFileAsync("git", ["init"], { cwd });
+        await execFileAsync("git", ["config", "user.email", "doctor@example.com"], { cwd });
+        await execFileAsync("git", ["config", "user.name", "PROdex Doctor"], { cwd });
+        await execFileAsync("git", ["add", "notes.md"], { cwd });
+        await execFileAsync("git", ["commit", "-m", "initial"], { cwd });
+        const { stdout: headOut } = await execFileAsync("git", ["rev-parse", "HEAD"], { cwd });
+        const head = headOut.trim();
+        const handlers = createMcpToolHandlers({ cwd });
+        const dryRun = await handlers.repo_write_file_dry_run({
+            path: "notes.md",
+            content: "new\n",
+            expected_head: head
+        });
+        const receipt = JSON.parse(await readFile(path.join(cwd, ".bridge", "receipts", `${dryRun.receipt.id}.json`), "utf8"));
+        if (Object.hasOwn(receipt.metadata ?? {}, "new_content")) {
+            throw new Error("dry-run receipt contains inline write payload");
+        }
+        if (typeof receipt.metadata?.new_content_artifact !== "string") {
+            throw new Error("dry-run receipt is missing write payload artifact");
+        }
+        const applied = await handlers.repo_write_file_apply({
+            receipt_id: dryRun.receipt.id,
+            expected_head: head,
+            preimage_sha256: dryRun.preimage_sha256
+        });
+        const staged = await handlers.repo_stage_reviewed_paths({
+            receipt_ids: [applied.receipt.id],
+            expected_head: head
+        });
+        const { stdout: stagedOut } = await execFileAsync("git", ["diff", "--cached", "--name-only"], { cwd });
+        const stagedName = stagedOut.trim();
+        if (stagedName !== "notes.md" || staged.paths.join(",") !== "notes.md") {
+            throw new Error(`unexpected staged paths: ${stagedName || "<none>"}`);
+        }
+        return { path: "notes.md", receipt_payload: "artifact", staged: stagedName };
+    }
+    catch (error) {
+        smokeFailed = true;
+        throw error;
+    }
+    finally {
+        try {
+            await rm(cwd, { recursive: true, force: true });
+        }
+        catch (error) {
+            if (!smokeFailed)
+                throw error;
+        }
+    }
+}
+function printBrowserLoginGuide(stdout, input) {
+    const loginCommand = formatBrowserLoginCommand(input.sourceCli, input.commandOptions);
+    const runtimeCommandOptions = {
+        ...(input.commandOptions?.cwd ? { cwd: input.commandOptions.cwd } : {}),
+        ...(input.commandOptions?.port ? { port: input.commandOptions.port } : {})
+    };
+    const checkCommand = formatBrowserCheckCommand(input.sourceCli, runtimeCommandOptions);
+    const smokeCommand = formatBrowserSmokeCommand(input.sourceCli, runtimeCommandOptions);
+    stdout("ChatGPT Pro browser login");
+    stdout(input.opened ? "Opened the dedicated Chrome window for ChatGPT." : "Dry run: no browser was opened.");
+    stdout("");
+    stdout("Steps:");
+    if (input.opened) {
+        stdout(`1. Log in manually at ${input.loginUrl} in the dedicated Chrome window.`);
+        stdout("2. If ChatGPT asks for captcha, Cloudflare/human verification, permission, or account verification, complete it in the browser.");
+        stdout("3. For usage limit, message limit, model limit, or rate limit, wait for the reset or choose an available model in the browser.");
+        stdout("4. Open a normal ChatGPT chat or the intended Project/thread so the prompt composer is visible.");
+        stdout("5. Select the Pro/Thinking model you want in the ChatGPT UI.");
+        stdout(`6. Run \`${checkCommand}\` to confirm the session is reachable.`);
+        stdout(`7. Run \`${smokeCommand}\` to verify a real Pro response path.`);
+    }
+    else {
+        stdout(`1. Run \`${loginCommand}\` without \`--dry-run\` to open the dedicated Chrome window.`);
+        stdout(`2. Log in manually at ${input.loginUrl} in that Chrome window.`);
+        stdout("3. If ChatGPT asks for captcha, Cloudflare/human verification, permission, or account verification, complete it in the browser.");
+        stdout("4. For usage limit, message limit, model limit, or rate limit, wait for the reset or choose an available model in the browser.");
+        stdout("5. Open a normal ChatGPT chat or the intended Project/thread so the prompt composer is visible.");
+        stdout("6. Select the Pro/Thinking model you want in the ChatGPT UI.");
+        stdout(`7. Run \`${checkCommand}\` to confirm the session is reachable.`);
+        stdout(`8. Run \`${smokeCommand}\` to verify a real Pro response path.`);
+    }
+    stdout("");
+    stdout(`Profile: ${input.profileDir}`);
+    stdout(`Debug: http://127.0.0.1:${input.port}`);
+    if (input.opened) {
+        stdout("You can close this Chrome window after check/smoke or when you are done. The dedicated profile is reused next time.");
+    }
+    else {
+        stdout("The dedicated profile path above will be reused by the real login command.");
+    }
+}
+function printProBrowserHelp(stdout, sourceCli) {
+    const cli = formatCliCommand(sourceCli);
+    const sourceCliOption = formatSourceCliOption(sourceCli);
+    const loginUsage = sourceCli
+        ? `${cli} pro browser login${sourceCliOption} [--cwd /absolute/path/to/repo] [--dry-run] [--profile-dir path] [--port 9333] [--url https://chatgpt.com/...] [--launch-timeout-ms 5000]`
+        : "prodex pro browser login [--cwd /absolute/path/to/repo] [--dry-run] [--source-cli /absolute/path/to/dist/cli.js] [--profile-dir path] [--port 9333] [--url https://chatgpt.com/...] [--launch-timeout-ms 5000]";
+    const checkUsage = sourceCli
+        ? `${cli} pro browser check${sourceCliOption} [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 1500]`
+        : "prodex pro browser check [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 1500]";
+    const smokeUsage = sourceCli
+        ? `${cli} pro browser smoke${sourceCliOption} [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 90000]`
+        : "prodex pro browser smoke [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 90000]";
+    const askUsage = sourceCli
+        ? `${cli} pro browser ask${sourceCliOption} [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 90000] [--target-url url --confirm-target] [--file path] "prompt"`
+        : 'prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 90000] [--target-url url --confirm-target] [--file path] "prompt"';
+    stdout(`${cli} pro browser
+
+Commands:
+  ${loginUsage}
+  ${checkUsage}
+  ${smokeUsage}
+  ${askUsage}
+
+Visible-browser sends require a manual browser session and stop on login, captcha, Cloudflare, permission, rate-limit, or usage-limit blockers.
+Use \`${cli} pro ask\` for dry-run/manual previews.
+\`${cli} pro browser ask${sourceCliOption}\` always attempts an explicit visible-browser send.`);
+}
+async function assertBrowserLaunchStayedAlive(opened, timeoutMs) {
+    const outcome = await waitForBrowserLaunchReady(opened, timeoutMs);
+    if (outcome.reachable)
+        return;
+    if (outcome.earlyExit) {
+        const detail = formatBrowserEarlyExit(outcome.earlyExit);
+        throw new Error(`Chrome/Chromium exited before DevTools became reachable (${detail}). Check the visible browser environment, profile lock, display access, or PRODEX_CHROME, then retry.`);
+    }
+    throw new Error(`Chrome/Chromium did not expose a reachable DevTools endpoint after launch. Check the visible browser environment, profile lock, display access, or PRODEX_CHROME, then retry.`);
+}
+async function waitForBrowserLaunchReady(opened, timeoutMs = 5_000) {
+    const deadline = Date.now() + timeoutMs;
+    let earlyExit;
+    while (Date.now() <= deadline) {
+        const remainingMs = Math.max(1, deadline - Date.now());
+        const status = await getChatGptBrowserStatus({ port: opened.port, timeoutMs: Math.min(250, remainingMs) });
+        if (status.reachable)
+            return { reachable: true };
+        earlyExit ??= await opened.waitForEarlyExit(1);
+        if (earlyExit && (earlyExit.code !== 0 || earlyExit.signal || earlyExit.error)) {
+            return { reachable: false, earlyExit };
+        }
+        if (Date.now() >= deadline)
+            break;
+        await sleep(Math.min(100, Math.max(1, deadline - Date.now())));
+    }
+    return { reachable: false, ...(earlyExit ? { earlyExit } : {}) };
+}
+function formatBrowserEarlyExit(exit) {
+    if (!exit)
+        return "no exit details";
+    return exit.error ?? `exit code ${exit.code ?? "null"}${exit.signal ? ` signal ${exit.signal}` : ""}`;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatBrowserModelHints(modelHints) {
+    const modelish = /\b(?:ChatGPT|GPT(?:-[\w.]+)?|Pro|Plus|Team|Enterprise|Thinking|Extra High|Auto)\b/i;
+    const hints = [...new Set(modelHints.map((hint) => hint.trim()).filter((hint) => modelish.test(hint)))]
+        .map((hint) => (hint.length > 80 ? `${hint.slice(0, 77)}...` : hint))
+        .slice(0, 6);
+    return hints.length > 0 ? hints.join(" | ") : undefined;
+}
+function browserReadinessNextStep(input) {
+    if (!input.loggedInLikely) {
+        return "Log in manually in the visible ChatGPT browser, then retry.";
+    }
+    if (!input.hasComposer) {
+        return "Open a normal ChatGPT chat or Project thread, select the Pro/Thinking model, and retry.";
+    }
+    return "Review the visible ChatGPT browser state, then retry.";
+}
+async function printProductCheck(store, io, args, configCwd = io.cwd) {
+    const sourceCli = resolveOptionalFileFlag(io.cwd, args, "--source-cli");
+    const setupHintCwd = readFlag(args, "--cwd") ? configCwd : undefined;
+    io.stdout("prodex product check");
+    let bridgeReady = false;
+    try {
+        bridgeReady = await store.hasReadyBridgeStorageReadOnly();
+        io.stdout(bridgeReady
+            ? "bridge: ok (.bridge)"
+            : `bridge: missing (.bridge) - run \`${formatInitCommand(sourceCli, { cwd: setupHintCwd })}\` when you need local task/result storage`);
+    }
+    catch (error) {
+        io.stdout(`bridge: blocked - ${errorMessage(error)}`);
+    }
+    let configReady = false;
+    try {
+        const config = await loadLocalConfig(configCwd);
+        const tokenStatus = getTokenExpiryStatus(config);
+        if (tokenStatus.status === "expired") {
+            io.stdout(`config: expired - run \`${formatSetupCommand(sourceCli, { cwd: setupHintCwd })}\``);
+        }
+        else {
+            io.stdout(`config: ok ${redactServerUrl(config.server_url)} token_status=${tokenStatus.status}`);
+            const warningLine = formatConfigWarningLine(tokenStatus, sourceCli, setupHintCwd);
+            if (warningLine)
+                io.stdout(warningLine);
+            configReady = true;
+        }
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            io.stdout(`config: missing - run \`${formatSetupCommand(sourceCli, { cwd: setupHintCwd })}\``);
+        }
+        else {
+            io.stdout(`config: failed ${sourceAwareSetupMessage(errorMessage(error), sourceCli, { cwd: setupHintCwd })}`);
+        }
+    }
+    const browserStatus = await getChatGptBrowserStatus({
+        port: readPortFlag(args, "--port") ?? 9333,
+        timeoutMs: readPositiveNumberFlag(args, "--timeout-ms") ?? 1500
+    });
+    const browserCommandOptions = {
+        cwd: setupHintCwd,
+        port: readPortFlag(args, "--port") ?? undefined
+    };
+    let chatgptReady = false;
+    const visibilityBlocker = chatGptVisibilityBlocker(browserStatus.visibilityState, browserStatus.url);
+    if (!browserStatus.reachable) {
+        io.stdout(`chatgpt: ${browserStatus.blocker?.code ?? "unreachable"} - ${browserStatus.blocker?.message ?? "browser is not reachable"}`);
+        const nextStep = productCheckBrowserNextStep(browserStatus.blocker?.next_step, sourceCli, browserCommandOptions);
+        if (nextStep)
+            io.stdout(`next: ${nextStep}`);
+    }
+    else if (browserStatus.blocker) {
+        const visibilityText = browserStatus.blocker.code === "tab_not_visible" ? ` visibility=${browserStatus.visibilityState ?? "unknown"}` : "";
+        io.stdout(`chatgpt: blocked ${browserStatus.blocker.code}${visibilityText} - ${browserStatus.blocker.message}`);
+        const nextStep = productCheckBrowserNextStep(browserStatus.blocker.next_step, sourceCli, browserCommandOptions);
+        if (nextStep)
+            io.stdout(`next: ${nextStep}`);
+    }
+    else if (visibilityBlocker) {
+        io.stdout(`chatgpt: blocked ${visibilityBlocker.code} visibility=${browserStatus.visibilityState ?? "unknown"} - ${visibilityBlocker.message}`);
+        const nextStep = productCheckBrowserNextStep(visibilityBlocker.next_step, sourceCli, browserCommandOptions);
+        if (nextStep)
+            io.stdout(`next: ${nextStep}`);
+    }
+    else if (browserStatus.loggedInLikely && browserStatus.hasComposer) {
+        io.stdout(`chatgpt: ok logged_in=true composer=true${browserStatus.url ? ` url=${browserStatus.url}` : ""}`);
+        chatgptReady = true;
+    }
+    else {
+        io.stdout(`chatgpt: blocked logged_in=${browserStatus.loggedInLikely} composer=${browserStatus.hasComposer}`);
+        const nextStep = productCheckBrowserNextStep(browserReadinessNextStep(browserStatus), sourceCli, browserCommandOptions);
+        io.stdout(`next: ${nextStep}`);
+    }
+    const modelHints = formatBrowserModelHints(browserStatus.modelHints);
+    if (modelHints)
+        io.stdout(`model_hints: ${modelHints}`);
+    if (bridgeReady) {
+        try {
+            const latest = await latestTrustedConsult(store, { readOnly: false });
+            if (latest) {
+                for (const line of formatProductCheckLatestProLines(latest, sourceCli, browserCommandOptions))
+                    io.stdout(line);
+            }
+            else {
+                io.stdout("latest_pro: missing");
+            }
+        }
+        catch (error) {
+            if (isUntrustedResultError(error)) {
+                io.stdout(`latest_pro: untrusted ${error.taskId} ${sourceAwareResultMessage(errorMessage(error), sourceCli, browserCommandOptions)}`);
+            }
+            else {
+                io.stdout(`latest_pro: unavailable ${firstLine(errorMessage(error))}`);
+            }
+        }
+    }
+    else {
+        io.stdout("latest_pro: missing");
+    }
+    return bridgeReady && configReady && chatgptReady;
+}
+async function listTasksForInspection(store, status) {
+    return store.listTasksReadOnly(status);
+}
+async function listResultsForInspection(store) {
+    return store.listFinalizedResultsReadOnly();
+}
+async function listRawResultsForInspection(store) {
+    return store.listResultsReadOnly();
+}
+async function listReceiptsForInspection(store, input = {}) {
+    return store.listReceiptsReadOnly(input);
+}
+async function listSessionsForInspection(store, status) {
+    return store.listSessionsReadOnly(status);
+}
+async function listConsults(store, options = {}) {
+    const [tasks, results] = options.readOnly
+        ? await Promise.all([listTasksForInspection(store), listRawResultsForInspection(store)])
+        : await Promise.all([store.listTasks(), store.listResults()]);
+    const tasksById = new Map(tasks.map((task) => [task.id, task]));
+    assertNoMissingTerminalConsultResults(tasks, results);
+    assertNoOrphanConsultResults(tasksById, results);
+    const records = results
+        .map((result) => {
+        const task = tasksById.get(result.task_id);
+        return task ? { task, result } : undefined;
+    })
+        .filter((record) => Boolean(record && isConsultRecord(record)))
+        .sort((a, b) => b.result.created_at.localeCompare(a.result.created_at));
+    const finalized = [];
+    for (const record of records) {
+        finalized.push({ ...record, result: await store.getFinalizedResultReadOnly(record.result.task_id) });
+    }
+    return finalized;
+}
+async function listConsultListEntries(store, options = { readOnly: true }) {
+    const [tasks, results] = options.readOnly === false
+        ? await Promise.all([store.listTasks(), store.listResults()])
+        : await Promise.all([listTasksForInspection(store), listRawResultsForInspection(store)]);
+    const tasksById = new Map(tasks.map((task) => [task.id, task]));
+    assertNoMissingTerminalConsultResults(tasks, results);
+    assertNoOrphanConsultResults(tasksById, results);
+    const records = results
+        .map((result) => {
+        const task = tasksById.get(result.task_id);
+        return task ? { task, result } : undefined;
+    })
+        .filter((record) => Boolean(record && isConsultRecord(record)))
+        .sort((a, b) => b.result.created_at.localeCompare(a.result.created_at));
+    const entries = [];
+    for (const record of records) {
+        try {
+            entries.push({ kind: "trusted", consult: { ...record, result: await store.getFinalizedResultReadOnly(record.result.task_id) } });
+        }
+        catch (error) {
+            if (isUntrustedResultError(error)) {
+                entries.push({ kind: "untrusted", task: record.task, result: record.result, error });
+                continue;
+            }
+            throw error;
+        }
+    }
+    return entries;
+}
+async function latestTrustedConsult(store, options = { readOnly: true }) {
+    const entries = await listConsultListEntries(store, options);
+    const trusted = entries.find((entry) => entry.kind === "trusted");
+    if (trusted)
+        return trusted.consult;
+    const untrusted = entries.find((entry) => entry.kind === "untrusted");
+    if (untrusted)
+        throw untrusted.error;
+    return undefined;
+}
+function assertNoOrphanConsultResults(tasksById, results) {
+    const orphan = results
+        .filter((result) => !tasksById.has(result.task_id) && isConsultResult(result))
+        .sort((a, b) => b.created_at.localeCompare(a.created_at) || b.task_id.localeCompare(a.task_id))[0];
+    if (orphan)
+        throw orphanConsultResultError(orphan.task_id);
+}
+async function latestResultTaskId(store, options = {}) {
+    const results = options.readOnly ? await listResultsForInspection(store) : await store.listResults();
+    const result = results.at(-1);
+    if (!result)
+        throw new Error("No results found");
+    return result.task_id;
+}
+async function latestRawResultTaskId(store) {
+    const result = (await store.listResults()).at(-1);
+    if (!result)
+        throw new Error("No results found");
+    return result.task_id;
+}
+async function latestTask(store, options = {}) {
+    const tasks = options.readOnly ? await listTasksForInspection(store) : await store.listTasks();
+    return tasks.sort((a, b) => b.created_at.localeCompare(a.created_at) || b.id.localeCompare(a.id))[0];
+}
+async function writeTaskCompleteArtifacts(store, values) {
+    const artifacts = [];
+    for (const value of values) {
+        const separator = value.indexOf("=");
+        if (separator <= 0) {
+            throw new Error("tasks complete --artifact requires path=text");
+        }
+        const artifactPath = value.slice(0, separator);
+        const content = value.slice(separator + 1);
+        if (!artifactPath.trim()) {
+            throw new Error("tasks complete --artifact requires path=text");
+        }
+        const storedPath = await store.writeArtifactText(artifactPath, content);
+        artifacts.push({ path: storedPath, role: "result" });
+    }
+    return artifacts;
+}
+async function getConsult(store, taskId, options = {}) {
+    let task;
+    try {
+        task = options.readOnly ? await store.getTaskReadOnly(taskId) : await store.getTask(taskId);
+    }
+    catch (error) {
+        if (isMissingFileError(error))
+            return undefined;
+        throw error;
+    }
+    if (!isConsultTask(task))
+        return undefined;
+    let result;
+    try {
+        result = await store.getFinalizedResultReadOnly(taskId);
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            if (isTerminalTask(task) && isConsultTask(task))
+                throw missingConsultResultError(task);
+            return undefined;
+        }
+        throw error;
+    }
+    if (!task || !result)
+        return undefined;
+    const record = { task, result };
+    return isConsultRecord(record) ? record : undefined;
+}
+function assertNoMissingTerminalConsultResults(tasks, results) {
+    const resultTaskIds = new Set(results.map((result) => result.task_id));
+    const missing = tasks
+        .filter((task) => isTerminalTask(task) && isConsultTask(task) && !resultTaskIds.has(task.id))
+        .sort((a, b) => b.updated_at.localeCompare(a.updated_at) || b.id.localeCompare(a.id))[0];
+    if (missing)
+        throw missingConsultResultError(missing);
+}
+function isTerminalTask(task) {
+    return task.status === "done" || task.status === "blocked";
+}
+function isConsultTask(task) {
+    return task.provenance.adapter === "chatgpt-control";
+}
+function isConsultResult(result) {
+    return result.commands.some((command) => /chatgpt|gpt pro|visible ChatGPT/i.test(command));
+}
+function missingConsultResultError(task) {
+    return new Error(`GPT Pro answer is corrupt: task ${task.id} is ${task.status} but .bridge/results/${task.id}.json is missing. Restore the result file, retry the completion path, or move the task record aside, then retry.`);
+}
+function orphanConsultResultError(taskId) {
+    return new Error(`GPT Pro answer is corrupt: result .bridge/results/${taskId}.json exists but .bridge/tasks/${taskId}.json is missing. Restore the task file or move the orphan result record aside, then retry.`);
+}
+function isConsultRecord(record) {
+    return isConsultTask(record.task);
+}
+function formatProAnswer(consult, sourceCli, options = {}) {
+    const blocker = sourceAwareProAnswerBlocker(consult, sourceCli, options);
+    const summary = sourceAwareProAnswerSummary(consult.result.summary, consult.result.blocker, blocker);
+    const lines = [
+        `task_id: ${consult.task.id}`,
+        `status: ${consult.result.status}`,
+        consult.task.provenance.thread ? `thread: ${consult.task.provenance.thread}` : undefined,
+        `created_at: ${consult.result.created_at}`,
+        "",
+        summary
+    ].filter((line) => line !== undefined);
+    if (blocker) {
+        lines.push("", "blocker:", `- code: ${blocker.code}`, `- retryable: ${blocker.retryable}`);
+        if (blocker.next_step)
+            lines.push(`- next_step: ${blocker.next_step}`);
+    }
+    if (consult.result.warnings.length > 0) {
+        lines.push("", "warnings:");
+        for (const warning of consult.result.warnings)
+            lines.push(`- ${warning}`);
+    }
+    return lines.join("\n");
+}
+function formatProListSummary(consult, sourceCli, options = {}) {
+    const blocker = sourceAwareProAnswerBlocker(consult, sourceCli, options);
+    return firstLine(sourceAwareProAnswerSummary(consult.result.summary, consult.result.blocker, blocker));
+}
+function formatProductCheckLatestProLines(consult, sourceCli, options = {}) {
+    if (consult.result.status === "blocked") {
+        const blocker = sourceAwareProAnswerBlocker(consult, sourceCli, options);
+        const code = blocker?.code ?? "unknown";
+        const retryable = blocker?.retryable ?? false;
+        const lines = [`latest_pro: blocked ${consult.task.id} code=${code} retryable=${retryable} ${consult.result.created_at}`];
+        if (blocker?.next_step)
+            lines.push(`latest_pro_next: ${blocker.next_step}`);
+        return lines;
+    }
+    return [`latest_pro: ok ${consult.task.id} ${consult.result.status} ${consult.result.created_at}`];
+}
+function sourceAwareProAnswerBlocker(consult, sourceCli, options = {}) {
+    if (!consult.result.blocker)
+        return undefined;
+    const browserAware = sourceAwareBrowserBlocker(consult.result.blocker, sourceCli, options);
+    if ((!sourceCli && !options.cwd && !options.port) || !isSmokeConsultRecord(consult) || !browserAware.next_step)
+        return browserAware;
+    const nextStep = productCheckBrowserNextStep(browserAware.next_step, sourceCli, options);
+    return nextStep === browserAware.next_step ? browserAware : { ...browserAware, next_step: nextStep };
+}
+function sourceAwareProAnswerSummary(summary, originalBlocker, displayedBlocker) {
+    const originalNextStep = originalBlocker?.next_step;
+    const displayedNextStep = displayedBlocker?.next_step;
+    if (!originalNextStep || !displayedNextStep || originalNextStep === displayedNextStep)
+        return summary;
+    return summary.replaceAll(originalNextStep, displayedNextStep);
+}
+function isSmokeConsultRecord(consult) {
+    return consult.task.title === "GPT Pro smoke" || consult.result.commands.includes("visible ChatGPT browser smoke");
+}
+function receiptInspectionListSuffix(receipt) {
+    const status = receipt.metadata.integrity_status;
+    if (typeof status === "object" &&
+        status !== null &&
+        "trusted" in status &&
+        status.trusted === false) {
+        return "\tintegrity=untrusted";
+    }
+    return "";
+}
+function formatSession(session) {
+    return JSON.stringify({
+        id: session.id,
+        status: session.status,
+        direction: session.direction,
+        backend: session.backend,
+        project: session.project,
+        thread: session.thread,
+        task_id: session.task_id,
+        blocker: session.blocker,
+        warnings: session.warnings,
+        created_at: session.created_at,
+        last_used_at: session.last_used_at
+    }, null, 2);
+}
+function formatProConsultArtifact(consult) {
+    const lines = [`# ChatGPT Pro Consult`, "", `Thread: ${consult.url}`, `Title: ${consult.title}`, ""];
+    if (consult.modelHints.length > 0) {
+        lines.push("Model hints:", ...consult.modelHints.map((hint) => `- ${hint}`), "");
+    }
+    if (consult.warnings.length > 0) {
+        lines.push("Warnings:", ...consult.warnings.map((warning) => `- ${warning}`), "");
+    }
+    lines.push("## Answer", "", consult.answer.trim(), "");
+    return lines.join("\n");
+}
+async function writeSessionBestEffort(store, input, io) {
+    try {
+        await store.writeSession(input);
+    }
+    catch (error) {
+        io.stderr(`session_record_warning: ${errorMessage(error)}`);
+    }
+}
+async function writeSessionBeforeBrowserSend(store, input) {
+    try {
+        await store.writeSession(input);
+    }
+    catch (error) {
+        throw new Error(`failed to record running consult session before browser send: ${errorMessage(error)}`);
+    }
+}
+function firstLine(value) {
+    return value.split(/\r?\n/).find((line) => line.trim())?.trim() ?? "";
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function browserSendBlockerFromError(error) {
+    const blocker = typeof error === "object" && error !== null && "blocker" in error ? error.blocker : undefined;
+    if (typeof blocker === "object" &&
+        blocker !== null &&
+        "code" in blocker &&
+        "message" in blocker &&
+        "retryable" in blocker &&
+        typeof blocker.code === "string" &&
+        typeof blocker.message === "string" &&
+        typeof blocker.retryable === "boolean") {
+        return {
+            code: blocker.code,
+            message: blocker.message,
+            retryable: blocker.retryable,
+            ...("next_step" in blocker && typeof blocker.next_step === "string" ? { next_step: blocker.next_step } : {})
+        };
+    }
+    const message = errorMessage(error);
+    return {
+        code: "browser_send_failed",
+        message,
+        retryable: true,
+        next_step: "Resolve the visible browser issue manually, then rerun the consult if needed."
+    };
+}
+function isMissingFileError(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function isUntrustedResultError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        "taskId" in error &&
+        error.code === "EUNTRUSTED_RESULT" &&
+        typeof error.taskId === "string");
+}
+function assertTokenNotExpiredForCommand(config, sourceCli, setupHintCwd) {
+    const tokenStatus = getTokenExpiryStatus(config);
+    if (tokenStatus.status === "expired") {
+        throw new Error(sourceAwareSetupMessage(tokenStatus.warning.toLowerCase(), sourceCli, { cwd: setupHintCwd }));
+    }
+}
+async function loadLocalConfigForCommand(cwd, command, sourceCli, setupHintCwd) {
+    return loadLocalConfig(cwd).catch(async (error) => {
+        if (isMissingFileError(error)) {
+            throw new Error(sourceAwareSetupMessage(`${command} requires local MCP setup. Run \`prodex setup\` first. Add \`--token-ttl-hours <hours>\` before revealing token URLs, using tunnels, or connecting ChatGPT Projects.`, sourceCli, { cwd: setupHintCwd }));
+        }
+        throw new Error(sourceAwareSetupMessage(errorMessage(error), sourceCli, { cwd: setupHintCwd }));
+    });
+}
+function redactServerUrl(value) {
+    return formatServerUrlForOutput(value, { showToken: false });
+}
+function formatServerUrlForOutput(value, options) {
+    try {
+        const url = new URL(value);
+        url.username = "";
+        url.password = "";
+        if (!options.showToken && url.searchParams.has("prodex_token"))
+            url.searchParams.set("prodex_token", "***");
+        return url.toString();
+    }
+    catch {
+        const withoutUserinfo = value.replace(/\/\/[^/@\s]+@/g, "//");
+        return options.showToken ? withoutUserinfo : withoutUserinfo.replace(/([?&]prodex_token=)[^&]+/g, "$1***");
+    }
+}
+function makeTunnelMcpUrl(publicUrl, token) {
+    const url = parseTunnelPublicUrl(publicUrl);
+    url.username = "";
+    url.password = "";
+    url.pathname = "/mcp";
+    url.search = "";
+    url.hash = "";
+    url.searchParams.set("prodex_token", token);
+    return url.toString();
+}
+function parseTunnelPublicUrl(publicUrl) {
+    let url;
+    try {
+        url = new URL(publicUrl);
+    }
+    catch {
+        throw new Error("--public-url must be a valid URL");
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw new Error("--public-url must use http or https");
+    }
+    if (url.protocol !== "https:" && !isLoopbackHost(url.hostname)) {
+        throw new Error("--public-url must use https for non-loopback tunnel URLs");
+    }
+    return url;
+}
+function isLoopbackHost(hostname) {
+    return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
+}
+function readFlag(args, flag) {
+    const index = args.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return readFlagValue(args, index, flag);
+}
+function readNumberFlag(args, flag) {
+    const raw = readFlag(args, flag);
+    if (raw === undefined)
+        return undefined;
+    const value = Number(raw);
+    if (!Number.isFinite(value))
+        throw new Error(`${flag} requires a finite number`);
+    return value;
+}
+function readPositiveNumberFlag(args, flag) {
+    const value = readNumberFlag(args, flag);
+    if (value === undefined)
+        return undefined;
+    if (value <= 0)
+        throw new Error(`${flag} must be greater than 0`);
+    return value;
+}
+function readPortFlag(args, flag) {
+    const value = readNumberFlag(args, flag);
+    if (value === undefined)
+        return undefined;
+    if (!Number.isInteger(value) || value < 1 || value > 65535) {
+        throw new Error(`${flag} must be an integer from 1 to 65535`);
+    }
+    return value;
+}
+function readChatGptBrowserUrlFlag(args) {
+    return normalizeChatGptTargetUrl(readFlag(args, "--url") ?? "https://chatgpt.com/");
+}
+function readRepeatedFlag(args, flag) {
+    const values = [];
+    for (let index = 0; index < args.length; index += 1) {
+        if (args[index] === flag) {
+            values.push(readFlagValue(args, index, flag));
+            index += 1;
+        }
+    }
+    return values;
+}
+function resolveCwdFlag(defaultCwd, args) {
+    const cwd = readFlag(args, "--cwd");
+    if (!cwd)
+        return defaultCwd;
+    return resolveExistingDirectoryFlag(defaultCwd, cwd, "--cwd");
+}
+function resolveOptionalPathFlag(defaultCwd, args, flag) {
+    const value = readFlag(args, flag);
+    return value ? resolveExistingPathFlag(defaultCwd, value, flag) : undefined;
+}
+function resolveOptionalFileFlag(defaultCwd, args, flag) {
+    const value = readFlag(args, flag);
+    return value ? resolveExistingFileFlag(defaultCwd, value, flag) : undefined;
+}
+function resolveExistingPathFlag(defaultCwd, value, flag) {
+    const resolved = path.resolve(defaultCwd, value);
+    try {
+        return realpathSync(resolved);
+    }
+    catch {
+        throw new Error(`${flag} does not exist or is not accessible: ${resolved}`);
+    }
+}
+function resolveExistingFileFlag(defaultCwd, value, flag) {
+    const resolved = resolveExistingPathFlag(defaultCwd, value, flag);
+    if (!statSync(resolved).isFile()) {
+        throw new Error(`${flag} must be a file: ${resolved}`);
+    }
+    return resolved;
+}
+function resolveExistingDirectoryFlag(defaultCwd, value, flag) {
+    const resolved = resolveExistingPathFlag(defaultCwd, value, flag);
+    if (!statSync(resolved).isDirectory()) {
+        throw new Error(`${flag} must be a directory: ${resolved}`);
+    }
+    return resolved;
+}
+function assertOnlyOptions(args, command, valueFlags, booleanFlags = []) {
+    const valueFlagSet = new Set(valueFlags);
+    const booleanFlagSet = new Set(booleanFlags);
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (valueFlagSet.has(arg)) {
+            readFlagValue(args, index, arg);
+            index += 1;
+            continue;
+        }
+        if (booleanFlagSet.has(arg))
+            continue;
+        if (arg.startsWith("-")) {
+            throw unknownOptionError(arg, command, [...valueFlagSet, ...booleanFlagSet]);
+        }
+        throw new Error(`Unexpected argument for ${command}: ${arg}`);
+    }
+}
+function readPositionalsWithOptions(args, command, maxPositionals, valueFlags, booleanFlags = []) {
+    const valueFlagSet = new Set(valueFlags);
+    const booleanFlagSet = new Set(booleanFlags);
+    const positionals = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (valueFlagSet.has(arg)) {
+            readFlagValue(args, index, arg);
+            index += 1;
+            continue;
+        }
+        if (booleanFlagSet.has(arg))
+            continue;
+        if (arg.startsWith("-")) {
+            throw unknownOptionError(arg, command, [...valueFlagSet, ...booleanFlagSet]);
+        }
+        if (positionals.length >= maxPositionals) {
+            throw new Error(`Unexpected argument for ${command}: ${arg}`);
+        }
+        positionals.push(arg);
+    }
+    return positionals;
+}
+function assertNoExtraArgs(args, command, maxPositionals) {
+    for (const arg of args.slice(maxPositionals)) {
+        if (arg.startsWith("-")) {
+            throw new Error(`Unknown option for ${command}: ${arg}`);
+        }
+        throw new Error(`Unexpected argument for ${command}: ${arg}`);
+    }
+}
+function readRequiredLeadingArgument(args, command, placeholder) {
+    const value = args[0];
+    if (!value || value.startsWith("-"))
+        throw new Error(`${command} requires ${placeholder}`);
+    return value;
+}
+const ASK_PRO_BOOLEAN_FLAGS = new Set(["--dry-run", "--send", "--confirm-target"]);
+const ASK_PRO_VALUE_FLAGS = new Set(["--cwd", "--file", "--port", "--timeout-ms", "--target-url", "--source-cli"]);
+const ASK_PRO_PREVIEW_VALUE_FLAGS = new Set(["--cwd", "--file", "--port", "--timeout-ms", "--target-url"]);
+function parseAskProArgs(args, valueFlags = ASK_PRO_VALUE_FLAGS) {
+    const delimiterIndex = args.indexOf("--");
+    const optionArgs = delimiterIndex === -1 ? args : args.slice(0, delimiterIndex);
+    const promptTail = delimiterIndex === -1 ? [] : args.slice(delimiterIndex + 1);
+    const positionalPromptParts = [];
+    for (let index = 0; index < optionArgs.length; index += 1) {
+        const arg = optionArgs[index];
+        if (!arg.startsWith("--")) {
+            if (arg.startsWith("-"))
+                throw unknownOptionError(arg, undefined, [...valueFlags, ...ASK_PRO_BOOLEAN_FLAGS]);
+            positionalPromptParts.push(arg);
+            continue;
+        }
+        if (ASK_PRO_BOOLEAN_FLAGS.has(arg))
+            continue;
+        if (valueFlags.has(arg)) {
+            readFlagValue(optionArgs, index, arg);
+            index += 1;
+            continue;
+        }
+        throw unknownOptionError(arg, undefined, [...valueFlags, ...ASK_PRO_BOOLEAN_FLAGS]);
+    }
+    return { optionArgs, promptParts: [...positionalPromptParts, ...promptTail] };
+}
+function askProOptionArgs(args) {
+    const delimiterIndex = args.indexOf("--");
+    return delimiterIndex === -1 ? args : args.slice(0, delimiterIndex);
+}
+function hasAskProMode(args) {
+    const optionArgs = askProOptionArgs(args);
+    return optionArgs.includes("--send") || optionArgs.includes("--dry-run");
+}
+function hasAskProSendMode(args) {
+    return askProOptionArgs(args).includes("--send");
+}
+function hasAskProDryRunMode(args) {
+    return askProOptionArgs(args).includes("--dry-run");
+}
+function readFlagValue(args, index, flag) {
+    const value = args[index + 1];
+    if (!value || value.startsWith("--"))
+        throw new Error(`${flag} requires a value`);
+    return value;
+}
+function readSessionStatusFlag(args) {
+    const value = readFlag(args, "--status");
+    if (value === undefined)
+        return undefined;
+    if (value === "preview" || value === "running" || value === "done" || value === "blocked")
+        return value;
+    throw new Error("--status must be one of preview, running, done, blocked");
+}
+const TASK_STATUSES = TaskStatusSchema.options;
+function readTaskStatusFlag(args) {
+    const value = readFlag(args, "--status");
+    if (value === undefined)
+        return undefined;
+    if (TaskStatusSchema.safeParse(value).success)
+        return value;
+    throw new Error(`--status must be one of ${TASK_STATUSES.join(", ")}`);
+}
+const RECEIPT_KINDS = ReceiptKindSchema.options;
+function readReceiptKindFlag(args) {
+    const value = readFlag(args, "--kind");
+    if (value === undefined)
+        return undefined;
+    if (ReceiptKindSchema.safeParse(value).success)
+        return value;
+    throw new Error(`--kind must be one of ${RECEIPT_KINDS.join(", ")}`);
+}
+function formatTokenExpiryLine(config) {
+    const tokenStatus = getTokenExpiryStatus(config);
+    if (tokenStatus.status === "valid")
+        return `Token expires: ${tokenStatus.token_expires_at}`;
+    if (tokenStatus.status === "expired")
+        return `Token expired: ${tokenStatus.token_expires_at}`;
+    return "Token expires: never (local-only; use --token-ttl-hours before exposing through a tunnel).";
+}
+function formatConfigWarningLine(tokenStatus, sourceCli, setupHintCwd) {
+    return tokenStatus.warning ? `config_warning: ${sourceAwareSetupMessage(tokenStatus.warning, sourceCli, { cwd: setupHintCwd })}` : undefined;
+}
+async function ensureBridgeGitignore(cwd) {
+    const bridgeIgnorePath = path.join(cwd, ".bridge", ".gitignore");
+    await mkdir(path.dirname(bridgeIgnorePath), { recursive: true });
+    await writeVerifiedUtf8File(bridgeIgnorePath, ["tasks/*.json", "results/*.json", "sessions/*.json", "receipts/*.json", "artifacts/*", "config.local.json", "receipt-key.local", "!.gitignore", ""].join("\n"), () => assertGitignoreTargetSafe(bridgeIgnorePath), { create: true });
+    const rootIgnorePath = path.join(cwd, ".gitignore");
+    let current = "";
+    try {
+        current = await readVerifiedUtf8File(rootIgnorePath, () => assertGitignoreTargetSafe(rootIgnorePath));
+    }
+    catch (error) {
+        if (!isMissingFileError(error))
+            throw error;
+    }
+    const ignored = new Set(current.split(/\r?\n/).filter(Boolean));
+    const additions = ["node_modules/", "dist/"].filter((line) => !ignored.has(line));
+    if (additions.length > 0) {
+        await writeVerifiedUtf8File(rootIgnorePath, `${current}${current && !current.endsWith("\n") ? "\n" : ""}${additions.join("\n")}\n`, () => assertGitignoreTargetSafe(rootIgnorePath), { create: true });
+    }
+}
+async function assertGitignoreTargetSafe(filePath) {
+    try {
+        const stat = await lstat(filePath);
+        if (stat.isSymbolicLink())
+            throw new Error(`${filePath} must not be a symlink`);
+        if (!stat.isFile())
+            throw new Error(`${filePath} must be a regular file`);
+    }
+    catch (error) {
+        if (isMissingFileError(error))
+            return;
+        throw error;
+    }
+}
+async function waitForShutdown(close) {
+    await new Promise((resolve) => {
+        const shutdown = () => resolve();
+        process.once("SIGINT", shutdown);
+        process.once("SIGTERM", shutdown);
+    });
+    await close();
+}
+function isDirectCliInvocation() {
+    if (!process.argv[1])
+        return false;
+    const modulePath = fileURLToPath(import.meta.url);
+    try {
+        return realpathSync(process.argv[1]) === realpathSync(modulePath);
+    }
+    catch {
+        return path.resolve(process.argv[1]) === modulePath;
+    }
+}
+if (isDirectCliInvocation()) {
+    runCli(process.argv.slice(2))
+        .then((code) => {
+        if (code !== 0)
+            process.exitCode = code;
+    })
+        .catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    });
+}
+//# sourceMappingURL=cli.js.map