prompts-gpt 0.2.8

package/dist/runtime.js

@@ -0,0 +1,1490 @@
+import { existsSync, readFileSync } from "node:fs";
+import { cpus } from "node:os";
+import path from "node:path";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { spawn, spawnSync } from "node:child_process";
+export const DEFAULT_RUN_ARTIFACTS_DIR = ".scripts/runs";
+export const DEFAULT_RUN_CONFIG_PATH = ".prompts-gpt/config.json";
+export const ORCHESTRATION_AGENT_PROFILES = ["codex", "cursor", "claude", "copilot", "router"];
+const DEFAULT_PROVIDER_ORDER = ["codex", "cursor", "claude", "copilot"];
+const PROVIDER_ALIASES = {
+    codex: "codex",
+    openai: "codex",
+    "openai-codex": "codex",
+    cursor: "cursor",
+    "cursor-agent": "cursor",
+    agent: "cursor",
+    claude: "claude",
+    "claude-code": "claude",
+    anthropic: "claude",
+    copilot: "copilot",
+    "github-copilot": "copilot",
+    "gh-copilot": "copilot",
+    router: "router",
+};
+export const DEFAULT_MODELS = {
+    codex: "gpt-5.4-mini",
+    cursor: "auto",
+    claude: "claude-sonnet-4-6",
+    copilot: "auto",
+};
+const NON_CODEX_MAX_PROMPT_BYTES = 100_000;
+const RETRYABLE_RUN_ERROR_CODES = new Set(["PROVIDER_SPAWN_FAILED", "PROVIDER_TIMEOUT"]);
+export function isCI() {
+    const env = process.env;
+    return Boolean(env.CI || env.CONTINUOUS_INTEGRATION || env.GITHUB_ACTIONS ||
+        env.GITLAB_CI || env.CIRCLECI || env.JENKINS_URL || env.BUILDKITE ||
+        env.TRAVIS || env.TF_BUILD || env.CODEBUILD_BUILD_ID);
+}
+class ProviderRunError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "ProviderRunError";
+        this.code = code;
+    }
+}
+export function normalizeOrchestrationAgent(value) {
+    const raw = String(value ?? "router").trim().toLowerCase();
+    return PROVIDER_ALIASES[raw] ?? "router";
+}
+export function normalizeConcreteProvider(value) {
+    const parsed = parseConcreteProvider(value);
+    if (!parsed) {
+        throw new Error("Invalid provider. Use codex, cursor, claude, or copilot.");
+    }
+    return parsed;
+}
+function parseConcreteProvider(value) {
+    const raw = String(value ?? "").trim().toLowerCase();
+    if (!raw || raw === "router") {
+        return null;
+    }
+    const normalized = normalizeOrchestrationAgent(raw);
+    if (normalized === "router") {
+        return null;
+    }
+    return normalized;
+}
+export async function loadRunConfig(cwd = process.cwd()) {
+    const configPath = path.resolve(cwd, DEFAULT_RUN_CONFIG_PATH);
+    let parsed = {};
+    const configWarnings = [];
+    if (existsSync(configPath)) {
+        try {
+            const data = JSON.parse(await readFile(configPath, "utf8"));
+            parsed = data && typeof data === "object" ? data : {};
+        }
+        catch (error) {
+            parsed = {};
+            configWarnings.push(`Could not parse ${DEFAULT_RUN_CONFIG_PATH}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const env = process.env;
+    const envProviderOrder = parseProviderOrderEnv(env.PROMPTS_GPT_RUN_PROVIDER_ORDER);
+    const envDefaultAgent = normalizeOptionalAgent(env.PROMPTS_GPT_RUN_AGENT);
+    const envTimeoutSeconds = parsePositiveIntEnv(env.PROMPTS_GPT_RUN_TIMEOUT_SECONDS);
+    const envRetryCount = parseNonNegativeIntEnv(env.PROMPTS_GPT_RUN_RETRY_COUNT);
+    const envArtifactsDir = env.PROMPTS_GPT_RUN_ARTIFACTS_DIR?.trim();
+    const envSafety = parseBooleanEnv(env.PROMPTS_GPT_RUN_DISALLOW_DESTRUCTIVE_GIT);
+    const envModelOverrides = readModelOverridesFromEnv(env);
+    const configProviderOrder = Array.isArray(parsed.providerOrder) && parsed.providerOrder.length > 0
+        ? parsed.providerOrder
+            .map((p) => parseConcreteProvider(String(p)))
+            .filter((provider) => provider !== null)
+        : DEFAULT_PROVIDER_ORDER;
+    const providerOrder = envProviderOrder.length > 0 ? envProviderOrder : configProviderOrder;
+    const uniqueProviderOrder = [...new Set(providerOrder)].filter((p) => DEFAULT_PROVIDER_ORDER.includes(p));
+    const defaultAgent = envDefaultAgent ?? normalizeOrchestrationAgent(parsed.defaultAgent ?? "router");
+    const defaultPromptFile = typeof parsed.defaultPromptFile === "string" && parsed.defaultPromptFile.trim()
+        ? path.resolve(cwd, parsed.defaultPromptFile.trim())
+        : null;
+    const timeoutRaw = envTimeoutSeconds ?? Number(parsed.timeoutSeconds);
+    const timeoutSeconds = Number.isFinite(timeoutRaw) && timeoutRaw > 0 ? Math.trunc(timeoutRaw) : 900;
+    const retryRaw = envRetryCount ?? Number(parsed.retryCount);
+    const retryCount = Number.isFinite(retryRaw) && retryRaw >= 0 ? Math.trunc(retryRaw) : 0;
+    const artifactsDir = path.resolve(cwd, envArtifactsDir || parsed.artifactsDir?.trim() || DEFAULT_RUN_ARTIFACTS_DIR);
+    const batchDefaults = resolveConfiguredBatchDefaults(cwd, parsed.batchDefaults);
+    return {
+        providerOrder: uniqueProviderOrder.length ? uniqueProviderOrder : DEFAULT_PROVIDER_ORDER,
+        defaultAgent,
+        defaultPromptFile,
+        modelOverrides: {
+            ...(parsed.modelOverrides ?? {}),
+            ...envModelOverrides,
+        },
+        customModels: parsed.customModels ?? {},
+        timeoutSeconds,
+        retryCount,
+        artifactsDir,
+        batchDefaults,
+        safety: {
+            disallowDestructiveGit: envSafety ?? parsed.safety?.disallowDestructiveGit ?? true,
+        },
+        configPath,
+        configWarnings,
+    };
+}
+export async function detectProviders(cwd = process.cwd()) {
+    const env = process.env;
+    const providers = ["codex", "cursor", "claude", "copilot"];
+    const checks = providers.map((provider) => {
+        const bin = resolveProviderBin(provider, env);
+        const available = isExecutableAvailable(bin);
+        const version = available ? readProviderVersion(provider, bin, cwd) : null;
+        return {
+            provider,
+            bin,
+            available,
+            version,
+            modelDefault: DEFAULT_MODELS[provider],
+            checkedAt: new Date().toISOString(),
+            installHint: installHintForProvider(provider),
+        };
+    });
+    return checks;
+}
+export async function doctor(cwd = process.cwd()) {
+    const resolvedCwd = path.resolve(cwd);
+    const config = await loadRunConfig(resolvedCwd);
+    const providers = await detectProviders(resolvedCwd);
+    const notes = [];
+    if (!existsSync(config.configPath)) {
+        notes.push(`No ${DEFAULT_RUN_CONFIG_PATH} found. Defaults are active.`);
+        notes.push(`Run \`prompts-gpt setup\` to scaffold a project-local run config.`);
+    }
+    const gitResult = spawnSync("git", ["--version"], { encoding: "utf8", windowsHide: true, timeout: 5_000 });
+    if (gitResult.error || gitResult.status !== 0) {
+        notes.push("Git is not available on PATH. Git is required for worktree tracking and sweep safety.");
+    }
+    const nodeVersionParts = process.version.replace("v", "").split(".").map(Number);
+    if ((nodeVersionParts[0] ?? 0) < 18 || ((nodeVersionParts[0] ?? 0) === 18 && (nodeVersionParts[1] ?? 0) < 18)) {
+        notes.push(`Node.js ${process.version} is below the minimum required (>=18.18). Upgrade Node.js.`);
+    }
+    notes.push(...config.configWarnings);
+    if (!providers.some((p) => p.available)) {
+        notes.push("No supported provider CLI found on PATH. Install Codex, Cursor Agent, Claude Code, or Copilot CLI.");
+    }
+    if (config.retryCount > 0) {
+        notes.push(`Run retries enabled: ${config.retryCount}. Only spawn and timeout failures are retried automatically.`);
+    }
+    if (config.providerOrder.length > 0) {
+        notes.push(`Router provider order: ${config.providerOrder.join(", ")}.`);
+    }
+    if (config.defaultPromptFile) {
+        notes.push(`Default prompt file: ${config.defaultPromptFile}.`);
+    }
+    if (config.batchDefaults.manifestPath) {
+        notes.push(`Batch default manifest: ${config.batchDefaults.manifestPath}.`);
+    }
+    else if (config.batchDefaults.promptFiles.length > 0) {
+        notes.push(`Batch default prompt files: ${config.batchDefaults.promptFiles.length}.`);
+    }
+    else {
+        notes.push("No batch prompt source configured. Run `prompts-gpt setup` to scan prompt files or set one explicitly.");
+    }
+    if (config.safety.disallowDestructiveGit) {
+        notes.push("Destructive Git protection is configured, but provider-side enforcement still depends on prompt/runtime policy in this local-first V1 runner.");
+    }
+    const sweepDir = path.resolve(resolvedCwd, ".prompts-gpt/sweeps");
+    if (existsSync(sweepDir)) {
+        try {
+            const sweepEntries = await readdir(sweepDir, { withFileTypes: true });
+            const sweepFiles = sweepEntries.filter((e) => e.isFile() && e.name.endsWith(".md"));
+            notes.push(`Sweep files: ${sweepFiles.length} found in .prompts-gpt/sweeps/`);
+        }
+        catch { /* skip */ }
+    }
+    else {
+        notes.push("Sweep files: none (create .prompts-gpt/sweeps/<name>.md to add sweeps)");
+    }
+    const lockPath = path.resolve(resolvedCwd, ".sweep.lock");
+    if (existsSync(lockPath)) {
+        try {
+            const lockContent = JSON.parse(await readFile(lockPath, "utf8"));
+            notes.push(`Sweep lock: active (PID ${lockContent.pid}, started ${lockContent.startedAt}). Remove with: rm ${lockPath}`);
+        }
+        catch {
+            notes.push(`Sweep lock: found but unreadable at ${lockPath}`);
+        }
+    }
+    return {
+        cwd: resolvedCwd,
+        nodeVersion: process.version,
+        osPlatform: process.platform,
+        osArch: process.arch,
+        cpuCount: cpus().length,
+        configPath: config.configPath,
+        configFound: existsSync(config.configPath),
+        providers,
+        notes,
+    };
+}
+export async function initRunConfig(input = {}) {
+    const cwd = path.resolve(input.cwd ?? process.cwd());
+    const configPath = path.resolve(cwd, DEFAULT_RUN_CONFIG_PATH);
+    const providers = await detectProviders(cwd);
+    const discovered = await detectPromptSources(cwd, input);
+    const config = {
+        providerOrder: normalizeProviderOrderInput(input.providerOrder, providers),
+        defaultAgent: normalizeOrchestrationAgent(input.defaultAgent ?? "router"),
+        defaultPromptFile: discovered.defaultPromptFile ? toProjectConfigPath(cwd, discovered.defaultPromptFile) : undefined,
+        modelOverrides: buildScaffoldModelOverrides(input.modelOverrides),
+        customModels: {},
+        timeoutSeconds: resolveTimeoutSeconds(input.timeoutSeconds, 900),
+        retryCount: resolveRetryCount(input.retryCount),
+        artifactsDir: toProjectConfigPath(cwd, input.artifactsDir?.trim() || DEFAULT_RUN_ARTIFACTS_DIR),
+        batchDefaults: {
+            manifestPath: discovered.manifestPath ? toProjectConfigPath(cwd, discovered.manifestPath) : undefined,
+            promptFiles: discovered.promptFiles.map((file) => toProjectConfigPath(cwd, file)),
+        },
+        safety: {
+            disallowDestructiveGit: input.disallowDestructiveGit ?? true,
+        },
+    };
+    await mkdir(path.dirname(configPath), { recursive: true });
+    if (input.overwrite) {
+        await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`);
+    }
+    else {
+        try {
+            await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, { flag: "wx" });
+        }
+        catch (err) {
+            if (err.code === "EEXIST") {
+                throw new Error(`Run config already exists: ${configPath}. Re-run with overwrite enabled to replace it.`);
+            }
+            throw err;
+        }
+    }
+    await ensureGitignoreEntry(cwd, toGitignorePath(cwd, path.resolve(cwd, config.artifactsDir ?? DEFAULT_RUN_ARTIFACTS_DIR)));
+    await ensureGitignoreEntry(cwd, ".sweep.lock");
+    return {
+        configPath,
+        config,
+        providerSummary: providers,
+        sourceSummary: discovered,
+    };
+}
+export async function runBatch(input) {
+    const cwd = path.resolve(input.cwd ?? process.cwd());
+    const config = await loadRunConfig(cwd);
+    const promptFiles = [...new Set(await resolveBatchPromptFiles(cwd, input, config))];
+    const results = [];
+    for (const promptFile of promptFiles) {
+        const result = await runPrompt({
+            cwd,
+            promptFile,
+            agent: input.agent,
+            model: input.model,
+            timeoutSeconds: input.timeoutSeconds,
+            artifactsDir: input.artifactsDir,
+        });
+        results.push(result);
+    }
+    const success = results.filter((result) => result.exitCode === 0).length;
+    return {
+        total: results.length,
+        success,
+        failed: results.length - success,
+        results,
+        tokenUsage: aggregateTokenUsage(results.map((result) => result.tokenUsage)),
+    };
+}
+export async function runPrompt(input) {
+    const cwd = path.resolve(input.cwd ?? process.cwd());
+    const config = await loadRunConfig(cwd);
+    const providers = await detectProviders(cwd);
+    const agent = normalizeOrchestrationAgent(input.agent ?? config.defaultAgent);
+    const provider = resolveRunProvider(agent, providers, config.providerOrder);
+    const providerHealth = providers.find((item) => item.provider === provider);
+    if (!providerHealth || !providerHealth.available) {
+        throw new Error(`Provider ${provider} is not available. ${installHintForProvider(provider)} Run \`prompts-gpt doctor\` for details.`);
+    }
+    const promptFile = input.promptFile
+        ? path.resolve(cwd, input.promptFile)
+        : await resolveDefaultPromptFile(cwd, config);
+    if (!existsSync(promptFile)) {
+        throw new Error(`Prompt file not found: ${promptFile}`);
+    }
+    const model = input.model?.trim() || config.modelOverrides[provider]?.trim() || DEFAULT_MODELS[provider];
+    const timeoutSeconds = resolveTimeoutSeconds(input.timeoutSeconds, config.timeoutSeconds);
+    const hex = Array.from({ length: 4 }, () => Math.floor(Math.random() * 256).toString(16).padStart(2, "0")).join("");
+    const runId = input.runId?.trim() || `agent-${new Date().toISOString().replace(/[-:T]/g, "").slice(0, 14)}-${process.pid}-${hex}`;
+    const runDir = path.resolve(input.artifactsDir ? path.resolve(cwd, input.artifactsDir) : config.artifactsDir, runId);
+    try {
+        await mkdir(runDir, { recursive: true });
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "EPERM" || code === "EACCES") {
+            throw new Error(`Cannot create run directory ${runDir}: permission denied. Check filesystem permissions or use --artifacts-dir.`);
+        }
+        throw err;
+    }
+    const summaryFile = path.join(runDir, "summary.md");
+    const logFile = path.join(runDir, "agent.log");
+    const worktreeBeforeFile = path.join(runDir, "worktree-before.txt");
+    const worktreeAfterFile = path.join(runDir, "worktree-after.txt");
+    const worktreeDeltaFile = path.join(runDir, "worktree-delta.diff");
+    const before = captureWorktreeStatus(cwd);
+    await writeFile(worktreeBeforeFile, before);
+    const startedAt = new Date();
+    const startedMs = Date.now();
+    let run;
+    try {
+        const promptText = await readFile(promptFile, "utf8");
+        assertPromptFitsLaunch(provider, promptText, promptFile);
+        run = await executeProviderCommandWithRetries({
+            provider,
+            bin: providerHealth.bin,
+            model,
+            cwd,
+            promptText,
+            promptFile,
+            summaryFile,
+            logFile,
+            timeoutSeconds,
+            retryCount: config.retryCount,
+            approveMcps: input.approveMcps ?? true,
+            sandboxMode: input.sandboxMode ?? "workspace-write",
+            background: input.background,
+            permissionMode: input.permissionMode,
+        });
+    }
+    finally {
+        const after = captureWorktreeStatus(cwd);
+        await writeFile(worktreeAfterFile, after);
+        await writeFile(worktreeDeltaFile, buildWorktreeDelta(before, after));
+    }
+    const finishedAt = new Date();
+    const tokenUsage = await readTokenUsageFromLog(logFile);
+    return {
+        runId,
+        provider,
+        model,
+        promptFile,
+        runDir,
+        summaryFile,
+        logFile,
+        worktreeBeforeFile,
+        worktreeAfterFile,
+        worktreeDeltaFile,
+        exitCode: run.exitCode,
+        startedAt: startedAt.toISOString(),
+        finishedAt: finishedAt.toISOString(),
+        durationMs: Date.now() - startedMs,
+        commandPreview: run.commandPreview,
+        tokenUsage,
+    };
+}
+const TOKEN_USAGE_NUMERIC_KEYS = new Set([
+    "input_tokens",
+    "prompt_tokens",
+    "output_tokens",
+    "completion_tokens",
+    "total_tokens",
+    "reasoning_tokens",
+    "cached_input_tokens",
+    "cache_read_input_tokens",
+    "cache_creation_input_tokens",
+    "cache_write_input_tokens",
+    "inputTokens",
+    "promptTokens",
+    "outputTokens",
+    "completionTokens",
+    "totalTokens",
+    "reasoningTokens",
+    "cacheReadInputTokens",
+    "cacheWriteInputTokens",
+    "cacheReadTokens",
+    "cacheWriteTokens",
+]);
+export function emptyTokenUsage() {
+    return {
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        reasoningTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+    };
+}
+export function hasTokenUsage(usage) {
+    if (!usage)
+        return false;
+    return Object.values(usage).some((value) => Number.isFinite(value) && value > 0);
+}
+export function aggregateTokenUsage(usages) {
+    const totals = emptyTokenUsage();
+    let found = false;
+    for (const usage of usages) {
+        if (!hasTokenUsage(usage))
+            continue;
+        found = true;
+        totals.inputTokens += usage.inputTokens;
+        totals.outputTokens += usage.outputTokens;
+        totals.totalTokens += usage.totalTokens;
+        totals.reasoningTokens += usage.reasoningTokens;
+        totals.cacheReadTokens += usage.cacheReadTokens;
+        totals.cacheWriteTokens += usage.cacheWriteTokens;
+    }
+    return found ? totals : null;
+}
+export async function readTokenUsageFromLog(logFile) {
+    if (!existsSync(logFile))
+        return null;
+    try {
+        const content = await readFile(logFile, "utf8");
+        return extractTokenUsageFromLog(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function extractTokenUsageFromLog(logContent) {
+    if (!logContent.trim())
+        return null;
+    const terminalCandidates = [];
+    const generalCandidates = [];
+    for (const rawLine of logContent.split("\n")) {
+        const trimmed = rawLine.trim();
+        if (!trimmed)
+            continue;
+        if (trimmed.startsWith("{")) {
+            try {
+                const parsed = JSON.parse(trimmed);
+                const candidate = extractBestTokenUsageCandidate(parsed);
+                if (!candidate)
+                    continue;
+                const lineType = String(parsed.type ?? parsed.event ?? parsed.kind ?? "").toLowerCase();
+                if (lineType === "result" ||
+                    lineType === "final" ||
+                    lineType === "response.completed" ||
+                    lineType === "message_stop") {
+                    terminalCandidates.push(candidate);
+                }
+                else {
+                    generalCandidates.push(candidate);
+                }
+                continue;
+            }
+            catch {
+                // Fall through to text parsing below.
+            }
+        }
+        const textCandidate = extractTokenUsageFromText(trimmed);
+        if (textCandidate) {
+            generalCandidates.push(textCandidate);
+        }
+    }
+    if (terminalCandidates.length > 0) {
+        return aggregateTokenUsage(terminalCandidates);
+    }
+    if (generalCandidates.length > 0) {
+        return generalCandidates.reduce((best, current) => {
+            if (!best)
+                return current;
+            if (current.totalTokens > best.totalTokens)
+                return current;
+            if (current.totalTokens === best.totalTokens && current.inputTokens + current.outputTokens > best.inputTokens + best.outputTokens) {
+                return current;
+            }
+            return best;
+        }, null);
+    }
+    return null;
+}
+function extractBestTokenUsageCandidate(value) {
+    const candidates = collectTokenUsageCandidates(value);
+    return candidates.reduce((best, current) => {
+        if (!best)
+            return current;
+        if (current.totalTokens > best.totalTokens)
+            return current;
+        if (current.totalTokens === best.totalTokens && current.inputTokens + current.outputTokens > best.inputTokens + best.outputTokens) {
+            return current;
+        }
+        return best;
+    }, null);
+}
+function collectTokenUsageCandidates(value) {
+    if (!value || typeof value !== "object")
+        return [];
+    const record = value;
+    const candidates = [];
+    const directCandidate = normalizeTokenUsageCandidate(record);
+    if (directCandidate) {
+        candidates.push(directCandidate);
+    }
+    for (const nestedValue of Object.values(record)) {
+        if (!nestedValue || typeof nestedValue !== "object")
+            continue;
+        candidates.push(...collectTokenUsageCandidates(nestedValue));
+    }
+    return candidates;
+}
+function normalizeTokenUsageCandidate(value) {
+    const hasRelevantKey = Object.keys(value).some((key) => TOKEN_USAGE_NUMERIC_KEYS.has(key));
+    if (!hasRelevantKey)
+        return null;
+    const usage = {
+        inputTokens: readNumericField(value, ["input_tokens", "prompt_tokens", "inputTokens", "promptTokens"]),
+        outputTokens: readNumericField(value, ["output_tokens", "completion_tokens", "outputTokens", "completionTokens"]),
+        totalTokens: readNumericField(value, ["total_tokens", "totalTokens"]),
+        reasoningTokens: readNumericField(value, ["reasoning_tokens", "reasoningTokens"]),
+        cacheReadTokens: readNumericField(value, ["cached_input_tokens", "cache_read_input_tokens", "cacheReadInputTokens", "cacheReadTokens"]),
+        cacheWriteTokens: readNumericField(value, ["cache_creation_input_tokens", "cache_write_input_tokens", "cacheWriteInputTokens", "cacheWriteTokens"]),
+    };
+    if (usage.totalTokens <= 0) {
+        usage.totalTokens = usage.inputTokens + usage.outputTokens;
+    }
+    return hasTokenUsage(usage) ? usage : null;
+}
+function extractTokenUsageFromText(text) {
+    const usage = emptyTokenUsage();
+    const patterns = [
+        ["inputTokens", [/\binput[_ ]tokens?\b[^0-9]*(\d+)/i, /\bprompt[_ ]tokens?\b[^0-9]*(\d+)/i]],
+        ["outputTokens", [/\boutput[_ ]tokens?\b[^0-9]*(\d+)/i, /\bcompletion[_ ]tokens?\b[^0-9]*(\d+)/i]],
+        ["totalTokens", [/\btotal[_ ]tokens?\b[^0-9]*(\d+)/i]],
+        ["reasoningTokens", [/\breasoning[_ ]tokens?\b[^0-9]*(\d+)/i]],
+        ["cacheReadTokens", [/\bcache(?:d|[_ ]read(?:[_ ]input)?)?[_ ]tokens?\b[^0-9]*(\d+)/i]],
+        ["cacheWriteTokens", [/\bcache(?:[_ ]creation|[_ ]write(?:[_ ]input)?)?[_ ]tokens?\b[^0-9]*(\d+)/i]],
+    ];
+    for (const [field, regexes] of patterns) {
+        for (const regex of regexes) {
+            const match = text.match(regex);
+            if (!match)
+                continue;
+            usage[field] = parseInt(match[1] ?? "0", 10) || 0;
+            break;
+        }
+    }
+    if (usage.totalTokens <= 0) {
+        usage.totalTokens = usage.inputTokens + usage.outputTokens;
+    }
+    return hasTokenUsage(usage) ? usage : null;
+}
+function readNumericField(value, keys) {
+    for (const key of keys) {
+        const raw = value[key];
+        if (typeof raw === "number" && Number.isFinite(raw)) {
+            return Math.max(0, Math.trunc(raw));
+        }
+        if (typeof raw === "string" && raw.trim()) {
+            const parsed = Number(raw);
+            if (Number.isFinite(parsed)) {
+                return Math.max(0, Math.trunc(parsed));
+            }
+        }
+    }
+    return 0;
+}
+export async function executeProviderCommandWithRetries(input) {
+    let attempt = 0;
+    let lastError;
+    while (attempt <= input.retryCount) {
+        try {
+            return await executeProviderCommand(input, attempt);
+        }
+        catch (error) {
+            lastError = error;
+            if (!(error instanceof ProviderRunError) || !RETRYABLE_RUN_ERROR_CODES.has(error.code) || attempt >= input.retryCount) {
+                throw error;
+            }
+            attempt += 1;
+            const note = `Retrying ${input.provider} after ${error.code} (${attempt}/${input.retryCount})\n`;
+            await appendFileSafe(input.logFile, note);
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+export async function executeProviderCommand(input, attempt = 0) {
+    const { provider, bin, model, cwd, promptText, promptFile, summaryFile, logFile, timeoutSeconds, approveMcps, sandboxMode } = input;
+    const command = buildProviderCommand(provider, bin, model, cwd, promptText, summaryFile, approveMcps, sandboxMode, {
+        background: input.background,
+        permissionMode: input.permissionMode,
+    });
+    const commandPreview = buildCommandPreview(command, provider);
+    const timeoutMs = timeoutSeconds * 1_000;
+    const MAX_OUTPUT_BYTES = 50 * 1024 * 1024; // 50 MB cap per stream
+    const { createWriteStream } = await import("node:fs");
+    const outcome = await new Promise((resolve, reject) => {
+        let child;
+        try {
+            child = spawn(command.command, command.args, {
+                cwd,
+                stdio: ["pipe", "pipe", "pipe"],
+                windowsHide: true,
+            });
+        }
+        catch (error) {
+            reject(new ProviderRunError("PROVIDER_SPAWN_FAILED", `Failed to launch ${provider} via ${command.command}: ${error instanceof Error ? error.message : String(error)}`));
+            return;
+        }
+        const err = [];
+        let errSize = 0;
+        let didTimeout = false;
+        let settled = false;
+        const header = attempt > 0 ? `# Attempt ${attempt + 1}\n` : "";
+        const logStream = createWriteStream(logFile, { flags: "a" });
+        logStream.on("error", () => undefined);
+        if (header)
+            logStream.write(header);
+        child.stdout.on("data", (chunk) => {
+            try {
+                logStream.write(chunk);
+            }
+            catch { /* pipe broken */ }
+        });
+        child.stderr.on("data", (chunk) => {
+            const buf = Buffer.from(chunk);
+            if (errSize < MAX_OUTPUT_BYTES) {
+                err.push(buf);
+                errSize += buf.length;
+            }
+        });
+        const timer = setTimeout(() => {
+            didTimeout = true;
+            child.kill("SIGTERM");
+            setTimeout(() => { try {
+                child.kill("SIGKILL");
+            }
+            catch { } }, 5_000).unref?.();
+        }, timeoutMs);
+        timer.unref?.();
+        child.stdin.on("error", () => undefined);
+        if (provider === "codex") {
+            child.stdin.write(promptText);
+        }
+        child.stdin.end();
+        child.on("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            const done = new Promise((res) => {
+                logStream.on("finish", res);
+                logStream.on("error", res);
+            });
+            logStream.end();
+            done.then(() => {
+                reject(new ProviderRunError("PROVIDER_SPAWN_FAILED", `Failed to launch ${provider} via ${command.command}: ${error.message}`));
+            }).catch(() => {
+                reject(new ProviderRunError("PROVIDER_SPAWN_FAILED", `Failed to launch ${provider} via ${command.command}: ${error.message}`));
+            });
+        });
+        child.on("close", (code, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            const stderrText = Buffer.concat(err).toString("utf8");
+            if (stderrText.trim()) {
+                logStream.write(`\n--- stderr ---\n${stderrText}`);
+            }
+            const streamDone = new Promise((res) => {
+                logStream.on("finish", res);
+                logStream.on("error", res);
+            });
+            logStream.end();
+            const stderrWrite = stderrText.trim()
+                ? appendFileSafe(logFile.replace(/\.log$/, ".stderr"), stderrText)
+                : Promise.resolve();
+            Promise.all([streamDone, stderrWrite]).then(() => {
+                if (provider !== "codex") {
+                    return readFile(logFile, "utf8").then((content) => writeFile(summaryFile, content)).catch(() => undefined);
+                }
+                else if (!existsSync(summaryFile)) {
+                    return readFile(logFile, "utf8").then((content) => writeFile(summaryFile, content)).catch(() => undefined);
+                }
+                return undefined;
+            }).then(() => {
+                if (didTimeout) {
+                    reject(new ProviderRunError("PROVIDER_TIMEOUT", `${provider} exceeded the ${timeoutSeconds}s timeout. Increase --timeout or reduce prompt scope.`));
+                    return;
+                }
+                const exitCode = typeof code === "number" ? code : (signal === "SIGTERM" ? 143 : signal === "SIGKILL" ? 137 : 1);
+                resolve({ exitCode });
+            }).catch(reject);
+        });
+    });
+    if (provider !== "codex" && existsSync(logFile) && !existsSync(summaryFile)) {
+        await writeFile(summaryFile, await readFile(logFile, "utf8"));
+    }
+    if (provider === "codex" && !existsSync(summaryFile)) {
+        await writeFile(summaryFile, `No summary output produced for prompt file ${promptFile}\n`);
+    }
+    if (outcome.exitCode !== 0 && existsSync(summaryFile)) {
+        const summaryContent = await readFile(summaryFile, "utf8");
+        if (summaryContent.startsWith("[stderr]") && summaryContent.includes("ERROR:")) {
+            const errorPrefix = `# Run Failed (exit code ${outcome.exitCode})\n\nThe ${provider} provider reported an error. See the full log for details:\n  ${logFile}\n\n---\n\n`;
+            await writeFile(summaryFile, errorPrefix + summaryContent);
+        }
+    }
+    return { exitCode: outcome.exitCode, commandPreview };
+}
+export function buildProviderCommand(provider, bin, model, cwd, promptText, summaryFile, approveMcps, sandboxMode, options) {
+    if (provider === "codex") {
+        return {
+            command: bin,
+            args: ["exec", "-m", model, "--sandbox", sandboxMode, "-C", cwd, "--color", "never", "-o", summaryFile, "-"],
+        };
+    }
+    if (provider === "cursor") {
+        const args = options?.background
+            ? ["--background", "--force", "--trust", "--workspace", cwd, "--output-format", "stream-json"]
+            : ["--print", "--force", "--trust", "--workspace", cwd, "--output-format", "stream-json"];
+        if (model !== "auto") {
+            args.push("--model", model);
+        }
+        if (approveMcps) {
+            args.push("--approve-mcps");
+        }
+        args.push(promptText);
+        return { command: bin, args };
+    }
+    if (provider === "claude") {
+        const permissionMode = options?.permissionMode ?? "acceptEdits";
+        return {
+            command: bin,
+            args: ["-p", "--model", model, "--output-format", "stream-json", "--permission-mode", permissionMode, "--add-dir", cwd, promptText],
+        };
+    }
+    return {
+        command: bin,
+        args: ["-p", promptText, "--model", model, "--output-format=json", "--add-dir", cwd, "--no-color"],
+    };
+}
+export function resolveRunProvider(requested, providers, providerOrder) {
+    if (requested !== "router") {
+        return requested;
+    }
+    for (const provider of providerOrder) {
+        const health = providers.find((item) => item.provider === provider);
+        if (health?.available) {
+            return provider;
+        }
+    }
+    for (const provider of DEFAULT_PROVIDER_ORDER) {
+        const health = providers.find((item) => item.provider === provider);
+        if (health?.available)
+            return provider;
+    }
+    return providerOrder[0] ?? "codex";
+}
+export function resolveTimeoutSeconds(override, fallback) {
+    const MAX_TIMEOUT_SECONDS = 86_400;
+    const raw = Number(override);
+    if (Number.isFinite(raw) && raw > 0) {
+        return Math.min(Math.trunc(raw), MAX_TIMEOUT_SECONDS);
+    }
+    return Math.min(fallback, MAX_TIMEOUT_SECONDS);
+}
+function resolveProviderBin(provider, env) {
+    const requested = readProviderBinOverride(provider, env);
+    if (requested) {
+        return requested;
+    }
+    const candidates = providerCandidates(provider);
+    const match = candidates.find((candidate) => isExecutableAvailable(candidate));
+    return match ?? providerDefaultBin(provider);
+}
+function readProviderBinOverride(provider, env) {
+    const aliases = providerBinEnvAliases(provider);
+    for (const name of aliases) {
+        const value = String(env[name] ?? "").trim();
+        if (value) {
+            return value;
+        }
+    }
+    return "";
+}
+function providerBinEnvAliases(provider) {
+    if (provider === "codex")
+        return ["CODEX_BIN", "OPENAI_CODEX_BIN"];
+    if (provider === "cursor")
+        return ["AGENT_BIN", "CURSOR_AGENT_BIN", "CURSOR_BIN"];
+    if (provider === "claude")
+        return ["CLAUDE_BIN", "CLAUDE_CODE_BIN"];
+    return ["COPILOT_BIN", "GITHUB_COPILOT_BIN", "GH_COPILOT_BIN"];
+}
+function providerDefaultBin(provider) {
+    if (provider === "codex")
+        return "codex";
+    if (provider === "cursor")
+        return "agent";
+    if (provider === "claude")
+        return "claude";
+    return "copilot";
+}
+function isWSL() {
+    if (process.platform !== "linux")
+        return false;
+    try {
+        return existsSync("/proc/version") && readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
+    }
+    catch {
+        return false;
+    }
+}
+function providerCandidates(provider) {
+    const home = process.env.HOME || process.env.USERPROFILE || (process.env.HOMEDRIVE && process.env.HOMEPATH ? `${process.env.HOMEDRIVE}${process.env.HOMEPATH}` : "");
+    const user = process.env.USER || process.env.USERNAME || "user";
+    const wsl = isWSL();
+    if (provider === "codex") {
+        return [
+            "codex",
+            "codex.exe",
+            path.join(home, ".local", "bin", "codex"),
+            "/usr/local/bin/codex",
+            "/opt/homebrew/bin/codex",
+            ...(wsl ? [`/mnt/c/Users/${user}/AppData/Local/OpenAI/Codex/bin/codex.exe`] : []),
+        ];
+    }
+    if (provider === "cursor") {
+        return [
+            "agent",
+            "cursor-agent",
+            path.join(home, ".local", "bin", "agent"),
+            path.join(home, ".cursor", "bin", "agent"),
+            "/usr/local/bin/agent",
+            "/usr/local/bin/cursor-agent",
+            ...(wsl ? [
+                `/mnt/c/Users/${user}/AppData/Local/Programs/cursor/resources/app/bin/agent`,
+                `/mnt/c/Users/${user}/AppData/Local/Cursor/resources/app/bin/agent`,
+            ] : []),
+        ];
+    }
+    if (provider === "claude") {
+        return [
+            "claude",
+            path.join(home, ".local", "bin", "claude"),
+            path.join(home, ".claude", "local", "claude"),
+            "/usr/local/bin/claude",
+            "/opt/homebrew/bin/claude",
+        ];
+    }
+    return [
+        "copilot",
+        "copilot.exe",
+        "gh-copilot",
+        path.join(home, ".local", "bin", "copilot"),
+        "/usr/local/bin/copilot",
+        "/opt/homebrew/bin/copilot",
+        ...(wsl ? [`/mnt/c/Users/${user}/AppData/Local/Microsoft/WinGet/Links/copilot.exe`] : []),
+    ];
+}
+function isExecutableAvailable(command) {
+    if (!command.trim())
+        return false;
+    if (/[\x00-\x1f]/.test(command))
+        return false;
+    if (/[;&|`$(){}]/.test(command))
+        return false;
+    try {
+        if (path.isAbsolute(command)) {
+            return existsSync(command);
+        }
+        const result = spawnSync(command, ["--version"], { stdio: "ignore", windowsHide: true, timeout: 8_000 });
+        return !result.error;
+    }
+    catch {
+        return false;
+    }
+}
+function readProviderVersion(_provider, bin, cwd) {
+    const result = spawnSync(bin, ["--version"], { cwd, encoding: "utf8", windowsHide: true, timeout: 10_000 });
+    if (result.status !== 0) {
+        return null;
+    }
+    const output = `${result.stdout || ""}\n${result.stderr || ""}`.trim();
+    return output.split(/\r?\n/).find((line) => {
+        const t = line.trim();
+        return t.length > 0 && !t.toLowerCase().startsWith("warning") && !t.toLowerCase().startsWith("deprecat");
+    }) ?? output.split(/\r?\n/).find((line) => line.trim().length > 0) ?? null;
+}
+function installHintForProvider(provider) {
+    if (provider === "codex")
+        return "Install OpenAI Codex CLI and ensure `codex` is on PATH.";
+    if (provider === "cursor")
+        return "Install Cursor Agent CLI (`agent`) and ensure PATH includes it.";
+    if (provider === "claude")
+        return "Install Claude Code CLI (`claude`) and ensure PATH includes it.";
+    return "Install GitHub Copilot CLI (`copilot`) and ensure PATH includes it.";
+}
+function parseProviderOrderEnv(value) {
+    if (!value)
+        return [];
+    return value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean)
+        .map((item) => parseConcreteProvider(item))
+        .filter((provider) => provider !== null)
+        .filter((provider, index, arr) => arr.indexOf(provider) === index);
+}
+function normalizeOptionalAgent(value) {
+    const raw = value?.trim();
+    if (!raw)
+        return undefined;
+    return normalizeOrchestrationAgent(raw);
+}
+function parsePositiveIntEnv(value) {
+    const raw = Number(value);
+    if (!Number.isFinite(raw) || raw <= 0)
+        return undefined;
+    return Math.trunc(raw);
+}
+function parseNonNegativeIntEnv(value) {
+    const raw = Number(value);
+    if (!Number.isFinite(raw) || raw < 0)
+        return undefined;
+    return Math.trunc(raw);
+}
+function parseBooleanEnv(value) {
+    const raw = value?.trim().toLowerCase();
+    if (!raw)
+        return undefined;
+    if (["1", "true", "yes", "on"].includes(raw))
+        return true;
+    if (["0", "false", "no", "off"].includes(raw))
+        return false;
+    return undefined;
+}
+function toGitignorePath(cwd, absolutePath) {
+    const relative = path.relative(cwd, absolutePath).replace(/\\/g, "/").replace(/^\.?\//, "");
+    return relative || DEFAULT_RUN_ARTIFACTS_DIR;
+}
+export async function ensureGitignoreEntry(cwd, entry) {
+    const gitignorePath = path.resolve(cwd, ".gitignore");
+    const existing = existsSync(gitignorePath) ? await readFile(gitignorePath, "utf8") : "";
+    const eol = existing.includes("\r\n") ? "\r\n" : "\n";
+    const lines = existing.split(/\r?\n/).map((line) => line.trim());
+    if (lines.includes(entry))
+        return;
+    const needsLeadingNewline = existing.length > 0 && !existing.endsWith("\n") && !existing.endsWith("\r\n");
+    const prefix = needsLeadingNewline ? eol : "";
+    await writeFile(gitignorePath, `${existing}${prefix}${entry}${eol}`);
+}
+function sanitizeModelName(value) {
+    return value.replace(/[^\w./-]/g, "").slice(0, 64);
+}
+function readModelOverridesFromEnv(env) {
+    const globalModel = env.PROMPTS_GPT_MODEL?.trim();
+    const entries = [
+        ["codex", env.PROMPTS_GPT_RUN_MODEL_CODEX],
+        ["cursor", env.PROMPTS_GPT_RUN_MODEL_CURSOR],
+        ["claude", env.PROMPTS_GPT_RUN_MODEL_CLAUDE],
+        ["copilot", env.PROMPTS_GPT_RUN_MODEL_COPILOT],
+    ];
+    const overrides = {};
+    for (const [provider, value] of entries) {
+        const trimmed = value?.trim() || globalModel;
+        if (trimmed) {
+            overrides[provider] = sanitizeModelName(trimmed);
+        }
+    }
+    return overrides;
+}
+async function resolveBatchPromptFiles(cwd, input, config) {
+    if (Array.isArray(input.promptFiles) && input.promptFiles.length > 0) {
+        return [...new Set(input.promptFiles.map((file) => path.resolve(cwd, file)))];
+    }
+    if (input.manifestPath) {
+        return readPromptFilesFromManifest(path.resolve(cwd, input.manifestPath), cwd);
+    }
+    if (config?.batchDefaults.promptFiles.length) {
+        return [...new Set(config.batchDefaults.promptFiles.map((file) => path.resolve(file)))];
+    }
+    const manifestPath = path.resolve(cwd, config?.batchDefaults.manifestPath || ".prompts-gpt/manifest.json");
+    return readPromptFilesFromManifest(manifestPath, cwd);
+}
+async function readPromptFilesFromManifest(manifestPath, cwd, options = {}) {
+    if (!existsSync(manifestPath)) {
+        throw new Error(`Manifest not found: ${manifestPath}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(await readFile(manifestPath, "utf8"));
+    }
+    catch {
+        throw new Error(`Manifest contains invalid JSON: ${manifestPath}`);
+    }
+    if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.prompts)) {
+        throw new Error(`Manifest has invalid structure (expected { prompts: [...] }): ${manifestPath}`);
+    }
+    const manifestDir = path.dirname(manifestPath);
+    const promptFiles = (parsed.prompts ?? [])
+        .map((item) => {
+        if (typeof item?.recommendedPath === "string" && item.recommendedPath.trim()) {
+            return path.resolve(cwd, item.recommendedPath);
+        }
+        if (typeof item?.file === "string" && item.file.trim()) {
+            return path.resolve(manifestDir, item.file);
+        }
+        return "";
+    })
+        .filter(Boolean);
+    if (promptFiles.length === 0) {
+        throw new Error(`Manifest has no prompt file entries: ${manifestPath}`);
+    }
+    const unique = [...new Set(promptFiles)];
+    const missing = unique.filter((f) => !existsSync(f));
+    if (!options.allowMissing && missing.length > 0) {
+        throw new Error(`Manifest references ${missing.length} missing file(s): ${missing.slice(0, 5).join(", ")}${missing.length > 5 ? ` (and ${missing.length - 5} more)` : ""}`);
+    }
+    return unique;
+}
+export function captureWorktreeStatus(cwd) {
+    const output = spawnSync("git", ["-C", cwd, "status", "--porcelain=v1", "-uall"], {
+        encoding: "utf8",
+        windowsHide: true,
+        timeout: 30_000,
+    });
+    if (output.status !== 0) {
+        return "git status unavailable\n";
+    }
+    return output.stdout || "";
+}
+export function buildWorktreeDelta(before, after) {
+    if (before === after) {
+        return "No worktree delta.\n";
+    }
+    return [
+        "=== BEFORE ===",
+        before.trimEnd(),
+        "",
+        "=== AFTER ===",
+        after.trimEnd(),
+        "",
+    ].join("\n");
+}
+function resolveConfiguredBatchDefaults(cwd, batchDefaults) {
+    const manifestPath = typeof batchDefaults?.manifestPath === "string" && batchDefaults.manifestPath.trim()
+        ? path.resolve(cwd, batchDefaults.manifestPath.trim())
+        : null;
+    const promptFiles = Array.isArray(batchDefaults?.promptFiles)
+        ? batchDefaults.promptFiles
+            .map((file) => String(file ?? "").trim())
+            .filter(Boolean)
+            .map((file) => path.resolve(cwd, file))
+        : [];
+    return {
+        manifestPath,
+        promptFiles: [...new Set(promptFiles)],
+    };
+}
+async function detectPromptSources(cwd, input) {
+    const explicitPromptFile = input.promptFile ? path.resolve(cwd, input.promptFile) : null;
+    const explicitPromptFiles = Array.isArray(input.promptFiles)
+        ? input.promptFiles.map((file) => path.resolve(cwd, file)).filter(Boolean)
+        : [];
+    if (explicitPromptFile) {
+        return {
+            defaultPromptFile: explicitPromptFile,
+            manifestPath: input.manifestPath ? path.resolve(cwd, input.manifestPath) : null,
+            promptFiles: [...new Set([explicitPromptFile, ...explicitPromptFiles])],
+        };
+    }
+    if (explicitPromptFiles.length > 0) {
+        return {
+            defaultPromptFile: explicitPromptFiles[0] ?? null,
+            manifestPath: input.manifestPath ? path.resolve(cwd, input.manifestPath) : null,
+            promptFiles: [...new Set(explicitPromptFiles)],
+        };
+    }
+    const manifestCandidate = path.resolve(cwd, input.manifestPath || ".prompts-gpt/manifest.json");
+    if (existsSync(manifestCandidate)) {
+        const promptFiles = await readPromptFilesFromManifest(manifestCandidate, cwd, { allowMissing: true });
+        return {
+            defaultPromptFile: promptFiles[0] ?? null,
+            manifestPath: manifestCandidate,
+            promptFiles,
+        };
+    }
+    const promptDirs = input.promptDir
+        ? [path.resolve(cwd, input.promptDir)]
+        : [
+            path.resolve(cwd, ".prompts-gpt"),
+            path.resolve(cwd, ".scripts", "prompts"),
+            path.resolve(cwd, "prompts"),
+            path.resolve(cwd, ".prompts"),
+        ];
+    const promptFiles = await discoverPromptFiles(promptDirs);
+    if (promptFiles.length === 0) {
+        return { defaultPromptFile: null, manifestPath: null, promptFiles: [] };
+    }
+    return {
+        defaultPromptFile: promptFiles[0] ?? null,
+        manifestPath: null,
+        promptFiles,
+    };
+}
+async function discoverPromptFiles(promptDirs) {
+    const files = [];
+    for (const promptDir of promptDirs) {
+        if (!existsSync(promptDir)) {
+            continue;
+        }
+        const entries = await readdir(promptDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile()) {
+                continue;
+            }
+            const name = entry.name.toLowerCase();
+            if ((name.endsWith(".md") || name.endsWith(".txt")) && name !== "readme.md") {
+                files.push(path.join(promptDir, entry.name));
+            }
+        }
+    }
+    return [...new Set(files)].sort();
+}
+function normalizeProviderOrderInput(providerOrder, providers) {
+    const normalized = Array.isArray(providerOrder) && providerOrder.length > 0
+        ? providerOrder
+            .map((provider) => parseConcreteProvider(String(provider)))
+            .filter((provider) => provider !== null)
+        : derivePreferredProviderOrder(providers);
+    return [...new Set(normalized)].filter((provider) => DEFAULT_PROVIDER_ORDER.includes(provider));
+}
+function derivePreferredProviderOrder(providers) {
+    const available = providers.filter((provider) => provider.available).map((provider) => provider.provider);
+    const unavailable = DEFAULT_PROVIDER_ORDER.filter((provider) => !available.includes(provider));
+    return [...available, ...unavailable];
+}
+function buildScaffoldModelOverrides(overrides) {
+    const result = {};
+    for (const provider of DEFAULT_PROVIDER_ORDER) {
+        const override = overrides?.[provider]?.trim();
+        if (override) {
+            result[provider] = override;
+        }
+    }
+    return result;
+}
+function resolveRetryCount(value) {
+    const raw = Number(value);
+    if (Number.isFinite(raw) && raw >= 0) {
+        return Math.trunc(raw);
+    }
+    return 0;
+}
+function toProjectConfigPath(cwd, value) {
+    const absolute = path.isAbsolute(value) ? value : path.resolve(cwd, value);
+    const relative = path.relative(cwd, absolute).replace(/\\/g, "/");
+    if (!relative || relative === "") {
+        return ".";
+    }
+    if (!relative.startsWith("..")) {
+        return relative.startsWith(".") ? relative : `./${relative}`;
+    }
+    const normalized = value.replace(/\\/g, "/").trim();
+    if (!normalized)
+        return DEFAULT_RUN_ARTIFACTS_DIR;
+    if (path.isAbsolute(normalized))
+        return normalized;
+    return normalized.replace(/^\.?\//, "./");
+}
+export async function resolveDefaultPromptFile(cwd, config) {
+    if (config.defaultPromptFile) {
+        return config.defaultPromptFile;
+    }
+    if (config.batchDefaults.promptFiles.length > 0) {
+        return config.batchDefaults.promptFiles[0];
+    }
+    if (config.batchDefaults.manifestPath) {
+        const promptFiles = await readPromptFilesFromManifest(config.batchDefaults.manifestPath, cwd);
+        if (promptFiles.length > 0) {
+            return promptFiles[0];
+        }
+    }
+    const discovered = await detectPromptSources(cwd, {});
+    if (discovered.defaultPromptFile && existsSync(discovered.defaultPromptFile)) {
+        const ext = path.extname(discovered.defaultPromptFile).toLowerCase();
+        if (ext === ".md" || ext === ".txt" || ext === "") {
+            return discovered.defaultPromptFile;
+        }
+    }
+    throw new Error("No default prompt file configured. Run `prompts-gpt list` to see available prompts, or pass `--prompt-file`.");
+}
+export function warnModelProviderMismatch(provider, model) {
+    if (provider === "codex" && model.includes("claude")) {
+        return `Model "${model}" is an Anthropic model but provider is codex (OpenAI). Use --agent claude instead.`;
+    }
+    if (provider === "claude" && (model.includes("gpt") || model.includes("codex") || model.includes("o4"))) {
+        return `Model "${model}" is an OpenAI model but provider is claude. Use --agent codex instead.`;
+    }
+    if (provider === "codex" && model === "gpt-5.1-codex") {
+        return `Model "gpt-5.1-codex" may not be available for all Codex accounts. If it fails, try --model o4-mini.`;
+    }
+    return null;
+}
+export function assertPromptFitsLaunch(provider, promptText, promptFile) {
+    if (!promptText || !promptText.trim()) {
+        throw new ProviderRunError("PROMPT_EMPTY", `Prompt file ${promptFile} is empty or contains only whitespace.`);
+    }
+    const nullByteIndex = promptText.indexOf("\0");
+    if (nullByteIndex !== -1) {
+        throw new ProviderRunError("PROMPT_BINARY", `Prompt file ${promptFile} contains null bytes at position ${nullByteIndex}. It may be a binary file.`);
+    }
+    if (provider === "codex") {
+        return;
+    }
+    const size = Buffer.byteLength(promptText, "utf8");
+    if (size > NON_CODEX_MAX_PROMPT_BYTES) {
+        throw new ProviderRunError("PROMPT_TOO_LARGE", `Prompt file ${promptFile} is ${size} bytes. ${provider} V1 execution passes prompt text on the command line and currently supports up to ${NON_CODEX_MAX_PROMPT_BYTES} bytes. Split the prompt, shorten it, or use codex/router.`);
+    }
+}
+function buildCommandPreview(command, provider) {
+    const MAX_PREVIEW_ARG_LEN = 120;
+    const safeArgs = command.args.map((arg) => {
+        if (arg.length > MAX_PREVIEW_ARG_LEN) {
+            return `<${provider}-prompt:${arg.length}chars>`;
+        }
+        let safe = arg;
+        for (const pattern of [
+            /pgpt_[a-zA-Z0-9]{4,}/g,
+            /sk-[a-zA-Z0-9]{20,}/g,
+            /ghp_[a-zA-Z0-9]{36,}/g,
+            /ghu_[a-zA-Z0-9]{36,}/g,
+            /Bearer\s+[a-zA-Z0-9_.-]{20,}/gi,
+            /ANTHROPIC_API_KEY=[^\s]+/gi,
+            /OPENAI_API_KEY=[^\s]+/gi,
+            /xai-[a-zA-Z0-9]{20,}/g,
+        ]) {
+            safe = safe.replace(pattern, (match) => `${match.slice(0, 6)}***`);
+        }
+        return safe;
+    });
+    return [command.command, ...safeArgs].join(" ");
+}
+export function formatCombinedOutput(stdoutText, stderrText) {
+    const out = stdoutText.trimEnd();
+    const err = stderrText.trimEnd();
+    if (!out && !err)
+        return "No provider output captured.\n";
+    if (!err)
+        return `${out}\n`;
+    if (!out)
+        return `[stderr]\n${err}\n`;
+    return `${out}\n\n[stderr]\n${err}\n`;
+}
+export async function appendFileSafe(filePath, content) {
+    const { appendFile: nodeAppend } = await import("node:fs/promises");
+    await nodeAppend(filePath, content).catch(async (err) => {
+        if (err.code === "ENOENT") {
+            await writeFile(filePath, content);
+        }
+    });
+}
+/** Discover all runnable assets in the workspace: prompts, sweeps, agent files. */
+export async function discoverWorkspaceAssets(cwd = process.cwd()) {
+    const resolvedCwd = path.resolve(cwd);
+    const configPath = path.resolve(resolvedCwd, DEFAULT_RUN_CONFIG_PATH);
+    const manifestPath = path.resolve(resolvedCwd, ".prompts-gpt/manifest.json");
+    const credsPath = path.resolve(resolvedCwd, ".prompts-gpt/.credentials.json");
+    const prompts = [];
+    const sweeps = [];
+    const agents = [];
+    if (existsSync(manifestPath)) {
+        try {
+            const raw = JSON.parse(await readFile(manifestPath, "utf8"));
+            for (const p of raw.prompts ?? []) {
+                if (p.file) {
+                    prompts.push({
+                        file: p.file,
+                        title: p.title ?? p.slug ?? p.file,
+                        slug: p.slug ?? p.file.replace(/\.md$/, ""),
+                        source: p.source ?? "library",
+                    });
+                }
+            }
+        }
+        catch { /* malformed manifest */ }
+    }
+    if (prompts.length === 0) {
+        const promptDir = path.resolve(resolvedCwd, ".prompts-gpt");
+        if (existsSync(promptDir)) {
+            try {
+                const entries = await readdir(promptDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isFile() && entry.name.endsWith(".md") && entry.name !== "README.md") {
+                        prompts.push({
+                            file: entry.name,
+                            title: entry.name.replace(/\.md$/, "").replace(/-/g, " "),
+                            slug: entry.name.replace(/\.md$/, ""),
+                            source: "local",
+                        });
+                    }
+                }
+            }
+            catch { /* dir read failed */ }
+        }
+    }
+    const sweepDir = path.resolve(resolvedCwd, ".prompts-gpt/sweeps");
+    if (existsSync(sweepDir)) {
+        try {
+            const entries = await readdir(sweepDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isFile() && entry.name.endsWith(".md")) {
+                    sweeps.push({
+                        file: `.prompts-gpt/sweeps/${entry.name}`,
+                        name: entry.name.replace(/\.md$/, ""),
+                    });
+                }
+            }
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === "EACCES" || code === "EPERM") {
+                throw new Error(`Cannot read sweep directory ${sweepDir}: permission denied.`);
+            }
+            if (code !== "ENOENT") {
+                throw err;
+            }
+        }
+    }
+    const agentFiles = [
+        ["AGENTS.md", "codex"],
+        ["CLAUDE.md", "claude-code"],
+        ["GEMINI.md", "gemini-cli"],
+        ["AGENT.md", "amp"],
+    ];
+    for (const [file, target] of agentFiles) {
+        if (existsSync(path.resolve(resolvedCwd, file))) {
+            agents.push({ file, target });
+        }
+    }
+    const agentDirs = [
+        [".cursor/rules", "cursor"],
+        [".github/prompts", "copilot"],
+        [".continue/rules", "continue"],
+        [".windsurf/rules", "windsurf"],
+        [".clinerules", "cline"],
+        [".junie", "junie"],
+    ];
+    for (const [dir, target] of agentDirs) {
+        const dirPath = path.resolve(resolvedCwd, dir);
+        if (existsSync(dirPath)) {
+            try {
+                const entries = await readdir(dirPath, { withFileTypes: true });
+                const pgptFiles = entries.filter((e) => e.isFile() && e.name.startsWith("prompts-gpt-"));
+                if (pgptFiles.length > 0) {
+                    agents.push({ file: dir, target });
+                }
+            }
+            catch { /* dir read failed */ }
+        }
+    }
+    return {
+        prompts,
+        sweeps,
+        agents,
+        configFound: existsSync(configPath),
+        manifestFound: existsSync(manifestPath),
+        credentialsFound: existsSync(credsPath),
+    };
+}
+/** Validate a run config file and return structured diagnostics. */
+export async function validateRunConfig(cwd = process.cwd()) {
+    const configPath = path.resolve(cwd, DEFAULT_RUN_CONFIG_PATH);
+    const errors = [];
+    const warnings = [];
+    if (!existsSync(configPath)) {
+        return { valid: true, configPath, errors, warnings: ["No config file found — using defaults."] };
+    }
+    let raw;
+    try {
+        raw = await readFile(configPath, "utf8");
+    }
+    catch (err) {
+        errors.push(`Cannot read config file: ${err instanceof Error ? err.message : String(err)}`);
+        return { valid: false, configPath, errors, warnings };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        errors.push("Config file contains invalid JSON.");
+        return { valid: false, configPath, errors, warnings };
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        errors.push("Config must be a JSON object.");
+        return { valid: false, configPath, errors, warnings };
+    }
+    if (parsed.providerOrder !== undefined) {
+        if (!Array.isArray(parsed.providerOrder)) {
+            errors.push("providerOrder must be an array of provider names.");
+        }
+        else {
+            const validProviders = new Set(DEFAULT_PROVIDER_ORDER);
+            for (const item of parsed.providerOrder) {
+                const p = parseConcreteProvider(String(item));
+                if (!p || !validProviders.has(p)) {
+                    warnings.push(`providerOrder contains unknown provider: ${String(item)}`);
+                }
+            }
+        }
+    }
+    if (parsed.timeoutSeconds !== undefined) {
+        const val = Number(parsed.timeoutSeconds);
+        if (!Number.isFinite(val) || val <= 0) {
+            errors.push("timeoutSeconds must be a positive number.");
+        }
+        else if (val > 86400) {
+            warnings.push("timeoutSeconds exceeds 24 hours — this may be unintentional.");
+        }
+    }
+    if (parsed.retryCount !== undefined) {
+        const val = Number(parsed.retryCount);
+        if (!Number.isFinite(val) || val < 0) {
+            errors.push("retryCount must be a non-negative integer.");
+        }
+        else if (val > 10) {
+            warnings.push("retryCount exceeds 10 — excessive retries can waste resources.");
+        }
+    }
+    if (parsed.modelOverrides !== undefined && typeof parsed.modelOverrides === "object" && parsed.modelOverrides !== null) {
+        const validProviderKeys = new Set(DEFAULT_PROVIDER_ORDER);
+        for (const key of Object.keys(parsed.modelOverrides)) {
+            if (!validProviderKeys.has(key)) {
+                warnings.push(`modelOverrides contains unknown provider key: ${key}`);
+            }
+        }
+    }
+    if (parsed.defaultAgent !== undefined) {
+        const agent = normalizeOrchestrationAgent(String(parsed.defaultAgent));
+        if (agent === "router" && String(parsed.defaultAgent).toLowerCase() !== "router") {
+            warnings.push(`Unrecognized defaultAgent: ${String(parsed.defaultAgent)} — will fall back to router.`);
+        }
+    }
+    if (typeof parsed.defaultPromptFile === "string" && parsed.defaultPromptFile.trim()) {
+        const resolved = path.resolve(cwd, parsed.defaultPromptFile.trim());
+        if (!existsSync(resolved)) {
+            warnings.push(`defaultPromptFile does not exist: ${parsed.defaultPromptFile}`);
+        }
+    }
+    if (typeof parsed.batchDefaults === "object" && parsed.batchDefaults !== null) {
+        const bd = parsed.batchDefaults;
+        if (typeof bd.manifestPath === "string" && bd.manifestPath.trim()) {
+            const resolved = path.resolve(cwd, bd.manifestPath.trim());
+            if (!existsSync(resolved)) {
+                warnings.push(`batchDefaults.manifestPath does not exist: ${bd.manifestPath}`);
+            }
+        }
+        if (Array.isArray(bd.promptFiles)) {
+            for (const pf of bd.promptFiles) {
+                if (typeof pf === "string" && pf.trim()) {
+                    const resolved = path.resolve(cwd, pf.trim());
+                    if (!existsSync(resolved)) {
+                        warnings.push(`batchDefaults.promptFiles entry does not exist: ${pf}`);
+                    }
+                }
+            }
+        }
+    }
+    return { valid: errors.length === 0, configPath, errors, warnings };
+}
+//# sourceMappingURL=runtime.js.map