prompts-gpt 0.3.2 → 0.3.3

package/dist/cli.js

@@ -3,7 +3,7 @@ import { existsSync, readFileSync, statSync, readdirSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 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, normalizeConcreteProvider, normalizeOrchestrationAgent, ORCHESTRATION_AGENT_PROFILES, runBatch, runPrompt, resolveRunProvider, warnModelProviderMismatch, sweepPrompt, validateRunConfig, discoverWorkspaceAssets, SUPPORTED_AGENT_TARGETS, detectProviders, loadLocalCredentials, saveLocalCredentials, syncPrompts, writeAgentFiles, writePromptManifest, writePromptMarkdownFiles, ensureGitignoreEntry, isCI, orchestrateParallel, orchestratePipeline, orchestrateEval, captureGitBranch, resolveModelWithWarning, getModelCostTier, estimateTokenCost, } from "./index.js";
+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, normalizeConcreteProvider, normalizeOrchestrationAgent, ORCHESTRATION_AGENT_PROFILES, runBatch, runPrompt, resolveRunProvider, warnModelProviderMismatch, sweepPrompt, validateRunConfig, discoverWorkspaceAssets, SUPPORTED_AGENT_TARGETS, detectProviders, loadLocalCredentials, saveLocalCredentials, syncPrompts, writeAgentFiles, writePromptManifest, writePromptMarkdownFiles, ensureGitignoreEntry, isCI, orchestrateParallel, orchestratePipeline, orchestrateEval, captureGitBranch, resolveModelWithWarning, getModelCostTier, estimateTokenCost, DEFAULT_MODELS, } from "./index.js";
 const CLI_EXIT_CODES = {
     success: 0,
     general: 1,
@@ -1229,6 +1229,14 @@ async function runCommand(command, flags) {
             flags["non-interactive"] = true;
         }
         const sweepPromptFile = getStringFlag(flags, "prompt-file");
+        const sweepFilesFlag = getStringFlag(flags, "sweep-files");
+        const allSweepsFlag = Boolean(flags["all-sweeps"]);
+        if (sweepPromptFile && (sweepFilesFlag || allSweepsFlag)) {
+            throw new CliError("Use either --prompt-file for one sweep, --sweep-files for selected sweeps, or --all-sweeps for every sweep file.", CLI_EXIT_CODES.validation, { helpCommand: "sweep" });
+        }
+        if (sweepFilesFlag && allSweepsFlag) {
+            throw new CliError("Use either --sweep-files or --all-sweeps, not both.", CLI_EXIT_CODES.validation, { helpCommand: "sweep" });
+        }
         if (sweepPromptFile && !existsSync(path.resolve(cwd, sweepPromptFile))) {
             throw new CliError(`Sweep file not found: ${sweepPromptFile}\n\nCheck the path and try again. Run \`prompts-gpt list\` to see available sweep files.`, CLI_EXIT_CODES.validation, { helpCommand: "sweep" });
         }
@@ -1255,7 +1263,7 @@ async function runCommand(command, flags) {
             }
             throw new CliError("No supported provider CLI was found on PATH. Install Codex, Cursor Agent, Claude Code, or Copilot CLI, then run `prompts-gpt doctor`.", CLI_EXIT_CODES.validation, { helpCommand: "providers" });
         }
-        if (!sweepPromptFile && !Boolean(flags.json)) {
+        if (!sweepPromptFile && !sweepFilesFlag && !allSweepsFlag && !Boolean(flags.json)) {
             const assets = await discoverWorkspaceAssets(cwd);
             if (assets.sweeps.length === 1) {
                 const autoFile = assets.sweeps[0].file;
@@ -1656,6 +1664,159 @@ async function runCommand(command, flags) {
             evaluatorModel: getStringFlag(flags, "eval-model") ?? getStringFlag(flags, "evaluator-model"),
             criteria: getStringFlag(flags, "eval-criteria")?.split(",").map((c) => c.trim()),
         } : undefined;
+        const requestedSweepFiles = await resolveSweepFileSelection(cwd, flags);
+        if (requestedSweepFiles.length > 0) {
+            const rawSweepStrategy = getStringFlag(flags, "sweep-strategy") ?? getStringFlag(flags, "files-mode") ?? "sequential";
+            if (rawSweepStrategy !== "sequential" && rawSweepStrategy !== "parallel") {
+                throw new CliError("--sweep-strategy must be either sequential or parallel.", CLI_EXIT_CODES.validation, { helpCommand: "sweep" });
+            }
+            const rawFileConcurrency = parsePositiveIntFlag(getStringFlag(flags, "file-concurrency"), "file-concurrency");
+            const MAX_FILE_CONCURRENCY = 12;
+            const fileConcurrency = rawSweepStrategy === "parallel"
+                ? Math.min(rawFileConcurrency ?? requestedSweepFiles.length, MAX_FILE_CONCURRENCY, requestedSweepFiles.length)
+                : 1;
+            if (rawFileConcurrency && rawFileConcurrency > MAX_FILE_CONCURRENCY) {
+                console.log(`Warning: --file-concurrency ${rawFileConcurrency} capped to ${MAX_FILE_CONCURRENCY} to prevent resource exhaustion.`);
+            }
+            const rawParallelCount = parsePositiveIntFlag(getStringFlag(flags, "parallel"), "parallel");
+            const MAX_PARALLEL_SWEEPS = 16;
+            const parallelCount = rawParallelCount ? Math.min(rawParallelCount, MAX_PARALLEL_SWEEPS) : undefined;
+            if (rawParallelCount && rawParallelCount > MAX_PARALLEL_SWEEPS) {
+                console.log(`Warning: --parallel ${rawParallelCount} capped to ${MAX_PARALLEL_SWEEPS} to prevent resource exhaustion.`);
+            }
+            const explicitIterations = parsePositiveIntFlag(getStringFlag(flags, "iterations"), "iterations");
+            const runBaseId = getStringFlag(flags, "run-id") || `sweep-plan-${new Date().toISOString().replace(/[-:T]/g, "").slice(0, 14)}`;
+            const planStartMs = Date.now();
+            async function resolveIterationsForFile(file) {
+                if (explicitIterations)
+                    return explicitIterations;
+                return await readSweepIterationsFromFrontmatter(path.resolve(cwd, file)) ?? 1;
+            }
+            async function runSweepFile(file, index) {
+                const iterationsForFile = await resolveIterationsForFile(file);
+                const fileSlug = path.basename(file, ".md").replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || `file-${index + 1}`;
+                const fileRunId = `${runBaseId}-${String(index + 1).padStart(2, "0")}-${fileSlug}`;
+                if (parallelCount && parallelCount > 1) {
+                    const batchSize = Math.min(parallelCount, iterationsForFile);
+                    if (!silent) {
+                        console.log(`\n${path.basename(file)}: running ${iterationsForFile} independent iteration${iterationsForFile === 1 ? "" : "s"} with parallelism=${batchSize}`);
+                    }
+                    const allResults = [];
+                    for (let batchStart = 0; batchStart < iterationsForFile; batchStart += batchSize) {
+                        const batchEnd = Math.min(batchStart + batchSize, iterationsForFile);
+                        const batchPromises = [];
+                        for (let i = batchStart; i < batchEnd; i++) {
+                            batchPromises.push(sweepPrompt({
+                                cwd,
+                                promptFile: file,
+                                agent,
+                                model: getStringFlag(flags, "model"),
+                                iterations: 1,
+                                iterationTimeoutSeconds: parsePositiveIntFlag(getStringFlag(flags, "iteration-timeout"), "iteration-timeout"),
+                                maxRetries: parseNonNegativeIntFlag(getStringFlag(flags, "max-retries"), "max-retries"),
+                                artifactsDir: getStringFlag(flags, "artifacts-dir"),
+                                runId: `${fileRunId}-iter-${i + 1}`,
+                                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"),
+                                evalAfterEachIteration: evalConfig,
+                                onProgress,
+                            }));
+                        }
+                        const batchResults = await Promise.allSettled(batchPromises);
+                        for (const batchResult of batchResults) {
+                            if (batchResult.status === "fulfilled")
+                                allResults.push(batchResult.value);
+                            else if (!Boolean(flags.json))
+                                console.error(`Sweep failed for ${file}: ${batchResult.reason instanceof Error ? batchResult.reason.message : String(batchResult.reason)}`);
+                        }
+                    }
+                    const succeeded = allResults.reduce((sum, result) => sum + result.succeeded, 0);
+                    const failed = allResults.reduce((sum, result) => sum + result.failed, 0) + (iterationsForFile - allResults.length);
+                    return { file, iterations: iterationsForFile, succeeded, failed, results: allResults };
+                }
+                const result = await sweepPrompt({
+                    cwd,
+                    promptFile: file,
+                    agent,
+                    model: getStringFlag(flags, "model"),
+                    iterations: iterationsForFile,
+                    iterationTimeoutSeconds: parsePositiveIntFlag(getStringFlag(flags, "iteration-timeout"), "iteration-timeout"),
+                    maxRetries: parseNonNegativeIntFlag(getStringFlag(flags, "max-retries"), "max-retries"),
+                    artifactsDir: getStringFlag(flags, "artifacts-dir"),
+                    runId: fileRunId,
+                    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"),
+                    evalAfterEachIteration: evalConfig,
+                    onProgress,
+                });
+                return { file, iterations: result.totalIterations, succeeded: result.succeeded, failed: result.failed, results: [result] };
+            }
+            if (!Boolean(flags.json)) {
+                console.log(`Running ${requestedSweepFiles.length} sweep file${requestedSweepFiles.length === 1 ? "" : "s"} with ${rawSweepStrategy} file execution${rawSweepStrategy === "parallel" ? ` (file concurrency=${fileConcurrency})` : ""}.`);
+                if (parallelCount && parallelCount > 1) {
+                    console.log(`Each file runs its iterations independently with --parallel ${parallelCount}.`);
+                }
+            }
+            const plannedResults = [];
+            if (rawSweepStrategy === "parallel") {
+                for (let batchStart = 0; batchStart < requestedSweepFiles.length; batchStart += fileConcurrency) {
+                    const batch = requestedSweepFiles.slice(batchStart, batchStart + fileConcurrency);
+                    const settled = await Promise.allSettled(batch.map((file, offset) => runSweepFile(file, batchStart + offset)));
+                    for (const result of settled) {
+                        if (result.status === "fulfilled")
+                            plannedResults.push(result.value);
+                        else if (!Boolean(flags.json))
+                            console.error(result.reason instanceof Error ? result.reason.message : String(result.reason));
+                    }
+                }
+            }
+            else {
+                for (let index = 0; index < requestedSweepFiles.length; index++) {
+                    plannedResults.push(await runSweepFile(requestedSweepFiles[index], index));
+                }
+            }
+            const totalSucceeded = plannedResults.reduce((sum, result) => sum + result.succeeded, 0);
+            const totalFailed = plannedResults.reduce((sum, result) => sum + result.failed, 0);
+            const totalIterations = plannedResults.reduce((sum, result) => sum + result.iterations, 0);
+            const totalDuration = Date.now() - planStartMs;
+            if (Boolean(flags.json)) {
+                console.log(JSON.stringify({
+                    multiFile: true,
+                    sweepStrategy: rawSweepStrategy,
+                    fileConcurrency,
+                    files: plannedResults,
+                    totalFiles: requestedSweepFiles.length,
+                    totalIterations,
+                    totalSucceeded,
+                    totalFailed,
+                    totalDurationMs: totalDuration,
+                }, null, 2));
+            }
+            else {
+                console.log(`\nSweep plan complete: ${totalSucceeded}/${totalIterations} iterations succeeded across ${requestedSweepFiles.length} file${requestedSweepFiles.length === 1 ? "" : "s"}.`);
+                if (totalFailed > 0)
+                    console.log(`Failed iterations: ${totalFailed}`);
+                console.log(`Total wall-clock time: ${formatDuration(totalDuration)}`);
+                for (const result of plannedResults) {
+                    console.log(`  ${result.file}: ${result.succeeded}/${result.iterations} succeeded`);
+                }
+            }
+            if (totalFailed > 0 || plannedResults.length < requestedSweepFiles.length)
+                process.exitCode = 1;
+            return;
+        }
         // Parallel sweep — run N iterations concurrently
         const rawParallelCount = parsePositiveIntFlag(getStringFlag(flags, "parallel"), "parallel");
         const MAX_PARALLEL_SWEEPS = 16;
@@ -1912,12 +2073,34 @@ async function runCommand(command, flags) {
                 }
                 else if (event.type === "provider_start") {
                     const stepLabel = event.step ? ` [${event.step}]` : "";
-                    console.log(`  ${orchUc ? "▶" : ">"} ${event.provider}${stepLabel} starting...`);
+                    const modelLabel = event.model ? colorize(` (${event.model})`, "\x1b[2m") : "";
+                    const promptLabel = event.promptFile ? colorize(` ${event.promptFile}`, "\x1b[2m") : "";
+                    console.log(`  ${orchUc ? "▶" : ">"} ${event.provider}${stepLabel}${modelLabel} starting...${promptLabel}`);
+                }
+                else if (event.type === "step_context") {
+                    console.log(`    ${colorize(orchUc ? "↳" : "->", "\x1b[36m")} Receiving ${formatContextSize(event.contextChars)} context from "${event.source}"`);
+                    if (event.contextPreview) {
+                        console.log(`      ${colorize(truncatePreview(event.contextPreview, 120), "\x1b[2m")}`);
+                    }
                 }
                 else if (event.type === "provider_end") {
                     const icon = event.exitCode === 0 ? colorize(orchUc ? "✓" : "OK", "\x1b[32m") : colorize(orchUc ? "✗" : "FAIL", "\x1b[31m");
                     console.log(`  ${icon} ${event.provider} finished (${formatDuration(event.durationMs)}, exit=${event.exitCode})`);
                 }
+                else if (event.type === "step_summary") {
+                    if (event.filesChanged.length > 0) {
+                        console.log(`    ${colorize(orchUc ? "📝" : "[files]", "\x1b[36m")} ${event.filesChanged.length} file(s) changed:`);
+                        for (const f of event.filesChanged.slice(0, 10)) {
+                            console.log(`      ${colorize(f, "\x1b[2m")}`);
+                        }
+                        if (event.filesChanged.length > 10) {
+                            console.log(`      ${colorize(`...and ${event.filesChanged.length - 10} more`, "\x1b[2m")}`);
+                        }
+                    }
+                    if (event.outputChars > 0) {
+                        console.log(`    ${colorize(orchUc ? "💬" : "[out]", "\x1b[36m")} Output: ${formatContextSize(event.outputChars)} ${colorize(`→ passed to next step`, "\x1b[2m")}`);
+                    }
+                }
                 else if (event.type === "eval_start") {
                     console.log(`  ${orchUc && supportsUnicode() ? "🧪" : "[eval]"} Evaluating with ${event.evaluator}...`);
                 }
@@ -1927,8 +2110,12 @@ async function runCommand(command, flags) {
                 else if (event.type === "warning") {
                     console.log(`  ${colorize(orchUc ? "⚠" : "[warn]", "\x1b[33m")} ${event.text}`);
                 }
+                else if (event.type === "info") {
+                    console.log(`  ${colorize(orchUc ? "ℹ" : "[info]", "\x1b[36m")} ${event.text}`);
+                }
                 else if (event.type === "orchestrate_end") {
-                    console.log(`\n${colorize(orchBar, "\x1b[35m")} Done in ${formatDuration(event.totalDurationMs)}${event.winner ? ` | winner=${event.winner}` : ""} ${colorize(orchBar, "\x1b[35m")}\n`);
+                    const artLabel = event.artifactsDir ? ` | logs: ${path.relative(cwd, event.artifactsDir)}` : "";
+                    console.log(`\n${colorize(orchBar, "\x1b[35m")} Done in ${formatDuration(event.totalDurationMs)}${event.winner ? ` | winner=${event.winner}` : ""}${artLabel} ${colorize(orchBar, "\x1b[35m")}\n`);
                 }
             };
         if (mode === "parallel") {
@@ -1991,20 +2178,25 @@ async function runCommand(command, flags) {
                 throw new CliError(`Pipeline steps file not found: ${resolvedStepsFile}`, CLI_EXIT_CODES.usage);
             }
             let stepsJson;
+            let pipelineDefaults = {};
             try {
                 const parsed = JSON.parse(readFileSync(resolvedStepsFile, "utf8"));
                 if (Array.isArray(parsed)) {
                     stepsJson = parsed;
                 }
                 else if (parsed && typeof parsed === "object" && Array.isArray(parsed.steps)) {
-                    stepsJson = parsed.steps;
+                    const wrapper = parsed;
+                    stepsJson = wrapper.steps;
+                    if (wrapper.defaults && typeof wrapper.defaults === "object") {
+                        pipelineDefaults = wrapper.defaults;
+                    }
                 }
                 else {
-                    throw new Error("Pipeline steps config must be either an array of steps or an object with a steps array.");
+                    throw new Error("Pipeline config must be an array of steps or an object with { defaults?, steps }.");
                 }
             }
             catch (error) {
-                if (error instanceof Error && error.message.includes("Pipeline steps config must be either")) {
+                if (error instanceof Error && error.message.includes("Pipeline config must be")) {
                     throw new CliError(error.message, CLI_EXIT_CODES.validation);
                 }
                 throw new CliError(`Pipeline steps file contains invalid JSON: ${resolvedStepsFile}`, CLI_EXIT_CODES.validation);
@@ -2012,8 +2204,11 @@ async function runCommand(command, flags) {
             if (!Array.isArray(stepsJson) || stepsJson.length === 0) {
                 throw new CliError("Pipeline steps file must contain a non-empty JSON array", CLI_EXIT_CODES.usage);
             }
-            const defaultPipelineAgent = resolveRunAgent(flags, config.defaultAgent);
-            const globalPipelineModel = getStringFlag(flags, "model");
+            const defaultPipelineAgent = pipelineDefaults.agent?.trim() || resolveRunAgent(flags, config.defaultAgent);
+            const globalPipelineModel = getStringFlag(flags, "model") || pipelineDefaults.model?.trim();
+            const globalPipelineTimeout = pipelineDefaults.timeout;
+            const globalPipelineRetries = pipelineDefaults.retries;
+            const globalPipelineSandbox = pipelineDefaults.sandboxMode;
             for (const step of stepsJson) {
                 if (!step || typeof step.name !== "string" || typeof step.promptFile !== "string") {
                     throw new CliError(`Pipeline step entries must include name and promptFile fields: ${resolvedStepsFile}`, CLI_EXIT_CODES.validation);
@@ -2030,6 +2225,15 @@ async function runCommand(command, flags) {
                 if (!step.model && globalPipelineModel) {
                     step.model = globalPipelineModel;
                 }
+                if (!step.timeout && globalPipelineTimeout) {
+                    step.timeout = globalPipelineTimeout;
+                }
+                if (typeof step.retries !== "number" && typeof globalPipelineRetries === "number") {
+                    step.retries = globalPipelineRetries;
+                }
+                if (!step.sandboxMode && globalPipelineSandbox) {
+                    step.sandboxMode = globalPipelineSandbox;
+                }
                 if (step.model) {
                     const stepProvider = resolveRunProvider(normalizeOrchestrationAgent(step.agent), providers, config.providerOrder);
                     const modelCheck = validateModelForProvider(step.model, stepProvider);
@@ -2038,11 +2242,40 @@ async function runCommand(command, flags) {
                     }
                 }
             }
+            if (isTTYInteractive(flags) && !jsonOutput && !globalPipelineModel) {
+                for (const step of stepsJson) {
+                    if (!step.model) {
+                        const stepProvider = resolveRunProvider(normalizeOrchestrationAgent(step.agent ?? defaultPipelineAgent), providers, config.providerOrder);
+                        const modelChoices = getModelChoicesForProvider(stepProvider, config);
+                        const defaultModel = config.modelOverrides[stepProvider] || DEFAULT_MODELS[stepProvider] || "auto";
+                        modelChoices.unshift({ label: `${defaultModel} (default)`, value: defaultModel });
+                        const pickedModel = await interactiveSelect(`Model for step "${step.name}" (${stepProvider}):`, modelChoices.filter((c, i, arr) => arr.findIndex((x) => x.value === c.value) === i));
+                        if (pickedModel === "__custom__") {
+                            step.model = await interactiveInput("Enter custom model name", "");
+                        }
+                        else {
+                            step.model = pickedModel;
+                        }
+                    }
+                }
+            }
+            if (!jsonOutput && !dryRun) {
+                console.log(`\n  Pipeline Plan (${stepsJson.length} steps):`);
+                for (let idx = 0; idx < stepsJson.length; idx++) {
+                    const s = stepsJson[idx];
+                    const sp = resolveRunProvider(normalizeOrchestrationAgent(s.agent ?? defaultPipelineAgent), providers, config.providerOrder);
+                    const sm = s.model?.trim() || config.modelOverrides[sp] || DEFAULT_MODELS[sp] || "auto";
+                    console.log(`    ${idx + 1}. ${s.name} ${colorize(`(${sp} / ${sm})`, "\x1b[2m")}`);
+                }
+                console.log();
+            }
+            const continueOnError = Boolean(flags["continue-on-error"]);
             const result = await orchestratePipeline({
                 cwd,
                 steps: stepsJson,
                 timeoutSeconds,
                 dryRun,
+                continueOnError,
                 onProgress,
             });
             if (jsonOutput) {
@@ -2052,12 +2285,25 @@ async function runCommand(command, flags) {
                 console.log("Pipeline Results:");
                 for (const step of result.steps) {
                     const icon = step.result.exitCode === 0 ? sym("✓", "+") : sym("✗", "x");
-                    const model = step.result.model && step.result.model !== "dry-run" ? ` model=${step.result.model}` : "";
-                    console.log(`  ${icon} ${step.name} (${step.provider}${model}) — ${formatDuration(step.durationMs)}`);
+                    const modelStr = step.result.model && step.result.model !== "dry-run" ? colorize(` model=${step.result.model}`, "\x1b[2m") : "";
+                    console.log(`  ${icon} ${step.name} (${step.provider}${modelStr}) — ${formatDuration(step.durationMs)}`);
+                    if (step.result.summaryFile && existsSync(step.result.summaryFile)) {
+                        const summary = readFileSync(step.result.summaryFile, "utf8").trim();
+                        if (summary) {
+                            const summaryPreview = truncatePreview(summary.replace(/\n/g, " "), 150);
+                            console.log(`    ${colorize(summaryPreview, "\x1b[2m")}`);
+                        }
+                    }
                 }
                 const successCount = result.steps.filter((s) => s.result.exitCode === 0).length;
                 const failCount = result.steps.filter((s) => s.result.exitCode !== 0).length;
                 console.log(`\n  Total: ${formatDuration(result.totalDurationMs)} | ${successCount} passed${failCount > 0 ? `, ${failCount} failed` : ""}`);
+                if (result.artifactsDir) {
+                    const relativeArtifacts = path.relative(cwd, result.artifactsDir) || result.artifactsDir;
+                    console.log(`  Artifacts: ${colorize(relativeArtifacts, "\x1b[2m")}`);
+                    console.log(`\n  Inspect step details:`);
+                    console.log(`    prompts-gpt diff ${relativeArtifacts}`);
+                }
             }
             return;
         }
@@ -2704,20 +2950,90 @@ async function runCommand(command, flags) {
         if (existsSync(filePath) && !Boolean(flags.overwrite)) {
             throw new CliError(`Orchestration file already exists: ${filePath}\nUse --overwrite to replace it.`, CLI_EXIT_CODES.validation);
         }
-        const content = isPipelineTemplate
-            ? PIPELINE_TEMPLATE
-                .replace(/\{goal\}/g, goal.trim())
-            : ORCHESTRATION_TEMPLATE
+        if (isPipelineTemplate) {
+            const stepsDir = path.join(orchDir, "pipeline-steps");
+            await fsMkdir(stepsDir, { recursive: true });
+            let numSteps = 3;
+            let stepDefs = [
+                { name: "research", description: `Research and analyze requirements for: ${goal.trim()}`, agent: "codex" },
+                { name: "implement", description: `Implement the solution based on the research analysis`, agent: "claude" },
+                { name: "test-and-review", description: `Test, review, and validate the implementation`, agent: "cursor" },
+            ];
+            if (isTTYInteractive()) {
+                const stepCountChoice = await interactiveSelect("How many pipeline steps?", [
+                    { label: "2 steps (research + implement)", value: "2" },
+                    { label: "3 steps (research + implement + review)", value: "3" },
+                    { label: "4 steps (research + implement + test + review)", value: "4" },
+                ]);
+                numSteps = parseInt(stepCountChoice, 10);
+                if (numSteps === 2) {
+                    stepDefs = [
+                        { name: "research", description: `Research and analyze: ${goal.trim()}`, agent: "codex" },
+                        { name: "implement", description: `Implement based on research`, agent: "claude" },
+                    ];
+                }
+                else if (numSteps === 4) {
+                    stepDefs = [
+                        { name: "research", description: `Research and analyze: ${goal.trim()}`, agent: "codex" },
+                        { name: "implement", description: `Implement the solution`, agent: "claude" },
+                        { name: "test", description: `Run tests and fix failures`, agent: "cursor" },
+                        { name: "review", description: `Code review and final validation`, agent: "codex" },
+                    ];
+                }
+                for (let si = 0; si < stepDefs.length; si++) {
+                    const s = stepDefs[si];
+                    const customName = await interactiveInput(`Step ${si + 1} name`, s.name);
+                    s.name = customName || s.name;
+                    const agentPick = await interactiveSelect(`Step ${si + 1} ("${s.name}") agent:`, [
+                        { label: "codex — OpenAI Codex CLI", value: "codex" },
+                        { label: "claude — Anthropic Claude Code", value: "claude" },
+                        { label: "cursor — Cursor Agent", value: "cursor" },
+                        { label: "copilot — GitHub Copilot", value: "copilot" },
+                    ]);
+                    s.agent = agentPick;
+                }
+            }
+            const stepFilePaths = [];
+            for (const s of stepDefs) {
+                const stepFileName = `${s.name.replace(/[^a-zA-Z0-9_-]/g, "-").toLowerCase()}.md`;
+                const stepFilePath = path.join(stepsDir, stepFileName);
+                stepFilePaths.push(path.relative(cwd, stepFilePath));
+                if (!existsSync(stepFilePath)) {
+                    const stepContent = buildPipelineStepPrompt(s.name, s.description, stepDefs.indexOf(s), stepDefs.length);
+                    await fsWriteFile(stepFilePath, stepContent);
+                }
+            }
+            const pipelineConfig = {
+                defaults: { timeout: 900 },
+                steps: stepDefs.map((s, si) => ({
+                    name: s.name,
+                    promptFile: stepFilePaths[si],
+                    agent: s.agent,
+                })),
+            };
+            await fsWriteFile(filePath, JSON.stringify(pipelineConfig, null, 2) + "\n");
+            console.log(`${sym("\u2713", "+")} Created pipeline orchestration:`);
+            console.log(`  Config: ${path.relative(cwd, filePath)}`);
+            for (const fp of stepFilePaths) {
+                console.log(`  Prompt: ${fp}`);
+            }
+            console.log(`\nRun it with:`);
+            console.log(`  prompts-gpt orchestrate --mode pipeline --steps ${path.relative(cwd, filePath)}`);
+            console.log(`\nEdit the step prompt files to customize behavior, then run the pipeline.`);
+        }
+        else {
+            const content = ORCHESTRATION_TEMPLATE
                 .replace(/\{title\}/g, title.trim())
                 .replace(/\{description\}/g, (description || title).trim())
                 .replace('"parallel"', `"${mode}"`)
                 .replace("{goal}", goal.trim())
                 .replace("{step1}", `Analyze the requirements for: ${goal.trim()}`)
                 .replace("{step2}", `Implement the solution based on the analysis`);
-        await fsWriteFile(filePath, content);
-        console.log(`${sym("\u2713", "+")} Created orchestration file: ${filePath}`);
-        console.log(`\nRun it with:`);
-        console.log(`  prompts-gpt orchestrate --mode ${mode}${isPipelineTemplate ? ` --steps ${path.relative(cwd, filePath)}` : ` -f ${path.relative(cwd, filePath)}`}`);
+            await fsWriteFile(filePath, content);
+            console.log(`${sym("\u2713", "+")} Created orchestration file: ${filePath}`);
+            console.log(`\nRun it with:`);
+            console.log(`  prompts-gpt orchestrate --mode ${mode} -f ${path.relative(cwd, filePath)}`);
+        }
         return;
     }
     if (command === "sync") {
@@ -3124,6 +3440,11 @@ function getCommandOptions(command) {
             quiet: { type: "boolean", short: "q" },
             silent: { type: "boolean" },
             parallel: { type: "string" },
+            "all-sweeps": { type: "boolean" },
+            "sweep-files": { type: "string" },
+            "sweep-strategy": { type: "string" },
+            "files-mode": { type: "string" },
+            "file-concurrency": { type: "string" },
             eval: { type: "boolean" },
             "eval-criteria": { type: "string" },
             "eval-agent": { type: "string" },
@@ -3151,6 +3472,7 @@ function getCommandOptions(command) {
             model: { type: "string" },
             timeout: { type: "string" },
             "dry-run": { type: "boolean" },
+            "continue-on-error": { type: "boolean" },
             "non-interactive": { type: "boolean" },
             "list-models": { type: "boolean" },
         };
@@ -3604,6 +3926,19 @@ function formatDuration(ms) {
         return `${minutes}m ${seconds}s`;
     return `${seconds}s`;
 }
+function formatContextSize(chars) {
+    if (chars < 1000)
+        return `${chars} chars`;
+    if (chars < 100_000)
+        return `${(chars / 1000).toFixed(1)}k chars`;
+    return `${(chars / 1_000_000).toFixed(2)}M chars`;
+}
+function truncatePreview(text, maxLen) {
+    const clean = text.replace(/\s+/g, " ").trim();
+    if (clean.length <= maxLen)
+        return clean;
+    return clean.slice(0, maxLen - 3) + "...";
+}
 function formatList(values) {
     if (!Array.isArray(values) || values.length === 0)
         return "None";
@@ -4342,9 +4677,14 @@ Usage:
   prompts-gpt generate-orchestration [--title <text>] [--goal <text>] [--description <text>] [--mode <parallel|pipeline|eval>] [--overwrite] [--cwd <path>]
 
 Why use it:
-  Scaffolds a new orchestration template locally for multi-agent workflows.
-  Pipeline mode emits a runnable JSON steps file; parallel and eval modes emit Markdown prompt templates.
-  Run interactively (no flags) for a guided experience, or pass all flags for scripting.
+  Scaffolds a new orchestration locally. Pipeline mode creates a JSON config AND step prompt files
+  so you can immediately run the pipeline. Parallel and eval modes create Markdown prompt templates.
+  Run interactively (no flags) for a guided wizard that lets you pick steps, agents, and models.
+
+What it creates (pipeline mode):
+  .prompts-gpt/orchestrations/<name>.json         — Pipeline config with steps
+  .prompts-gpt/orchestrations/pipeline-steps/     — Step prompt Markdown files
+    research.md, implement.md, test-and-review.md
 
 Options:
   --title <text>           Required. The orchestration title (used as filename).
@@ -4356,8 +4696,15 @@ Options:
   --help                   Show this command help.
 
 Examples:
+  # Interactive wizard — pick steps, agents, models
   prompts-gpt generate-orchestration
+
+  # Non-interactive pipeline scaffolding
   prompts-gpt generate-orchestration --title "Full Stack Feature" --goal "Add user auth" --mode pipeline
+
+  # Then customize the generated step prompts and run
+  # Edit: .prompts-gpt/orchestrations/pipeline-steps/*.md
+  prompts-gpt orchestrate --mode pipeline --steps .prompts-gpt/orchestrations/full-stack-feature.json
 `;
     }
     if (command === "completions") {
@@ -4485,6 +4832,8 @@ Examples:
 
 Usage:
   prompts-gpt sweep [-f <path>] [-n <count>] [--agent <name>] [--model <name>] [--dry-run]
+  prompts-gpt sweep --all-sweeps [--sweep-strategy sequential|parallel] [-n <count>]
+  prompts-gpt sweep --sweep-files <a,b,c> [--sweep-strategy sequential|parallel] [-n <count>]
 
 Why use it:
   Runs the same prompt N times, feeding each iteration's summary into the next.
@@ -4496,6 +4845,11 @@ Why use it:
 Options:
   -f, --prompt-file <path>     Prompt file to sweep. Auto-detects local sweeps if omitted.
   -n, --iterations <n>         Number of iterations. Interactive default: 1.
+  --all-sweeps                 Run every file in .prompts-gpt/sweeps.
+  --sweep-files <list>         Comma-separated sweep paths, filenames, or sweep names.
+  --sweep-strategy <mode>      File execution mode: sequential or parallel. Default: sequential.
+  --files-mode <mode>          Alias for --sweep-strategy.
+  --file-concurrency <n>       Max sweep files to run at once in parallel mode.
   --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)
@@ -4510,7 +4864,7 @@ Options:
   --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.
-  --parallel <n>               Run iterations in parallel batches (experimental).
+  --parallel <n>               Run iterations in parallel batches inside each selected file (experimental).
   --quiet, -q                  Suppress live tool/message logs (keep iteration headers).
   --silent                     Suppress all output except errors and final result.
   --list-models                List available models for the selected provider.
@@ -4534,6 +4888,11 @@ 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 --all-sweeps --sweep-strategy sequential      # every sweep file, one after another
+  prompts-gpt sweep --all-sweeps --sweep-strategy parallel -n 2   # every sweep file in parallel, 2 iterations each
+  prompts-gpt sweep --sweep-files design,research --sweep-strategy parallel -n 2
+  prompts-gpt sweep --sweep-files .prompts-gpt/sweeps/a.md,.prompts-gpt/sweeps/b.md --sweep-strategy sequential
+  prompts-gpt sweep -f .prompts-gpt/sweeps/design.md -n 6 --parallel 3
   prompts-gpt sweep --model claude-sonnet-4-6                     # specify model
   prompts-gpt sweep --quiet                                       # suppress live logs
   prompts-gpt sweep --list-models --agent codex                   # see codex models
@@ -4677,7 +5036,7 @@ Options:
         return `prompts-gpt orchestrate
 
 Usage:
-  prompts-gpt orchestrate --mode <parallel|pipeline|eval> [--prompt-file <path>] [--providers <list>] [--agent <name>] [--model <name>] [--timeout <secs>] [--evaluator <name>] [--evaluator-model <name>] [--criteria <list>] [--eval-criteria <list>] [--steps <file>] [--dry-run] [--json] [--cwd <path>]
+  prompts-gpt orchestrate --mode <parallel|pipeline|eval> [--prompt-file <path>] [--providers <list>] [--agent <name>] [--model <name>] [--timeout <secs>] [--evaluator <name>] [--evaluator-model <name>] [--criteria <list>] [--eval-criteria <list>] [--steps <file>] [--continue-on-error] [--dry-run] [--json] [--cwd <path>]
 
 Why use it:
   Run multi-agent orchestration — execute the same prompt across multiple providers in parallel,
@@ -4700,6 +5059,7 @@ Options:
   --eval-criteria <list>    Alias for --criteria in eval mode and sweep self-evaluation.
   --steps <file>            JSON step file for pipeline mode.
   --timeout <secs>          Timeout per provider in seconds.
+  --continue-on-error       Continue running remaining pipeline steps even if one fails.
   --dry-run                 Preview what the orchestration would do.
   --list-models             Show model choices for the resolved provider(s).
   --non-interactive         Skip all interactive prompts.
@@ -5284,6 +5644,48 @@ async function readSweepFrontmatter(filePath) {
 async function readSweepIterationsFromFrontmatter(filePath) {
     return (await readSweepFrontmatter(filePath)).iterations;
 }
+async function resolveSweepFileSelection(cwd, flags) {
+    const allSweeps = Boolean(flags["all-sweeps"]);
+    const rawSelected = getStringFlag(flags, "sweep-files");
+    if (!allSweeps && !rawSelected)
+        return [];
+    const assets = await discoverWorkspaceAssets(cwd);
+    if (assets.sweeps.length === 0) {
+        throw new CliError("No sweep files found in .prompts-gpt/sweeps.", CLI_EXIT_CODES.validation, { helpCommand: "sweep" });
+    }
+    if (allSweeps) {
+        return assets.sweeps.map((sweep) => sweep.file);
+    }
+    const requested = rawSelected
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    if (requested.length === 0) {
+        throw new CliError("--sweep-files must include at least one file path, filename, or sweep name.", CLI_EXIT_CODES.validation, { helpCommand: "sweep" });
+    }
+    const resolved = [];
+    const seen = new Set();
+    for (const item of requested) {
+        const directPath = path.resolve(cwd, item);
+        let matched = existsSync(directPath) ? item : undefined;
+        if (!matched) {
+            const normalizedItem = item.replace(/\.md$/i, "");
+            const asset = assets.sweeps.find((sweep) => {
+                const basename = path.basename(sweep.file, ".md");
+                return sweep.file === item || basename === item || basename === normalizedItem || sweep.name === item || sweep.name === normalizedItem;
+            });
+            matched = asset?.file;
+        }
+        if (!matched || !existsSync(path.resolve(cwd, matched))) {
+            throw new CliError(`Sweep file not found: ${item}\n\nUse --sweep-files with paths, filenames, or names from \`prompts-gpt list\`.`, CLI_EXIT_CODES.validation, { helpCommand: "sweep" });
+        }
+        if (!seen.has(matched)) {
+            seen.add(matched);
+            resolved.push(matched);
+        }
+    }
+    return resolved;
+}
 function buildGenerateInput(flags) {
     return {
         goal: getStringFlag(flags, "goal") || "",
@@ -5347,7 +5749,7 @@ function printCompletionScript(shell) {
     const commands = [...COMMANDS].sort().join(" ");
     const sweepFlags = "--prompt-file --agent --model --iterations --timeout --retries --json --verbose --dry-run --non-interactive --cwd --help --quiet --list-models";
     const runFlags = "--prompt-file --agent --model --timeout --verbose --dry-run --json --non-interactive --cwd --help --list-models";
-    const orchFlags = "--mode --prompt-file --providers --agent --model --timeout --evaluator --evaluator-model --criteria --eval-criteria --steps --dry-run --json --non-interactive --cwd --help --list-models";
+    const orchFlags = "--mode --prompt-file --providers --agent --model --timeout --evaluator --evaluator-model --criteria --eval-criteria --steps --continue-on-error --dry-run --json --non-interactive --cwd --help --list-models";
     if (shell === "zsh") {
         console.log(`# Zsh completions for prompts-gpt
 # Add to ~/.zshrc:  eval "$(prompts-gpt completions zsh)"
@@ -5455,19 +5857,29 @@ mode: "parallel"
 - Quality: Is the output production-ready?
 - Correctness: Are there any bugs or issues?
 `;
-const PIPELINE_TEMPLATE = `[
-  {
-    "name": "analyze",
-    "promptFile": ".prompts-gpt/review.md",
-    "agent": "codex"
-  },
-  {
-    "name": "implement",
-    "promptFile": ".prompts-gpt/review.md",
-    "agent": "claude"
-  }
-]
-`;
+function buildPipelineStepPrompt(stepName, description, stepIndex, totalSteps) {
+    const isFirstStep = stepIndex === 0;
+    const isLastStep = stepIndex === totalSteps - 1;
+    const sections = [
+        `You are the **{{ step_name }}** step ({{ step_index }}/{{ total_steps }}) of a multi-step pipeline.`,
+        "",
+        `## Goal`,
+        "",
+        description,
+        "",
+    ];
+    if (isFirstStep) {
+        sections.push("## Instructions", "", "1. Analyze the codebase structure and understand the existing patterns", "2. Identify the best approach for the task", "3. Produce a structured plan with specific file paths and changes", "", "## Output Format", "", "Provide a structured plan with:", "- Architecture decisions", "- Implementation checklist (numbered, with file paths)", "- Risk assessment", "- Existing patterns to follow", "");
+    }
+    else if (isLastStep) {
+        sections.push("## Instructions", "", "1. Review the output from the previous step(s)", "2. Validate correctness and completeness", "3. Run any available tests: `npm run lint && npm run build`", "4. Fix any issues found", "", "## Output Format", "", "Provide:", "- Files reviewed (pass/fail per file)", "- Tests run and results", "- Issues found and fixed", "- Final status", "");
+    }
+    else {
+        sections.push("## Instructions", "", "1. Read the plan/context from the previous step", "2. Implement each item systematically", "3. Follow existing patterns identified in the research", "4. Handle error states, edge cases, and validation", "", "## Output Format", "", "List every file created or modified with a one-line description.", "");
+    }
+    sections.push("{{ previous_output }}", "");
+    return sections.join("\n");
+}
 main().catch((error) => {
     if (error instanceof CliError) {
         try {