prompts-gpt 0.2.8

package/dist/cli.js

@@ -0,0 +1,3650 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { parseArgs } from "node:util";
+import { hasTokenUsage, DEFAULT_PROMPTS_GPT_API_URL, DEFAULT_PROMPTS_GPT_OUT_DIR, DEFAULT_RUN_CONFIG_PATH, PROMPTS_GPT_CREDENTIALS_FILE, PromptsGptApiError, PromptsGptClient, doctor, initRunConfig, loadRunConfig, normalizeOrchestrationAgent, ORCHESTRATION_AGENT_PROFILES, runBatch, runPrompt, resolveRunProvider, warnModelProviderMismatch, sweepPrompt, validateRunConfig, discoverWorkspaceAssets, SUPPORTED_AGENT_TARGETS, detectProviders, loadLocalCredentials, saveLocalCredentials, syncPrompts, writeAgentFiles, writePromptManifest, writePromptMarkdownFiles, ensureGitignoreEntry, } from "./index.js";
+const CLI_EXIT_CODES = {
+    success: 0,
+    general: 1,
+    auth: 2,
+    validation: 3,
+    rateLimit: 4,
+    usage: 64,
+};
+const VALID_TOOLS = ["Codex", "Claude Code", "Cursor", "GitHub Copilot", "ChatGPT", "Gemini", "Perplexity", "Grok", "DeepSeek", "Claude"];
+const COMMANDS = ["setup", "init", "project", "pull", "generate", "sync", "run", "run-batch", "sweep", "list", "status", "validate", "providers", "models", "sync-models", "doctor", "load-config", "quickstart", "version", "help"];
+const MAX_STDIN_TOKEN_LENGTH = 4_096;
+class CliError extends Error {
+    exitCode;
+    helpCommand;
+    constructor(message, exitCode, options) {
+        super(message);
+        this.name = "CliError";
+        this.exitCode = exitCode;
+        this.helpCommand = options?.helpCommand;
+    }
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    if (argv.length === 0) {
+        const assets = await discoverWorkspaceAssets(process.cwd()).catch(() => null);
+        const hasSetup = assets && (assets.credentialsFound || assets.configFound || assets.prompts.length > 0 || assets.sweeps.length > 0);
+        if (hasSetup && assets) {
+            console.log(`Prompts-GPT CLI — ${assets.prompts.length} prompts, ${assets.sweeps.length} sweeps available\n`);
+            if (assets.sweeps.length > 0) {
+                console.log("  prompts-gpt sweep                   — run a sweep (interactive picker)");
+            }
+            if (assets.prompts.length > 0) {
+                console.log("  prompts-gpt run                     — run a prompt");
+            }
+            console.log("  prompts-gpt list                    — see all available assets");
+            console.log("  prompts-gpt sync                    — refresh prompts from studio");
+            console.log("  prompts-gpt status                  — check workspace readiness");
+            console.log(`\nRun \`prompts-gpt help\` for the full command list.\n`);
+        }
+        else {
+            console.log(`Prompts-GPT CLI — sync and run AI prompt packs locally\n`);
+            console.log("Get started:");
+            console.log("  prompts-gpt quickstart              — setup credentials, config, and first run");
+            console.log("  prompts-gpt init --token-prompt     — save your project token");
+            console.log("");
+            console.log("Already have sweep files?");
+            console.log("  prompts-gpt sweep                   — auto-detect and run local sweeps");
+            console.log("  prompts-gpt list                    — see available prompts and sweeps");
+            console.log(`\nRun \`prompts-gpt help\` for the full command list.\n`);
+        }
+        return;
+    }
+    const first = argv[0];
+    if (first === "--help") {
+        printHelp();
+        return;
+    }
+    if (first === "--version") {
+        await printVersion();
+        return;
+    }
+    if (first === "help") {
+        handleHelpCommand(argv.slice(1));
+        return;
+    }
+    if (first === "version") {
+        if (argv.length > 1) {
+            throw new CliError("The `version` command does not accept additional arguments.", CLI_EXIT_CODES.usage, {
+                helpCommand: "version",
+            });
+        }
+        await printVersion();
+        return;
+    }
+    const command = asCommandName(first);
+    if (!command) {
+        throw new CliError(`Unknown command: ${first}.`, CLI_EXIT_CODES.usage);
+    }
+    if (!isRunnableCommand(command)) {
+        throw new CliError(`Unknown command: ${first}.`, CLI_EXIT_CODES.usage, {
+            helpCommand: "help",
+        });
+    }
+    const flags = parseCommandFlags(command, argv.slice(1));
+    if (Boolean(flags.help)) {
+        printHelp(command);
+        return;
+    }
+    await runCommand(command, flags);
+}
+async function runCommand(command, flags) {
+    if (command === "providers") {
+        const cwd = getResolvedCwd(flags);
+        const providers = await detectProviders(cwd);
+        if (Boolean(flags.json)) {
+            console.log(JSON.stringify({ cwd, providers }, null, 2));
+            return;
+        }
+        console.log(`Workspace: ${cwd}\n`);
+        for (const provider of providers) {
+            const icon = provider.available ? "✓" : "✗";
+            console.log(`${icon} ${provider.provider}: ${provider.available ? "available" : "missing"} | bin=${provider.bin} | model=${provider.modelDefault}${provider.version ? ` | ${provider.version}` : ""}`);
+            if (!provider.available) {
+                console.log(`  → ${provider.installHint}`);
+            }
+        }
+        const noneAvailable = providers.every((p) => !p.available);
+        if (noneAvailable) {
+            console.log("\nNo providers installed. Quick install:");
+            console.log("  npm install -g @openai/codex              # OpenAI Codex");
+            console.log("  npm install -g @anthropic-ai/claude-code  # Claude Code");
+            console.log("  # Cursor: install Cursor IDE");
+        }
+        return;
+    }
+    if (command === "setup") {
+        const cwd = getResolvedCwd(flags);
+        const providerOrder = getStringFlag(flags, "provider-order")
+            ?.split(",")
+            .map((item) => item.trim())
+            .filter(Boolean);
+        validateProviderOrderFlag(providerOrder);
+        const promptFile = getStringFlag(flags, "prompt-file");
+        const promptFiles = getStringFlag(flags, "prompt-files")
+            ?.split(",")
+            .map((item) => item.trim())
+            .filter(Boolean);
+        const result = await initRunConfig({
+            cwd,
+            promptFile,
+            manifestPath: getStringFlag(flags, "manifest"),
+            promptFiles,
+            promptDir: getStringFlag(flags, "prompt-dir"),
+            defaultAgent: resolveRunAgent(flags, "router"),
+            providerOrder,
+            artifactsDir: getStringFlag(flags, "artifacts-dir"),
+            timeoutSeconds: parsePositiveIntFlag(getStringFlag(flags, "timeout"), "timeout"),
+            retryCount: parseNonNegativeIntFlag(getStringFlag(flags, "retry-count"), "retry-count"),
+            disallowDestructiveGit: Boolean(flags["allow-destructive-git"]) ? false : true,
+            modelOverrides: {
+                codex: getStringFlag(flags, "codex-model"),
+                cursor: getStringFlag(flags, "cursor-model"),
+                claude: getStringFlag(flags, "claude-model"),
+                copilot: getStringFlag(flags, "copilot-model"),
+            },
+            overwrite: Boolean(flags.overwrite),
+        });
+        if (Boolean(flags.json)) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Config: ${result.configPath}`);
+        console.log(`Agent: ${result.config.defaultAgent ?? "router"} | Providers: ${(result.config.providerOrder ?? []).join(", ")}`);
+        if (result.sourceSummary.defaultPromptFile) {
+            console.log(`Default prompt: ${result.sourceSummary.defaultPromptFile}`);
+        }
+        const availableCount = result.providerSummary.filter((p) => p.available).length;
+        console.log(`Providers: ${availableCount}/${result.providerSummary.length} available`);
+        if (availableCount === 0) {
+            console.log("⚠ No provider CLIs detected. Install codex, cursor agent, claude, or copilot.");
+        }
+        const setupAssets = await discoverWorkspaceAssets(cwd);
+        if (isTTYInteractive() && (setupAssets.sweeps.length > 0 || setupAssets.prompts.length > 0)) {
+            const setupOptions = [];
+            for (const s of setupAssets.sweeps) {
+                setupOptions.push({ label: `sweep: ${s.name}`, value: `sweep:${s.file}` });
+            }
+            for (const p of setupAssets.prompts.slice(0, 3)) {
+                setupOptions.push({ label: `run: ${p.title}`, value: `run:.prompts-gpt/${p.file}` });
+            }
+            setupOptions.push({ label: "prompts-gpt list", value: "list" });
+            setupOptions.push({ label: "(done)", value: "done" });
+            console.log("");
+            const setupPicked = await interactiveSelect("What next?", setupOptions);
+            if (setupPicked === "list") {
+                const { spawnSync: spSync } = await import("node:child_process");
+                const cliEntry = process.argv[1] || require.resolve("./cli.js");
+                spSync(process.execPath, [cliEntry, "list"], { stdio: "inherit", cwd });
+            }
+            else if (setupPicked !== "done") {
+                const [action, file] = setupPicked.split(":", 2);
+                const cmd = action === "sweep" ? "sweep" : "run";
+                console.log(`\nRunning: prompts-gpt ${cmd} -f ${file}\n`);
+                const { spawnSync: spSync } = await import("node:child_process");
+                const cliEntry = process.argv[1] || require.resolve("./cli.js");
+                const setupResult = spSync(process.execPath, [cliEntry, cmd, "-f", file], { stdio: "inherit", cwd });
+                process.exitCode = setupResult.status ?? 1;
+            }
+        }
+        else {
+            console.log("Next steps:");
+            console.log(`  prompts-gpt run${result.sourceSummary.defaultPromptFile ? "" : " --prompt-file <path>"}`);
+            if (setupAssets.sweeps.length > 0) {
+                console.log(`  prompts-gpt sweep       — run a multi-iteration sweep (${setupAssets.sweeps.length} found)`);
+            }
+            console.log("  prompts-gpt list        — see all runnable assets");
+            console.log("  prompts-gpt status      — check workspace readiness");
+        }
+        return;
+    }
+    if (command === "models") {
+        const cwd = getResolvedCwd(flags);
+        const config = await loadRunConfig(cwd);
+        const providerFilter = getStringFlag(flags, "provider") || getStringFlag(flags, "agent");
+        const providers = providerFilter ? [providerFilter] : Object.keys(PROVIDER_MODELS);
+        if (Boolean(flags.json)) {
+            const result = {};
+            for (const p of providers) {
+                const entries = PROVIDER_MODELS[p] ?? [];
+                const custom = config.customModels?.[p] ?? [];
+                result[p] = [
+                    ...entries.map((e) => ({ value: e.value, tier: e.tier })),
+                    ...custom.map((c) => ({ value: c, tier: "custom" })),
+                ];
+            }
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        for (const p of providers) {
+            const entries = PROVIDER_MODELS[p] ?? [];
+            const custom = config.customModels?.[p] ?? [];
+            const cachedModels = loadCachedModelRegistry(p, cwd);
+            const allNames = [...entries.map((e) => e.value), ...custom, ...cachedModels];
+            const nameW = Math.max(30, ...allNames.map((n) => n.length + 2));
+            const uc = supportsColor();
+            console.log(colorize(`\n${p}:`, "\x1b[1;36m"));
+            for (const e of entries) {
+                const tierBadge = e.tier === "frontier"
+                    ? (uc ? " ⭐" : " [F]")
+                    : e.tier === "budget" ? (uc ? " 💰" : " [$]") : e.tier === "fast" ? (uc ? " ⚡" : " [>]") : "";
+                console.log(`  ${e.value.padEnd(nameW)} ${e.tier.padEnd(10)}${tierBadge}`);
+            }
+            if (custom.length > 0) {
+                console.log(colorize("  Custom:", "\x1b[33m"));
+                for (const c of custom)
+                    console.log(`  ${c.padEnd(nameW)} custom`);
+            }
+            if (cachedModels.length > 0) {
+                console.log(colorize("  Synced:", "\x1b[32m"));
+                for (const c of cachedModels)
+                    console.log(`  ${c.padEnd(nameW)} synced`);
+            }
+        }
+        const addFlag = getStringFlag(flags, "add");
+        if (addFlag && providerFilter) {
+            const modelNamePattern = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/;
+            const addModels = addFlag.split(",").map((m) => m.trim()).filter(Boolean);
+            const invalidModels = addModels.filter((m) => !modelNamePattern.test(m));
+            if (invalidModels.length > 0) {
+                console.error(`Invalid model name(s): ${invalidModels.join(", ")}. Model names must be alphanumeric with dots, hyphens, or underscores.`);
+                process.exitCode = CLI_EXIT_CODES.validation;
+                return;
+            }
+            if (addModels.length > 0) {
+                const configPath = config.configPath;
+                try {
+                    const { readFile: fsRead, writeFile: fsWrite } = await import("node:fs/promises");
+                    const rawConfig = JSON.parse(await fsRead(configPath, "utf8"));
+                    const existing = rawConfig.customModels ?? {};
+                    const providerList = existing[providerFilter] ?? [];
+                    for (const m of addModels) {
+                        if (!providerList.includes(m))
+                            providerList.push(m);
+                    }
+                    existing[providerFilter] = providerList;
+                    rawConfig.customModels = existing;
+                    await fsWrite(configPath, JSON.stringify(rawConfig, null, 2) + "\n");
+                    console.log(`\nAdded ${addModels.join(", ")} to ${providerFilter} custom models.`);
+                }
+                catch (err) {
+                    console.log(`Failed to update config: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+        }
+        const removeFlag = getStringFlag(flags, "remove");
+        if (removeFlag && providerFilter) {
+            const removeModels = removeFlag.split(",").map((m) => m.trim()).filter(Boolean);
+            if (removeModels.length > 0) {
+                const configPath = config.configPath;
+                try {
+                    const { readFile: fsRead, writeFile: fsWrite } = await import("node:fs/promises");
+                    const rawConfig = JSON.parse(await fsRead(configPath, "utf8"));
+                    const existing = rawConfig.customModels ?? {};
+                    const currentList = existing[providerFilter] ?? [];
+                    const notFound = removeModels.filter((m) => !currentList.includes(m));
+                    if (notFound.length > 0) {
+                        console.log(`Note: ${notFound.join(", ")} not found in ${providerFilter} custom models.`);
+                    }
+                    const providerList = currentList.filter((m) => !removeModels.includes(m));
+                    existing[providerFilter] = providerList;
+                    rawConfig.customModels = existing;
+                    await fsWrite(configPath, JSON.stringify(rawConfig, null, 2) + "\n");
+                    const removed = removeModels.filter((m) => !notFound.includes(m));
+                    if (removed.length > 0) {
+                        console.log(`\nRemoved ${removed.join(", ")} from ${providerFilter} custom models.`);
+                    }
+                }
+                catch (err) {
+                    console.error(`Failed to update config: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+        }
+        console.log("\nAliases:");
+        for (const [alias, target] of Object.entries(MODEL_ALIASES)) {
+            console.log(`  ${alias.padEnd(15)} → ${target}`);
+        }
+        console.log("\nManage models:");
+        console.log("  prompts-gpt models --provider codex --add my-custom-model");
+        console.log("  prompts-gpt models --provider codex --remove gpt-4.1");
+        console.log("  prompts-gpt sync-models");
+        return;
+    }
+    if (command === "sync-models") {
+        const cwd = getResolvedCwd(flags);
+        try {
+            const client = await createClientForCommand("sync-models", flags);
+            console.log("Fetching model registry from prompts-gpt.com...");
+            let models;
+            try {
+                models = await client.fetchModels();
+            }
+            catch (fetchErr) {
+                if (fetchErr instanceof PromptsGptApiError && fetchErr.status === 404) {
+                    console.log("Model registry API not yet available on your server. Using built-in model lists.");
+                    console.log("This feature requires a server update. Check https://prompts-gpt.com/docs/sdk/models");
+                    return;
+                }
+                throw fetchErr;
+            }
+            if (Object.keys(models).length === 0) {
+                console.log("No models returned from API. Using built-in model lists.");
+                return;
+            }
+            const { writeFile: fsWrite, mkdir: fsMkdir } = await import("node:fs/promises");
+            const outDir = path.resolve(cwd, DEFAULT_PROMPTS_GPT_OUT_DIR);
+            await fsMkdir(outDir, { recursive: true });
+            const registry = {};
+            for (const [provider, modelList] of Object.entries(models)) {
+                registry[provider] = { models: modelList, syncedAt: new Date().toISOString() };
+                console.log(`  ${provider}: ${modelList.length} models`);
+            }
+            await fsWrite(path.resolve(outDir, ".models.json"), JSON.stringify(registry, null, 2) + "\n");
+            await ensureGitignoreEntry(cwd, `${DEFAULT_PROMPTS_GPT_OUT_DIR}/.models.json`);
+            console.log(`Model registry saved to ${DEFAULT_PROMPTS_GPT_OUT_DIR}/.models.json`);
+            console.log("\nSchedule regular syncs:");
+            console.log(`  crontab: 0 6 * * * cd ${cwd} && npx prompts-gpt sync-models`);
+            console.log("  GitHub Actions: schedule a weekly workflow calling 'npx prompts-gpt sync-models'");
+        }
+        catch (err) {
+            if (err instanceof PromptsGptApiError) {
+                if (err.status === 401 || err.code === "AUTH_ERROR") {
+                    throw new CliError(`Authentication failed: ${err.message}. Run 'prompts-gpt init' to set up credentials.`, CLI_EXIT_CODES.auth);
+                }
+                console.error(`API error: ${err.message}`);
+                console.log("Using built-in model lists.");
+            }
+            else if (err instanceof CliError) {
+                throw err;
+            }
+            else {
+                console.error(`Failed to sync models: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        return;
+    }
+    if (command === "doctor") {
+        const cwd = getResolvedCwd(flags);
+        const report = await doctor(cwd);
+        if (Boolean(flags.json)) {
+            console.log(JSON.stringify(report, null, 2));
+            return;
+        }
+        console.log("Prompts-GPT Doctor");
+        console.log("==================\n");
+        console.log("System:");
+        console.log(`  ${report.nodeVersion.startsWith("v18") || report.nodeVersion.startsWith("v2") ? "✓" : "⚠"} Node: ${report.nodeVersion}`);
+        console.log(`  ✓ OS: ${report.osPlatform}/${report.osArch} | CPUs: ${report.cpuCount}`);
+        console.log(`  ${report.configFound ? "✓" : "✗"} Config: ${report.configFound ? report.configPath : "not found — run \`prompts-gpt setup\`"}`);
+        console.log(`\n  Workspace: ${report.cwd}\n`);
+        console.log("Providers:");
+        for (const provider of report.providers) {
+            const icon = provider.available ? "✓" : "✗";
+            console.log(`  ${icon} ${provider.provider}: ${provider.available ? `${provider.bin}` : "not found"}${provider.version ? ` (${provider.version})` : ""}`);
+            if (!provider.available) {
+                console.log(`    → ${provider.installHint}`);
+            }
+        }
+        const configNotes = report.notes.filter((n) => n.includes("config") || n.includes("Config") || n.includes("provider order") || n.includes("Router"));
+        const sweepNotes = report.notes.filter((n) => n.includes("weep") || n.includes("lock"));
+        const otherNotes = report.notes.filter((n) => !configNotes.includes(n) && !sweepNotes.includes(n));
+        if (configNotes.length > 0) {
+            console.log("\nConfiguration:");
+            for (const n of configNotes)
+                console.log(`  ℹ ${n}`);
+        }
+        if (sweepNotes.length > 0) {
+            console.log("\nSweep:");
+            for (const n of sweepNotes)
+                console.log(`  ℹ ${n}`);
+        }
+        if (otherNotes.length > 0) {
+            console.log("\nNotes:");
+            for (const n of otherNotes)
+                console.log(`  ℹ ${n}`);
+        }
+        try {
+            const config = await loadRunConfig(cwd);
+            const modelIssues = [];
+            for (const [provider, model] of Object.entries(config.modelOverrides)) {
+                if (model) {
+                    const check = validateModelForProvider(model, provider);
+                    if (!check.valid) {
+                        modelIssues.push(`modelOverrides.${provider} = "${model}" is not a known model${check.suggestion ? ` (did you mean "${check.suggestion}"?)` : ""}`);
+                    }
+                }
+            }
+            if (modelIssues.length > 0) {
+                console.log("\nModel Overrides:");
+                for (const issue of modelIssues)
+                    console.log(`  ⚠ ${issue}`);
+            }
+            const cachedModelsPath = path.resolve(cwd, DEFAULT_PROMPTS_GPT_OUT_DIR, ".models.json");
+            if (existsSync(cachedModelsPath)) {
+                try {
+                    const data = JSON.parse(readFileSync(cachedModelsPath, "utf8"));
+                    const firstKey = Object.keys(data)[0];
+                    const syncedAt = firstKey ? data[firstKey]?.syncedAt : undefined;
+                    console.log(`\nModel Registry: synced${syncedAt ? ` (${syncedAt})` : ""}`);
+                    console.log("  Run 'prompts-gpt sync-models' to refresh");
+                }
+                catch { /* skip */ }
+            }
+            else {
+                console.log("\nModel Registry: not synced");
+                console.log("  Run 'prompts-gpt sync-models' to fetch latest models");
+            }
+        }
+        catch { /* skip config check */ }
+        console.log("\nAPI Connectivity:");
+        if (typeof globalThis.fetch !== "function") {
+            console.log("  ⚠ fetch is not available (Node.js 18.18+ required). Skipping API check.");
+        }
+        else {
+            try {
+                const healthRes = await Promise.race([
+                    globalThis.fetch(`${DEFAULT_PROMPTS_GPT_API_URL}/api/health`, { method: "HEAD" }),
+                    new Promise((_, rej) => setTimeout(() => rej(new Error("timeout")), 5000)),
+                ]);
+                if (healthRes instanceof Response && healthRes.ok) {
+                    console.log(`  ✓ prompts-gpt.com reachable`);
+                }
+                else {
+                    console.log(`  ⚠ prompts-gpt.com responded with status ${healthRes.status}`);
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : "";
+                if (msg.includes("ECONNREFUSED") || msg.includes("ENOTFOUND")) {
+                    console.log("  ✗ prompts-gpt.com unreachable — check network or proxy settings (HTTPS_PROXY)");
+                }
+                else {
+                    console.log("  ✗ prompts-gpt.com unreachable — check network connection");
+                }
+            }
+        }
+        try {
+            const pkgData = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+            console.log(`\nSDK Version: ${pkgData.version ?? "unknown"}`);
+        }
+        catch { /* skip */ }
+        return;
+    }
+    if (command === "list") {
+        const cwd = getResolvedCwd(flags);
+        const assets = await discoverWorkspaceAssets(cwd);
+        if (Boolean(flags.json)) {
+            console.log(JSON.stringify(assets, null, 2));
+            return;
+        }
+        console.log(`Workspace: ${cwd}`);
+        console.log("");
+        const providers = await detectProviders(cwd);
+        const availableProviderNames = providers.filter((p) => p.available).map((p) => p.provider);
+        if (assets.prompts.length > 0) {
+            console.log(`Prompt packs (${assets.prompts.length}):`);
+            for (const p of assets.prompts) {
+                const providerHint = availableProviderNames.length > 0
+                    ? ` (run with: ${availableProviderNames[0]})`
+                    : "";
+                console.log(`  ${p.slug} — ${p.title} [${p.source}]${providerHint}`);
+                console.log(`    file: .prompts-gpt/${p.file}`);
+                console.log(`    run:  prompts-gpt run --prompt-file .prompts-gpt/${p.file}`);
+            }
+            console.log("");
+        }
+        else {
+            console.log("Prompt packs: none found");
+            console.log("  Run `prompts-gpt sync` to pull prompt packs, or `prompts-gpt pull` to download them.");
+            console.log("");
+        }
+        if (assets.sweeps.length > 0) {
+            console.log(`Sweep prompts (${assets.sweeps.length}):`);
+            const listConfig = await loadRunConfig(cwd).catch(() => null);
+            const artifactsDir = path.resolve(cwd, listConfig?.artifactsDir ?? ".scripts/runs");
+            let lastRunDate = null;
+            try {
+                if (existsSync(artifactsDir)) {
+                    const { readdir: rd, stat: fsStat } = await import("node:fs/promises");
+                    const dirs = await rd(artifactsDir);
+                    const sweepDirs = dirs.filter((d) => d.includes("sweep")).sort().reverse();
+                    if (sweepDirs[0]) {
+                        const s2 = await fsStat(path.join(artifactsDir, sweepDirs[0]));
+                        lastRunDate = s2.mtime.toLocaleDateString();
+                    }
+                }
+            }
+            catch { /* skip */ }
+            for (const s of assets.sweeps) {
+                const iterCount = await readSweepIterationsFromFrontmatter(path.resolve(cwd, s.file));
+                const iterHint = iterCount ? ` (${iterCount} iterations)` : "";
+                const iterFlag = iterCount ? ` --iterations ${iterCount}` : "";
+                const lastRun = lastRunDate ? ` | last run: ${lastRunDate}` : "";
+                console.log(`  ${s.name}${iterHint}${lastRun}`);
+                console.log(`    file:  ${s.file}`);
+                console.log(`    sweep: prompts-gpt sweep -f ${s.file}${iterFlag}`);
+            }
+            console.log("");
+        }
+        else {
+            console.log("Sweep prompts: none found");
+            console.log("  Create .prompts-gpt/sweeps/<name>.md to add sweep prompts.");
+            console.log("");
+        }
+        if (assets.agents.length > 0) {
+            console.log(`Agent integrations (${assets.agents.length}):`);
+            for (const a of assets.agents) {
+                console.log(`  ${a.target} — ${a.file}`);
+            }
+            console.log("");
+        }
+        else {
+            console.log("Agent integrations: none synced");
+            console.log("  Run `prompts-gpt sync` to generate agent files.");
+            console.log("");
+        }
+        console.log(`Config:      ${assets.configFound ? "found" : "not found — run `prompts-gpt setup`"}`);
+        console.log(`Manifest:    ${assets.manifestFound ? "found" : "not found — run `prompts-gpt sync`"}`);
+        console.log(`Credentials: ${assets.credentialsFound ? "found" : "not found — run `prompts-gpt init --token <token>`"}`);
+        if (isTTYInteractive() && availableProviderNames.length > 0) {
+            const runnableOptions = [];
+            for (const p of assets.prompts) {
+                runnableOptions.push({ label: `run: ${p.slug} — ${p.title}`, value: `run:.prompts-gpt/${p.file}` });
+            }
+            for (const s of assets.sweeps) {
+                runnableOptions.push({ label: `sweep: ${s.name}`, value: `sweep:${s.file}` });
+            }
+            if (runnableOptions.length > 1) {
+                console.log("");
+                const picked = await interactiveSelect("Run something now?", [
+                    ...runnableOptions,
+                    { label: "(exit)", value: "exit" },
+                ]);
+                if (picked !== "exit") {
+                    const [action, file] = picked.split(":", 2);
+                    const cmd = action === "sweep" ? "sweep" : "run";
+                    console.log(`\nRunning: prompts-gpt ${cmd} -f ${file}\n`);
+                    const { spawnSync: spSync } = await import("node:child_process");
+                    const cliEntry = process.argv[1] || require.resolve("./cli.js");
+                    const result = spSync(process.execPath, [cliEntry, cmd, "-f", file], { stdio: "inherit", cwd });
+                    process.exitCode = result.status ?? 1;
+                }
+            }
+        }
+        return;
+    }
+    if (command === "status") {
+        const cwd = getResolvedCwd(flags);
+        const assets = await discoverWorkspaceAssets(cwd);
+        const providers = await detectProviders(cwd);
+        const availableProviders = providers.filter((p) => p.available);
+        if (Boolean(flags.json)) {
+            console.log(JSON.stringify({ cwd, assets, providers }, null, 2));
+            return;
+        }
+        console.log(`Workspace: ${cwd}`);
+        console.log("");
+        console.log("Readiness:");
+        console.log(`  Credentials:  ${assets.credentialsFound ? "✓" : "✗ — run \`prompts-gpt init --token <token>\`"}`);
+        console.log(`  Config:       ${assets.configFound ? "✓" : "✗ — run \`prompts-gpt setup\`"}`);
+        console.log(`  Manifest:     ${assets.manifestFound ? "✓" : "✗ — run \`prompts-gpt sync\`"}`);
+        const cloudCount = assets.prompts.filter((p) => p.source === "library" || p.source === "generated").length;
+        const localCount = assets.prompts.filter((p) => p.source === "local").length;
+        const promptSummary = assets.prompts.length > 0
+            ? `✓ (${assets.prompts.length}${cloudCount > 0 ? `, ${cloudCount} synced` : ""}${localCount > 0 ? `, ${localCount} local-only` : ""})`
+            : "✗ — none found";
+        console.log(`  Prompts:      ${promptSummary}`);
+        console.log(`  Sweeps:       ${assets.sweeps.length > 0 ? `✓ (${assets.sweeps.length})` : "— none found"}`);
+        console.log(`  Agents:       ${assets.agents.length > 0 ? `✓ (${assets.agents.length} targets)` : "✗ — run \`prompts-gpt sync\`"}`);
+        if (availableProviders.length > 0) {
+            console.log(`  Providers:    ✓`);
+            for (const p of availableProviders) {
+                console.log(`    ${p.provider}: ${p.bin} | model: ${p.modelDefault}${p.version ? ` | ${p.version}` : ""}`);
+            }
+        }
+        else {
+            console.log("  Providers:    ✗ — no CLI found. Install one:");
+            console.log("    npm install -g @openai/codex            # Codex");
+            console.log("    npm install -g @anthropic-ai/claude-code # Claude Code");
+            console.log("    # Cursor: install Cursor IDE (includes agent CLI)");
+        }
+        console.log("");
+        const statusModelCache = path.resolve(cwd, DEFAULT_PROMPTS_GPT_OUT_DIR, ".models.json");
+        if (existsSync(statusModelCache)) {
+            try {
+                const fs = require("node:fs");
+                const mStat = fs.statSync(statusModelCache);
+                const ageMs = Date.now() - mStat.mtimeMs;
+                const ageDays = Math.floor(ageMs / (1000 * 60 * 60 * 24));
+                console.log(`  Models:       ${ageDays <= 7 ? "✓" : "⚠"} synced ${ageDays === 0 ? "today" : `${ageDays}d ago`}${ageDays > 7 ? " — run 'prompts-gpt sync-models'" : ""}`);
+            }
+            catch { /* skip */ }
+        }
+        else {
+            console.log("  Models:       — not synced. Run 'prompts-gpt sync-models'");
+        }
+        console.log("");
+        const lockFile = path.resolve(cwd, ".sweep.lock");
+        if (existsSync(lockFile)) {
+            try {
+                const { readFile: fsRead } = await import("node:fs/promises");
+                const lockData = JSON.parse(await fsRead(lockFile, "utf8"));
+                console.log(`  Sweep lock:   ⚠ active (PID ${lockData.pid}, started ${lockData.startedAt})`);
+            }
+            catch {
+                console.log("  Sweep lock:   ⚠ found but unreadable");
+            }
+        }
+        console.log("");
+        if (assets.prompts.length > 0 && availableProviders.length > 0) {
+            console.log("Ready to run:");
+            console.log(`  prompts-gpt run --prompt-file .prompts-gpt/${assets.prompts[0].file}`);
+            if (assets.sweeps.length > 0) {
+                for (const s of assets.sweeps) {
+                    console.log(`  prompts-gpt sweep --prompt-file ${s.file}`);
+                }
+            }
+        }
+        else {
+            console.log("Not ready yet. Quick fix:");
+            console.log("  prompts-gpt quickstart");
+            console.log("");
+            console.log("Or step by step:");
+            let step = 1;
+            if (!assets.credentialsFound)
+                console.log(`  ${step++}. prompts-gpt init --token <project-token>`);
+            if (assets.prompts.length === 0)
+                console.log(`  ${step++}. prompts-gpt sync`);
+            if (availableProviders.length === 0)
+                console.log(`  ${step++}. Install a provider CLI (codex, cursor agent, claude, copilot)`);
+            if (!assets.configFound)
+                console.log(`  ${step++}. prompts-gpt setup`);
+        }
+        return;
+    }
+    if (command === "validate") {
+        const cwd = getResolvedCwd(flags);
+        const result = await validateRunConfig(cwd);
+        if (Boolean(flags.json)) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Config: ${result.configPath}`);
+        console.log(`Valid: ${result.valid ? "yes" : "no"}`);
+        for (const e of result.errors) {
+            console.log(`  error: ${e}`);
+        }
+        for (const w of result.warnings) {
+            console.log(`  warning: ${w}`);
+        }
+        const validAssets = await discoverWorkspaceAssets(cwd);
+        if (validAssets.sweeps.length > 0) {
+            console.log(`\nSweep files (${validAssets.sweeps.length}):`);
+            for (const s of validAssets.sweeps) {
+                const fm = await readSweepFrontmatter(path.resolve(cwd, s.file));
+                const issues = [];
+                if (!fm.iterations)
+                    issues.push("no iterations in frontmatter");
+                if (!fm.title)
+                    issues.push("no title heading");
+                const icon = issues.length === 0 ? "✓" : "⚠";
+                console.log(`  ${icon} ${s.name}${issues.length > 0 ? ` — ${issues.join(", ")}` : ""}`);
+            }
+        }
+        const modelCachePath = path.resolve(cwd, DEFAULT_PROMPTS_GPT_OUT_DIR, ".models.json");
+        try {
+            const { statSync } = await import("node:fs");
+            const mStat = statSync(modelCachePath);
+            const ageMs = Date.now() - mStat.mtimeMs;
+            const ageDays = Math.floor(ageMs / (1000 * 60 * 60 * 24));
+            if (ageDays > 7) {
+                console.log(`\n⚠ Model registry is ${ageDays} days old. Run 'prompts-gpt sync-models' to refresh.`);
+            }
+            else {
+                console.log(`\n✓ Model registry: synced ${ageDays === 0 ? "today" : `${ageDays}d ago`}`);
+            }
+        }
+        catch {
+            console.log("\n⚠ Model registry not synced. Run 'prompts-gpt sync-models'.");
+        }
+        if (result.valid && result.errors.length === 0 && result.warnings.length === 0) {
+            console.log("  No issues found.");
+        }
+        return;
+    }
+    if (command === "run") {
+        const cwd = getResolvedCwd(flags);
+        const promptFile = getStringFlag(flags, "prompt-file");
+        const config = await loadRunConfig(cwd);
+        warnOnConfigIssues(config);
+        if (Boolean(flags["list-models"])) {
+            const agentStr = getStringFlag(flags, "agent") || config.defaultAgent;
+            const targetProvider = resolveRunAgent({ agent: agentStr }, config.defaultAgent);
+            const choices = getModelChoicesForProvider(targetProvider, config);
+            console.log(`Models for ${targetProvider}:\n`);
+            for (const c of choices) {
+                if (c.value !== "__custom__")
+                    console.log(`  ${c.value.padEnd(30)} ${c.label}`);
+            }
+            return;
+        }
+        if (!promptFile && !Boolean(flags.json)) {
+            if (!config.defaultPromptFile && config.batchDefaults.promptFiles.length === 0 && !config.batchDefaults.manifestPath) {
+                const assets = await discoverWorkspaceAssets(cwd);
+                if (assets.prompts.length > 0 && isTTYInteractive(flags)) {
+                    const promptOptions = assets.prompts.map((p) => ({
+                        label: `${p.slug} — ${p.title}`,
+                        value: `.prompts-gpt/${p.file}`,
+                    }));
+                    const picked = await interactiveSelect("Select a prompt to run:", promptOptions);
+                    flags["prompt-file"] = picked;
+                }
+                else if (assets.prompts.length > 0 || assets.sweeps.length > 0) {
+                    console.log("No default prompt configured. Available options:\n");
+                    if (assets.prompts.length > 0) {
+                        console.log("Prompt packs:");
+                        for (const p of assets.prompts) {
+                            console.log(`  prompts-gpt run -f .prompts-gpt/${p.file}`);
+                        }
+                    }
+                    if (assets.sweeps.length > 0) {
+                        console.log("\nSweep prompts (use `sweep` command):");
+                        for (const s of assets.sweeps) {
+                            console.log(`  prompts-gpt sweep -f ${s.file}`);
+                        }
+                    }
+                    console.log("\nOr set a default: prompts-gpt setup --prompt-file <path>");
+                    return;
+                }
+            }
+        }
+        const runProviders = await detectProviders(cwd);
+        const runAvailable = runProviders.filter((p) => p.available);
+        if (!getStringFlag(flags, "agent") && isTTYInteractive(flags) && !Boolean(flags.json) && runAvailable.length > 1) {
+            const lastRunProvider = await getLastUsedProvider(cwd);
+            const providerOpts = runAvailable.map((p) => ({
+                label: `${p.provider} (${p.modelDefault}${p.version ? `, ${p.version}` : ""})${p.provider === lastRunProvider ? " ★" : ""}`,
+                value: p.provider,
+            }));
+            providerOpts.push({ label: "router (auto-select)", value: "router" });
+            if (lastRunProvider) {
+                const idx = providerOpts.findIndex((o) => o.value === lastRunProvider);
+                if (idx > 0) {
+                    const [item] = providerOpts.splice(idx, 1);
+                    providerOpts.unshift(item);
+                }
+            }
+            flags.agent = await interactiveSelect("Select a provider:", providerOpts);
+            if (flags.agent !== "router") {
+                await saveLastUsedProvider(cwd, flags.agent);
+            }
+        }
+        if (!getStringFlag(flags, "model") && isTTYInteractive(flags) && !Boolean(flags.json)) {
+            const currentAgent = resolveRunAgent(flags, config.defaultAgent);
+            if (currentAgent !== "router") {
+                const modelChoices = getModelChoicesForProvider(currentAgent, config);
+                if (modelChoices.length > 0) {
+                    const lastModel = await getLastUsedModel(cwd, currentAgent);
+                    if (lastModel) {
+                        const idx = modelChoices.findIndex((c) => c.value === lastModel);
+                        if (idx > 0) {
+                            const [item] = modelChoices.splice(idx, 1);
+                            modelChoices.unshift({ label: `${item.label} ★`, value: item.value });
+                        }
+                    }
+                    let picked = await interactiveSelect("Select a model:", modelChoices);
+                    if (picked === "__custom__") {
+                        picked = await interactiveInput("Enter model name", "");
+                        if (!picked.trim()) {
+                            console.log("No model entered, using default.");
+                            picked = "";
+                        }
+                    }
+                    if (picked) {
+                        flags.model = resolveModelAlias(picked);
+                        await saveLastUsedModel(cwd, currentAgent, flags.model);
+                    }
+                }
+            }
+        }
+        const agent = resolveRunAgent(flags, config.defaultAgent);
+        if (Boolean(flags["dry-run"])) {
+            const providers = await detectProviders(cwd);
+            const resolvedProvider = resolveRunProvider(agent, providers, config.providerOrder);
+            const resolvedModel = getStringFlag(flags, "model")?.trim() || config.modelOverrides[resolvedProvider]?.trim() || "";
+            let resolvedPrompt = promptFile || getStringFlag(flags, "prompt-file") || config.defaultPromptFile || null;
+            if (!resolvedPrompt) {
+                try {
+                    const { resolveDefaultPromptFile: resolvePf } = await import("./index.js");
+                    resolvedPrompt = await resolvePf(cwd, config);
+                }
+                catch {
+                    resolvedPrompt = null;
+                }
+            }
+            const agentStr = getStringFlag(flags, "agent") ? agent : `${agent} (auto-selected)`;
+            console.log("[dry-run] Would execute:");
+            console.log(`  Agent: ${agentStr}`);
+            console.log(`  Provider: ${resolvedProvider}`);
+            console.log(`  Model: ${resolvedModel || "(default)"}`);
+            console.log(`  Prompt: ${resolvedPrompt || "(none found — pass --prompt-file)"}`);
+            console.log(`  Timeout: ${getStringFlag(flags, "timeout") || config.timeoutSeconds}s`);
+            return;
+        }
+        if (isTTYInteractive(flags) && !Boolean(flags.json) && !Boolean(flags["dry-run"])) {
+            const previewFile = getStringFlag(flags, "prompt-file");
+            if (previewFile && existsSync(path.resolve(cwd, previewFile))) {
+                try {
+                    const { readFile: fsRead } = await import("node:fs/promises");
+                    const previewContent = await fsRead(path.resolve(cwd, previewFile), "utf8");
+                    const previewLines = previewContent.split("\n").slice(0, 5);
+                    console.log(`\nPrompt preview (${path.basename(previewFile)}):`);
+                    for (const line of previewLines)
+                        console.log(`  ${line}`);
+                    if (previewContent.split("\n").length > 5)
+                        console.log(`  ... (${previewContent.split("\n").length - 5} more lines)`);
+                    console.log("");
+                }
+                catch { /* skip preview */ }
+            }
+        }
+        const modelFlag = getStringFlag(flags, "model");
+        if (modelFlag && !Boolean(flags.json) && agent !== "router") {
+            const providers = await detectProviders(cwd);
+            const resolvedProvider = resolveRunProvider(agent, providers, config.providerOrder);
+            const mismatchWarning = warnModelProviderMismatch(resolvedProvider, modelFlag);
+            if (mismatchWarning) {
+                console.error(`[warning] ${mismatchWarning}`);
+            }
+        }
+        const result = await runPrompt({
+            cwd,
+            promptFile,
+            agent,
+            model: modelFlag,
+            timeoutSeconds: parsePositiveIntFlag(getStringFlag(flags, "timeout"), "timeout"),
+            artifactsDir: getStringFlag(flags, "artifacts-dir"),
+            runId: getStringFlag(flags, "run-id"),
+            approveMcps: !Boolean(flags["no-approve-mcps"]),
+            sandboxMode: getStringFlag(flags, "sandbox"),
+            background: Boolean(flags.background),
+            permissionMode: getStringFlag(flags, "permission-mode"),
+        });
+        if (Boolean(flags.json)) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        const agentLabel = getStringFlag(flags, "agent") ? result.provider : `${result.provider} (auto — first available from provider order)`;
+        console.log(`Run ID: ${result.runId}`);
+        console.log(`Provider: ${agentLabel} | Model: ${result.model}`);
+        console.log(`Exit code: ${result.exitCode}`);
+        console.log(`Duration: ${formatDuration(result.durationMs)}`);
+        if (hasTokenUsage(result.tokenUsage)) {
+            console.log(`Tokens: ${formatTokenUsage(result.tokenUsage)}`);
+        }
+        console.log(`Run dir: ${result.runDir}`);
+        console.log(`Summary: ${result.summaryFile}`);
+        console.log(`Log: ${result.logFile}`);
+        if (result.exitCode === 0) {
+            try {
+                const { readFile: fsRead } = await import("node:fs/promises");
+                const deltaContent = await fsRead(result.worktreeDeltaFile, "utf8");
+                if (!deltaContent.includes("No worktree delta")) {
+                    const afterLines = deltaContent.split("\n").filter((l) => l.startsWith("=== AFTER ===") ? false : true);
+                    const changedFiles = afterLines.filter((l) => /^\s*[MADRCU?!]/.test(l)).length;
+                    if (changedFiles > 0) {
+                        console.log(`Files changed: ${changedFiles}`);
+                    }
+                }
+            }
+            catch { /* skip */ }
+            console.log("");
+            console.log(`View results: cat ${result.summaryFile}`);
+        }
+        if (Boolean(flags.open) && result.summaryFile) {
+            try {
+                const { spawn: openSpawn } = await import("node:child_process");
+                const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "notepad" : "xdg-open";
+                openSpawn(openCmd, [result.summaryFile], { detached: true, stdio: "ignore" }).unref();
+            }
+            catch { /* ignore */ }
+        }
+        if (result.exitCode !== 0) {
+            const diagnostics = await extractRunDiagnostics(result.logFile, result.provider, result.model);
+            if (diagnostics.length > 0) {
+                console.log("");
+                console.log("Diagnostics:");
+                for (const d of diagnostics) {
+                    console.log(`  ${d}`);
+                }
+            }
+        }
+        return;
+    }
+    if (command === "run-batch") {
+        const cwd = getResolvedCwd(flags);
+        const promptFiles = getStringFlag(flags, "prompt-files")
+            ?.split(",")
+            .map((item) => item.trim())
+            .filter(Boolean);
+        const config = await loadRunConfig(cwd);
+        warnOnConfigIssues(config);
+        if (!promptFiles && !getStringFlag(flags, "manifest") && !Boolean(flags.json)) {
+            if (!config.batchDefaults.manifestPath && config.batchDefaults.promptFiles.length === 0) {
+                const assets = await discoverWorkspaceAssets(cwd);
+                if (assets.prompts.length > 0) {
+                    console.log("No batch source configured. Available prompt packs:\n");
+                    const fileList = assets.prompts.map((p) => `.prompts-gpt/${p.file}`).join(",");
+                    console.log(`  prompts-gpt run-batch --prompt-files ${fileList}`);
+                    if (assets.manifestFound) {
+                        console.log(`  prompts-gpt run-batch --manifest .prompts-gpt/manifest.json`);
+                    }
+                    console.log("\nOr configure batch defaults: prompts-gpt setup");
+                    return;
+                }
+            }
+        }
+        const agent = resolveRunAgent(flags, config.defaultAgent);
+        const result = await runBatch({
+            cwd,
+            manifestPath: getStringFlag(flags, "manifest"),
+            promptFiles,
+            agent,
+            model: getStringFlag(flags, "model"),
+            timeoutSeconds: parsePositiveIntFlag(getStringFlag(flags, "timeout"), "timeout"),
+            artifactsDir: getStringFlag(flags, "artifacts-dir"),
+        });
+        if (Boolean(flags.json)) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Batch complete: total=${result.total} success=${result.success} failed=${result.failed}`);
+        if (hasTokenUsage(result.tokenUsage)) {
+            console.log(`Batch tokens: ${formatTokenUsage(result.tokenUsage)}`);
+        }
+        for (const [idx, run] of result.results.entries()) {
+            const status = run.exitCode === 0 ? "ok" : "FAIL";
+            const usageStr = hasTokenUsage(run.tokenUsage) ? `, tokens=${run.tokenUsage.totalTokens.toLocaleString()}` : "";
+            console.log(`  [${idx + 1}/${result.total}] ${status} ${path.basename(run.promptFile)} -> ${run.provider} (exit=${run.exitCode}, ${formatDuration(run.durationMs)}${usageStr})`);
+        }
+        return;
+    }
+    if (command === "sweep") {
+        const cwd = getResolvedCwd(flags);
+        const sweepPromptFile = getStringFlag(flags, "prompt-file");
+        const config = await loadRunConfig(cwd);
+        warnOnConfigIssues(config);
+        if (Boolean(flags["list-models"])) {
+            const agentStr = getStringFlag(flags, "agent") || config.defaultAgent;
+            const targetProvider = resolveRunAgent({ agent: agentStr }, config.defaultAgent);
+            const choices = getModelChoicesForProvider(targetProvider, config);
+            console.log(`Models for ${targetProvider}:\n`);
+            for (const c of choices) {
+                if (c.value !== "__custom__")
+                    console.log(`  ${c.value.padEnd(30)} ${c.label}`);
+            }
+            return;
+        }
+        if (!sweepPromptFile && !Boolean(flags.json)) {
+            const assets = await discoverWorkspaceAssets(cwd);
+            if (assets.sweeps.length === 1) {
+                const autoFile = assets.sweeps[0].file;
+                const iterFromFm = await readSweepIterationsFromFrontmatter(path.resolve(cwd, autoFile));
+                console.log(`Auto-selected sweep: ${path.basename(autoFile)}${iterFromFm ? ` (${iterFromFm} iterations from frontmatter)` : ""}`);
+                flags["prompt-file"] = autoFile;
+                if (iterFromFm && !getStringFlag(flags, "iterations")) {
+                    flags.iterations = String(iterFromFm);
+                }
+            }
+            else if (assets.sweeps.length > 1) {
+                if (isTTYInteractive(flags)) {
+                    const sweepOptions = await Promise.all(assets.sweeps.map(async (s) => {
+                        const fm = await readSweepFrontmatter(path.resolve(cwd, s.file));
+                        const iterLabel = fm.iterations ? ` (${fm.iterations} iterations)` : "";
+                        const titleLabel = fm.title ? ` — ${fm.title}` : "";
+                        return { label: `${path.basename(s.file, ".md")}${titleLabel}${iterLabel}`, value: s.file };
+                    }));
+                    const picked = await interactiveSelect("Select a sweep file:", sweepOptions);
+                    flags["prompt-file"] = picked;
+                    const iterFromFm = await readSweepIterationsFromFrontmatter(path.resolve(cwd, picked));
+                    if (iterFromFm && !getStringFlag(flags, "iterations")) {
+                        flags.iterations = String(iterFromFm);
+                    }
+                }
+                else {
+                    console.log(`${assets.sweeps.length} sweep files found. Pick one with --prompt-file:\n`);
+                    for (const s of assets.sweeps) {
+                        const iterCount = await readSweepIterationsFromFrontmatter(path.resolve(cwd, s.file));
+                        const iterFlag = iterCount ? ` --iterations ${iterCount}` : "";
+                        console.log(`  prompts-gpt sweep -f ${s.file}${iterFlag}`);
+                    }
+                    return;
+                }
+            }
+            else {
+                console.log("No sweep files found.");
+                console.log("  Create .prompts-gpt/sweeps/<name>.md to add sweep prompts.");
+                console.log("  Run `prompts-gpt list` to see what's available.");
+                return;
+            }
+        }
+        if (!getStringFlag(flags, "iterations") && getStringFlag(flags, "prompt-file")) {
+            const iterFromFm = await readSweepIterationsFromFrontmatter(path.resolve(cwd, getStringFlag(flags, "prompt-file")));
+            if (iterFromFm) {
+                flags.iterations = String(iterFromFm);
+            }
+        }
+        const providers = await detectProviders(cwd);
+        const availableProviders = providers.filter((p) => p.available);
+        if (!getStringFlag(flags, "agent") && isTTYInteractive(flags) && !Boolean(flags.json) && availableProviders.length > 1) {
+            const lastProvider = await getLastUsedProvider(cwd);
+            const providerOptions = availableProviders.map((p) => ({
+                label: `${p.provider} (${p.modelDefault}${p.version ? `, ${p.version}` : ""})${p.provider === lastProvider ? " ★" : ""}`,
+                value: p.provider,
+            }));
+            providerOptions.push({ label: "router (auto-select best available)", value: "router" });
+            if (lastProvider) {
+                const idx = providerOptions.findIndex((o) => o.value === lastProvider);
+                if (idx > 0) {
+                    const [item] = providerOptions.splice(idx, 1);
+                    providerOptions.unshift(item);
+                }
+            }
+            const picked = await interactiveSelect("Select a provider:", providerOptions);
+            flags.agent = picked;
+            if (picked !== "router") {
+                await saveLastUsedProvider(cwd, picked);
+            }
+        }
+        if (!getStringFlag(flags, "model") && isTTYInteractive(flags) && !Boolean(flags.json)) {
+            const currentAgent = resolveRunAgent(flags, config.defaultAgent);
+            if (currentAgent !== "router") {
+                const modelChoices = getModelChoicesForProvider(currentAgent, config);
+                if (modelChoices.length > 0) {
+                    const lastModel = await getLastUsedModel(cwd, currentAgent);
+                    if (lastModel) {
+                        const idx = modelChoices.findIndex((c) => c.value === lastModel);
+                        if (idx > 0) {
+                            const [item] = modelChoices.splice(idx, 1);
+                            modelChoices.unshift({ label: `${item.label} ★`, value: item.value });
+                        }
+                    }
+                    let picked = await interactiveSelect("Select a model:", modelChoices);
+                    if (picked === "__custom__") {
+                        picked = await interactiveInput("Enter model name", "");
+                        if (!picked.trim()) {
+                            console.log("No model entered, using default.");
+                            picked = "";
+                        }
+                    }
+                    if (picked) {
+                        flags.model = resolveModelAlias(picked);
+                        await saveLastUsedModel(cwd, currentAgent, flags.model);
+                    }
+                }
+            }
+        }
+        if (!getStringFlag(flags, "iterations") && isTTYInteractive(flags) && !Boolean(flags.json) && getStringFlag(flags, "prompt-file")) {
+            const fmIter = await readSweepIterationsFromFrontmatter(path.resolve(cwd, getStringFlag(flags, "prompt-file")));
+            const defaultIter = fmIter ? String(fmIter) : "1";
+            const iterOptions = [
+                { label: `${defaultIter} (default)`, value: defaultIter },
+                ...(defaultIter !== "1" ? [{ label: "1", value: "1" }] : []),
+                ...(defaultIter !== "2" ? [{ label: "2", value: "2" }] : []),
+                ...(defaultIter !== "3" ? [{ label: "3", value: "3" }] : []),
+                ...(defaultIter !== "5" ? [{ label: "5", value: "5" }] : []),
+            ];
+            flags.iterations = await interactiveSelect("Select iterations:", iterOptions);
+        }
+        const agent = resolveRunAgent(flags, config.defaultAgent);
+        const sweepModelFlag = getStringFlag(flags, "model");
+        if (sweepModelFlag && agent !== "router" && !Boolean(flags.json)) {
+            const resolvedP = resolveRunProvider(agent, providers, config.providerOrder);
+            const check = validateModelForProvider(sweepModelFlag, resolvedP);
+            if (!check.valid) {
+                console.log(`⚠ Model "${sweepModelFlag}" may not be available for ${resolvedP}.${check.suggestion ? ` Did you mean "${check.suggestion}"?` : ""}`);
+            }
+        }
+        if (isTTYInteractive(flags) && !Boolean(flags.json) && !Boolean(flags["dry-run"])) {
+            const resolvedProvider = resolveRunProvider(agent, providers, config.providerOrder);
+            const resolvedModel = getStringFlag(flags, "model")?.trim() || config.modelOverrides[resolvedProvider]?.trim() || availableProviders.find((p) => p.provider === resolvedProvider)?.modelDefault || "auto";
+            const resolvedIter = getStringFlag(flags, "iterations") || "1";
+            const sweepFile = getStringFlag(flags, "prompt-file") || "(default)";
+            const iterTimeout = parsePositiveIntFlag(getStringFlag(flags, "iteration-timeout"), "iteration-timeout") ?? 5400;
+            const estMaxMs = parseInt(resolvedIter, 10) * iterTimeout * 1000;
+            const maxRetries = parseNonNegativeIntFlag(getStringFlag(flags, "max-retries"), "max-retries") ?? 2;
+            console.log("");
+            const modelTier = (PROVIDER_MODELS[resolvedProvider] ?? []).find((m) => m.value === resolvedModel)?.tier ?? "standard";
+            const tierBadge = modelTier === "frontier" ? "⭐ frontier" : modelTier === "fast" ? "⚡ fast" : modelTier === "budget" ? "💰 budget" : "standard";
+            const boxValues = [
+                path.basename(sweepFile), resolvedProvider, resolvedModel, resolvedIter,
+                `${formatDuration(iterTimeout * 1000)} per iteration`, `~${formatDuration(estMaxMs)}`,
+                String(maxRetries), tierBadge,
+            ];
+            const longestVal = Math.max(...boxValues.map((v) => v.length), 30);
+            const innerW = longestVal + 16;
+            const bar = "═".repeat(innerW);
+            const pad = (v) => v.padEnd(longestVal);
+            const row = (label, val) => `${colorize("║", "\x1b[36m")}  ${label.padEnd(12)} ${pad(val)} ${colorize("║", "\x1b[36m")}`;
+            const titleText = "Prompts-GPT Sweep";
+            const titlePad = Math.max(0, Math.floor((innerW - titleText.length) / 2));
+            console.log(colorize(`╔${bar}╗`, "\x1b[36m"));
+            console.log(colorize(`║${" ".repeat(titlePad)}${titleText}${" ".repeat(innerW - titlePad - titleText.length)}║`, "\x1b[36m"));
+            console.log(colorize(`╠${bar}╣`, "\x1b[36m"));
+            console.log(row("Sweep:", path.basename(sweepFile)));
+            console.log(row("Provider:", resolvedProvider));
+            console.log(row("Model:", resolvedModel));
+            console.log(row("Iterations:", resolvedIter));
+            console.log(row("Timeout:", `${formatDuration(iterTimeout * 1000)} per iteration`));
+            console.log(row("Max time:", `~${formatDuration(estMaxMs)}`));
+            console.log(row("Retries:", String(maxRetries)));
+            console.log(row("Tier:", tierBadge));
+            if (modelTier === "frontier") {
+                console.log(`${colorize("║", "\x1b[36m")}  ${colorize("⚠ Frontier model — higher cost per token", "\x1b[33m")}${" ".repeat(Math.max(0, innerW - 43))} ${colorize("║", "\x1b[36m")}`);
+            }
+            console.log(colorize(`╚${bar}╝`, "\x1b[36m"));
+            console.log("");
+            const confirmOpts = [
+                { label: "Yes, run this sweep", value: "y" },
+                { label: "Cancel", value: "n" },
+            ];
+            const confirm = await interactiveSelect("Run this sweep?", confirmOpts);
+            if (confirm === "n") {
+                console.log("Cancelled.");
+                return;
+            }
+        }
+        const quiet = Boolean(flags.quiet);
+        const summaryLineCount = parsePositiveIntFlag(getStringFlag(flags, "summary-lines"), "summary-lines") ?? 40;
+        const sweepDurations = [];
+        const onProgress = Boolean(flags.json)
+            ? undefined
+            : (event) => {
+                if (event.type === "preflight") {
+                    const report = JSON.parse(event.message);
+                    console.log(`Provider: ${report.provider} | Model: ${report.model} | Iterations: ${report.iterations}`);
+                    console.log(`Branch: ${report.gitBranch} | Dirty files: ${report.gitDirtyFiles} | Free disk: ${report.diskFreeMb}MB`);
+                    console.log(`Prompt: ${path.basename(report.promptFile)}`);
+                    try {
+                        const fs = require("node:fs");
+                        const skillDir = path.resolve(cwd, ".agents", "skills");
+                        const ruleDir = path.resolve(cwd, ".cursor", "rules");
+                        const skillCount = fs.existsSync(skillDir) ? fs.readdirSync(skillDir, { recursive: true }).filter((f) => String(f).endsWith("SKILL.md")).length : 0;
+                        const ruleCount = fs.existsSync(ruleDir) ? fs.readdirSync(ruleDir).filter((f) => String(f).endsWith(".mdc")).length : 0;
+                        const mcpConfig = fs.existsSync(path.resolve(cwd, ".cursor", "mcp.json")) ? "found" : "none";
+                        console.log(`Skills: ${skillCount} | Rules: ${ruleCount} | MCP config: ${mcpConfig}`);
+                    }
+                    catch { /* skip */ }
+                    const maxRunDirs = parsePositiveIntFlag(getStringFlag(flags, "max-run-dirs"), "max-run-dirs") ?? 20;
+                    console.log(`Log rotation: keep ${maxRunDirs} runs`);
+                    for (const w of report.warnings)
+                        console.log(`⚠ ${w}`);
+                }
+                else if (event.type === "iteration_start") {
+                    console.log(`\n${colorize("══════════════════════════════════════════════════════════════", "\x1b[35m")}`);
+                    console.log(colorize(`[${new Date().toLocaleTimeString()}] Iteration ${event.iteration}/${event.total}: ${event.provider} (${event.model})`, "\x1b[1;35m"));
+                    console.log(colorize("══════════════════════════════════════════════════════════════", "\x1b[35m"));
+                }
+                else if (event.type === "message") {
+                    if (!quiet) {
+                        const truncText = event.text.length > 120 ? `${event.text.slice(0, 117)}...` : event.text;
+                        console.log(`  ${colorize(`[${event.elapsed}]`, "\x1b[36m")} 💬 ${truncText}`);
+                    }
+                }
+                else if (event.type === "tool") {
+                    if (!quiet) {
+                        const c = event.counts;
+                        let icon = "🔧";
+                        let friendlyAction = event.action;
+                        if (event.action.includes("read")) {
+                            icon = "📖";
+                            friendlyAction = "read";
+                        }
+                        else if (event.action.includes("write") || event.action.includes("edit") || event.action === "str_replace") {
+                            icon = "✏️ ";
+                            friendlyAction = "write";
+                        }
+                        else if (event.action.includes("shell") || event.action === "bash") {
+                            icon = "⚡";
+                            friendlyAction = "shell";
+                        }
+                        else if (event.action.includes("search") || event.action.includes("grep") || event.action.includes("glob")) {
+                            icon = "🔍";
+                            friendlyAction = "search";
+                        }
+                        else if (event.action.includes("todo")) {
+                            icon = "📋";
+                            friendlyAction = "todo";
+                        }
+                        else if (event.action.includes("web") || event.action.includes("fetch")) {
+                            icon = "🌐";
+                            friendlyAction = "web";
+                        }
+                        else {
+                            friendlyAction = event.action.replace(/ToolCall$/i, "").replace(/Tool$/i, "");
+                        }
+                        const fileStr = event.file ? ` ${colorize(event.file, "\x1b[90m")}` : "";
+                        const countStr = colorize(`(R:${c.reads} W:${c.writes} S:${c.shells} 🔍:${c.searches})`, "\x1b[90m");
+                        console.log(`  ${icon} ${friendlyAction}${fileStr}  ${countStr}`);
+                    }
+                }
+                else if (event.type === "iteration_end") {
+                    const elapsed = formatDuration(event.durationMs);
+                    const icon = event.status === "success" ? colorize("✓", "\x1b[32m") : colorize("✗", "\x1b[31m");
+                    sweepDurations.push(event.durationMs);
+                    const remaining = ((parseInt(String(getStringFlag(flags, "iterations"))) || 1) - event.iteration);
+                    let etaStr = "";
+                    if (remaining > 0 && sweepDurations.length > 0) {
+                        const avgMs = sweepDurations.reduce((a, b) => a + b, 0) / sweepDurations.length;
+                        etaStr = ` | ETA: ~${formatDuration(avgMs * remaining)}`;
+                    }
+                    console.log(`${icon} Iteration ${event.iteration} ${event.status} (${elapsed})${etaStr}`);
+                }
+                else if (event.type === "attempt_retry") {
+                    console.log(colorize(`  ⟳ Retry ${event.attempt}/${event.maxAttempts} for iteration ${event.iteration}, backoff ${event.backoffMs}ms`, "\x1b[33m"));
+                }
+                else if (event.type === "summary") {
+                    if (summaryLineCount > 0) {
+                        const preview = event.lines.slice(0, summaryLineCount);
+                        console.log(`\n── Summary (iteration ${event.iteration}, ${preview.length}/${event.lines.length} lines) ──`);
+                        for (const line of preview)
+                            console.log(`  ${line}`);
+                        if (event.lines.length > summaryLineCount) {
+                            console.log(`  ... (${event.lines.length - summaryLineCount} more lines)`);
+                        }
+                        console.log("── End summary ──");
+                    }
+                }
+                else if (event.type === "sweep_end") {
+                    const r = event.result;
+                    const cW = 62;
+                    const cBar = "═".repeat(cW);
+                    const cRow = (label, val) => {
+                        const plain = `  ${label.padEnd(12)} ${val}`;
+                        console.log(`${colorize("║", "\x1b[36m")}${plain.padEnd(cW)}${colorize("║", "\x1b[36m")}`);
+                    };
+                    console.log("");
+                    console.log(colorize(`╔${cBar}╗`, "\x1b[36m"));
+                    const cTitle = "Sweep Complete";
+                    const cTitlePad = Math.floor((cW - cTitle.length) / 2);
+                    console.log(colorize(`║${" ".repeat(cTitlePad)}${cTitle}${" ".repeat(cW - cTitlePad - cTitle.length)}║`, "\x1b[36m"));
+                    console.log(colorize(`╠${cBar}╣`, "\x1b[36m"));
+                    cRow("Model:", r.model);
+                    cRow("Duration:", formatDuration(r.totalDurationMs));
+                    cRow("Iterations:", String(r.totalIterations));
+                    cRow("Succeeded:", String(r.succeeded));
+                    if (r.failed > 0) {
+                        cRow("Failed:", String(r.failed));
+                    }
+                    console.log(colorize(`╠${cBar}╣`, "\x1b[36m"));
+                    for (const iter of r.iterations) {
+                        const statusIcon = iter.status === "success" ? "✓" : "✗";
+                        const plain = `  ${statusIcon} Iter ${iter.iteration}:  ${iter.status.padEnd(16)} ${formatDuration(iter.durationMs)}`;
+                        console.log(`${colorize("║", "\x1b[36m")}${plain.padEnd(cW)}${colorize("║", "\x1b[36m")}`);
+                    }
+                    console.log(colorize(`╚${cBar}╝`, "\x1b[36m"));
+                    if (hasTokenUsage(r.tokenUsage)) {
+                        const tu = r.tokenUsage;
+                        console.log(`Tokens: ${formatTokenUsage(tu)}`);
+                        const estCost = ((tu.inputTokens || 0) * 0.003 + (tu.outputTokens || 0) * 0.015) / 1000;
+                        if (estCost > 0.001) {
+                            console.log(`Estimated cost: ~$${estCost.toFixed(2)}`);
+                        }
+                    }
+                }
+            };
+        const result = await sweepPrompt({
+            cwd,
+            promptFile: getStringFlag(flags, "prompt-file"),
+            agent,
+            model: getStringFlag(flags, "model"),
+            iterations: parsePositiveIntFlag(getStringFlag(flags, "iterations"), "iterations"),
+            iterationTimeoutSeconds: parsePositiveIntFlag(getStringFlag(flags, "iteration-timeout"), "iteration-timeout"),
+            maxRetries: parseNonNegativeIntFlag(getStringFlag(flags, "max-retries"), "max-retries"),
+            artifactsDir: getStringFlag(flags, "artifacts-dir"),
+            runId: getStringFlag(flags, "run-id"),
+            approveMcps: !Boolean(flags["no-approve-mcps"]),
+            sandboxMode: getStringFlag(flags, "sandbox"),
+            phase: getStringFlag(flags, "phase"),
+            dryRun: Boolean(flags["dry-run"]),
+            maxRunDirs: parsePositiveIntFlag(getStringFlag(flags, "max-run-dirs"), "max-run-dirs"),
+            summaryLines: parsePositiveIntFlag(getStringFlag(flags, "summary-lines"), "summary-lines"),
+            background: Boolean(flags.background),
+            permissionMode: getStringFlag(flags, "permission-mode"),
+            onProgress,
+        });
+        if (Boolean(flags.json)) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        if (result.dryRun) {
+            const iterTimeout = parsePositiveIntFlag(getStringFlag(flags, "iteration-timeout"), "iteration-timeout") ?? 5400;
+            const estMaxDuration = result.totalIterations * iterTimeout;
+            console.log("[dry-run] Would execute sweep with:");
+            console.log(`  Provider: ${result.provider}`);
+            console.log(`  Model: ${result.model}`);
+            console.log(`  Iterations: ${result.totalIterations}`);
+            console.log(`  Prompt: ${result.promptFile}`);
+            console.log(`  Max duration: ~${formatDuration(estMaxDuration * 1000)} (${result.totalIterations} x ${formatDuration(iterTimeout * 1000)})`);
+            try {
+                const { readFile: fsRead } = await import("node:fs/promises");
+                const previewText = await fsRead(result.promptFile, "utf8");
+                const previewLines = previewText.split("\n").slice(0, 5);
+                console.log(`  Prompt preview:`);
+                for (const line of previewLines)
+                    console.log(`    ${line}`);
+                if (previewText.split("\n").length > 5)
+                    console.log(`    ... (${previewText.split("\n").length - 5} more lines)`);
+            }
+            catch { /* skip preview */ }
+            return;
+        }
+        console.log(`Run ID: ${result.runId}`);
+        console.log(`Provider: ${result.provider} | Model: ${result.model}`);
+        console.log(`Prompt: ${result.promptFile}`);
+        console.log(`Iterations: ${result.succeeded}/${result.totalIterations} succeeded`);
+        console.log(`Duration: ${formatDuration(result.totalDurationMs)}`);
+        if (hasTokenUsage(result.tokenUsage)) {
+            console.log(`Tokens: ${formatTokenUsage(result.tokenUsage)}`);
+        }
+        console.log(`Run dir: ${result.runDir}`);
+        console.log(`Manifest: ${result.manifestFile}`);
+        if (result.iterations.length > 1) {
+            console.log("");
+            console.log("Per-iteration results:");
+            for (const iter of result.iterations) {
+                const tools = iter.toolCounts;
+                const toolStr = tools.total > 0 ? ` | tools: ${tools.total} (R:${tools.reads} W:${tools.writes} S:${tools.shells})` : "";
+                const usageStr = hasTokenUsage(iter.tokenUsage) ? ` | tokens: ${iter.tokenUsage.totalTokens.toLocaleString()}` : "";
+                console.log(`  [${iter.iteration}/${result.totalIterations}] ${iter.status} (${formatDuration(iter.durationMs)})${toolStr}${usageStr}`);
+            }
+            const totalTools = result.iterations.reduce((acc, i) => ({
+                reads: acc.reads + i.toolCounts.reads, writes: acc.writes + i.toolCounts.writes,
+                shells: acc.shells + i.toolCounts.shells, searches: acc.searches + i.toolCounts.searches,
+                webSearches: acc.webSearches + i.toolCounts.webSearches, total: acc.total + i.toolCounts.total,
+            }), { reads: 0, writes: 0, shells: 0, searches: 0, webSearches: 0, total: 0 });
+            if (totalTools.total > 0) {
+                console.log(`  Total tools: ${totalTools.total} (reads: ${totalTools.reads}, writes: ${totalTools.writes}, shells: ${totalTools.shells}, searches: ${totalTools.searches})`);
+            }
+        }
+        console.log("");
+        console.log("Inspect results:");
+        console.log(`  cat ${result.manifestFile}`);
+        console.log(`  ls ${result.runDir}`);
+        if (Boolean(flags.open) && result.manifestFile) {
+            try {
+                const { spawn: openSpawn } = await import("node:child_process");
+                const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "notepad" : "xdg-open";
+                openSpawn(openCmd, [result.manifestFile], { detached: true, stdio: "ignore" }).unref();
+            }
+            catch { /* ignore */ }
+        }
+        if (result.failed > 0) {
+            const failedIters = result.iterations.filter((it) => it.status !== "success");
+            for (const fi of failedIters) {
+                try {
+                    const { readFile: fsRead } = await import("node:fs/promises");
+                    const logText = await fsRead(fi.logFile, "utf8");
+                    const tailLines = logText.split("\n").slice(-80);
+                    if (tailLines.length > 0) {
+                        console.log(`\n── Last 80 lines of iteration ${fi.iteration} log ──`);
+                        for (const line of tailLines)
+                            console.log(`  ${line}`);
+                        console.log("── End log tail ──");
+                    }
+                }
+                catch { /* skip */ }
+            }
+            process.exitCode = 1;
+        }
+        console.log("\nNext steps:");
+        console.log("  1. Review iteration summaries in the run directory");
+        if (result.failed > 0) {
+            console.log(`  2. Re-run failed: prompts-gpt sweep -f ${getStringFlag(flags, "prompt-file")} -n ${result.failed}`);
+        }
+        return;
+    }
+    if (command === "quickstart") {
+        const cwd = getResolvedCwd(flags);
+        const assets = await discoverWorkspaceAssets(cwd);
+        const providers = await detectProviders(cwd);
+        const availableProviders = providers.filter((p) => p.available);
+        console.log("Prompts-GPT Quickstart");
+        console.log("======================");
+        console.log("");
+        const { spawnSync: gitCheck } = await import("node:child_process");
+        const gitResult = gitCheck("git", ["rev-parse", "--is-inside-work-tree"], { cwd, encoding: "utf8", timeout: 5000, windowsHide: true });
+        if (gitResult.status !== 0) {
+            console.log("⚠ Not inside a git repository. Prompts-GPT works best in a git repo for worktree tracking.");
+            console.log("  Run: git init\n");
+        }
+        if (!assets.credentialsFound) {
+            let networkOk = true;
+            try {
+                const netCheck = await Promise.race([
+                    fetch("https://prompts-gpt.com/api/health", { method: "HEAD" }),
+                    new Promise((_, rej) => setTimeout(() => rej(new Error("timeout")), 5000)),
+                ]);
+                networkOk = netCheck instanceof Response;
+            }
+            catch {
+                networkOk = false;
+            }
+            if (!networkOk) {
+                console.log("⚠ Network unavailable. Quickstart requires internet for token validation.\n");
+                console.log("You can still use local sweep files without a network connection:");
+                console.log("  1. Create .prompts-gpt/sweeps/<name>.md with your sweep prompt");
+                console.log("  2. Run: prompts-gpt sweep");
+                console.log("\nWhen online, run `prompts-gpt quickstart` again.");
+                return;
+            }
+            console.log("Step 1: Save your project token");
+            console.log("  prompts-gpt init --token-prompt");
+            console.log("");
+            console.log("  Get your token from: https://prompts-gpt.com/studio/projects");
+            console.log("");
+            console.log("Run `prompts-gpt quickstart` again after saving your token.");
+            return;
+        }
+        console.log("✓ Credentials found");
+        if (!assets.configFound) {
+            console.log("→ Setting up config...");
+            try {
+                await initRunConfig({ cwd, overwrite: false });
+                console.log("✓ Config created");
+            }
+            catch {
+                console.log("✓ Config already exists");
+            }
+        }
+        else {
+            console.log("✓ Config found");
+        }
+        if (availableProviders.length === 0) {
+            console.log("");
+            console.log("✗ No provider CLIs found. Install at least one:");
+            console.log("  - codex:  npm install -g @openai/codex");
+            console.log("  - claude: npm install -g @anthropic-ai/claude-code");
+            console.log("  - cursor: Install Cursor IDE (includes `agent` CLI)");
+            return;
+        }
+        console.log(`✓ Providers: ${availableProviders.map((p) => p.provider).join(", ")}`);
+        if (assets.prompts.length === 0 && assets.sweeps.length === 0) {
+            console.log("");
+            console.log("→ No prompts found. Syncing from Prompts Studio...");
+            try {
+                const clientOpts = await resolveClientOptions("quickstart", flags).catch(() => null);
+                if (clientOpts) {
+                    const qsClient = new PromptsGptClient(clientOpts);
+                    const pulledPrompts = await qsClient.pullPrompts();
+                    if (pulledPrompts.length > 0) {
+                        const syncResult = await syncPrompts(pulledPrompts, { cwd, agent: "all" });
+                        console.log(`✓ Synced ${syncResult.markdown.written.length} prompt(s) and ${syncResult.agents.written.length} agent file(s)`);
+                        const refreshed = await discoverWorkspaceAssets(cwd);
+                        if (refreshed.prompts.length > 0 || refreshed.sweeps.length > 0) {
+                            console.log(`✓ Prompts: ${refreshed.prompts.length} prompt packs, ${refreshed.sweeps.length} sweeps`);
+                        }
+                    }
+                    else {
+                        console.log("No prompts found in your Prompts Studio library.");
+                        console.log("  Configure prompts at: https://prompts-gpt.com/studio/projects");
+                        console.log("  Or run: prompts-gpt generate --goal \"Your task\"");
+                        return;
+                    }
+                }
+                else {
+                    console.log("✗ Could not sync (credentials issue). Run manually:");
+                    console.log("  prompts-gpt sync");
+                    return;
+                }
+            }
+            catch (syncErr) {
+                const syncMsg = syncErr instanceof Error ? syncErr.message : String(syncErr);
+                if (syncErr instanceof PromptsGptApiError && (syncErr.status === 401 || syncErr.status === 403)) {
+                    console.log(`✗ Authentication failed: ${syncMsg}`);
+                    console.log("  Your token may be invalid or expired. Re-run:");
+                    console.log("  prompts-gpt init --token-prompt");
+                }
+                else if (syncMsg.includes("ENOTFOUND") || syncMsg.includes("ECONNREFUSED") || syncMsg.includes("fetch") || syncMsg.includes("network")) {
+                    console.log(`✗ Network error: ${syncMsg}`);
+                    console.log("  Check your internet connection and try again.");
+                    console.log("  You can still use local sweep files without network access.");
+                }
+                else {
+                    console.log(`✗ Sync failed: ${syncMsg}`);
+                    console.log("  Run manually: prompts-gpt sync");
+                }
+                return;
+            }
+            const refreshedAssets = await discoverWorkspaceAssets(cwd);
+            if (refreshedAssets.prompts.length === 0 && refreshedAssets.sweeps.length === 0) {
+                return;
+            }
+        }
+        console.log(`✓ Prompts: ${assets.prompts.length} prompt packs, ${assets.sweeps.length} sweeps`);
+        console.log("");
+        console.log("You're ready!");
+        if (isTTYInteractive() && (assets.prompts.length > 0 || assets.sweeps.length > 0)) {
+            const qsOptions = [];
+            for (const s of assets.sweeps) {
+                qsOptions.push({ label: `sweep: ${s.name}`, value: `sweep:${s.file}` });
+            }
+            for (const p of assets.prompts.slice(0, 5)) {
+                qsOptions.push({ label: `run: ${p.title}`, value: `run:.prompts-gpt/${p.file}` });
+            }
+            qsOptions.push({ label: "(show commands and exit)", value: "exit" });
+            console.log("");
+            const qsPicked = await interactiveSelect("Run something now?", qsOptions);
+            if (qsPicked !== "exit") {
+                const [action, file] = qsPicked.split(":", 2);
+                const cmd = action === "sweep" ? "sweep" : "run";
+                console.log(`\nRunning: prompts-gpt ${cmd} -f ${file}\n`);
+                const { spawnSync: spSync } = await import("node:child_process");
+                const cliEntry = process.argv[1] || require.resolve("./cli.js");
+                const result = spSync(process.execPath, [cliEntry, cmd, "-f", file], { stdio: "inherit", cwd });
+                process.exitCode = result.status ?? 1;
+                return;
+            }
+        }
+        console.log("");
+        console.log("Try these commands:");
+        console.log("");
+        if (assets.prompts.length > 0) {
+            console.log(`  prompts-gpt run -f .prompts-gpt/${assets.prompts[0].file}`);
+        }
+        if (assets.sweeps.length > 0) {
+            console.log(`  prompts-gpt sweep -f ${assets.sweeps[0].file}`);
+        }
+        console.log("  prompts-gpt list        — see all available prompts and sweeps");
+        console.log("  prompts-gpt status      — check workspace readiness");
+        return;
+    }
+    if (command === "load-config") {
+        const cwd = getResolvedCwd(flags);
+        const client = await createClientForCommand(command, flags);
+        const project = await client.getProject();
+        const prompts = await client.pullPrompts();
+        if (prompts.length === 0) {
+            console.log("No prompt packs found in the project library. Configure prompts in Prompts Studio first.");
+            console.log(`  Open: https://prompts-gpt.com/studio/projects`);
+            return;
+        }
+        const result = await syncPrompts(prompts, {
+            cwd,
+            outDir: getStringFlag(flags, "out") || DEFAULT_PROMPTS_GPT_OUT_DIR,
+            overwrite: true,
+            agent: getStringFlag(flags, "agent") || "all",
+        });
+        const providers = await detectProviders(cwd);
+        const availableProviders = providers.filter((p) => p.available);
+        let configError = null;
+        let doOverwrite = true;
+        const existingConfig = existsSync(path.resolve(cwd, DEFAULT_RUN_CONFIG_PATH));
+        if (existingConfig && isTTYInteractive() && !Boolean(flags.json)) {
+            const confirmOverwrite = await interactiveInput("Existing run config found. Overwrite? [Y/n]", "Y");
+            if (confirmOverwrite.toLowerCase() === "n" || confirmOverwrite.toLowerCase() === "no") {
+                doOverwrite = false;
+            }
+        }
+        const configResult = doOverwrite ? await initRunConfig({
+            cwd,
+            overwrite: true,
+        }).catch((err) => {
+            configError = err.message;
+            return null;
+        }) : null;
+        if (Boolean(flags.json)) {
+            console.log(JSON.stringify({
+                project: { brandName: project.brandName, websiteUrl: project.websiteUrl },
+                synced: { prompts: result.markdown.written.length, agents: result.agents.written.length },
+                providers: availableProviders.map((p) => p.provider),
+                config: configResult ? "created" : "skipped",
+            }, null, 2));
+            return;
+        }
+        console.log(`Loaded configuration from Prompts Studio for: ${project.brandName}`);
+        console.log(`Synced ${result.markdown.written.length} prompt pack(s) to ${result.markdown.outDir}`);
+        console.log(`Synced ${result.agents.written.length} agent file(s): ${result.agents.targets.join(", ")}`);
+        console.log(`Manifest: ${result.manifest.manifestPath}`);
+        if (configResult) {
+            console.log(`Config: ${configResult.configPath}`);
+        }
+        else if (configError) {
+            console.error(`[config] Skipped: ${configError}`);
+        }
+        if (availableProviders.length > 0 && result.manifest.manifest.prompts.length > 0) {
+            const firstFile = result.manifest.manifest.prompts[0]?.file;
+            if (firstFile) {
+                console.log(`\nReady to run:`);
+                console.log(`  prompts-gpt run --prompt-file .prompts-gpt/${firstFile}`);
+            }
+        }
+        const lcAssets = await discoverWorkspaceAssets(cwd);
+        if (lcAssets.sweeps.length > 0) {
+            console.log(`\nSweep files available (${lcAssets.sweeps.length}):`);
+            for (const s of lcAssets.sweeps) {
+                console.log(`  prompts-gpt sweep --prompt-file ${s.file}`);
+            }
+        }
+        return;
+    }
+    if (command === "init") {
+        let token = await resolveTokenInput(flags, { command });
+        if (!token && process.stdin.isTTY && process.stdout.isTTY) {
+            console.log("No token flag provided — prompting interactively.");
+            console.log("Get your token from: https://prompts-gpt.com/studio/projects");
+            console.log("Token format: pgpt_xxxxxxxxxxxxxxxx (starts with 'pgpt_')\n");
+            token = await readTokenFromPrompt(command);
+        }
+        if (!token) {
+            throw new CliError("Run `prompts-gpt init --token <project-token>`, `--token-stdin`, or `--token-prompt`.", CLI_EXIT_CODES.validation, {
+                helpCommand: "init",
+            });
+        }
+        if (token.length > 256) {
+            throw new CliError("Token value is invalid or too long.", CLI_EXIT_CODES.validation, {
+                helpCommand: "init",
+            });
+        }
+        if (!token.startsWith("pgpt_")) {
+            throw new CliError("Token must start with `pgpt_`. Copy the full token from the Prompts-GPT dashboard.", CLI_EXIT_CODES.validation, {
+                helpCommand: "init",
+            });
+        }
+        const cwd = getResolvedCwd(flags);
+        const apiUrlFlag = getStringFlag(flags, "api-url");
+        if (apiUrlFlag) {
+            try {
+                const parsed = new URL(apiUrlFlag);
+                if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+                    throw new CliError("--api-url must use https or http.", CLI_EXIT_CODES.validation, { helpCommand: "init" });
+                }
+            }
+            catch (e) {
+                if (e instanceof CliError)
+                    throw e;
+                throw new CliError(`--api-url is not a valid URL: ${apiUrlFlag}`, CLI_EXIT_CODES.validation, { helpCommand: "init" });
+            }
+        }
+        const result = await saveLocalCredentials({
+            token,
+            apiUrl: apiUrlFlag || DEFAULT_PROMPTS_GPT_API_URL,
+            cwd,
+        });
+        console.log(`Saved Prompts-GPT credentials to ${result.credentialsPath}`);
+        console.log("The credentials file is added to .gitignore.");
+        if (isTTYInteractive()) {
+            console.log("");
+            const runQs = await interactiveInput("Run quickstart now? [Y/n]", "Y");
+            if (runQs.toLowerCase() !== "n" && runQs.toLowerCase() !== "no") {
+                const { spawnSync: spSync } = await import("node:child_process");
+                const cliEntry = process.argv[1] || require.resolve("./cli.js");
+                const qsResult = spSync(process.execPath, [cliEntry, "quickstart", "--cwd", cwd], { stdio: "inherit", cwd });
+                process.exitCode = qsResult.status ?? 1;
+                return;
+            }
+        }
+        console.log("");
+        console.log("Next steps:");
+        console.log("  prompts-gpt quickstart  — interactive setup (recommended)");
+        console.log("  prompts-gpt sync        — pull prompts, agent files, and model registry");
+        console.log("  prompts-gpt sync-models — sync latest model registry from prompts-gpt.com");
+        return;
+    }
+    if (command === "pull") {
+        const parsedLimit = parseLimitFlag(getStringFlag(flags, "limit"));
+        const client = await createClientForCommand(command, flags);
+        const prompts = await client.pullPrompts(buildPullQuery(flags, parsedLimit));
+        if (prompts.length === 0) {
+            console.log("No prompts matched the query. Try different filters or check the project prompt library.");
+            return;
+        }
+        const pullCwd = getResolvedCwd(flags);
+        const pullOutDir = getStringFlag(flags, "out") || DEFAULT_PROMPTS_GPT_OUT_DIR;
+        const result = await writePromptMarkdownFiles(prompts, {
+            cwd: pullCwd,
+            outDir: pullOutDir,
+            overwrite: Boolean(flags.overwrite),
+        });
+        const pullManifest = await writePromptManifest(prompts, { cwd: pullCwd, outDir: pullOutDir });
+        console.log(`Wrote ${result.written.length} prompt file(s) to ${result.outDir}.`);
+        console.log(`Updated manifest: ${pullManifest.manifestPath}`);
+        if (Boolean(flags.overwrite)) {
+            const agentResult = await writeAgentFiles(prompts, { cwd: pullCwd, agent: "all", overwriteAgentFiles: true });
+            if (agentResult.written.length > 0) {
+                console.log(`Updated ${agentResult.written.length} agent file(s): ${agentResult.targets.join(", ")}`);
+            }
+        }
+        if (result.skipped.length) {
+            console.log(`Skipped ${result.skipped.length} existing file(s). Use --overwrite to replace them.`);
+        }
+        if (result.written.length > 0) {
+            console.log("");
+            console.log("Run a pulled prompt:");
+            console.log(`  prompts-gpt run -f ${result.written[0]}`);
+            console.log("  prompts-gpt list  — see all available prompts");
+        }
+        return;
+    }
+    if (command === "generate") {
+        validateToolFlag(getStringFlag(flags, "tool"));
+        const goal = getStringFlag(flags, "goal");
+        if (!goal) {
+            throw new CliError("Prompt generation requires `--goal`.\n\n" +
+                "Example:\n" +
+                "  prompts-gpt generate --goal \"Review pull requests for security issues\"\n" +
+                "  prompts-gpt generate --goal \"Write unit tests\" --sync-agents\n\n" +
+                "Use --sync-agents to also write agent files (AGENTS.md, .cursor/rules, etc.).", CLI_EXIT_CODES.validation, { helpCommand: "generate" });
+        }
+        validateAgentFlag(getStringFlag(flags, "agent"));
+        if (!Boolean(flags.json)) {
+            printDataTransmissionNotice("generate", { goal, context: getStringFlag(flags, "context"), constraints: getStringFlag(flags, "constraints") });
+        }
+        const client = await createClientForCommand(command, flags);
+        const prompt = await client.generatePrompt(buildGenerateInput(flags));
+        const cwd = getResolvedCwd(flags);
+        const result = await writePromptMarkdownFiles([prompt], {
+            cwd,
+            outDir: getStringFlag(flags, "out") || DEFAULT_PROMPTS_GPT_OUT_DIR,
+            overwrite: Boolean(flags.overwrite),
+        });
+        const shouldSyncAgents = Boolean(flags["sync-agents"]) || typeof getStringFlag(flags, "agent") === "string";
+        if (shouldSyncAgents) {
+            const target = getStringFlag(flags, "agent") || "all";
+            const pulled = await client.pullPrompts().catch((err) => {
+                if (!Boolean(flags.json)) {
+                    console.error(`⚠ Could not pull existing prompts for agent sync: ${err.message}`);
+                    console.error("  Agent files will only include the newly generated prompt.");
+                    console.error("  Run \`prompts-gpt sync\` afterward to include all library prompts.");
+                }
+                return [];
+            });
+            const syncedPrompts = mergePromptPacks([prompt, ...pulled]);
+            const agentResult = await writeAgentFiles(syncedPrompts, {
+                cwd,
+                agent: target,
+                overwriteAgentFiles: true,
+            });
+            const manifestResult = await writePromptManifest(syncedPrompts, {
+                cwd,
+                outDir: getStringFlag(flags, "out") || DEFAULT_PROMPTS_GPT_OUT_DIR,
+            });
+            console.log(`Synced ${agentResult.written.length} agent file(s) for ${agentResult.targets.join(", ")}.`);
+            console.log(`Updated manifest: ${manifestResult.manifestPath}`);
+        }
+        console.log(`Generated: ${prompt.title}`);
+        console.log(`Wrote to ${result.written[0] ?? result.outDir}.`);
+        if (result.skipped.length) {
+            console.log("Skipped existing generated prompt. Use --overwrite to replace it.");
+        }
+        const genFile = result.written[0];
+        if (genFile && isTTYInteractive()) {
+            const genProviders = await detectProviders(cwd);
+            if (genProviders.some((p) => p.available)) {
+                console.log("");
+                const runNow = await interactiveInput("Run this prompt now? [Y/n]", "Y");
+                if (runNow.toLowerCase() !== "n" && runNow.toLowerCase() !== "no") {
+                    console.log(`\nRunning: prompts-gpt run -f ${genFile}\n`);
+                    const { spawnSync: spSync } = await import("node:child_process");
+                    const cliEntry = process.argv[1] || require.resolve("./cli.js");
+                    const genResult = spSync(process.execPath, [cliEntry, "run", "-f", genFile], { stdio: "inherit", cwd });
+                    process.exitCode = genResult.status ?? 1;
+                }
+            }
+        }
+        return;
+    }
+    if (command === "sync") {
+        validateToolFlag(getStringFlag(flags, "tool"));
+        validateAgentFlag(getStringFlag(flags, "agent"));
+        const parsedLimit = parseLimitFlag(getStringFlag(flags, "limit"));
+        const prompts = [];
+        const goal = getStringFlag(flags, "goal");
+        const generatedOnly = Boolean(flags["generated-only"]);
+        let client;
+        try {
+            client = await createClientForCommand(command, flags);
+        }
+        catch (clientErr) {
+            if (clientErr instanceof CliError && clientErr.exitCode === CLI_EXIT_CODES.auth) {
+                throw new CliError(`Authentication failed. Your token may be invalid, expired, or lack the required scope.\n\n` +
+                    `Re-run: prompts-gpt init --token-prompt\n` +
+                    `Get a new token: https://prompts-gpt.com/studio/projects`, CLI_EXIT_CODES.auth, { helpCommand: "sync" });
+            }
+            throw clientErr;
+        }
+        if (goal && !Boolean(flags.json)) {
+            printDataTransmissionNotice("sync", { goal, context: getStringFlag(flags, "context"), constraints: getStringFlag(flags, "constraints") });
+        }
+        if (goal) {
+            prompts.push(await client.generatePrompt(buildGenerateInput(flags)));
+        }
+        if (!generatedOnly) {
+            prompts.push(...await client.pullPrompts(buildPullQuery(flags, parsedLimit)));
+        }
+        if (prompts.length === 0) {
+            throw new CliError("No prompts to sync. Provide `--goal` or remove `--generated-only`.", CLI_EXIT_CODES.validation, {
+                helpCommand: "sync",
+            });
+        }
+        if (Boolean(flags["dry-run"])) {
+            const agentTarget = getStringFlag(flags, "agent") || "all";
+            console.log(`[dry-run] Would sync ${prompts.length} prompt(s) for agent target: ${agentTarget}`);
+            for (const p of prompts)
+                console.log(`  - ${p.title} (${p.source})`);
+            const targetList = agentTarget === "all" ? SUPPORTED_AGENT_TARGETS.join(", ") : agentTarget;
+            console.log(`\n  Agent file targets: ${targetList}`);
+            console.log(`  Output dir: ${getStringFlag(flags, "out") || DEFAULT_PROMPTS_GPT_OUT_DIR}`);
+            return;
+        }
+        const result = await syncPrompts(prompts, {
+            cwd: getResolvedCwd(flags),
+            outDir: getStringFlag(flags, "out") || DEFAULT_PROMPTS_GPT_OUT_DIR,
+            overwrite: Boolean(flags.overwrite),
+            agent: getStringFlag(flags, "agent") || "all",
+        });
+        console.log(`Synced ${result.markdown.written.length} new prompt file(s) to ${result.markdown.outDir}.`);
+        if (result.markdown.skipped.length) {
+            console.log(`Kept ${result.markdown.skipped.length} existing file(s) unchanged. Use --overwrite to replace.`);
+        }
+        console.log(`Synced ${result.agents.written.length} agent file(s): ${result.agents.targets.join(", ")}.`);
+        console.log(`Manifest: ${result.manifest.manifestPath}`);
+        const syncCwd = getResolvedCwd(flags);
+        try {
+            const syncedModels = await client.fetchModels();
+            if (Object.keys(syncedModels).length > 0) {
+                const { writeFile: fsWrite, mkdir: fsMkdir } = await import("node:fs/promises");
+                const modelsDir = path.resolve(syncCwd, DEFAULT_PROMPTS_GPT_OUT_DIR);
+                await fsMkdir(modelsDir, { recursive: true });
+                const modelsRegistry = {};
+                for (const [p, ml] of Object.entries(syncedModels)) {
+                    modelsRegistry[p] = { models: ml, syncedAt: new Date().toISOString() };
+                }
+                await fsWrite(path.resolve(modelsDir, ".models.json"), JSON.stringify(modelsRegistry, null, 2) + "\n");
+                console.log(`Synced model registry (${Object.keys(syncedModels).length} providers).`);
+            }
+        }
+        catch { /* model sync is best-effort */ }
+        const postSyncAssets = await discoverWorkspaceAssets(syncCwd);
+        if (postSyncAssets.sweeps.length > 0) {
+            console.log(`Sweeps: ${postSyncAssets.sweeps.length} sweep file(s) available.`);
+        }
+        const postProviders = await detectProviders(syncCwd);
+        const postAvailable = postProviders.filter((p) => p.available);
+        if (postAvailable.length > 0 && postSyncAssets.prompts.length > 0) {
+            console.log("");
+            console.log("Next steps:");
+            console.log(`  prompts-gpt run --prompt-file .prompts-gpt/${postSyncAssets.prompts[0].file}`);
+            if (postSyncAssets.sweeps.length > 0) {
+                console.log(`  prompts-gpt sweep --prompt-file ${postSyncAssets.sweeps[0].file}`);
+            }
+        }
+        return;
+    }
+    if (command === "project") {
+        const clientOptions = await resolveClientOptions(command, flags);
+        const client = new PromptsGptClient(clientOptions);
+        const project = await client.getProject();
+        const apiUrl = clientOptions.apiUrl;
+        if (Boolean(flags.json)) {
+            console.log(JSON.stringify({
+                project,
+                apiUrl,
+            }, null, 2));
+            return;
+        }
+        console.log(`Project: ${project.brandName}`);
+        console.log(`Website: ${project.websiteUrl}`);
+        console.log(`Industry: ${project.industryCategory}`);
+        console.log(`Language: ${project.targetLanguage}`);
+        console.log(`Countries: ${formatList(project.targetCountries)}`);
+        console.log(`Aliases: ${formatList(project.brandAliases)}`);
+        console.log(`Keywords: ${formatList(project.productKeywords)}`);
+        console.log(`Personas: ${formatList(project.targetPersonas)}`);
+        console.log(`Competitors: ${formatCompetitors(project.competitors)}`);
+        console.log(`API URL: ${apiUrl}`);
+        if (isTTYInteractive()) {
+            console.log("");
+            const syncNow = await interactiveInput("Sync prompts from this project? [Y/n]", "Y");
+            if (syncNow.toLowerCase() !== "n" && syncNow.toLowerCase() !== "no") {
+                console.log("\nSyncing...");
+                const { spawnSync: spSync } = await import("node:child_process");
+                const cliEntry = process.argv[1] || require.resolve("./cli.js");
+                const projCwd = getResolvedCwd(flags);
+                const syncResult = spSync(process.execPath, [cliEntry, "sync", "--cwd", projCwd], { stdio: "inherit", cwd: projCwd });
+                process.exitCode = syncResult.status ?? 1;
+            }
+        }
+        return;
+    }
+}
+async function createClientForCommand(command, flags) {
+    return new PromptsGptClient(await resolveClientOptions(command, flags));
+}
+async function resolveClientOptions(command, flags) {
+    const cwd = getResolvedCwd(flags);
+    const explicitToken = await resolveTokenInput(flags, { command });
+    const explicitApiUrl = getStringFlag(flags, "api-url");
+    const credentialsPath = path.resolve(cwd, DEFAULT_PROMPTS_GPT_OUT_DIR, PROMPTS_GPT_CREDENTIALS_FILE);
+    const hasCredentialsFile = existsSync(credentialsPath);
+    const credentials = await loadLocalCredentials(cwd);
+    if (hasCredentialsFile && !credentials && !explicitToken) {
+        throw new CliError(`Could not read local credentials at ${credentialsPath}. Re-run \`prompts-gpt init --token <project-token>\` to replace the file.`, CLI_EXIT_CODES.auth, { helpCommand: command });
+    }
+    const token = explicitToken || credentials?.token || "";
+    if (!token && !process.stdin.isTTY) {
+        // CI fallback — never read process.env in the importable SDK, only in the CLI entrypoint
+        const envToken = process.env.PROMPTS_GPT_TOKEN?.trim();
+        if (envToken) {
+            if (!envToken.startsWith("pgpt_")) {
+                throw new CliError("PROMPTS_GPT_TOKEN env var must start with 'pgpt_'. Check the value.", CLI_EXIT_CODES.auth);
+            }
+            return {
+                token: envToken,
+                apiUrl: explicitApiUrl || credentials?.apiUrl || DEFAULT_PROMPTS_GPT_API_URL,
+                fetch,
+            };
+        }
+    }
+    if (!token) {
+        const cloudCommands = new Set(["sync", "generate", "pull", "load-config", "project", "sync-models"]);
+        const extra = cloudCommands.has(command)
+            ? `\n\nThis command connects to prompts-gpt.com. Set up credentials first:\n  prompts-gpt init --token <project-token>\n  prompts-gpt quickstart`
+            : "";
+        throw new CliError(`Project token is missing. Run \`prompts-gpt init --token <project-token>\` or pass \`--token\`, \`--token-stdin\`, or \`--token-prompt\` for this command.${extra}`, CLI_EXIT_CODES.auth, { helpCommand: command });
+    }
+    return {
+        token,
+        apiUrl: explicitApiUrl || credentials?.apiUrl || DEFAULT_PROMPTS_GPT_API_URL,
+        fetch,
+    };
+}
+function buildPullQuery(flags, limit) {
+    return {
+        q: getStringFlag(flags, "query") || getStringFlag(flags, "q"),
+        category: getStringFlag(flags, "category"),
+        tool: getStringFlag(flags, "tool"),
+        outputType: getStringFlag(flags, "output-type"),
+        limit,
+    };
+}
+function parseCommandFlags(command, argv) {
+    const options = getCommandOptions(command);
+    try {
+        const result = parseArgs({
+            args: argv,
+            options,
+            allowPositionals: false,
+            strict: true,
+        });
+        const values = result.values;
+        validateFlagConflicts(command, values);
+        return values;
+    }
+    catch (error) {
+        throw toCliParseError(error, command);
+    }
+}
+function handleHelpCommand(argv) {
+    try {
+        const { positionals, values } = parseArgs({
+            args: argv,
+            options: { help: { type: "boolean" } },
+            allowPositionals: true,
+            strict: true,
+        });
+        if (values.help) {
+            printHelp();
+            return;
+        }
+        if (positionals.length > 1) {
+            throw new CliError("The `help` command accepts at most one command name.", CLI_EXIT_CODES.usage, {
+                helpCommand: "help",
+            });
+        }
+        if (positionals.length === 0) {
+            printHelp();
+            return;
+        }
+        const topic = asCommandName(positionals[0]);
+        if (!topic) {
+            throw new CliError(`Unknown help topic: ${positionals[0]}.`, CLI_EXIT_CODES.usage, {
+                helpCommand: "help",
+            });
+        }
+        printHelp(topic);
+    }
+    catch (error) {
+        if (error instanceof CliError)
+            throw error;
+        throw toCliParseError(error, "help");
+    }
+}
+function getCommandOptions(command) {
+    const common = {
+        help: { type: "boolean" },
+        token: { type: "string" },
+        "token-stdin": { type: "boolean" },
+        "token-prompt": { type: "boolean" },
+        "api-url": { type: "string" },
+        cwd: { type: "string" },
+    };
+    if (command === "init") {
+        return common;
+    }
+    if (command === "setup") {
+        return {
+            help: { type: "boolean" },
+            cwd: { type: "string" },
+            json: { type: "boolean" },
+            overwrite: { type: "boolean" },
+            "prompt-file": { type: "string" },
+            "prompt-dir": { type: "string" },
+            manifest: { type: "string" },
+            "prompt-files": { type: "string" },
+            agent: { type: "string" },
+            "provider-order": { type: "string" },
+            timeout: { type: "string" },
+            "retry-count": { type: "string" },
+            "artifacts-dir": { type: "string" },
+            "allow-destructive-git": { type: "boolean" },
+            "codex-model": { type: "string" },
+            "cursor-model": { type: "string" },
+            "claude-model": { type: "string" },
+            "copilot-model": { type: "string" },
+        };
+    }
+    if (command === "project") {
+        return {
+            ...common,
+            json: { type: "boolean" },
+        };
+    }
+    if (command === "pull") {
+        return {
+            ...common,
+            query: { type: "string" },
+            q: { type: "string" },
+            category: { type: "string" },
+            tool: { type: "string" },
+            "output-type": { type: "string" },
+            limit: { type: "string" },
+            out: { type: "string" },
+            overwrite: { type: "boolean" },
+        };
+    }
+    if (command === "generate") {
+        return {
+            ...common,
+            goal: { type: "string" },
+            context: { type: "string" },
+            constraints: { type: "string" },
+            "desired-output": { type: "string" },
+            tool: { type: "string" },
+            mode: { type: "string" },
+            "artifact-type": { type: "string" },
+            "web-search": { type: "boolean" },
+            out: { type: "string" },
+            overwrite: { type: "boolean" },
+            agent: { type: "string" },
+            "sync-agents": { type: "boolean" },
+        };
+    }
+    if (command === "sync") {
+        return {
+            ...common,
+            goal: { type: "string" },
+            context: { type: "string" },
+            constraints: { type: "string" },
+            "desired-output": { type: "string" },
+            tool: { type: "string" },
+            mode: { type: "string" },
+            "artifact-type": { type: "string" },
+            "web-search": { type: "boolean" },
+            query: { type: "string" },
+            q: { type: "string" },
+            category: { type: "string" },
+            "output-type": { type: "string" },
+            limit: { type: "string" },
+            out: { type: "string" },
+            overwrite: { type: "boolean" },
+            agent: { type: "string" },
+            "generated-only": { type: "boolean" },
+            "dry-run": { type: "boolean" },
+        };
+    }
+    if (command === "run") {
+        return {
+            help: { type: "boolean" },
+            cwd: { type: "string" },
+            json: { type: "boolean" },
+            "prompt-file": { type: "string", short: "f" },
+            agent: { type: "string" },
+            model: { type: "string" },
+            timeout: { type: "string" },
+            "artifacts-dir": { type: "string" },
+            "run-id": { type: "string" },
+            sandbox: { type: "string" },
+            "no-approve-mcps": { type: "boolean" },
+            background: { type: "boolean" },
+            "permission-mode": { type: "string" },
+            "dry-run": { type: "boolean" },
+            "non-interactive": { type: "boolean" },
+            verbose: { type: "boolean", short: "v" },
+            open: { type: "boolean" },
+            "list-models": { type: "boolean" },
+        };
+    }
+    if (command === "sweep") {
+        return {
+            help: { type: "boolean" },
+            cwd: { type: "string" },
+            json: { type: "boolean" },
+            "prompt-file": { type: "string", short: "f" },
+            agent: { type: "string" },
+            model: { type: "string" },
+            iterations: { type: "string", short: "n" },
+            "iteration-timeout": { type: "string" },
+            "max-retries": { type: "string" },
+            "artifacts-dir": { type: "string" },
+            "run-id": { type: "string" },
+            sandbox: { type: "string" },
+            "no-approve-mcps": { type: "boolean" },
+            phase: { type: "string" },
+            "dry-run": { type: "boolean" },
+            "max-run-dirs": { type: "string" },
+            "summary-lines": { type: "string" },
+            background: { type: "boolean" },
+            "permission-mode": { type: "string" },
+            "non-interactive": { type: "boolean" },
+            verbose: { type: "boolean", short: "v" },
+            open: { type: "boolean" },
+            quiet: { type: "boolean", short: "q" },
+            "list-models": { type: "boolean" },
+        };
+    }
+    if (command === "models") {
+        return {
+            ...common,
+            provider: { type: "string" },
+            agent: { type: "string" },
+            add: { type: "string" },
+            remove: { type: "string" },
+        };
+    }
+    if (command === "sync-models") {
+        return common;
+    }
+    if (command === "run-batch") {
+        return {
+            help: { type: "boolean" },
+            cwd: { type: "string" },
+            json: { type: "boolean" },
+            manifest: { type: "string" },
+            "prompt-files": { type: "string" },
+            agent: { type: "string" },
+            model: { type: "string" },
+            timeout: { type: "string" },
+            "artifacts-dir": { type: "string" },
+            "non-interactive": { type: "boolean" },
+        };
+    }
+    if (command === "load-config") {
+        return {
+            ...common,
+            json: { type: "boolean" },
+            out: { type: "string" },
+            agent: { type: "string" },
+        };
+    }
+    if (command === "quickstart" || command === "list" || command === "status" || command === "validate" || command === "providers" || command === "doctor") {
+        return {
+            help: { type: "boolean" },
+            cwd: { type: "string" },
+            json: { type: "boolean" },
+        };
+    }
+    throw new CliError(`Unsupported command: ${command}.`, CLI_EXIT_CODES.usage, {
+        helpCommand: "help",
+    });
+}
+function toCliParseError(error, command) {
+    const runnableCmd = isRunnableCommand(command) ? command : undefined;
+    const message = normalizeParseErrorMessage(error instanceof Error ? error.message : String(error), runnableCmd);
+    return new CliError(message, CLI_EXIT_CODES.usage, {
+        helpCommand: command,
+    });
+}
+function normalizeParseErrorMessage(message, command) {
+    const trimmed = message.trim();
+    if (trimmed.startsWith("Unknown option")) {
+        const match = trimmed.match(/Unknown option '(--[^']+)'/);
+        const unknownFlag = match?.[1];
+        const base = trimmed.endsWith(".") ? trimmed : `${trimmed}.`;
+        if (unknownFlag && command) {
+            const suggestion = suggestClosestFlag(unknownFlag, command);
+            if (suggestion) {
+                return `${base} Did you mean ${suggestion}?\nRun \`prompts-gpt help ${command}\` to see all available flags.`;
+            }
+        }
+        return `${base}\nRun \`prompts-gpt help ${command ?? ""}\` to see all available flags.`;
+    }
+    return trimmed;
+}
+function suggestClosestFlag(unknown, command) {
+    const options = getCommandOptions(command);
+    const flagName = unknown.replace(/^--/, "");
+    const candidates = Object.keys(options);
+    let best = null;
+    let bestScore = 0;
+    for (const candidate of candidates) {
+        const score = computeFlagSimilarity(flagName, candidate);
+        if (score > bestScore && score >= 0.4) {
+            bestScore = score;
+            best = candidate;
+        }
+    }
+    return best ? `--${best}` : null;
+}
+function computeFlagSimilarity(a, b) {
+    if (a === b)
+        return 1;
+    const shorter = a.length < b.length ? a : b;
+    const longer = a.length < b.length ? b : a;
+    if (longer.startsWith(shorter) || longer.endsWith(shorter))
+        return 0.8;
+    if (longer.includes(shorter) && shorter.length >= 3)
+        return 0.6;
+    if (shorter.length === 0)
+        return 0;
+    let matches = 0;
+    for (let i = 0; i < Math.min(a.length, b.length); i++) {
+        if (a[i] === b[i])
+            matches++;
+    }
+    return matches / Math.max(a.length, b.length);
+}
+function validateFlagConflicts(command, flags) {
+    const tokenSourceCount = [Boolean(flags.token), Boolean(flags["token-stdin"]), Boolean(flags["token-prompt"])].filter(Boolean).length;
+    if (tokenSourceCount > 1) {
+        throw new CliError("Use only one token source: `--token`, `--token-stdin`, or `--token-prompt`.", CLI_EXIT_CODES.usage, {
+            helpCommand: command,
+        });
+    }
+    if (flags.query && flags.q) {
+        throw new CliError("Use either `--query` or `--q`, not both.", CLI_EXIT_CODES.usage, {
+            helpCommand: command,
+        });
+    }
+    const promptSourceCount = [
+        Boolean(flags["prompt-file"]),
+        Boolean(flags["prompt-files"]),
+        Boolean(flags.manifest),
+        Boolean(flags["prompt-dir"]),
+    ].filter(Boolean).length;
+    if (command === "setup" && promptSourceCount > 1) {
+        throw new CliError("Use only one prompt source for `setup`: `--prompt-file`, `--prompt-files`, `--manifest`, or `--prompt-dir`.", CLI_EXIT_CODES.usage, {
+            helpCommand: command,
+        });
+    }
+    if (command === "run-batch" && Boolean(flags["prompt-files"]) && Boolean(flags.manifest)) {
+        throw new CliError("Use either `--prompt-files` or `--manifest`, not both.", CLI_EXIT_CODES.usage, {
+            helpCommand: command,
+        });
+    }
+}
+async function resolveTokenInput(flags, options) {
+    const explicitToken = getStringFlag(flags, "token")?.trim();
+    if (explicitToken) {
+        return explicitToken;
+    }
+    if (flags["token-stdin"]) {
+        const token = await readTokenFromStdin();
+        if (!token) {
+            throw new CliError("No token was received on stdin. Pipe a project token into `--token-stdin`.", CLI_EXIT_CODES.validation, {
+                helpCommand: options.command,
+            });
+        }
+        return token;
+    }
+    if (flags["token-prompt"]) {
+        return readTokenFromPrompt(options.command);
+    }
+    return undefined;
+}
+async function readTokenFromStdin() {
+    if (process.stdin.isTTY) {
+        throw new CliError("`--token-stdin` expects piped input. Use `--token-prompt` for an interactive terminal.", CLI_EXIT_CODES.usage);
+    }
+    const chunks = [];
+    let totalLength = 0;
+    for await (const chunk of process.stdin) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+        totalLength += buffer.length;
+        if (totalLength > MAX_STDIN_TOKEN_LENGTH) {
+            throw new CliError("Token input from stdin is too long.", CLI_EXIT_CODES.validation);
+        }
+        chunks.push(buffer);
+    }
+    const combined = Buffer.concat(chunks);
+    const result = combined.toString("utf8").trim();
+    combined.fill(0);
+    for (const chunk of chunks)
+        chunk.fill(0);
+    return result;
+}
+function readTokenFromPrompt(command) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new CliError("`--token-prompt` requires an interactive terminal. Use `--token-stdin` for CI or piped input.", CLI_EXIT_CODES.usage, {
+            helpCommand: command,
+        });
+    }
+    return new Promise((resolve, reject) => {
+        const stdin = process.stdin;
+        const stdout = process.stdout;
+        const buf = Buffer.alloc(MAX_STDIN_TOKEN_LENGTH);
+        let bufLen = 0;
+        const cleanup = () => {
+            stdin.removeListener("data", onData);
+            process.removeListener("SIGTERM", onSigterm);
+            process.removeListener("SIGINT", onSigint);
+            stdin.setRawMode?.(false);
+            stdin.pause();
+        };
+        const extractAndWipe = () => {
+            const result = buf.toString("utf8", 0, bufLen).trim();
+            buf.fill(0, 0, bufLen);
+            bufLen = 0;
+            return result;
+        };
+        const finish = (callback) => {
+            stdout.write("\n");
+            cleanup();
+            callback();
+        };
+        const onSigterm = () => {
+            buf.fill(0, 0, bufLen);
+            cleanup();
+            process.exit(130);
+        };
+        const onSigint = () => {
+            buf.fill(0, 0, bufLen);
+            cleanup();
+            process.exit(130);
+        };
+        process.on("SIGTERM", onSigterm);
+        process.on("SIGINT", onSigint);
+        const onData = (chunk) => {
+            const value = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+            for (const char of value) {
+                if (char === "\u0003") {
+                    buf.fill(0, 0, bufLen);
+                    finish(() => reject(new CliError("Token entry cancelled.", CLI_EXIT_CODES.general, { helpCommand: command })));
+                    return;
+                }
+                if (char === "\r" || char === "\n") {
+                    const trimmed = extractAndWipe();
+                    if (!trimmed) {
+                        finish(() => reject(new CliError("Project token is required.", CLI_EXIT_CODES.validation, { helpCommand: command })));
+                        return;
+                    }
+                    finish(() => resolve(trimmed));
+                    return;
+                }
+                if (char === "\u007f" || char === "\b") {
+                    if (bufLen > 0) {
+                        bufLen--;
+                        buf[bufLen] = 0;
+                    }
+                    continue;
+                }
+                if (char >= " ") {
+                    const charBytes = Buffer.byteLength(char, "utf8");
+                    if (bufLen + charBytes > MAX_STDIN_TOKEN_LENGTH) {
+                        buf.fill(0, 0, bufLen);
+                        finish(() => reject(new CliError("Token input is too long.", CLI_EXIT_CODES.validation, { helpCommand: command })));
+                        return;
+                    }
+                    buf.write(char, bufLen, "utf8");
+                    bufLen += charBytes;
+                    stdout.write("*");
+                }
+            }
+        };
+        stdout.write("Project token: ");
+        stdin.setEncoding("utf8");
+        try {
+            stdin.setRawMode?.(true);
+        }
+        catch {
+            reject(new CliError("Cannot enable raw mode for token prompt. Use --token-stdin instead.", CLI_EXIT_CODES.usage, { helpCommand: command }));
+            return;
+        }
+        stdin.resume();
+        stdin.on("data", onData);
+    });
+}
+function parseLimitFlag(raw) {
+    if (raw === undefined)
+        return undefined;
+    if (!/^\d+$/.test(raw)) {
+        throw new CliError("`--limit` must be a positive integer between 1 and 100.", CLI_EXIT_CODES.validation);
+    }
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isSafeInteger(value) || value < 1 || value > 100) {
+        throw new CliError("`--limit` must be a positive integer between 1 and 100.", CLI_EXIT_CODES.validation);
+    }
+    return value;
+}
+function validateToolFlag(tool) {
+    if (!tool)
+        return;
+    const validSet = new Set(VALID_TOOLS);
+    if (!validSet.has(tool)) {
+        throw new CliError(`Invalid --tool "${tool}". Valid tools: ${VALID_TOOLS.join(", ")}.`, CLI_EXIT_CODES.validation);
+    }
+}
+function validateAgentFlag(agent) {
+    if (!agent)
+        return;
+    const targets = agent.split(",").map((item) => item.trim().toLowerCase()).filter(Boolean);
+    const validSet = new Set([...SUPPORTED_AGENT_TARGETS, "all"]);
+    const invalid = [...new Set(targets.filter((target) => !validSet.has(target)))];
+    if (invalid.length) {
+        throw new CliError(`Invalid --agent target: ${invalid.join(", ")}. Use ${SUPPORTED_AGENT_TARGETS.join(", ")}, or all.`, CLI_EXIT_CODES.validation);
+    }
+}
+function validateProviderOrderFlag(values) {
+    if (!values?.length)
+        return;
+    const invalid = values.filter((value) => {
+        const raw = value.trim().toLowerCase();
+        const normalized = normalizeOrchestrationAgent(raw);
+        return !raw || normalized === "router";
+    });
+    if (invalid.length > 0) {
+        throw new CliError(`Invalid --provider-order value: ${invalid.join(", ")}. Use codex, cursor, claude, or copilot.`, CLI_EXIT_CODES.validation);
+    }
+}
+function getResolvedCwd(flags) {
+    return path.resolve(getStringFlag(flags, "cwd") || process.cwd());
+}
+function getStringFlag(flags, name) {
+    const value = flags[name];
+    return typeof value === "string" ? value : undefined;
+}
+function formatDuration(ms) {
+    if (ms < 1000)
+        return ms < 1 ? "<1ms" : `${Math.round(ms)}ms`;
+    const totalSeconds = Math.round(ms / 1000);
+    if (totalSeconds === 0)
+        return "<1s";
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    if (hours > 0)
+        return `${hours}h ${minutes}m ${seconds}s`;
+    if (minutes > 0)
+        return `${minutes}m ${seconds}s`;
+    return `${seconds}s`;
+}
+function formatList(values) {
+    if (!Array.isArray(values) || values.length === 0)
+        return "None";
+    return values.join(", ");
+}
+function formatCompetitors(values) {
+    if (!Array.isArray(values) || values.length === 0)
+        return "None";
+    return values.map((competitor) => {
+        const aliases = competitor.aliases?.length ? ` [aliases: ${competitor.aliases.join(", ")}]` : "";
+        return competitor.websiteUrl ? `${competitor.name} (${competitor.websiteUrl})${aliases}` : `${competitor.name}${aliases}`;
+    }).join("; ");
+}
+function mergePromptPacks(prompts) {
+    const deduped = new Map();
+    for (const prompt of prompts) {
+        deduped.set(normalizePromptKey(prompt), prompt);
+    }
+    return [...deduped.values()];
+}
+function normalizePromptKey(prompt) {
+    const raw = String(prompt.slug || prompt.title || "prompt").trim().toLowerCase();
+    const normalized = raw.replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+    return normalized || "prompt";
+}
+function asCommandName(value) {
+    if (!value)
+        return undefined;
+    return COMMANDS.find((command) => command === value);
+}
+function isRunnableCommand(command) {
+    return command !== "help" && command !== "version";
+}
+async function printVersion() {
+    const version = await getCliVersion();
+    const apiUrl = process.env.PROMPTS_GPT_API_URL?.trim() || DEFAULT_PROMPTS_GPT_API_URL;
+    console.log(`prompts-gpt v${version}`);
+    console.log(`  Node:     ${process.version}`);
+    console.log(`  Platform: ${process.platform}/${process.arch}`);
+    console.log(`  API:      ${apiUrl}`);
+}
+async function getCliVersion() {
+    try {
+        const { readFile } = await import("node:fs/promises");
+        const pkg = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+        return pkg.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+function printHelp(command) {
+    if (command) {
+        console.log(getCommandHelp(command));
+        return;
+    }
+    console.log(`Prompts-GPT CLI
+
+Usage:
+  prompts-gpt <command> [options]
+  prompts-gpt help [command]
+  prompts-gpt version
+
+Setup:
+  quickstart      Interactive setup — credentials, config, and first run
+  init            Save a project token
+  setup           Scaffold local orchestration config
+  status          Show workspace readiness and next steps
+  doctor          Validate prerequisites and config
+
+Sync & Generate:
+  sync            Pull prompt packs and sync agent files
+  pull            Download prompt packs as Markdown files
+  generate        Generate a prompt pack from a goal
+  load-config     Pull config and prompts from Prompts Studio
+
+Run:
+  run             Execute one prompt with a local agent (-f <file>)
+  run-batch       Execute multiple prompts
+  sweep           Multi-iteration execution (-f <file> -n <count>)
+
+Inspect:
+  list            Show prompts, sweeps, and agent integrations
+  validate        Check config for errors
+  providers       Show detected provider CLIs
+  models          List/add/remove models per provider
+  sync-models     Sync model registry from prompts-gpt.com
+  project         Show project linked to the token
+
+Global options:
+  --help          Show help
+  --version       Show the current CLI version
+  --quiet         Suppress live tool/message logs during sweep
+  --list-models   List available models for the selected provider
+  --json          Output structured JSON (for run, sweep, list, etc.)
+
+Environment variables:
+  PROMPTS_GPT_TOKEN         Project token (overrides stored credentials)
+  PROMPTS_GPT_API_URL       API URL (default: https://prompts-gpt.com)
+  PROMPTS_GPT_MODEL         Global model override (applied to all providers)
+  PROMPTS_GPT_NON_INTERACTIVE=1  Disable interactive prompts
+  NO_COLOR=1                Disable colored output
+
+Providers: ${ORCHESTRATION_AGENT_PROFILES.filter((p) => p !== "router").join(", ")} (or router for auto-select)
+Agent targets: ${SUPPORTED_AGENT_TARGETS.join(", ")}
+`);
+}
+function parsePositiveIntFlag(raw, flagName) {
+    if (raw === undefined)
+        return undefined;
+    const label = flagName ? `--${flagName}` : "Value";
+    if (!/^\d+$/.test(raw)) {
+        throw new CliError(`${label} must be a positive integer, got "${raw}".`, CLI_EXIT_CODES.validation);
+    }
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isSafeInteger(value) || value < 1) {
+        throw new CliError(`${label} must be a positive integer, got "${raw}".`, CLI_EXIT_CODES.validation);
+    }
+    return value;
+}
+function parseNonNegativeIntFlag(raw, flagName) {
+    if (raw === undefined)
+        return undefined;
+    const label = flagName ? `--${flagName}` : "Value";
+    if (!/^\d+$/.test(raw)) {
+        throw new CliError(`${label} must be a non-negative integer, got "${raw}".`, CLI_EXIT_CODES.validation);
+    }
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new CliError(`${label} must be a non-negative integer, got "${raw}".`, CLI_EXIT_CODES.validation);
+    }
+    return value;
+}
+async function getLastUsedProvider(cwd) {
+    try {
+        const { readFile: fsRead } = await import("node:fs/promises");
+        const data = JSON.parse(await fsRead(path.resolve(cwd, DEFAULT_PROMPTS_GPT_OUT_DIR, ".last-provider"), "utf8"));
+        return data.provider ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+async function saveLastUsedProvider(cwd, provider) {
+    try {
+        const { writeFile: fsWrite, mkdir: fsMkdir } = await import("node:fs/promises");
+        const dir = path.resolve(cwd, DEFAULT_PROMPTS_GPT_OUT_DIR);
+        await fsMkdir(dir, { recursive: true });
+        await fsWrite(path.resolve(dir, ".last-provider"), JSON.stringify({ provider, updatedAt: new Date().toISOString() }));
+    }
+    catch { /* ignore */ }
+}
+async function getLastUsedModel(cwd, provider) {
+    try {
+        const { readFile: fsRead } = await import("node:fs/promises");
+        const data = JSON.parse(await fsRead(path.resolve(cwd, DEFAULT_PROMPTS_GPT_OUT_DIR, ".last-models"), "utf8"));
+        return data[provider] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+async function saveLastUsedModel(cwd, provider, model) {
+    try {
+        const { readFile: fsRead, writeFile: fsWrite, mkdir: fsMkdir, rename } = await import("node:fs/promises");
+        const dir = path.resolve(cwd, DEFAULT_PROMPTS_GPT_OUT_DIR);
+        await fsMkdir(dir, { recursive: true });
+        const filePath = path.resolve(dir, ".last-models");
+        let existing = {};
+        try {
+            existing = JSON.parse(await fsRead(filePath, "utf8"));
+        }
+        catch { /* new file */ }
+        existing[provider] = model;
+        const tmpPath = `${filePath}.tmp.${process.pid}`;
+        await fsWrite(tmpPath, JSON.stringify(existing, null, 2));
+        await rename(tmpPath, filePath);
+    }
+    catch { /* ignore */ }
+}
+const PROVIDER_MODELS = Object.freeze({
+    codex: [
+        { value: "gpt-5.5", label: "gpt-5.5 — frontier coding & reasoning", tier: "frontier" },
+        { value: "gpt-5.5-pro", label: "gpt-5.5-pro — smarter, more precise", tier: "frontier" },
+        { value: "gpt-5.4", label: "gpt-5.4 — strong coding model", tier: "standard" },
+        { value: "gpt-5.4-pro", label: "gpt-5.4-pro — enhanced responses", tier: "standard" },
+        { value: "gpt-5.4-mini", label: "gpt-5.4-mini — fast coding & subagents", tier: "fast" },
+        { value: "gpt-5.4-nano", label: "gpt-5.4-nano — cheapest high-volume", tier: "budget" },
+        { value: "gpt-5.3-codex", label: "gpt-5.3-codex — previous gen codex", tier: "standard" },
+        { value: "gpt-5.3-codex-spark", label: "gpt-5.3-codex-spark — 15x faster gen", tier: "fast" },
+        { value: "o4-mini", label: "o4-mini — fast reasoning", tier: "fast" },
+        { value: "o3", label: "o3 — advanced reasoning", tier: "frontier" },
+        { value: "gpt-5.1-codex", label: "gpt-5.1-codex — legacy codex", tier: "budget" },
+        { value: "gpt-4.1", label: "gpt-4.1 — legacy", tier: "budget" },
+    ],
+    claude: [
+        { value: "claude-opus-4-7", label: "claude-opus-4-7 — most capable, complex reasoning", tier: "frontier" },
+        { value: "claude-sonnet-4-6", label: "claude-sonnet-4-6 — speed + intelligence", tier: "standard" },
+        { value: "claude-haiku-4-5", label: "claude-haiku-4-5 — fastest near-frontier", tier: "fast" },
+        { value: "claude-4.6-opus-high", label: "claude-4.6-opus-high — high-thinking opus", tier: "frontier" },
+        { value: "claude-4.6-sonnet-high", label: "claude-4.6-sonnet-high — high-thinking sonnet", tier: "standard" },
+        { value: "claude-4.5-opus", label: "claude-4.5-opus — previous gen opus", tier: "standard" },
+    ],
+    cursor: [
+        { value: "auto", label: "auto — Cursor auto-selects best", tier: "standard" },
+        { value: "claude-4.6-opus-high", label: "claude-4.6-opus-high — frontier reasoning", tier: "frontier" },
+        { value: "claude-4.6-sonnet-high", label: "claude-4.6-sonnet-high — fast + smart", tier: "standard" },
+        { value: "gpt-5.5-medium", label: "gpt-5.5-medium — GPT frontier", tier: "frontier" },
+        { value: "composer-2", label: "composer-2 — balanced multi-file", tier: "standard" },
+        { value: "composer-2-fast", label: "composer-2-fast — speed optimized", tier: "fast" },
+        { value: "gpt-5.3-codex", label: "gpt-5.3-codex — OpenAI codex", tier: "standard" },
+        { value: "gpt-5.4-mini", label: "gpt-5.4-mini — fast & affordable", tier: "fast" },
+        { value: "gemini-3.1-pro", label: "gemini-3.1-pro — Google frontier", tier: "standard" },
+        { value: "claude-4.5-opus", label: "claude-4.5-opus — previous gen opus", tier: "standard" },
+    ],
+    copilot: [
+        { value: "auto", label: "auto — Copilot auto-selects", tier: "standard" },
+        { value: "gpt-5.5", label: "gpt-5.5 — frontier", tier: "frontier" },
+        { value: "gpt-5.4-mini", label: "gpt-5.4-mini — fast", tier: "fast" },
+        { value: "claude-sonnet-4-6", label: "claude-sonnet-4-6 — Anthropic", tier: "standard" },
+        { value: "claude-opus-4-7", label: "claude-opus-4-7 — Anthropic frontier", tier: "frontier" },
+    ],
+});
+const MODEL_ALIASES = {
+    opus: "claude-4.6-opus-high",
+    sonnet: "claude-sonnet-4-6",
+    haiku: "claude-haiku-4-5",
+    codex: "gpt-5.3-codex",
+    gpt: "gpt-5.5",
+    mini: "gpt-5.4-mini",
+    nano: "gpt-5.4-nano",
+    composer: "composer-2",
+    fast: "composer-2-fast",
+    gemini: "gemini-3.1-pro",
+};
+function resolveModelAlias(model) {
+    return MODEL_ALIASES[model.toLowerCase().trim()] ?? model;
+}
+function validateModelForProvider(model, provider) {
+    const providerModels = PROVIDER_MODELS[provider] ?? [];
+    const known = providerModels.map((m) => m.value);
+    if (known.length === 0)
+        return { valid: true, suggestion: "" };
+    const resolved = resolveModelAlias(model);
+    if (known.includes(resolved))
+        return { valid: true, suggestion: "" };
+    const close = known.find((k) => k.startsWith(resolved.slice(0, 5)));
+    return { valid: false, suggestion: close ?? known[0] ?? "" };
+}
+function getModelChoicesForProvider(provider, config) {
+    const builtIn = PROVIDER_MODELS[provider] ?? [];
+    const unicode = supportsColor();
+    const choices = builtIn.map((m) => {
+        const tierBadge = m.tier === "frontier"
+            ? (unicode ? " ⭐" : " [F]")
+            : m.tier === "budget" ? (unicode ? " 💰" : " [$]") : m.tier === "fast" ? (unicode ? " ⚡" : " [>]") : "";
+        return { label: `${m.label}${tierBadge}`, value: m.value };
+    });
+    const customList = config.customModels?.[provider] ?? [];
+    for (const cm of customList) {
+        if (!choices.some((c) => c.value === cm)) {
+            choices.push({ label: `${cm} (custom)`, value: cm });
+        }
+    }
+    const cachedModels = loadCachedModelRegistry(provider);
+    for (const cm of cachedModels) {
+        if (!choices.some((c) => c.value === cm)) {
+            choices.push({ label: `${cm} (synced)`, value: cm });
+        }
+    }
+    const override = config.modelOverrides[provider]?.trim();
+    if (override && !choices.some((c) => c.value === override)) {
+        choices.unshift({ label: `${override} (configured)`, value: override });
+    }
+    choices.push({ label: "Enter custom model...", value: "__custom__" });
+    return choices;
+}
+function loadCachedModelRegistry(provider, cwd) {
+    try {
+        const base = cwd ?? process.cwd();
+        const modelsPath = path.resolve(base, DEFAULT_PROMPTS_GPT_OUT_DIR, ".models.json");
+        if (!existsSync(modelsPath))
+            return [];
+        const data = JSON.parse(readFileSync(modelsPath, "utf8"));
+        return data[provider]?.models ?? [];
+    }
+    catch {
+        return [];
+    }
+}
+function resolveRunAgent(flags, fallback) {
+    const raw = getStringFlag(flags, "agent");
+    if (!raw)
+        return fallback;
+    const sanitized = raw.replace(/[;&|`$(){}!<>]/g, "").trim();
+    const normalizedRaw = sanitized.toLowerCase();
+    const normalized = normalizeOrchestrationAgent(sanitized);
+    if (normalized === "router" && normalizedRaw !== "router") {
+        const profiles = ORCHESTRATION_AGENT_PROFILES.join(", ");
+        const hint = ORCHESTRATION_AGENT_PROFILES.find((p) => p.startsWith(normalizedRaw.slice(0, 3)));
+        const suggestion = hint ? ` Did you mean "${hint}"?` : "";
+        throw new CliError(`Invalid --agent target: ${sanitized}. Use ${profiles}.${suggestion}`, CLI_EXIT_CODES.validation);
+    }
+    return normalized;
+}
+function getCommandHelp(command) {
+    if (command === "init") {
+        return `prompts-gpt init
+
+Usage:
+  prompts-gpt init [--token <project-token> | --token-stdin | --token-prompt] [--api-url <url>] [--cwd <path>]
+
+Why use it:
+  Stores a project token locally so you don't have to pass it on every command.
+  If run without flags in an interactive terminal, it will prompt for the token.
+
+Options:
+  --token <token>       Project API token. Must start with pgpt_.
+  --token-stdin         Read the project token from stdin (for CI/CD pipelines).
+  --token-prompt        Prompt for the project token without echoing it.
+  --api-url <url>       Custom API base URL for self-hosted instances.
+  --cwd <path>          Target project directory.
+  --help                Show this command help.
+
+Examples:
+  prompts-gpt init                                  # interactive prompt
+  prompts-gpt init --token pgpt_abc123              # direct token
+  printf '%s' "$TOKEN" | prompts-gpt init --token-stdin  # CI/CD
+`;
+    }
+    if (command === "setup") {
+        return `prompts-gpt setup
+
+Usage:
+  prompts-gpt setup [--prompt-file <path> | --prompt-files <a,b,c> | --manifest <path> | --prompt-dir <path>] [--agent codex|cursor|claude|copilot|router] [--provider-order <a,b,c>] [--timeout <seconds>] [--retry-count <n>] [--artifacts-dir <path>] [--codex-model <name>] [--cursor-model <name>] [--claude-model <name>] [--copilot-model <name>] [--allow-destructive-git] [--overwrite] [--json] [--cwd <path>]
+
+Why use it:
+  Scaffolds a generic local orchestration config so a repo can run prompts through Codex, Cursor, Claude Code, or Copilot with minimal repeated CLI flags.
+
+Options:
+  --prompt-file <path>      Default single prompt file for \`prompts-gpt run\`.
+  --prompt-files <list>     Default batch prompt files for \`prompts-gpt run-batch\`.
+  --manifest <path>         Use this manifest as the batch source. Default: auto-detect .prompts-gpt/manifest.json
+  --prompt-dir <path>       Scan a prompt directory when you do not use .prompts-gpt.
+  --agent <name>            Default orchestration profile. Default: router
+  --provider-order <list>   Comma-separated router order such as codex,cursor,claude,copilot
+  --timeout <seconds>       Default timeout in seconds. Default: 900
+  --retry-count <n>         Retry count for spawn and timeout failures. Default: 0
+  --artifacts-dir <path>    Run artifact directory. Default: .scripts/runs
+  --codex-model <name>      Default model override for codex.
+  --cursor-model <name>     Default model override for cursor.
+  --claude-model <name>     Default model override for claude.
+  --copilot-model <name>    Default model override for copilot.
+  --allow-destructive-git   Write config with destructive git protection disabled.
+  --overwrite               Replace an existing config file.
+  --json                    Print the generated config payload as JSON.
+  --cwd <path>              Project directory.
+  --help                    Show this command help.
+`;
+    }
+    if (command === "project") {
+        return `prompts-gpt project
+
+Usage:
+  prompts-gpt project [--json] [--token <project-token> | --token-stdin | --token-prompt] [--api-url <url>] [--cwd <path>]
+
+Why use it:
+  Verifies that the current local token resolves to the expected Prompts-GPT project before syncing files.
+
+Options:
+  --json                Print the full project payload as JSON.
+  --token <token>       Override the saved local token for this command only.
+  --token-stdin         Read the override token from stdin for this command only.
+  --token-prompt        Prompt for the override token without echoing it.
+  --api-url <url>       Override the saved API base URL for this command only.
+  --cwd <path>          Project directory to inspect for local credentials.
+  --help                Show this command help.
+`;
+    }
+    if (command === "pull") {
+        return `prompts-gpt pull
+
+Usage:
+  prompts-gpt pull [--query <text> | --q <text>] [--category <name>] [--tool <name>] [--output-type <name>] [--limit <n>] [--out <dir>] [--overwrite] [--token <project-token> | --token-stdin | --token-prompt] [--api-url <url>] [--cwd <path>]
+
+Why use it:
+  Pulls prompt packs into local Markdown files so teams can review and use the same prompt assets inside their repository.
+
+Data privacy:
+  Downloads prompts from your prompts-gpt.com project library.
+  No local files or repo content are uploaded.
+
+Options:
+  --query <text>        Search query for the project prompt library.
+  --q <text>            Short alias for --query.
+  --category <name>     Filter prompts by category.
+  --tool <name>         Filter prompts by supported tool.
+  --output-type <name>  Filter prompts by output type.
+  --limit <n>           Positive integer limit for returned prompts.
+  --out <dir>           Output directory inside the current project. Default: .prompts-gpt
+  --overwrite           Replace existing Markdown files instead of skipping them.
+  --token <token>       Override the saved local token for this command only.
+  --token-stdin         Read the override token from stdin for this command only.
+  --token-prompt        Prompt for the override token without echoing it.
+  --api-url <url>       Override the saved API base URL for this command only.
+  --cwd <path>          Project directory to inspect for local credentials and output files.
+  --help                Show this command help.
+`;
+    }
+    if (command === "generate") {
+        return `prompts-gpt generate
+
+Usage:
+  prompts-gpt generate --goal <text> [--context <text>] [--constraints <text>] [--desired-output <text>] [--tool <name>] [--mode <name>] [--artifact-type <name>] [--web-search] [--out <dir>] [--overwrite] [--agent <targets>] [--sync-agents] [--token <project-token> | --token-stdin | --token-prompt] [--api-url <url>] [--cwd <path>]
+
+Why use it:
+  Creates a new reusable prompt pack from a concrete developer goal, then optionally installs agent-readable files immediately.
+
+Data privacy:
+  The text you pass via --goal, --context, and --constraints is sent to prompts-gpt.com
+  for AI-powered prompt generation. No local files or repo content are uploaded.
+  Do not include PII, secrets, or confidential data in these flags.
+
+Options:
+  --goal <text>            Required. The task to generate a prompt pack for.
+  --context <text>         Extra project or stack context for the generator.
+  --constraints <text>     Constraints that the generated prompt must honor.
+  --desired-output <text>  Preferred output shape for the generated prompt pack.
+  --tool <name>            Target tool. Default: Codex
+  --mode <name>            Prompt generation mode. Default: implement
+  --artifact-type <name>   Artifact type. Default: prompt-file
+  --web-search             Allow server-side web research when generating the prompt.
+  --out <dir>              Output directory inside the current project. Default: .prompts-gpt
+  --overwrite              Replace an existing generated Markdown file.
+  --agent <targets>        Sync agent files for specific targets after generation.
+                           When set, also writes agent-specific files (AGENTS.md, .cursor/rules, etc.).
+  --sync-agents            Sync all agent files after generation (same as --agent all).
+  --token <token>          Override the saved local token for this command only.
+  --token-stdin            Read the override token from stdin for this command only.
+  --token-prompt           Prompt for the override token without echoing it.
+  --api-url <url>          Override the saved API base URL for this command only.
+  --cwd <path>             Project directory to inspect for local credentials and output files.
+  --help                   Show this command help.
+
+Examples:
+  prompts-gpt generate --goal "Review PRs for security issues"
+  prompts-gpt generate --goal "Write unit tests" --sync-agents
+  prompts-gpt generate --goal "Add error handling" --agent cursor,codex
+`;
+    }
+    if (command === "sync") {
+        return `prompts-gpt sync
+
+Usage:
+  prompts-gpt sync [--goal <text>] [--generated-only] [--query <text> | --q <text>] [--category <name>] [--tool <name>] [--output-type <name>] [--limit <n>] [--context <text>] [--constraints <text>] [--desired-output <text>] [--mode <name>] [--artifact-type <name>] [--web-search] [--agent <targets>] [--out <dir>] [--overwrite] [--dry-run] [--token <project-token> | --token-stdin | --token-prompt] [--api-url <url>] [--cwd <path>]
+
+Why use it:
+  Gives teams a one-command path to refresh Markdown prompts, agent files, and the local manifest from the same source of truth.
+
+Data privacy:
+  Prompts are downloaded from your prompts-gpt.com project library.
+  When --goal is used, the text you pass is sent to prompts-gpt.com for AI generation.
+  No local files or repo content are uploaded — only explicit flag values are transmitted.
+  Do not include PII, secrets, or confidential data in --goal, --context, or --constraints.
+  Use --dry-run to preview what would be synced without sending or writing anything.
+
+Options:
+  --goal <text>            Generate one prompt pack before syncing.
+  --generated-only         Skip library pull and sync only the generated prompt pack from --goal.
+  --query <text>           Search query for pulled prompt packs.
+  --q <text>               Short alias for --query.
+  --category <name>        Filter pulled prompt packs by category.
+  --tool <name>            Filter pulled prompt packs and generated output by tool.
+  --output-type <name>     Filter pulled prompt packs by output type.
+  --limit <n>              Positive integer limit for pulled prompt packs.
+  --context <text>         Extra project or stack context for generated prompt packs.
+  --constraints <text>     Constraints for generated prompt packs.
+  --desired-output <text>  Preferred output shape for generated prompt packs.
+  --mode <name>            Prompt generation mode. Default: implement
+  --artifact-type <name>   Artifact type. Default: prompt-file
+  --web-search             Allow server-side web research when generating a prompt pack.
+  --agent <targets>        Comma-separated agent targets. Default: all
+  --out <dir>              Output directory inside the current project. Default: .prompts-gpt
+  --overwrite              Replace existing Markdown files instead of skipping them.
+  --dry-run                Preview what would be synced without writing any files.
+  --token <token>          Override the saved local token for this command only.
+  --token-stdin            Read the override token from stdin for this command only.
+  --token-prompt           Prompt for the override token without echoing it.
+  --api-url <url>          Override the saved API base URL for this command only.
+  --cwd <path>             Project directory to inspect for local credentials and output files.
+  --help                   Show this command help.
+
+Examples:
+  prompts-gpt sync                                      # pull all prompts + sync agent files
+  prompts-gpt sync --goal "Add error handling"           # generate + pull + sync
+  prompts-gpt sync --dry-run                             # preview without writing
+  prompts-gpt sync --agent cursor,codex                  # sync only specific agents
+`;
+    }
+    if (command === "run") {
+        return `prompts-gpt run
+
+Usage:
+  prompts-gpt run [-f <path>] [--agent <name>] [--model <name>] [--timeout <seconds>] [--dry-run]
+
+Why use it:
+  Executes one local prompt file with the built-in provider adapter runtime and writes run artifacts.
+  If \`--prompt-file\` is omitted and only one prompt exists locally, it is auto-selected.
+
+Options:
+  -f, --prompt-file <path>   Optional explicit prompt Markdown or text file.
+  --agent <name>             Orchestration profile. Default from ${DEFAULT_RUN_CONFIG_PATH} or router.
+  --model <name>             Optional model override for the selected provider.
+  --timeout <seconds>        Execution timeout in seconds.
+  --artifacts-dir <path>     Override run artifacts directory.
+  --run-id <id>              Explicit run ID for artifact folder naming.
+  --sandbox <mode>           Codex sandbox mode. Default: workspace-write.
+  --no-approve-mcps          Disable Cursor MCP auto-approval flag.
+  --background               Run as a background agent (Cursor cloud agent mode).
+  --permission-mode <mode>   Claude Code permission mode. Default: acceptEdits.
+  --dry-run                  Preview the execution parameters without actually running.
+  --non-interactive          Skip all interactive prompts (same as CI mode).
+  --json                     Print machine-readable JSON output.
+  --cwd <path>               Project directory.
+  --help                     Show this command help.
+`;
+    }
+    if (command === "run-batch") {
+        return `prompts-gpt run-batch
+
+Usage:
+  prompts-gpt run-batch [--manifest <path> | --prompt-files <a,b,c>] [--agent <name>] [--model <name>] [--timeout <seconds>]
+
+Why use it:
+  Executes multiple prompt files in sequence using the configured prompt source, a manifest, or an explicit file list.
+
+Options:
+  --manifest <path>      Prompt manifest path. Overrides config batch defaults.
+  --prompt-files <list>  Comma-separated prompt files to run.
+  --agent <name>         Orchestration profile. Default from ${DEFAULT_RUN_CONFIG_PATH} or router.
+  --model <name>         Optional model override for all runs.
+  --timeout <seconds>    Execution timeout in seconds per prompt.
+  --artifacts-dir <path> Override run artifacts directory.
+  --json                 Print machine-readable JSON output.
+  --cwd <path>           Project directory.
+  --help                 Show this command help.
+
+Examples:
+  prompts-gpt run-batch --manifest .prompts-gpt/manifest.json
+  prompts-gpt run-batch --prompt-files .prompts-gpt/review.md,.prompts-gpt/tests.md
+`;
+    }
+    if (command === "sweep") {
+        return `prompts-gpt sweep
+
+Usage:
+  prompts-gpt sweep [-f <path>] [-n <count>] [--agent <name>] [--model <name>] [--dry-run]
+
+Why use it:
+  Runs the same prompt N times, feeding each iteration's summary into the next.
+  Includes pre-flight checks, safety guards, SIGTERM handling, and progress monitoring.
+
+  When --prompt-file is omitted and only one .prompts-gpt/sweeps/*.md file exists,
+  it is auto-selected. The iteration count defaults to the \`iterations:\` value
+  in the sweep file's YAML frontmatter (or 1 if not specified).
+
+Options:
+  -f, --prompt-file <path>     Prompt file to sweep. Auto-detects local sweeps if omitted.
+  -n, --iterations <n>         Number of iterations. Default: from frontmatter or 1.
+  --agent <name>               Orchestration profile. Default from config or router.
+  --model <name>               Model override for the selected provider.
+  --iteration-timeout <secs>   Timeout per iteration in seconds. Default: 5400 (90 min)
+  --max-retries <n>            Max retries per iteration on spawn/timeout. Default: 2
+  --phase <name>               Optional phase label injected into the prompt.
+  --artifacts-dir <path>       Override run artifacts directory.
+  --run-id <id>                Explicit run ID for artifact folder naming.
+  --sandbox <mode>             Codex sandbox mode. Default: workspace-write
+  --no-approve-mcps            Disable Cursor MCP auto-approval flag.
+  --background                 Run as a background agent (Cursor cloud agent mode).
+  --permission-mode <mode>     Claude Code permission mode. Default: acceptEdits
+  --max-run-dirs <n>           Max artifact directories to keep. Default: 20
+  --summary-lines <n>          Lines of summary to extract per iteration. Default: 40
+  --dry-run                    Preview what the sweep would do without executing.
+  --quiet, -q                  Suppress live tool/message logs (keep iteration headers).
+  --list-models                List available models for the selected provider.
+  --non-interactive            Skip all interactive prompts (same as CI mode).
+  --json                       Print machine-readable JSON output.
+  --cwd <path>                 Project directory.
+  --help                       Show this command help.
+
+Environment:
+  PROMPTS_GPT_TOKEN              Override project token.
+  PROMPTS_GPT_MODEL              Global model override.
+  PROMPTS_GPT_NON_INTERACTIVE=1  Skip interactive prompts.
+  NO_COLOR=1                     Disable colored output.
+
+Model aliases: ${Object.entries(MODEL_ALIASES).map(([k, v]) => `${k} → ${v}`).join(", ")}
+
+Examples:
+  prompts-gpt sweep                                               # interactive picker
+  prompts-gpt sweep -f .prompts-gpt/sweeps/sdk-hardening.md       # explicit file
+  prompts-gpt sweep -f .prompts-gpt/sweeps/design.md -n 5         # 5 iterations
+  prompts-gpt sweep --model opus                                  # use model alias
+  prompts-gpt sweep --quiet                                       # suppress live logs
+  prompts-gpt sweep --list-models --agent codex                   # see codex models
+  prompts-gpt sweep --dry-run                                     # preview without running
+  prompts-gpt sweep --non-interactive                              # skip interactive prompts
+`;
+    }
+    if (command === "list") {
+        return `prompts-gpt list
+
+Usage:
+  prompts-gpt list [--json] [--cwd <path>]
+
+Why use it:
+  Shows all prompt packs, sweep files, and agent integrations available in the workspace.
+  Gives runnable commands for each entry so you can copy-paste them directly.
+
+Options:
+  --json                Print as JSON.
+  --cwd <path>          Project directory.
+  --help                Show this command help.
+`;
+    }
+    if (command === "status") {
+        return `prompts-gpt status
+
+Usage:
+  prompts-gpt status [--json] [--cwd <path>]
+
+Why use it:
+  Shows workspace readiness at a glance: credentials, config, manifest,
+  prompts, sweeps, agent integrations, and available providers.
+
+Options:
+  --json                Print as JSON.
+  --cwd <path>          Project directory.
+  --help                Show this command help.
+`;
+    }
+    if (command === "validate") {
+        return `prompts-gpt validate
+
+Usage:
+  prompts-gpt validate [--json] [--cwd <path>]
+
+Why use it:
+  Validates the .prompts-gpt/config.json file and reports errors and
+  warnings without running any commands.
+
+Options:
+  --json                Print as JSON.
+  --cwd <path>          Project directory.
+  --help                Show this command help.
+`;
+    }
+    if (command === "providers") {
+        return `prompts-gpt providers
+
+Usage:
+  prompts-gpt providers [--json] [--cwd <path>]
+
+Why use it:
+  Shows provider CLI detection details for codex, cursor, claude, and copilot so you can decide the best router order before running setup.
+`;
+    }
+    if (command === "models") {
+        return `prompts-gpt models
+
+Usage:
+  prompts-gpt models [--provider <name>] [--add <model>] [--remove <model>] [--json] [--cwd <path>]
+
+Why use it:
+  Lists available models per provider with tier badges (frontier/standard/fast/budget).
+  Add or remove custom models stored in your config. Shows model aliases and synced models.
+
+Examples:
+  prompts-gpt models                                    — list all models
+  prompts-gpt models --provider codex                   — list codex models only
+  prompts-gpt models --provider cursor --add my-model   — add custom model
+  prompts-gpt models --provider codex --remove gpt-4.1  — remove a custom model
+`;
+    }
+    if (command === "sync-models") {
+        return `prompts-gpt sync-models
+
+Usage:
+  prompts-gpt sync-models [--token <project-token>] [--cwd <path>]
+
+Why use it:
+  Fetches the latest model registry from prompts-gpt.com and caches it locally.
+  Models synced from the API appear as "(synced)" in the interactive selector.
+
+Schedule regular syncs with cron:
+  0 6 * * * cd /path/to/project && npx prompts-gpt sync-models
+`;
+    }
+    if (command === "doctor") {
+        return `prompts-gpt doctor
+
+Usage:
+  prompts-gpt doctor [--json] [--cwd <path>]
+
+Why use it:
+  Checks runtime prerequisites, provider availability, prompt-source readiness, and run config health.
+`;
+    }
+    if (command === "load-config") {
+        return `prompts-gpt load-config
+
+Usage:
+  prompts-gpt load-config [--agent <targets>] [--out <dir>] [--json] [--token <project-token> | --token-stdin | --token-prompt] [--api-url <url>] [--cwd <path>]
+
+Why use it:
+  One command to pull all prompts, agent files, and config from Prompts Studio
+  into your local workspace. Replaces the multi-step init + sync + setup flow
+  for users who manage their prompt library in the Prompts Studio web app.
+
+Data privacy:
+  Downloads prompts and project config from your prompts-gpt.com project.
+  No local files or repo content are uploaded.
+
+Options:
+  --agent <targets>       Comma-separated agent targets. Default: all
+  --out <dir>             Output directory. Default: .prompts-gpt
+  --json                  Print machine-readable JSON output.
+  --token <token>         Override saved token.
+  --token-stdin           Read token from stdin.
+  --token-prompt          Prompt for token.
+  --api-url <url>         Override API URL.
+  --cwd <path>            Project directory.
+  --help                  Show this command help.
+`;
+    }
+    if (command === "quickstart") {
+        return `prompts-gpt quickstart
+
+Usage:
+  prompts-gpt quickstart [--json] [--cwd <path>]
+
+Why use it:
+  Walks through setup in one command — checks credentials, creates config, detects providers,
+  and shows runnable commands. The fastest path from install to first run.
+
+Options:
+  --json                Print machine-readable JSON output.
+  --cwd <path>          Project directory.
+  --help                Show this command help.
+`;
+    }
+    if (command === "version") {
+        return `prompts-gpt version
+
+Usage:
+  prompts-gpt version
+
+Why use it:
+  Confirms the installed CLI version when debugging package resolution or publish issues.
+`;
+    }
+    return `prompts-gpt help
+
+Usage:
+  prompts-gpt help [command]
+
+Why use it:
+  Shows focused usage for the exact command you are trying to run so shell users do not have to scan the full command list.
+`;
+}
+// ── Interactive TTY selection helpers ─────────────────────────────────────────
+function supportsColor() {
+    if (process.env.NO_COLOR || process.env.TERM === "dumb")
+        return false;
+    if (process.env.FORCE_COLOR)
+        return true;
+    if (process.platform === "win32") {
+        if (process.env.WT_SESSION || process.env.TERM_PROGRAM || process.env.ConEmuANSI === "ON" || process.env.ANSICON)
+            return true;
+        return Boolean(process.stdout.isTTY && (process.stdout.hasColors?.() ?? false));
+    }
+    return Boolean(process.stdout.isTTY);
+}
+function colorize(text, code) {
+    return supportsColor() ? `${code}${text}\x1b[0m` : text;
+}
+function isTTYInteractive(flags) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return false;
+    if (flags && Boolean(flags["non-interactive"]))
+        return false;
+    if (process.env.CI || process.env.CONTINUOUS_INTEGRATION || process.env.GITHUB_ACTIONS ||
+        process.env.GITLAB_CI || process.env.CIRCLECI || process.env.JENKINS_URL ||
+        process.env.BUILDKITE || process.env.TRAVIS || process.env.TF_BUILD ||
+        process.env.CODEBUILD_BUILD_ID)
+        return false;
+    if (process.env.PROMPTS_GPT_NON_INTERACTIVE === "1" || process.env.PROMPTS_GPT_NON_INTERACTIVE === "true")
+        return false;
+    return true;
+}
+function interactiveSelect(prompt, options) {
+    if (options.length === 0) {
+        return Promise.reject(new CliError("No options available for selection.", CLI_EXIT_CODES.usage));
+    }
+    if (options.length === 1) {
+        return Promise.resolve(options[0].value);
+    }
+    return new Promise((resolve, reject) => {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            reject(new CliError("Interactive selection requires a TTY.", CLI_EXIT_CODES.usage));
+            return;
+        }
+        const stdin = process.stdin;
+        const stdout = process.stdout;
+        let cursor = 0;
+        let escBuf = "";
+        let filterText = "";
+        const termRows = typeof process.stdout.rows === "number" && process.stdout.rows > 0 ? process.stdout.rows : 24;
+        const maxVisible = Math.max(3, Math.min(options.length, termRows - 4));
+        const useUnicode = supportsColor();
+        const pointer = useUnicode ? "❯" : ">";
+        const formatLine = (i, selected) => {
+            const num = i < 9 ? `${i + 1}` : " ";
+            const prefix = selected ? colorize(pointer, "\x1b[36m") : " ";
+            const label = selected ? colorize(options[i].label, "\x1b[1m") : options[i].label;
+            return `  ${prefix} ${num}. ${label}`;
+        };
+        const hints = colorize("  ↑↓ navigate · 1-9 jump · Enter select · type to filter", "\x1b[90m");
+        const writeInitial = () => {
+            stdout.write(`${prompt}\n`);
+            for (let i = 0; i < maxVisible; i++) {
+                stdout.write(`${formatLine(i, i === cursor)}\n`);
+            }
+            if (options.length > maxVisible) {
+                stdout.write(`  ... ${options.length - maxVisible} more (scroll with arrows)\n`);
+            }
+            stdout.write(`${hints}\n`);
+        };
+        const render = () => {
+            const footerLines = 1 + (options.length > maxVisible ? 1 : 0) + 1;
+            const lines = maxVisible + footerLines;
+            if (supportsColor()) {
+                stdout.write(`\x1b[${lines}A\x1b[J`);
+            }
+            else {
+                stdout.write("\n".repeat(2));
+            }
+            const posLabel = options.length > 1 ? ` (${cursor + 1}/${options.length})` : "";
+            const filterLabel = filterText ? colorize(` filter: "${filterText}"`, "\x1b[33m") : "";
+            stdout.write(`${prompt}${posLabel}${filterLabel}\n`);
+            const scrollStart = Math.max(0, Math.min(cursor - Math.floor(maxVisible / 2), options.length - maxVisible));
+            for (let vi = 0; vi < maxVisible; vi++) {
+                const i = scrollStart + vi;
+                stdout.write(`${formatLine(i, i === cursor)}\n`);
+            }
+            if (options.length > maxVisible) {
+                stdout.write(`  ... showing ${scrollStart + 1}-${scrollStart + maxVisible} of ${options.length}\n`);
+            }
+            stdout.write(`${hints}\n`);
+        };
+        writeInitial();
+        stdin.setEncoding("utf8");
+        try {
+            if (typeof stdin.setRawMode === "function")
+                stdin.setRawMode(true);
+        }
+        catch {
+            reject(new CliError("Cannot enable raw mode for interactive selection. Use --non-interactive or pass flags directly.", CLI_EXIT_CODES.usage));
+            return;
+        }
+        stdin.resume();
+        const cleanup = () => {
+            try {
+                stdin.removeListener("data", onData);
+            }
+            catch { /* already destroyed */ }
+            try {
+                if (typeof stdin.setRawMode === "function")
+                    stdin.setRawMode(false);
+            }
+            catch { /* ignore */ }
+            try {
+                if (!stdin.destroyed)
+                    stdin.pause();
+            }
+            catch { /* ignore */ }
+        };
+        const onData = (data) => {
+            for (let ci = 0; ci < data.length; ci++) {
+                const ch = data[ci];
+                if (escBuf.length > 0) {
+                    escBuf += ch;
+                    if (escBuf.length === 2 && ch === "[")
+                        continue;
+                    if (escBuf.length >= 3) {
+                        if (escBuf === "\x1b[A" || escBuf === "\x1b[k") {
+                            cursor = cursor > 0 ? cursor - 1 : options.length - 1;
+                            filterText = "";
+                            render();
+                        }
+                        else if (escBuf === "\x1b[B" || escBuf === "\x1b[j") {
+                            cursor = cursor < options.length - 1 ? cursor + 1 : 0;
+                            filterText = "";
+                            render();
+                        }
+                        else if (escBuf === "\x1b[H") {
+                            cursor = 0;
+                            render();
+                        }
+                        else if (escBuf === "\x1b[F") {
+                            cursor = options.length - 1;
+                            render();
+                        }
+                        escBuf = "";
+                    }
+                    continue;
+                }
+                if (ch === "\x1b") {
+                    escBuf = "\x1b";
+                    continue;
+                }
+                if (ch === "\x03") {
+                    cleanup();
+                    stdout.write("\n");
+                    process.exit(130);
+                    return;
+                }
+                if (ch === "\r" || ch === "\n") {
+                    cleanup();
+                    filterText = "";
+                    stdout.write("\n");
+                    resolve(options[cursor].value);
+                    return;
+                }
+                if (ch === "\x7f" || ch === "\b") {
+                    if (filterText.length > 0) {
+                        filterText = filterText.slice(0, -1);
+                        if (filterText) {
+                            const match = options.findIndex((o) => o.label.toLowerCase().includes(filterText.toLowerCase()));
+                            if (match >= 0)
+                                cursor = match;
+                        }
+                        render();
+                    }
+                }
+                else if (ch === "k" && !filterText) {
+                    cursor = cursor > 0 ? cursor - 1 : options.length - 1;
+                    render();
+                }
+                else if (ch === "j" && !filterText) {
+                    cursor = cursor < options.length - 1 ? cursor + 1 : 0;
+                    render();
+                }
+                else if (ch >= "1" && ch <= "9" && !filterText) {
+                    const idx = parseInt(ch, 10) - 1;
+                    if (idx < options.length && idx < 9) {
+                        cursor = idx;
+                        cleanup();
+                        stdout.write("\n");
+                        resolve(options[idx].value);
+                        return;
+                    }
+                }
+                else if (ch >= " " && ch <= "~") {
+                    filterText += ch;
+                    const match = options.findIndex((o) => o.label.toLowerCase().includes(filterText.toLowerCase()));
+                    if (match >= 0)
+                        cursor = match;
+                    render();
+                }
+            }
+        };
+        stdin.on("data", onData);
+    });
+}
+async function interactiveInput(prompt, defaultValue) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new CliError("Interactive input requires a TTY.", CLI_EXIT_CODES.usage);
+    }
+    const { createInterface } = await import("node:readline");
+    return new Promise((resolve) => {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        const suffix = defaultValue ? ` (${defaultValue})` : "";
+        rl.question(`${prompt}${suffix}: `, (answer) => {
+            rl.close();
+            rl.removeAllListeners();
+            resolve((answer.trim() || defaultValue || "").slice(0, 1024));
+        });
+        rl.on("close", () => resolve(defaultValue || ""));
+    });
+}
+async function readSweepFrontmatter(filePath) {
+    try {
+        const { readFile: fsRead } = await import("node:fs/promises");
+        const content = await fsRead(filePath, "utf8");
+        let iterations = null;
+        let title = null;
+        const iterMatch = content.match(/iterations:\s*(\d+)/i);
+        if (iterMatch) {
+            const val = parseInt(iterMatch[1], 10);
+            if (val > 0 && val <= 50)
+                iterations = val;
+        }
+        const fmEnd = content.indexOf("---", content.indexOf("---") + 3);
+        const bodyStart = fmEnd > 0 ? fmEnd + 3 : 0;
+        const titleMatch = content.slice(bodyStart).match(/^#\s+(.+)/m);
+        if (titleMatch) {
+            title = titleMatch[1].trim();
+        }
+        return { iterations, title };
+    }
+    catch { /* skip */ }
+    return { iterations: null, title: null };
+}
+async function readSweepIterationsFromFrontmatter(filePath) {
+    return (await readSweepFrontmatter(filePath)).iterations;
+}
+function buildGenerateInput(flags) {
+    return {
+        goal: getStringFlag(flags, "goal") || "",
+        context: sanitizeGenerateInput(getStringFlag(flags, "context") || ""),
+        constraints: sanitizeGenerateInput(getStringFlag(flags, "constraints") || ""),
+        desiredOutput: getStringFlag(flags, "desired-output") || "A reusable prompt pack saved as Markdown.",
+        tool: getStringFlag(flags, "tool") || "Codex",
+        mode: getStringFlag(flags, "mode") || "implement",
+        artifactType: getStringFlag(flags, "artifact-type") || "prompt-file",
+        includeWebSearch: Boolean(flags["web-search"]),
+    };
+}
+function sanitizeGenerateInput(value) {
+    return value
+        .replace(/pgpt_[a-zA-Z0-9]{4,}/g, "pgpt_***")
+        .replace(/sk-[a-zA-Z0-9]{20,}/g, "sk-***")
+        .replace(/ghp_[a-zA-Z0-9]{36,}/g, "ghp_***")
+        .replace(/ghu_[a-zA-Z0-9]{36,}/g, "ghu_***")
+        .replace(/Bearer\s+[a-zA-Z0-9_.-]{20,}/gi, "Bearer ***")
+        .replace(/xai-[a-zA-Z0-9]{20,}/g, "xai-***")
+        .replace(/ANTHROPIC_API_KEY=[^\s]+/gi, "ANTHROPIC_API_KEY=***")
+        .replace(/OPENAI_API_KEY=[^\s]+/gi, "OPENAI_API_KEY=***");
+}
+function printDataTransmissionNotice(command, input) {
+    console.log(`[notice] The --goal text${input.context ? ", --context" : ""}${input.constraints ? ", --constraints" : ""} you provided will be sent to prompts-gpt.com to generate a prompt.`);
+    console.log("[notice] Do not include PII, secrets, or confidential data in these flags.");
+    console.log(`[notice] No local files or repo content are uploaded. Only the explicit flag values for \`${command}\` are transmitted.`);
+    console.log("");
+}
+main().catch((error) => {
+    if (error instanceof CliError) {
+        console.error(error.message);
+        if (error.helpCommand) {
+            console.error(`Run \`prompts-gpt help${error.helpCommand ? ` ${error.helpCommand}` : ""}\` for usage.`);
+        }
+        process.exitCode = error.exitCode;
+        return;
+    }
+    if (error instanceof PromptsGptApiError) {
+        console.error(formatApiError(error));
+        process.exitCode = error.status === 401 || error.status === 403
+            ? CLI_EXIT_CODES.auth
+            : error.status === 429
+                ? CLI_EXIT_CODES.rateLimit
+                : error.code === "VALIDATION_ERROR"
+                    ? CLI_EXIT_CODES.validation
+                    : CLI_EXIT_CODES.general;
+        return;
+    }
+    const msg = error instanceof Error ? error.message : String(error);
+    console.error(msg.replace(/pgpt_[a-zA-Z0-9]{4,}/g, "pgpt_***"));
+    if (process.env.PROMPTS_GPT_DEBUG === "1" && error instanceof Error && error.stack) {
+        console.error(error.stack.replace(/pgpt_[a-zA-Z0-9]{4,}/g, "pgpt_***"));
+    }
+    process.exitCode = CLI_EXIT_CODES.general;
+});
+async function extractRunDiagnostics(logFile, provider, model) {
+    const diagnostics = [];
+    try {
+        const { readFile: fsReadFile } = await import("node:fs/promises");
+        const log = await fsReadFile(logFile, "utf8");
+        const errorLines = log.split("\n").filter((line) => line.startsWith("ERROR:") || line.includes('"error"'));
+        for (const line of errorLines.slice(0, 5)) {
+            if (line.includes("not supported")) {
+                const modelMatch = line.match(/The '([^']+)' model is not supported/);
+                const badModel = modelMatch?.[1] ?? model;
+                diagnostics.push(`Model "${badModel}" is not supported by ${provider} with your account.`);
+                diagnostics.push(`Fix: prompts-gpt run --model o4-mini`);
+                diagnostics.push(`Or:  prompts-gpt run --agent claude`);
+                break;
+            }
+            if (line.includes("unauthorized") || line.includes("authentication")) {
+                diagnostics.push(`Authentication failed for ${provider}. Check your ${provider} account login.`);
+                diagnostics.push(`Fix: Run the ${provider} CLI directly to verify auth: ${provider} --version`);
+                break;
+            }
+            if (line.includes("rate_limit") || line.includes("429")) {
+                diagnostics.push(`Rate limited by ${provider}. Wait and try again.`);
+                break;
+            }
+        }
+        if (diagnostics.length === 0 && errorLines.length > 0) {
+            const firstError = errorLines[0].slice(0, 200);
+            diagnostics.push(`Provider error: ${firstError}`);
+        }
+        if (diagnostics.length === 0) {
+            diagnostics.push(`${provider} exited with code 1. Check the log for details:`);
+            diagnostics.push(`  cat ${logFile}`);
+            diagnostics.push(`Try a different provider: prompts-gpt run --agent claude`);
+        }
+    }
+    catch {
+        diagnostics.push(`Could not read log file. Check: ${logFile}`);
+    }
+    return diagnostics;
+}
+function warnOnConfigIssues(config) {
+    for (const w of config.configWarnings) {
+        console.error(`[config warning] ${w}`);
+    }
+}
+function formatApiError(error) {
+    const lines = [error.message];
+    if (error.code === "NETWORK_ERROR" || error.code === "TIMEOUT") {
+        lines.push("Run `prompts-gpt doctor` to diagnose connectivity issues.");
+    }
+    for (const [field, messages] of Object.entries(error.fieldErrors ?? {})) {
+        const msgList = Array.isArray(messages) ? messages : [];
+        for (const message of msgList) {
+            lines.push(`- ${field}: ${String(message)}`);
+        }
+    }
+    if (error.requestId) {
+        lines.push(`Request ID: ${error.requestId}`);
+    }
+    if (error.recovery) {
+        lines.push(error.recovery);
+    }
+    return lines.join("\n");
+}
+function formatTokenUsage(usage) {
+    const parts = [
+        `total=${usage.totalTokens.toLocaleString()}`,
+        `input=${usage.inputTokens.toLocaleString()}`,
+        `output=${usage.outputTokens.toLocaleString()}`,
+    ];
+    if (usage.reasoningTokens > 0) {
+        parts.push(`reasoning=${usage.reasoningTokens.toLocaleString()}`);
+    }
+    if (usage.cacheReadTokens > 0) {
+        parts.push(`cache-read=${usage.cacheReadTokens.toLocaleString()}`);
+    }
+    if (usage.cacheWriteTokens > 0) {
+        parts.push(`cache-write=${usage.cacheWriteTokens.toLocaleString()}`);
+    }
+    return parts.join(" | ");
+}
+//# sourceMappingURL=cli.js.map