prompts-gpt 0.3.2 → 0.3.4

package/dist/cli.js

@@ -3,7 +3,8 @@ 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, isProcessAlive, isCI, orchestrateParallel, orchestratePipeline, orchestrateEval, captureGitBranch, resolveModelWithWarning, getModelCostTier, estimateTokenCost, DEFAULT_MODELS, } from "./index.js";
+import { PROVIDER_MODELS } from "./model-registry.js";
 const CLI_EXIT_CODES = {
     success: 0,
     general: 1,
@@ -210,7 +211,7 @@ async function runCommand(command, flags) {
             if (setupPicked === "list") {
                 const { spawnSync: spSync } = await import("node:child_process");
                 const cliEntry = resolveCliEntry();
-                spSync(process.execPath, [cliEntry, "list"], { stdio: "inherit", cwd });
+                spSync(process.execPath, [cliEntry, "list"], { stdio: "inherit", cwd, shell: false, windowsHide: true });
             }
             else if (setupPicked !== "done") {
                 const [action, file] = setupPicked.split(":", 2);
@@ -218,7 +219,7 @@ async function runCommand(command, flags) {
                 console.log(`\nRunning: prompts-gpt ${cmd} -f ${file}\n`);
                 const { spawnSync: spSync } = await import("node:child_process");
                 const cliEntry = resolveCliEntry();
-                const setupResult = spSync(process.execPath, [cliEntry, cmd, "-f", file], { stdio: "inherit", cwd });
+                const setupResult = spSync(process.execPath, [cliEntry, cmd, "-f", file], { stdio: "inherit", cwd, shell: false, windowsHide: true });
                 process.exitCode = setupResult.status ?? 1;
             }
         }
@@ -496,12 +497,7 @@ async function runCommand(command, flags) {
                 const lockContent = JSON.parse(readFileSync(sweepLockPath, "utf8"));
                 const lockAge = Date.now() - new Date(lockContent.startedAt ?? 0).getTime();
                 const lockAgeHours = lockAge / (60 * 60 * 1000);
-                let holderAlive = false;
-                try {
-                    process.kill(lockContent.pid ?? 0, 0);
-                    holderAlive = true;
-                }
-                catch { /* dead */ }
+                const holderAlive = isProcessAlive(lockContent.pid);
                 if (!holderAlive) {
                     console.log(`\n${sym("⚠", "!")} Stale sweep lock detected (PID ${lockContent.pid} is no longer running)`);
                     console.log(`  Started: ${lockContent.startedAt ?? "unknown"}`);
@@ -673,7 +669,7 @@ async function runCommand(command, flags) {
                     console.log(`\nRunning: prompts-gpt ${cmd} -f ${file}\n`);
                     const { spawnSync: spSync } = await import("node:child_process");
                     const cliEntry = resolveCliEntry();
-                    const result = spSync(process.execPath, [cliEntry, cmd, "-f", file], { stdio: "inherit", cwd });
+                    const result = spSync(process.execPath, [cliEntry, cmd, "-f", file], { stdio: "inherit", cwd, shell: false, windowsHide: true });
                     process.exitCode = result.status ?? 1;
                 }
             }
@@ -826,6 +822,9 @@ async function runCommand(command, flags) {
     }
     if (command === "run") {
         const cwd = getResolvedCwd(flags);
+        if (isCI() && !flags["non-interactive"]) {
+            flags["non-interactive"] = true;
+        }
         const promptFile = getStringFlag(flags, "prompt-file");
         const config = await loadRunConfig(cwd);
         warnOnConfigIssues(config);
@@ -1014,6 +1013,10 @@ async function runCommand(command, flags) {
             const doRun = async () => {
                 if (running)
                     return;
+                if (!existsSync(resolvedWatch)) {
+                    console.log(`  File deleted: ${resolvedWatch}. Skipping run.`);
+                    return;
+                }
                 running = true;
                 console.log(`\n${colorize("▶ Running...", "\x1b[36m")} (${new Date().toLocaleTimeString()})`);
                 try {
@@ -1041,20 +1044,28 @@ async function runCommand(command, flags) {
             };
             await doRun();
             let debounce = null;
+            const closeWatcher = (message) => {
+                if (debounce) {
+                    clearTimeout(debounce);
+                    debounce = null;
+                }
+                if (message)
+                    console.log(message);
+                watcher.close();
+            };
             const watcher = fsWatch(resolvedWatch, () => {
+                if (!existsSync(resolvedWatch)) {
+                    closeWatcher(`  File deleted: ${resolvedWatch}. Exiting watch mode.`);
+                    return;
+                }
                 if (debounce)
                     clearTimeout(debounce);
                 debounce = setTimeout(doRun, 500);
                 debounce.unref?.();
             });
             watcher.on("error", (err) => {
-                if (debounce) {
-                    clearTimeout(debounce);
-                    debounce = null;
-                }
                 console.error(`Watch error: ${err instanceof Error ? err.message : String(err)}`);
-                console.log("File may have been deleted. Exiting watch mode.");
-                watcher.close();
+                closeWatcher("File may have been deleted. Exiting watch mode.");
             });
             await new Promise((resolve) => {
                 let settled = false;
@@ -1141,11 +1152,11 @@ async function runCommand(command, flags) {
             try {
                 const { spawn: openSpawn } = await import("node:child_process");
                 if (process.platform === "win32") {
-                    openSpawn("cmd", ["/c", "start", "", result.summaryFile], { detached: true, stdio: "ignore", windowsHide: true }).unref();
+                    openSpawn("cmd", ["/c", "start", "", result.summaryFile], { detached: true, stdio: "ignore", windowsHide: true, shell: false }).unref();
                 }
                 else {
                     const openCmd = process.platform === "darwin" ? "open" : "xdg-open";
-                    openSpawn(openCmd, [result.summaryFile], { detached: true, stdio: "ignore" }).unref();
+                    openSpawn(openCmd, [result.summaryFile], { detached: true, stdio: "ignore", shell: false }).unref();
                 }
             }
             catch { /* ignore */ }
@@ -1229,6 +1240,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 +1274,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 +1675,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;
@@ -1804,11 +1976,11 @@ async function runCommand(command, flags) {
             try {
                 const { spawn: openSpawn } = await import("node:child_process");
                 if (process.platform === "win32") {
-                    openSpawn("cmd", ["/c", "start", "", result.manifestFile], { detached: true, stdio: "ignore", windowsHide: true }).unref();
+                    openSpawn("cmd", ["/c", "start", "", result.manifestFile], { detached: true, stdio: "ignore", windowsHide: true, shell: false }).unref();
                 }
                 else {
                     const openCmd = process.platform === "darwin" ? "open" : "xdg-open";
-                    openSpawn(openCmd, [result.manifestFile], { detached: true, stdio: "ignore" }).unref();
+                    openSpawn(openCmd, [result.manifestFile], { detached: true, stdio: "ignore", shell: false }).unref();
                 }
             }
             catch { /* ignore */ }
@@ -1912,12 +2084,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 +2121,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 +2189,22 @@ 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)) {
+                if (isPipelineStepArray(parsed)) {
                     stepsJson = parsed;
                 }
-                else if (parsed && typeof parsed === "object" && Array.isArray(parsed.steps)) {
+                else if (isPipelineConfigObject(parsed)) {
                     stepsJson = parsed.steps;
+                    pipelineDefaults = parsed.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,15 +2212,22 @@ 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);
                 }
-                if (step.promptFile && !existsSync(path.resolve(cwd, step.promptFile))) {
+                const stepPromptPath = path.resolve(cwd, step.promptFile);
+                if (!existsSync(stepPromptPath)) {
                     throw new CliError(`Pipeline step "${step.name}" references missing prompt file: ${step.promptFile}`, CLI_EXIT_CODES.usage);
                 }
+                if (!statSync(stepPromptPath).isFile()) {
+                    throw new CliError(`Pipeline step "${step.name}" promptFile is not a file: ${step.promptFile}`, CLI_EXIT_CODES.usage);
+                }
                 const effectiveAgent = typeof step.agent === "string" && step.agent.trim() ? step.agent : defaultPipelineAgent;
                 normalizeOrchestrationAgent(effectiveAgent);
                 step.agent = effectiveAgent;
@@ -2030,6 +2237,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 +2254,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 +2297,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;
         }
@@ -2195,7 +2453,19 @@ async function runCommand(command, flags) {
         if (!existsSync(runDir)) {
             throw new CliError(`Run directory not found: ${runDir}`, CLI_EXIT_CODES.usage);
         }
-        const { readFile: fsRead } = await import("node:fs/promises");
+        const { lstat: fsLstat, readFile: fsRead, realpath: fsRealpath } = await import("node:fs/promises");
+        const runDirStat = await fsLstat(runDir).catch((error) => {
+            throw new CliError(`Cannot inspect run directory ${runDir}: ${error instanceof Error ? error.message : String(error)}`, CLI_EXIT_CODES.usage);
+        });
+        if (!runDirStat.isDirectory() || runDirStat.isSymbolicLink()) {
+            throw new CliError(`Invalid run-id: ${runId} is not a regular run directory.`, CLI_EXIT_CODES.usage);
+        }
+        const [realRunDir, realArtifactsDir] = await Promise.all([fsRealpath(runDir), fsRealpath(artifactsDir)]);
+        const realRunDirCheck = caseInsensitive ? realRunDir.toLowerCase() : realRunDir;
+        const realArtifactsDirCheck = caseInsensitive ? realArtifactsDir.toLowerCase() : realArtifactsDir;
+        if (!realRunDirCheck.startsWith(realArtifactsDirCheck + path.sep) && realRunDirCheck !== realArtifactsDirCheck) {
+            throw new CliError("Invalid run-id: resolved path escapes the artifacts directory.", CLI_EXIT_CODES.usage);
+        }
         const deltaFile = path.join(runDir, "worktree-delta.diff");
         if (existsSync(deltaFile)) {
             const delta = await fsRead(deltaFile, "utf8");
@@ -2238,7 +2508,7 @@ async function runCommand(command, flags) {
         console.log("======================");
         console.log("");
         const { spawnSync: gitCheck } = await import("node:child_process");
-        const gitResult = gitCheck("git", ["rev-parse", "--is-inside-work-tree"], { cwd, encoding: "utf8", timeout: 5000, windowsHide: true });
+        const gitResult = gitCheck("git", ["rev-parse", "--is-inside-work-tree"], { cwd, encoding: "utf8", timeout: 5000, windowsHide: true, shell: false });
         if (gitResult.status !== 0) {
             console.log(`${sym("⚠", "!")} Not inside a git repository. Prompts-GPT works best in a git repo for worktree tracking.`);
             console.log("  Run: git init\n");
@@ -2373,7 +2643,7 @@ async function runCommand(command, flags) {
                 console.log(`\nRunning: prompts-gpt ${cmd} -f ${file}\n`);
                 const { spawnSync: spSync } = await import("node:child_process");
                 const cliEntry = resolveCliEntry();
-                const result = spSync(process.execPath, [cliEntry, cmd, "-f", file], { stdio: "inherit", cwd });
+                const result = spSync(process.execPath, [cliEntry, cmd, "-f", file], { stdio: "inherit", cwd, shell: false, windowsHide: true });
                 process.exitCode = result.status ?? 1;
                 return;
             }
@@ -2511,7 +2781,7 @@ async function runCommand(command, flags) {
             if (runQs.toLowerCase() !== "n" && runQs.toLowerCase() !== "no") {
                 const { spawnSync: spSync } = await import("node:child_process");
                 const cliEntry = resolveCliEntry();
-                const qsResult = spSync(process.execPath, [cliEntry, "quickstart", "--cwd", cwd], { stdio: "inherit", cwd });
+                const qsResult = spSync(process.execPath, [cliEntry, "quickstart", "--cwd", cwd], { stdio: "inherit", cwd, shell: false, windowsHide: true });
                 process.exitCode = qsResult.status ?? 1;
                 return;
             }
@@ -2619,7 +2889,7 @@ async function runCommand(command, flags) {
                     console.log(`\nRunning: prompts-gpt run -f ${genFile}\n`);
                     const { spawnSync: spSync } = await import("node:child_process");
                     const cliEntry = resolveCliEntry();
-                    const genResult = spSync(process.execPath, [cliEntry, "run", "-f", genFile], { stdio: "inherit", cwd });
+                    const genResult = spSync(process.execPath, [cliEntry, "run", "-f", genFile], { stdio: "inherit", cwd, shell: false, windowsHide: true });
                     process.exitCode = genResult.status ?? 1;
                 }
             }
@@ -2704,20 +2974,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") {
@@ -2837,7 +3177,7 @@ async function runCommand(command, flags) {
                 const { spawnSync: spSync } = await import("node:child_process");
                 const cliEntry = resolveCliEntry();
                 const projCwd = getResolvedCwd(flags);
-                const syncResult = spSync(process.execPath, [cliEntry, "sync", "--cwd", projCwd], { stdio: "inherit", cwd: projCwd });
+                const syncResult = spSync(process.execPath, [cliEntry, "sync", "--cwd", projCwd], { stdio: "inherit", cwd: projCwd, shell: false, windowsHide: true });
                 process.exitCode = syncResult.status ?? 1;
             }
         }
@@ -3124,6 +3464,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 +3496,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" },
         };
@@ -3426,6 +3772,7 @@ function readTokenFromPrompt(command) {
             stdin.setRawMode?.(true);
         }
         catch {
+            cleanup();
             reject(new CliError("Cannot enable raw mode for token prompt. Use --token-stdin instead.", CLI_EXIT_CODES.usage, { helpCommand: command }));
             return;
         }
@@ -3513,15 +3860,54 @@ async function applyDoctorFixes(cwd) {
         skipped.push(`${DEFAULT_PROMPTS_GPT_OUT_DIR}/ directory already exists`);
     }
     try {
-        await ensureGitignoreEntry(cwd, ".prompts-gpt/.credentials.json");
-        await ensureGitignoreEntry(cwd, ".prompts-gpt/.models.json");
-        await ensureGitignoreEntry(cwd, ".scripts/runs/");
-        await ensureGitignoreEntry(cwd, ".sweep.lock");
-        applied.push("Updated .gitignore with sensitive file and sweep artifact patterns");
+        const gitignoreEntries = [
+            ".prompts-gpt/.credentials.json",
+            ".prompts-gpt/.models.json",
+            ".scripts/runs",
+            ".sweep.lock",
+        ];
+        const gitignoreUpdates = [];
+        for (const entry of gitignoreEntries) {
+            gitignoreUpdates.push(await ensureGitignoreEntry(cwd, entry));
+        }
+        if (gitignoreUpdates.some(Boolean)) {
+            applied.push("Updated .gitignore with sensitive file and sweep artifact patterns");
+        }
+        else {
+            skipped.push(".gitignore already contains sensitive file and sweep artifact patterns");
+        }
     }
     catch {
         failed.push("Could not update .gitignore with sensitive file and sweep artifact patterns");
     }
+    const sweepLockPath = path.resolve(cwd, ".sweep.lock");
+    if (existsSync(sweepLockPath)) {
+        try {
+            const lockRaw = readFileSync(sweepLockPath, "utf8");
+            const lockData = JSON.parse(lockRaw);
+            const lockAge = Date.now() - new Date(lockData.startedAt ?? 0).getTime();
+            const lockAgeHours = lockAge / (60 * 60 * 1000);
+            const holderAlive = isProcessAlive(lockData.pid);
+            if (!holderAlive || (Number.isFinite(lockAgeHours) && lockAgeHours >= 4)) {
+                const { rm: fsRm } = await import("node:fs/promises");
+                await fsRm(sweepLockPath, { force: true });
+                applied.push("Removed stale sweep lock");
+            }
+            else {
+                skipped.push("Sweep lock is active (held by running process)");
+            }
+        }
+        catch {
+            try {
+                const { rm: fsRm } = await import("node:fs/promises");
+                await fsRm(sweepLockPath, { force: true });
+                applied.push("Removed corrupt sweep lock file");
+            }
+            catch {
+                failed.push("Could not remove corrupt sweep lock file");
+            }
+        }
+    }
     return { applied, skipped, failed };
 }
 function getStringFlag(flags, name) {
@@ -3604,6 +3990,64 @@ 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 isPlainRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isOptionalString(value) {
+    return value === undefined || typeof value === "string";
+}
+function isOptionalNumber(value) {
+    return value === undefined || (typeof value === "number" && Number.isFinite(value));
+}
+function isStringRecord(value) {
+    if (value === undefined)
+        return true;
+    if (!isPlainRecord(value))
+        return false;
+    return Object.entries(value).every(([key, entry]) => key !== "__proto__" && key !== "constructor" && key !== "prototype" && typeof entry === "string");
+}
+function isPipelineStepEntry(value) {
+    if (!isPlainRecord(value))
+        return false;
+    return typeof value.name === "string" &&
+        typeof value.promptFile === "string" &&
+        isOptionalString(value.agent) &&
+        isOptionalString(value.model) &&
+        isOptionalNumber(value.timeout) &&
+        isOptionalNumber(value.retries) &&
+        isOptionalString(value.sandboxMode) &&
+        isStringRecord(value.env);
+}
+function isPipelineStepArray(value) {
+    return Array.isArray(value) && value.every(isPipelineStepEntry);
+}
+function isPipelineDefaults(value) {
+    if (value === undefined)
+        return true;
+    if (!isPlainRecord(value))
+        return false;
+    return isOptionalString(value.agent) &&
+        isOptionalString(value.model) &&
+        isOptionalNumber(value.timeout) &&
+        isOptionalNumber(value.retries) &&
+        isOptionalString(value.sandboxMode);
+}
+function isPipelineConfigObject(value) {
+    return isPlainRecord(value) && isPipelineStepArray(value.steps) && isPipelineDefaults(value.defaults);
+}
 function formatList(values) {
     if (!Array.isArray(values) || values.length === 0)
         return "None";
@@ -3814,82 +4258,6 @@ async function saveLastUsedModel(cwd, provider, model) {
 }
 const CODEX_API_KEY_ENV_NAMES = ["OPENAI_API_KEY", "CODEX_API_KEY", "OPENAI_API_KEY_FILE"];
 const CODEX_CHATGPT_UNSUPPORTED_MODELS = new Set(["gpt-5.5-pro", "gpt-5.4-pro", "gpt-5.5-high-fast"]);
-const PROVIDER_MODELS = Object.freeze({
-    codex: [
-        { value: "gpt-5.5", label: "gpt-5.5 — frontier coding & reasoning", tier: "frontier" },
-        { value: "gpt-5.5-pro", label: "gpt-5.5-pro — smarter, more precise", tier: "frontier" },
-        { value: "gpt-5.4", label: "gpt-5.4 — strong coding model", tier: "standard" },
-        { value: "gpt-5.4-pro", label: "gpt-5.4-pro — enhanced responses", tier: "standard" },
-        { value: "gpt-5.4-mini", label: "gpt-5.4-mini — fast coding & subagents", tier: "fast" },
-        { value: "gpt-5.4-nano", label: "gpt-5.4-nano — cheapest high-volume", tier: "budget" },
-        { value: "gpt-5.3-codex", label: "gpt-5.3-codex — merged GPT-5 + Codex", tier: "standard" },
-        { value: "gpt-5.3-codex-spark", label: "gpt-5.3-codex-spark — 15x faster gen", tier: "fast" },
-        { value: "o3", label: "o3 — advanced reasoning", tier: "frontier" },
-    ],
-    claude: [
-        { value: "claude-opus-4-7", label: "claude-opus-4-7 — most capable model", tier: "frontier" },
-        { value: "claude-opus-4-6", label: "claude-opus-4-6 — previous gen opus", tier: "frontier" },
-        { value: "claude-sonnet-4-6", label: "claude-sonnet-4-6 — balanced default", tier: "standard" },
-        { value: "claude-sonnet-4-5", label: "claude-sonnet-4-5 — previous gen sonnet", tier: "standard" },
-        { value: "claude-3-5-haiku", label: "claude-3-5-haiku — fastest & cheapest", tier: "fast" },
-        { value: "claude-haiku-4-5", label: "claude-haiku-4-5 — fast haiku", tier: "fast" },
-    ],
-    cursor: [
-        { value: "auto", label: "auto — Cursor auto-selects best", tier: "standard" },
-        { value: "claude-4.7-opus", label: "claude-4.7-opus — Claude Opus 4.7", tier: "frontier" },
-        { value: "claude-4.7-opus-fast", label: "claude-4.7-opus-fast — Claude Opus 4.7 Fast", tier: "frontier" },
-        { value: "claude-4.6-opus-high", label: "claude-4.6-opus-high — Claude Opus 4.6 High", tier: "frontier" },
-        { value: "claude-4.6-opus-high-thinking", label: "claude-4.6-opus-high-thinking — Claude Opus 4.6 Thinking", tier: "frontier" },
-        { value: "claude-4.6-sonnet-high", label: "claude-4.6-sonnet-high — fast + smart", tier: "standard" },
-        { value: "gpt-5.5", label: "gpt-5.5 — OpenAI frontier", tier: "frontier" },
-        { value: "gpt-5.5-high-fast", label: "gpt-5.5-high-fast — GPT frontier fast", tier: "frontier" },
-        { value: "gpt-5.4", label: "gpt-5.4 — OpenAI strong coding", tier: "standard" },
-        { value: "gpt-5.4-mini", label: "gpt-5.4-mini — fast & affordable", tier: "fast" },
-        { value: "gpt-5.4-nano", label: "gpt-5.4-nano — cheapest", tier: "budget" },
-        { value: "gpt-5.3-codex", label: "gpt-5.3-codex — OpenAI codex", tier: "standard" },
-        { value: "gpt-5.2", label: "gpt-5.2 — OpenAI coding", tier: "standard" },
-        { value: "gpt-5", label: "gpt-5 — OpenAI base", tier: "standard" },
-        { value: "gpt-5-fast", label: "gpt-5-fast — faster GPT-5", tier: "standard" },
-        { value: "gpt-5-mini", label: "gpt-5-mini — small GPT-5", tier: "fast" },
-        { value: "o3-pro-high", label: "o3-pro-high — advanced reasoning", tier: "frontier" },
-        { value: "composer-2.5", label: "composer-2.5 — Cursor latest model", tier: "standard" },
-        { value: "composer-2", label: "composer-2 — balanced multi-file", tier: "standard" },
-        { value: "composer-2-fast", label: "composer-2-fast — speed optimized", tier: "fast" },
-        { value: "composer-1.5", label: "composer-1.5 — legacy capable", tier: "standard" },
-        { value: "composer-1", label: "composer-1 — legacy model", tier: "fast" },
-        { value: "gemini-3.1-pro", label: "gemini-3.1-pro — Google latest", tier: "standard" },
-        { value: "gemini-3-pro", label: "gemini-3-pro — Google frontier", tier: "standard" },
-        { value: "gemini-3-flash", label: "gemini-3-flash — Google fast", tier: "fast" },
-        { value: "gemini-2.5-flash", label: "gemini-2.5-flash — Google budget", tier: "fast" },
-        { value: "grok-4.3", label: "grok-4.3 — xAI frontier", tier: "frontier" },
-        { value: "grok-4.20", label: "grok-4.20 — xAI standard", tier: "standard" },
-        { value: "kimi-k2.5", label: "kimi-k2.5 — Moonshot coding", tier: "standard" },
-        { value: "claude-4.5-opus", label: "claude-4.5-opus — previous gen opus", tier: "standard" },
-        { value: "claude-4.5-haiku", label: "claude-4.5-haiku — fast haiku", tier: "fast" },
-    ],
-    copilot: [
-        { value: "auto", label: "auto — Copilot auto-selects", tier: "standard" },
-        { value: "claude-opus-4.7", label: "claude-opus-4.7 — Anthropic frontier", tier: "frontier" },
-        { value: "claude-opus-4.6", label: "claude-opus-4.6 — Anthropic frontier", tier: "frontier" },
-        { value: "claude-sonnet-4.6", label: "claude-sonnet-4.6 — Anthropic balanced", tier: "standard" },
-        { value: "claude-sonnet-4.5", label: "claude-sonnet-4.5 — Anthropic previous gen", tier: "standard" },
-        { value: "claude-opus-4.5", label: "claude-opus-4.5 — Anthropic legacy opus", tier: "standard" },
-        { value: "claude-haiku-4.5", label: "claude-haiku-4.5 — fastest", tier: "fast" },
-        { value: "gpt-5.5", label: "gpt-5.5 — OpenAI frontier", tier: "frontier" },
-        { value: "gpt-5.4", label: "gpt-5.4 — OpenAI standard", tier: "standard" },
-        { value: "gpt-5.4-mini", label: "gpt-5.4-mini — fast included", tier: "fast" },
-        { value: "gpt-5.4-nano", label: "gpt-5.4-nano — cheapest high-volume", tier: "budget" },
-        { value: "gpt-5.3-codex", label: "gpt-5.3-codex — OpenAI coding", tier: "standard" },
-        { value: "gpt-5-mini", label: "gpt-5-mini — included fast model", tier: "fast" },
-        { value: "gemini-3.1-pro", label: "gemini-3.1-pro — Google latest", tier: "frontier" },
-        { value: "gemini-3-pro", label: "gemini-3-pro — Google frontier", tier: "standard" },
-        { value: "gemini-2.5-pro", label: "gemini-2.5-pro — Google frontier", tier: "standard" },
-        { value: "gemini-2.5-flash", label: "gemini-2.5-flash — Google fast & affordable", tier: "fast" },
-        { value: "gemini-3-flash", label: "gemini-3-flash — Google fast", tier: "fast" },
-        { value: "raptor-mini", label: "raptor-mini — preview tuned mini", tier: "fast" },
-        { value: "goldeneye", label: "goldeneye — preview tuned coding model", tier: "budget" },
-    ],
-});
 // Model names are used directly — no alias resolution needed
 function hasCodexApiKeyAuth(env = process.env) {
     return CODEX_API_KEY_ENV_NAMES.some((name) => String(env[name] ?? "").trim().length > 0);
@@ -4342,9 +4710,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 +4729,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 +4865,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 +4878,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 +4897,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 +4921,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 +5069,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 +5092,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.
@@ -4825,8 +5218,8 @@ function slugifyFilename(text, fallback) {
 }
 function buildProgressBar(completed, total, width) {
     const safeWidth = Number.isFinite(width) && width > 0 ? Math.trunc(width) : 20;
-    const safeTotal = Math.max(total, 1);
-    const safeCompleted = Math.max(0, Math.min(completed, safeTotal));
+    const safeTotal = Number.isFinite(total) && total > 0 ? Math.trunc(total) : 1;
+    const safeCompleted = Number.isFinite(completed) ? Math.max(0, Math.min(Math.trunc(completed), safeTotal)) : 0;
     const fraction = safeCompleted / safeTotal;
     const filled = Math.min(Math.floor(fraction * safeWidth), safeWidth);
     const empty = safeWidth - filled;
@@ -4912,9 +5305,12 @@ function interactiveSelect(prompt, options) {
         const maxVisible = Math.min(options.length, Math.max(3, termRows - 4));
         const useUnicode = supportsUnicode();
         const pointer = useUnicode ? "\u276f" : ">";
-        const formatLine = (entry, index, selected) => {
-            const numberWidth = String(getVisibleOptions().length).length;
-            const num = String(index + 1).padStart(numberWidth, " ");
+        const getScrollStart = (visible) => visible.length <= maxVisible
+            ? 0
+            : Math.max(0, Math.min(cursor - Math.floor(maxVisible / 2), visible.length - maxVisible));
+        const formatLine = (entry, shortcutIndex, selected) => {
+            const numberWidth = String(Math.min(9, maxVisible)).length;
+            const num = shortcutIndex <= 9 ? String(shortcutIndex).padStart(numberWidth, " ") : " ".repeat(numberWidth);
             const prefix = selected ? colorize(pointer, "\x1b[36m") : " ";
             const label = selected ? colorize(entry.label, "\x1b[1m") : entry.label;
             return `  ${prefix} ${num}. ${label}`;
@@ -4935,15 +5331,13 @@ function interactiveSelect(prompt, options) {
             const visibleCount = Math.min(maxVisible, visible.length);
             const posLabel = visible.length > 1 ? ` (${cursor + 1}/${visible.length})` : "";
             const filterLabel = filterText ? colorize(` filter: "${filterText}"`, "\x1b[33m") : "";
-            const scrollStart = visible.length <= maxVisible
-                ? 0
-                : Math.max(0, Math.min(cursor - Math.floor(maxVisible / 2), visible.length - maxVisible));
+            const scrollStart = getScrollStart(visible);
             const lines = [];
             lines.push(`${prompt}${posLabel}${filterLabel}`);
             for (let vi = 0; vi < visibleCount; vi++) {
                 const i = scrollStart + vi;
                 if (i < visible.length) {
-                    lines.push(formatLine(visible[i], i, i === cursor));
+                    lines.push(formatLine(visible[i], vi + 1, i === cursor));
                 }
             }
             if (visible.length > maxVisible) {
@@ -5000,7 +5394,7 @@ function interactiveSelect(prompt, options) {
             return;
         }
         stdin.resume();
-        const onSigint = () => {
+        const cancelSelection = () => {
             if (settled)
                 return;
             settled = true;
@@ -5011,11 +5405,17 @@ function interactiveSelect(prompt, options) {
             catch { /* stdout may be closed */ }
             reject(new CliError("Selection cancelled.", CLI_EXIT_CODES.general));
         };
+        const onSigint = () => { cancelSelection(); };
+        const onSigterm = () => { cancelSelection(); };
         const cleanup = () => {
             try {
                 process.removeListener("SIGINT", onSigint);
             }
             catch { /* ignore */ }
+            try {
+                process.removeListener("SIGTERM", onSigterm);
+            }
+            catch { /* ignore */ }
             try {
                 stdin.removeListener("data", onData);
             }
@@ -5047,6 +5447,7 @@ function interactiveSelect(prompt, options) {
         stdin.on("end", onEnd);
         stdin.on("error", onError);
         process.on("SIGINT", onSigint);
+        process.on("SIGTERM", onSigterm);
         const onData = (data) => {
             const visible = getVisibleOptions();
             for (let ci = 0; ci < data.length; ci++) {
@@ -5182,17 +5583,18 @@ function interactiveSelect(prompt, options) {
                 }
                 else if (ch >= "1" && ch <= "9" && !filterText) {
                     const idx = parseInt(ch, 10) - 1;
-                    if (idx < visible.length && idx < 9) {
+                    const visibleIndex = getScrollStart(visible) + idx;
+                    if (visibleIndex < visible.length && idx < 9) {
                         if (settled)
                             return;
                         settled = true;
                         cleanup();
                         stdout.write("\n");
-                        resolve(visible[idx].value);
+                        resolve(visible[visibleIndex].value);
                         return;
                     }
                 }
-                else if (ch >= " " && ch <= "~") {
+                else if (isPrintableInteractiveInput(ch)) {
                     filterText += ch;
                     cursor = 0;
                     render();
@@ -5202,6 +5604,11 @@ function interactiveSelect(prompt, options) {
         stdin.on("data", onData);
     });
 }
+function isPrintableInteractiveInput(value) {
+    if (!value)
+        return false;
+    return !/[\x00-\x1f\x7f]/.test(value);
+}
 async function interactiveInput(prompt, defaultValue) {
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
         throw new CliError("Interactive input requires a TTY.", CLI_EXIT_CODES.usage);
@@ -5225,6 +5632,14 @@ async function interactiveInput(prompt, defaultValue) {
             resolved = true;
             resolve(defaultValue || "");
         });
+        rl.on("error", (err) => {
+            if (resolved)
+                return;
+            resolved = true;
+            rl.close();
+            rl.removeAllListeners();
+            reject(new CliError(`Input stream error: ${err.message}`, CLI_EXIT_CODES.general));
+        });
         rl.on("SIGINT", () => {
             if (resolved)
                 return;
@@ -5236,14 +5651,26 @@ async function interactiveInput(prompt, defaultValue) {
     });
 }
 async function checkPromptsGptSiteReachable(apiUrl) {
+    if (typeof globalThis.fetch !== "function") {
+        return { ok: false, status: null };
+    }
     const target = new URL("/", apiUrl).toString();
-    const request = (method) => Promise.race([
-        globalThis.fetch(target, { method }),
-        new Promise((_, rej) => {
-            const timer = setTimeout(() => rej(new Error("timeout")), 5000);
-            timer.unref?.();
-        }),
-    ]);
+    const request = async (method) => {
+        let timer = null;
+        try {
+            return await Promise.race([
+                globalThis.fetch(target, { method }),
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new Error("timeout")), 5000);
+                    timer.unref?.();
+                }),
+            ]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    };
     let response = await request("HEAD");
     if (response.status === 405) {
         response = await request("GET");
@@ -5284,6 +5711,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 +5816,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 +5924,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 {