@youdie006/prodex 0.5.0 → 0.6.1

package/dist/cli.js

@@ -1,8 +1,7 @@
 #!/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 { realpathSync } from "node:fs";
+import { lstat, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -10,43 +9,20 @@ 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, listChatGptModelOptions, openChatGptBrowser, parseProMode, parseReasoningEffort, sendChatGptPrompt } from "./chatgpt-browser.js";
-import { getTokenExpiryStatus, loadBrowserDefaults, loadLocalConfig, writeLocalConfig } from "./config.js";
+import { getTokenExpiryStatus, loadLocalConfig } 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";
+import { BridgeStore } from "./store.js";
+import { printHelpIfRequested, assertNoExtraArgs, assertOnlyOptions, formatCliCommand, formatSourceCliOption, isHelpSubcommand, readFlag, resolveCwdFlag, resolveExistingPathFlag, resolveOptionalFileFlag, shellQuote, unknownSubcommandError, unknownTopLevelCommandError } from "./cli-args.js";
+import { listRawResultsForInspection, listTasksForInspection, runReceiptsCommand, runResultsCommand, runSessionsCommand, runTasksCommand } from "./cli-ledger.js";
+import { isMissingFileError, errorMessage, formatInitCommand, formatReleaseStatusCommand, formatSetupCommand, sourceAwareReleaseMessage, sourceAwareSetupMessage } from "./cli-shared.js";
+import { TOKEN_BEARING_MCP_URL_AUTHORITY_WARNING, redactServerUrl, runInitCommand, runSetupCommand, runStartCommand, runStatusCommand, runTunnelCommand } from "./cli-server.js";
+import { assertNoMissingTerminalConsultResults, assertNoOrphanConsultResults, formatConfigWarningLine, isConsultRecord, runAskProCommand, runChatgptCommand, runConsultsCommand, runProCommand } from "./cli-pro.js";
+import { CLI_VERSION, printClaudeHelp, printDoctorHelp, printHelp, printMcpHelp, printOnboardHelp, printProjectHelp, printReleaseHelp } from "./cli-help.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",
@@ -80,179 +56,16 @@ export async function runCli(args, io = defaultIo()) {
         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") {
-        const setupValueFlags = ["--cwd", "--host", "--port", "--token", "--token-ttl-hours", ...ASK_PRO_SELECTION_DEFAULT_FLAGS];
-        const setupBooleanFlags = [...ASK_PRO_SELECTION_CLEAR_FLAGS, "--interactive"];
-        if (printHelpIfRequested(rest, "setup", io.stdout, printSetupHelp, { valueFlags: setupValueFlags, booleanFlags: setupBooleanFlags }))
-            return 0;
-        assertOnlyOptions(rest, "setup", setupValueFlags, setupBooleanFlags);
-        const targetCwd = resolveCwdFlag(io.cwd, rest);
-        const interactive = rest.includes("--interactive");
-        if (interactive) {
-            const conflicting = [...ASK_PRO_SELECTION_DEFAULT_FLAGS, ...ASK_PRO_SELECTION_CLEAR_FLAGS].filter((flag) => rest.includes(flag));
-            if (conflicting.length > 0) {
-                throw new Error(`setup --interactive collects the browser defaults itself; drop ${conflicting.join(", ")} or run without --interactive.`);
-            }
-        }
-        const browserDefaults = interactive
-            ? await runBrowserDefaultsWizard(resolvePromptUser(io), io.stdout)
-            : parseBrowserDefaultFlags(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"),
-            browserDefaults
-        });
-        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.");
-        if (config.browser_defaults) {
-            io.stdout(`Browser send defaults: ${formatBrowserDefaults(config.browser_defaults)}`);
-        }
-        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,
-            browser_defaults: config.browser_defaults ?? 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 === "init")
+        return runInitCommand(rest, io);
+    if (command === "setup")
+        return runSetupCommand(rest, io);
+    if (command === "start")
+        return runStartCommand(rest, io);
+    if (command === "status")
+        return runStatusCommand(rest, io);
+    if (command === "tunnel")
+        return runTunnelCommand(rest, io);
     if (command === "doctor") {
         if (printHelpIfRequested(rest, "doctor", io.stdout, printDoctorHelp, { valueFlags: ["--cwd", "--source-cli"] }))
             return 0;
@@ -352,830 +165,22 @@ export async function runCli(args, io = defaultIo()) {
         }
         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;
-        }
-        if (subcommand === "rotate-key") {
-            if (printHelpIfRequested(receiptArgs, "receipts rotate-key", io.stdout, printReceiptsHelp, { valueFlags: ["--cwd"] }))
-                return 0;
-            assertOnlyOptions(receiptArgs, "receipts rotate-key", ["--cwd"]);
-            const targetStore = new BridgeStore(resolveCwdFlag(io.cwd, receiptArgs));
-            await targetStore.ensure();
-            const rotated = await targetStore.rotateReceiptIntegrityKey();
-            io.stdout(`Rotated the local receipt integrity key: ${rotated.keys} key(s) in .bridge/receipt-key.local.`);
-            io.stdout("New receipts are signed with the new key; receipts signed before the rotation still verify via the retained legacy keys.");
-            return 0;
-        }
-        throw unknownSubcommandError("receipts", subcommand, ["list", "show", "rotate-key"]);
-    }
-    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;
-            }
-            if (browserSubcommand === "models") {
-                if (printProBrowserHelpIfRequested(browserArgs, "pro browser models", io, { valueFlags: ["--port", "--timeout-ms", "--source-cli"] }))
-                    return 0;
-                assertOnlyOptions(browserArgs, "pro browser models", ["--port", "--timeout-ms", "--source-cli"]);
-                const listed = await listChatGptModelOptions({
-                    port: readPortFlag(browserArgs, "--port"),
-                    timeoutMs: readPositiveNumberFlag(browserArgs, "--timeout-ms")
-                });
-                io.stdout("Model menu options in the visible ChatGPT tab (read-only; nothing was selected):");
-                for (const option of listed.options) {
-                    const marker = option.checked ? "*" : " ";
-                    const suffix = option.kind === "submenu" ? "  (has sub-variants; not selectable via --model yet)" : "";
-                    io.stdout(`${marker} ${option.label}${suffix}`);
-                }
-                io.stdout("Use radio entries with `pro browser ask --model/--effort`; Pro sub-modes via --pro-mode 기본|확장.");
-                return 0;
-            }
-            throw unknownSubcommandError("pro browser", browserSubcommand, ["login", "ask", "smoke", "check", "models"]);
-        }
-        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 browserDefaults = await loadBrowserDefaults(targetCwd);
-        const explicitProject = readFlag(parsedAskPro.optionArgs, "--project");
-        const explicitProjectNew = readFlag(parsedAskPro.optionArgs, "--project-new");
-        if (explicitProject !== undefined && explicitProjectNew !== undefined) {
-            throw new Error("ask-pro cannot combine --project and --project-new; pick an existing project or create one.");
-        }
-        if (normalizedTargetUrl && (explicitProject !== undefined || explicitProjectNew !== undefined)) {
-            throw new Error("ask-pro cannot combine --target-url with --project/--project-new: --target-url pins the confirmed tab while the project step navigates the sidebar away from it. Open the project thread in the browser and pass its URL as --target-url instead.");
-        }
-        const explicitModel = readFlag(parsedAskPro.optionArgs, "--model");
-        const explicitProModeRaw = readFlag(parsedAskPro.optionArgs, "--pro-mode");
-        const explicitEffortRaw = readFlag(parsedAskPro.optionArgs, "--effort");
-        if (explicitProModeRaw !== undefined && explicitEffortRaw !== undefined) {
-            throw new Error("ask-pro cannot combine --pro-mode and --effort; Pro sub-modes and reasoning effort are different model axes.");
-        }
-        const explicitProMode = explicitProModeRaw === undefined ? undefined : parseProMode(explicitProModeRaw);
-        const explicitEffort = explicitEffortRaw === undefined ? undefined : parseReasoningEffort(explicitEffortRaw);
-        // Explicit per-ask flags override persisted defaults. Choosing either
-        // reasoning axis explicitly suppresses the default for the other axis, and
-        // pinning --target-url suppresses a default project (it would navigate away
-        // from the confirmed tab).
-        const selectionModel = explicitModel ?? browserDefaults?.model;
-        const selectionProjectNew = explicitProjectNew;
-        const selectionProject = explicitProject ?? (normalizedTargetUrl || selectionProjectNew !== undefined ? undefined : browserDefaults?.project);
-        const reasoningAxisChosen = explicitProMode !== undefined || explicitEffort !== undefined;
-        const selectionProMode = explicitProMode ?? (reasoningAxisChosen ? undefined : browserDefaults?.pro_mode);
-        const selectionEffort = explicitEffort ?? (reasoningAxisChosen ? undefined : browserDefaults?.effort);
-        const selectionMetadata = {
-            ...(selectionProject ? { project: selectionProject } : {}),
-            ...(selectionProjectNew ? { project_new: selectionProjectNew } : {}),
-            ...(selectionModel ? { model: selectionModel } : {}),
-            ...(selectionProMode ? { pro_mode: selectionProMode } : {}),
-            ...(selectionEffort ? { effort: selectionEffort } : {})
-        };
-        const browserPort = hasSendMode ? (readPortFlag(parsedAskPro.optionArgs, "--port") ?? 9333) : undefined;
-        // Pro extended can legitimately think for minutes, so its default timeout is
-        // higher; an explicit --timeout-ms always wins.
-        const defaultBrowserTimeoutMs = selectionProMode === "확장" ? 300_000 : 90_000;
-        const browserTimeoutMs = hasSendMode
-            ? (readPositiveNumberFlag(parsedAskPro.optionArgs, "--timeout-ms") ?? defaultBrowserTimeoutMs)
-            : 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,
-                    project: selectionProject,
-                    projectNew: selectionProjectNew,
-                    model: selectionModel,
-                    proMode: selectionProMode,
-                    effort: selectionEffort
-                });
-            }
-            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,
-                        ...(Object.keys(selectionMetadata).length > 0 ? { selection: selectionMetadata } : {}),
-                        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 === "chatgpt")
+        return runChatgptCommand(rest, io);
+    if (command === "tasks")
+        return runTasksCommand(rest, io);
+    if (command === "results")
+        return runResultsCommand(rest, io);
+    if (command === "receipts")
+        return runReceiptsCommand(rest, io);
+    if (command === "sessions")
+        return runSessionsCommand(rest, io);
+    if (command === "pro")
+        return runProCommand(rest, io, runCli);
+    if (command === "consults")
+        return runConsultsCommand(rest, io);
+    if (command === "ask-pro")
+        return runAskProCommand(rest, io);
     if (command === "mcp") {
         if (printHelpIfRequested(rest, "mcp", io.stdout, printMcpHelp, { valueFlags: ["--cwd"] }))
             return 0;
@@ -1192,368 +197,54 @@ function defaultIo() {
         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>] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"] [--project "name"] [--clear-model|--clear-pro-mode|--clear-effort|--clear-project] [--interactive]
-  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 models [--source-cli /absolute/path/to/dist/cli.js] [--port 9333] [--timeout-ms 15000]  # read-only list of model menu options
-  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] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"] [--project "name" | --project-new "name"] "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 receipts rotate-key [--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 isHelpArgs(args) {
+    return args.length > 0 && isHelpSubcommand(args[0]);
 }
-function printInitHelp(stdout) {
-    stdout(`prodex init
+function formatProjectVerificationPrompt(cwd, sourceCli) {
+    const cli = formatCliCommand(sourceCli);
+    const quotedCwd = shellQuote(cwd);
+    const sourceCliOption = formatSourceCliOption(sourceCli);
+    return `ChatGPT Project MCP verification prompt
 
-Commands:
-  prodex init [--cwd /absolute/path/to/repo]
+Paste this into the ChatGPT Project after adding the prodex MCP server URL.
+${TOKEN_BEARING_MCP_URL_AUTHORITY_WARNING}
 
-Initialize the local .bridge receipt ledger and bridge .gitignore entries.`);
-}
-function printSetupHelp(stdout) {
-    stdout(`prodex setup
+Please verify the prodex MCP bridge for this private project:
 
-Commands:
-  prodex setup [--cwd /absolute/path/to/repo] [--host 127.0.0.1] [--port 8787] [--token-ttl-hours <hours>] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"] [--project "name"] [--clear-model|--clear-pro-mode|--clear-effort|--clear-project] [--interactive]
+1. Call the MCP tool \`bridge_create_task\` with:
 
-Save a loopback-only HTTP MCP profile in .bridge/config.local.json. Use --token-ttl-hours before tunnels or ChatGPT Project use.
+   {
+     "title": "prodex MCP verification",
+     "prompt": "Verify that this ChatGPT Project can create tasks through the local prodex MCP bridge.",
+     "repo_id": "default"
+   }
 
-Optional visible-browser send defaults (applied by \`pro browser ask\` when the matching per-ask flag is omitted):
-  --model      Composer model to pick by its exact menu label (verified: Pro)
-  --pro-mode   Pro sub-mode: 기본 (standard) or 확장 (extended)
-  --effort     Reasoning effort: 즉시 / 중간 / 높음 / 매우 높음 (English aliases: instant/medium/high/max); picking one deselects Pro
-  --project    Sidebar project to enter before sending
-Clear a saved default with --clear-model / --clear-pro-mode / --clear-effort / --clear-project.
---pro-mode and --effort are different model axes and cannot be combined. View saved defaults with \`prodex status\`.`);
-}
-function printStartHelp(stdout) {
-    stdout(`prodex start
+2. Call \`bridge_list_tasks\` with:
 
-Commands:
-  prodex start [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
+   { "status": "new" }
 
-Start the local loopback HTTP MCP server from the saved setup profile.`);
-}
-function printStatusHelp(stdout) {
-    stdout(`prodex status
+3. Call \`bridge_get_task\` with the task_id returned by \`bridge_create_task\`.
 
-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]
+4. Reply with the task_id and whether all three MCP calls succeeded. Ask me to run the local completion command below, then wait.
 
-Show the saved local MCP URL with tokens redacted by default.`);
-}
-function printTunnelHelp(stdout) {
-    stdout(`prodex tunnel
+5. After I reply exactly \`local completion done\`, call \`bridge_fetch_result\` with:
 
-Commands:
-  prodex tunnel url [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js] --public-url https://... [--show-token] [--url-only]
+   { "task_id": "<task-id>" }
 
-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
+6. If the fetched result lists artifacts, call \`bridge_fetch_result_artifact\` for each listed result artifact path:
 
-Commands:
-  prodex tunnel url [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js] --public-url https://... [--show-token] [--url-only]
+   { "task_id": "<task-id>", "path": "<artifact-path>" }
 
-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
+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.
 
-Commands:
-  prodex doctor [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
+Local follow-up after ChatGPT replies:
 
-Run local bridge, MCP, write/apply/stage, and HTTP MCP smoke checks without opening ChatGPT.`);
-}
-function printOnboardHelp(stdout) {
-    stdout(`prodex onboard
+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"
 
-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 models [--source-cli /absolute/path/to/dist/cli.js]
-  prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--target-url url --confirm-target] [--file path] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"] [--project "name" | --project-new "name"] "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.
-Model/project selection (visible-browser send):
-  --model "label"              Pick the composer model by its exact menu label (verified: Pro). Submenu models (e.g. GPT-5.5 variants) are rejected for now.
-  --pro-mode 기본 | 확장          Pro sub-mode (only when the model is Pro); 확장 raises the default timeout to 300000 ms
-  --effort 즉시|중간|높음|매우 높음   Reasoning effort (aliases: instant/medium/high/max); picking one deselects Pro
-  --project "name"             Enter an existing sidebar project first (cannot combine with --target-url)
-Labels match the Korean ChatGPT UI; run \`prodex pro browser models\` to list what your account shows.
-Persist defaults with \`prodex setup --model/--pro-mode/--effort/--project\`; clear them with setup --clear-model/--clear-pro-mode/--clear-effort/--clear-project.
-(Creating a new project from the CLI is planned; for now create it in ChatGPT and pass --project.)`);
-}
-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]
-  prodex receipts rotate-key [--cwd /absolute/path/to/repo]
-
-rotate-key generates a new signing key for receipt integrity seals and keeps the
-previous keys in .bridge/receipt-key.local so receipts signed before the
-rotation still verify.`);
-}
-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:
+Then reply to ChatGPT with:
 
 local completion done
 
@@ -1682,192 +373,9 @@ function formatClaudeConfig(cwd, sourceCli) {
         }
     }, 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) => {
@@ -2724,257 +1232,6 @@ async function runMcpWriteSmoke() {
         }
     }
 }
-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 selectionUsage = '[--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"] [--project "name" | --project-new "name"]';
-    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] ${selectionUsage} "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] ${selectionUsage} "prompt"`;
-    const modelsUsage = sourceCli
-        ? `${cli} pro browser models${sourceCliOption} [--port 9333] [--timeout-ms 15000]`
-        : "prodex pro browser models [--source-cli /absolute/path/to/dist/cli.js] [--port 9333] [--timeout-ms 15000]";
-    stdout(`${cli} pro browser
-
-Commands:
-  ${loginUsage}
-  ${checkUsage}
-  ${smokeUsage}
-  ${modelsUsage}
-  ${askUsage}
-
-Visible-browser sends require a manual browser session and stop on login, captcha, Cloudflare, permission, rate-limit, or usage-limit blockers.
-Model/project selection (ask):
-  --model      Composer model to pick by its exact menu label (verified: Pro). Models whose menu entry opens a submenu of variants are rejected with a clear error for now.
-  --pro-mode   Pro sub-mode: 기본 (standard) or 확장 (extended), used when the model is Pro. 확장 raises the default --timeout-ms to 300000.
-  --effort     Reasoning effort: 즉시 / 중간 / 높음 / 매우 높음 (aliases: instant/medium/high/max). Picking an effort switches the composer to the standard reasoning model, deselecting Pro.
-  --project    Enter an existing sidebar project before sending. Cannot be combined with --target-url.
---pro-mode and --effort cannot be combined. These labels match the Korean ChatGPT UI; set your ChatGPT display language to Korean for selection flags.
-Run \`${cli} pro browser models${sourceCliOption}\` to list the labels your account currently shows.
-Persist defaults with \`${cli} setup${sourceCliOption}\`; per-ask flags override them.
-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)])
@@ -2995,741 +1252,16 @@ async function listConsults(store, options = {}) {
     }
     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_SELECTION_VALUE_FLAGS = ["--project", "--project-new", "--model", "--pro-mode", "--effort"];
-const ASK_PRO_VALUE_FLAGS = new Set([
-    "--cwd",
-    "--file",
-    "--port",
-    "--timeout-ms",
-    "--target-url",
-    "--source-cli",
-    ...ASK_PRO_SELECTION_VALUE_FLAGS
-]);
-const ASK_PRO_PREVIEW_VALUE_FLAGS = new Set([
-    "--cwd",
-    "--file",
-    "--port",
-    "--timeout-ms",
-    "--target-url",
-    ...ASK_PRO_SELECTION_VALUE_FLAGS
-]);
-// Setup persists defaults for a subset of the per-ask selection flags. A new
-// project is created per-ask, never as a standing default, so --project-new is
-// intentionally excluded here.
-const ASK_PRO_SELECTION_DEFAULT_FLAGS = ["--model", "--pro-mode", "--effort", "--project"];
-const ASK_PRO_SELECTION_CLEAR_FLAGS = ["--clear-model", "--clear-pro-mode", "--clear-effort", "--clear-project"];
-function parseBrowserDefaultFlags(args) {
-    const model = readFlag(args, "--model");
-    const proModeRaw = readFlag(args, "--pro-mode");
-    const effortRaw = readFlag(args, "--effort");
-    const project = readFlag(args, "--project");
-    if (proModeRaw !== undefined && effortRaw !== undefined) {
-        throw new Error("setup cannot combine --pro-mode and --effort; Pro sub-modes and reasoning effort are different model axes.");
-    }
-    const clears = [
-        ["--clear-model", "--model", model],
-        ["--clear-pro-mode", "--pro-mode", proModeRaw],
-        ["--clear-effort", "--effort", effortRaw],
-        ["--clear-project", "--project", project]
-    ].map(([clearFlag, setFlag, setValue]) => {
-        const wantsClear = args.includes(clearFlag);
-        if (wantsClear && setValue !== undefined) {
-            throw new Error(`setup cannot combine ${setFlag} and ${clearFlag}; set a new default or clear it, not both.`);
-        }
-        return wantsClear;
-    });
-    const [clearModel, clearProMode, clearEffort, clearProject] = clears;
-    const anySet = model !== undefined || proModeRaw !== undefined || effortRaw !== undefined || project !== undefined;
-    if (!anySet && !clears.some(Boolean))
-        return undefined;
-    // Cleared fields are passed as explicit undefined so the config merge deletes
-    // them while untouched fields survive.
-    return {
-        ...(model !== undefined ? { model } : {}),
-        ...(clearModel ? { model: undefined } : {}),
-        ...(proModeRaw !== undefined ? { proMode: parseProMode(proModeRaw) } : {}),
-        ...(clearProMode ? { proMode: undefined } : {}),
-        ...(effortRaw !== undefined ? { effort: parseReasoningEffort(effortRaw) } : {}),
-        ...(clearEffort ? { effort: undefined } : {}),
-        ...(project !== undefined ? { project } : {}),
-        ...(clearProject ? { project: undefined } : {})
-    };
-}
-function resolvePromptUser(io) {
-    if (io.promptUser)
-        return io.promptUser;
-    if (!process.stdin.isTTY) {
-        throw new Error("setup --interactive needs a terminal (TTY). Use the --model/--pro-mode/--effort/--project flags instead.");
-    }
-    return async (question) => {
-        const readline = await import("node:readline/promises");
-        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        try {
-            return (await rl.question(question)).trim();
-        }
-        finally {
-            rl.close();
-        }
-    };
-}
-// Ask up to `attempts` times; empty input means skip (returns undefined).
-async function askChoice(prompt, question, choices, attempts = 3) {
-    for (let attempt = 0; attempt < attempts; attempt += 1) {
-        const raw = (await prompt(question)).trim();
-        if (raw === "")
-            return undefined;
-        const index = Number.parseInt(raw, 10);
-        if (Number.isInteger(index) && index >= 1 && index <= choices.length)
-            return choices[index - 1];
-    }
-    throw new Error(`No valid choice after ${attempts} attempts; run setup again or use flags.`);
-}
-async function runBrowserDefaultsWizard(prompt, stdout) {
-    stdout("Browser send defaults (press Enter to skip a question; labels match the Korean ChatGPT UI):");
-    const model = await askChoice(prompt, "Default model — 1) Pro [Enter=skip]: ", ["Pro"]);
-    let proMode;
-    let effort;
-    if (model === "Pro") {
-        proMode = (await askChoice(prompt, "Pro sub-mode — 1) 기본  2) 확장 [Enter=skip]: ", ["기본", "확장"]));
-    }
-    else {
-        effort = (await askChoice(prompt, "Reasoning effort — 1) 즉시  2) 중간  3) 높음  4) 매우 높음 [Enter=skip]: ", [
-            "즉시",
-            "중간",
-            "높음",
-            "매우 높음"
-        ]));
-    }
-    const projectRaw = (await prompt('Default project name (existing sidebar project) [Enter=skip]: ')).trim();
-    const project = projectRaw === "" ? undefined : projectRaw;
-    if (model === undefined && proMode === undefined && effort === undefined && project === undefined)
-        return undefined;
-    return {
-        ...(model !== undefined ? { model } : {}),
-        ...(proMode !== undefined ? { proMode } : {}),
-        ...(effort !== undefined ? { effort } : {}),
-        ...(project !== undefined ? { project } : {})
-    };
-}
-function formatBrowserDefaults(defaults) {
-    const parts = [];
-    if (defaults.model)
-        parts.push(`model=${defaults.model}`);
-    if (defaults.pro_mode)
-        parts.push(`pro-mode=${defaults.pro_mode}`);
-    if (defaults.effort)
-        parts.push(`effort=${defaults.effort}`);
-    if (defaults.project)
-        parts.push(`project=${defaults.project}`);
-    return parts.length > 0 ? parts.join(", ") : "(none)";
-}
-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;