@promptbook/cli 0.112.0-42 → 0.112.0-43

package/esm/index.es.js

@@ -37,6 +37,7 @@ import { spawn } from 'child_process';
 import { Client } from 'pg';
 import '@supabase/supabase-js';
 import { dirname as dirname$1 } from 'path/posix';
+import { EventEmitter } from 'events';
 import { Subject, BehaviorSubject } from 'rxjs';
 import { lookup, extension } from 'mime-types';
 import { parse, unparse } from 'papaparse';
@@ -57,7 +58,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.112.0-42';
+const PROMPTBOOK_ENGINE_VERSION = '0.112.0-43';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -2320,7 +2321,7 @@ function getDefaultCoderAgentCodingFileContent({ packageJsonScripts, }) {
         '',
         '## Customizing the workflow',
         '-   Edit `package.json` if you want `npm run coder:run` to use another coding agent, model, thinking level, context file, or wait mode.',
-        '-   Use direct CLI commands when you need one-off flags such as `--priority`, `--ignore-git-changes`, `--dry-run`, `--allow-credits`, or `--auto-migrate`.',
+        '-   Use direct CLI commands when you need one-off flags such as `--priority`, `--ignore-git-changes`, `--dry-run`, `--test`, `--allow-credits`, or `--auto-migrate`.',
         '-   Use `npx ptbk coder --help` and `npx ptbk coder <command> --help` for the full CLI reference.',
     ].join('\n');
 }
@@ -2580,6 +2581,26 @@ class ParseError extends Error {
 }
 // TODO: Maybe split `ParseError` and `ApplyError`
 
+/**
+ * Loads the TypeScript runtime used for parsing JSONC-style project files.
+ *
+ * @private internal utility of `coder init`
+ */
+async function getTypescriptModule() {
+    return normalizeImportedTypescriptModule((await import('typescript')));
+}
+/**
+ * Normalizes CommonJS-via-`default` and direct namespace imports of TypeScript.
+ *
+ * @private internal utility of `getTypescriptModule`
+ */
+function normalizeImportedTypescriptModule(importedTypescriptModule) {
+    return 'parseConfigFileTextToJson' in importedTypescriptModule
+        ? importedTypescriptModule
+        : importedTypescriptModule.default;
+}
+// Note: [🟡] Code for coder init TypeScript loading [getTypescriptModule](src/cli/cli-commands/coder/getTypescriptModule.ts) should never be published outside of `@promptbook/cli`
+
 /**
  * Default indentation used when creating new JSON configuration files.
  */
@@ -2625,7 +2646,7 @@ async function parseJsonObjectFile(relativeFilePath, fileContent) {
     if (fileContent.trim() === '') {
         return {};
     }
-    const typescript = await import('typescript');
+    const typescript = await getTypescriptModule();
     const parsedFile = typescript.parseConfigFileTextToJson(relativeFilePath, fileContent);
     if (parsedFile.error) {
         throw new ParseError(spaceTrim$1(`
@@ -2983,7 +3004,9 @@ function $initializeCoderRunCommand(program) {
 
             Features:
             - Automatically stages and commits changes with agent identity
+            - Optional post-commit git push with explicit --auto-push opt-in
             - Supports GPG signing of commits
+            - Optional post-prompt verification with test-feedback retries
             - Progress tracking and interactive controls
             - Dry-run mode to preview prompts
         `));
@@ -2996,17 +3019,19 @@ function $initializeCoderRunCommand(program) {
             Gemini examples: gemini-3-flash-preview, default
         `));
     command.option('--context <context-or-file>', 'Append extra instructions either inline or from a file path relative to the current project');
+    command.option('--test <test-command...>', 'Run a verification command after each prompt; quote it when the command itself contains top-level flags');
     command.addOption(new Option('--thinking-level <thinking-level>', `Set reasoning effort for supported runners (${THINKING_LEVEL_VALUES.join(', ')})`).choices([...THINKING_LEVEL_VALUES]));
     command.option('--priority <minimum-priority>', 'Filter prompts by minimum priority level', parseIntOption, 0);
     command.option('--no-wait', 'Skip user prompts between processing');
     command.option('--ignore-git-changes', 'Skip clean working tree check before running prompts', false);
     command.option('--allow-credits', 'Allow OpenAI Codex runner to spend credits when rate limits are exhausted', false);
     command.option('--no-normalize-line-endings', 'Disable automatic LF normalization for files changed in each coding round');
-    command.option('--no-push', 'Disable automatic git push after each commit');
+    command.option('--auto-push', 'Automatically git push after each commit', false);
     command.option('--auto-migrate', 'Run testing-server database migrations automatically after each successfully processed prompt');
     command.option('--allow-destructive-auto-migrate', 'Allow auto-migrate even when heuristic SQL safety check flags destructive pending migrations');
     command.action(handleActionErrors(async (cliOptions) => {
-        const { dryRun, agent, model, context, thinkingLevel, priority, wait, ignoreGitChanges, allowCredits, normalizeLineEndings, autoMigrate, allowDestructiveAutoMigrate, push, } = cliOptions;
+        const { dryRun, agent, model, context, test, thinkingLevel, priority, wait, ignoreGitChanges, allowCredits, normalizeLineEndings, autoMigrate, allowDestructiveAutoMigrate, autoPush, } = cliOptions;
+        const testCommand = normalizeCommandOptionValue(test);
         // Validate agent
         let agentName = undefined;
         if (agent) {
@@ -3035,13 +3060,14 @@ function $initializeCoderRunCommand(program) {
             agentName,
             model,
             context,
+            testCommand,
             thinkingLevel,
             priority,
             normalizeLineEndings,
             allowCredits,
             autoMigrate,
             allowDestructiveAutoMigrate,
-            noPush: !push,
+            autoPush,
         };
         // Note: Import the function dynamically to avoid loading heavy dependencies until needed
         const { runCodexPrompts } = await Promise.resolve().then(function () { return runCodexPrompts$1; });
@@ -3070,6 +3096,19 @@ function parseIntOption(value) {
     }
     return parsed;
 }
+/**
+ * Joins one Commander option that may be parsed either as a single string or a variadic token array.
+ *
+ * @private internal utility of `coder run` command
+ */
+function normalizeCommandOptionValue(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const parts = Array.isArray(value) ? value : [value];
+    const normalizedValue = parts.map((part) => part.trim()).filter(Boolean).join(' ').trim();
+    return normalizedValue === '' ? undefined : normalizedValue;
+}
 // Note: [🟡] Code for CLI command [run](src/cli/cli-commands/coder/run.ts) should never be published outside of `@promptbook/cli`
 // Note: [💞] Ignore a discrepancy between file name and entity name
 
@@ -22556,6 +22595,15 @@ const teamToolFunctions = {};
  * Map of team tool titles.
  */
 const teamToolTitles = {};
+/**
+ * Shared TEAM usage rules appended ahead of teammate listings.
+ *
+ * @private
+ */
+const TEAM_SYSTEM_MESSAGE_GUIDANCE_LINES = [
+    '- If a teammate is relevant to the request, consult that teammate using the matching tool.',
+    '- Do not ask the user for information that a listed teammate can provide directly.',
+];
 /**
  * Constant for remote agents by Url.
  */
@@ -22645,12 +22693,9 @@ class TeamCommitmentDefinition extends BaseCommitmentDefinition {
             if (updatedTools.some((tool) => tool.name === entry.toolName)) {
                 continue;
             }
-            const toolDescription = entry.description
-                ? `Consult teammate ${entry.teammate.label}\n${entry.description}`
-                : `Consult teammate ${entry.teammate.label}`;
             updatedTools.push({
                 name: entry.toolName,
-                description: toolDescription,
+                description: buildTeamToolDescription(entry),
                 parameters: {
                     type: 'object',
                     properties: {
@@ -22719,22 +22764,72 @@ function resolveTeamTeammateLabels(teamContent, teammates) {
 /**
  * Builds the textual TEAM section body for the final system message.
  *
- * Each teammate is listed with its tool name and, when available, a one-line description.
- * Uses `spaceTrim` to ensure consistent whitespace and indentation.
+ * Each teammate is listed with its tool name, TEAM instructions, and optional profile hints.
  */
 function buildTeamSystemMessageBody(teamEntries) {
-    const lines = teamEntries.map((entry, index) => {
-        const toolLine = `${index + 1}) ${entry.teammate.label} tool \`${entry.toolName}\``;
-        if (!entry.description) {
-            return toolLine;
-        }
-        return spaceTrim$1(`
-            ${toolLine}
-               ${entry.description}
-        `);
-    });
+    const lines = [
+        ...TEAM_SYSTEM_MESSAGE_GUIDANCE_LINES,
+        '',
+        ...teamEntries.map((entry, index) => {
+            const toolLine = `${index + 1}) ${entry.teammate.label} tool \`${entry.toolName}\``;
+            const detailLines = collectTeamEntryDetails(entry).map(formatTeamEntryDetailLine);
+            return [toolLine, ...detailLines].join('\n');
+        }),
+    ];
     return lines.join('\n');
 }
+/**
+ * Builds the model-visible description for one teammate tool.
+ *
+ * @private
+ */
+function buildTeamToolDescription(entry) {
+    const detailLines = collectTeamEntryDetails(entry).map(({ label, content }) => `${label}: ${content}`);
+    return [`Consult teammate ${entry.teammate.label}`, ...detailLines].join('\n');
+}
+/**
+ * Collects structured teammate details that should stay visible to the model.
+ *
+ * @private
+ */
+function collectTeamEntryDetails(entry) {
+    var _a;
+    const details = [];
+    const instructions = entry.teammate.instructions.trim();
+    const description = ((_a = entry.description) === null || _a === void 0 ? void 0 : _a.trim()) || '';
+    if (instructions) {
+        details.push({
+            label: 'TEAM instructions',
+            content: instructions,
+        });
+    }
+    if (description) {
+        details.push({
+            label: 'Profile',
+            content: description,
+        });
+    }
+    return details;
+}
+/**
+ * Formats one teammate detail line for the TEAM system-message section.
+ *
+ * @private
+ */
+function formatTeamEntryDetailLine(detail) {
+    return indentMultilineText(`${detail.label}: ${detail.content}`, '   ');
+}
+/**
+ * Indents all lines of one potentially multi-line text block.
+ *
+ * @private
+ */
+function indentMultilineText(text, prefix) {
+    return text
+        .split('\n')
+        .map((line) => `${prefix}${line}`)
+        .join('\n');
+}
 /**
  * Registers tool function and title for a teammate tool.
  */
@@ -40907,7 +41002,7 @@ function createEmptyAgentModelRequirements() {
         systemMessage: '',
         promptSuffix: '',
         // modelName: 'gpt-5',
-        modelName: 'gemini-2.5-flash-lite',
+        modelName: 'gpt-5.4-mini',
         temperature: 0.7,
         topP: 0.9,
         topK: 50,
@@ -44087,7 +44182,26 @@ var findRefactorCandidates$1 = /*#__PURE__*/Object.freeze({
 /**
  * CLI usage text for this script.
  */
-const USAGE = 'Usage: run-codex-prompts [--dry-run] [--agent <agent-name>] [--model <model>] [--context <context-or-file>] [--thinking-level <thinking-level>] [--priority <minimum-priority>] [--allow-credits] [--auto-migrate] [--allow-destructive-auto-migrate] [--no-wait] [--ignore-git-changes] [--no-normalize-line-endings] [--no-push]';
+const USAGE = 'Usage: run-codex-prompts [--dry-run] [--agent <agent-name>] [--model <model>] [--context <context-or-file>] [--test <test-command...>] [--thinking-level <thinking-level>] [--priority <minimum-priority>] [--allow-credits] [--auto-migrate] [--allow-destructive-auto-migrate] [--no-wait] [--ignore-git-changes] [--no-normalize-line-endings] [--auto-push]';
+/**
+ * Top-level flags supported by this command.
+ */
+const KNOWN_OPTION_FLAGS = new Set([
+    '--dry-run',
+    '--agent',
+    '--model',
+    '--context',
+    '--test',
+    '--thinking-level',
+    '--priority',
+    '--allow-credits',
+    '--auto-migrate',
+    '--allow-destructive-auto-migrate',
+    '--no-wait',
+    '--ignore-git-changes',
+    '--no-normalize-line-endings',
+    '--auto-push',
+]);
 /**
  * Parses CLI arguments into runner options.
  */
@@ -44108,6 +44222,8 @@ function parseRunOptions(args) {
     }
     const model = readOptionValue(args, '--model');
     const context = readOptionValue(args, '--context');
+    const hasTestCommandFlag = args.includes('--test');
+    const testCommand = readVariadicOptionValue(args, '--test');
     const hasThinkingLevelFlag = args.includes('--thinking-level');
     const thinkingLevelValue = readOptionValue(args, '--thinking-level');
     const hasPriorityFlag = args.includes('--priority');
@@ -44117,8 +44233,11 @@ function parseRunOptions(args) {
     const allowCredits = args.includes('--allow-credits');
     const autoMigrate = args.includes('--auto-migrate');
     const allowDestructiveAutoMigrate = args.includes('--allow-destructive-auto-migrate');
-    const noPush = args.includes('--no-push');
+    const autoPush = args.includes('--auto-push');
     let thinkingLevel;
+    if (hasTestCommandFlag && testCommand === undefined) {
+        exitWithUsageError('Missing value for --test. Use a shell command such as `npm run test` and quote it when it contains top-level CLI flags.');
+    }
     if (hasThinkingLevelFlag && thinkingLevelValue === undefined) {
         exitWithUsageError(`Missing value for --thinking-level. Use one of: ${THINKING_LEVEL_VALUES.join(', ')}.`);
     }
@@ -44139,10 +44258,11 @@ function parseRunOptions(args) {
         allowCredits,
         autoMigrate,
         allowDestructiveAutoMigrate,
-        noPush,
+        autoPush,
         agentName,
         model,
         context,
+        testCommand,
         thinkingLevel,
         priority,
     };
@@ -44157,6 +44277,28 @@ function readOptionValue(args, flag) {
     const index = args.indexOf(flag);
     return args[index + 1];
 }
+/**
+ * Reads a multi-token shell command value that follows a given flag.
+ */
+function readVariadicOptionValue(args, flag) {
+    if (!args.includes(flag)) {
+        return undefined;
+    }
+    const index = args.indexOf(flag);
+    const valueParts = [];
+    for (let i = index + 1; i < args.length; i++) {
+        const valuePart = args[i];
+        if (valuePart === undefined) {
+            continue;
+        }
+        if (KNOWN_OPTION_FLAGS.has(valuePart)) {
+            break;
+        }
+        valueParts.push(valuePart);
+    }
+    const normalizedValue = valueParts.join(' ').trim();
+    return normalizedValue === '' ? undefined : normalizedValue;
+}
 /**
  * Parses and validates the minimum prompt priority.
  */
@@ -44182,6 +44324,21 @@ function exitWithUsageError(message) {
     process.exit(1);
 }
 
+/**
+ * Appends optional coding context to a runner prompt.
+ */
+function appendCoderContext(prompt, context) {
+    const normalizedContext = context === null || context === void 0 ? void 0 : context.trim();
+    if (!normalizedContext) {
+        return prompt;
+    }
+    const normalizedPrompt = prompt.trimEnd();
+    if (normalizedPrompt === '') {
+        return normalizedContext;
+    }
+    return `${normalizedPrompt}\n\n${normalizedContext}`;
+}
+
 /**
  * Refresh interval for the progress header in milliseconds.
  */
@@ -44193,7 +44350,7 @@ const PROGRESS_HEADER_RESERVED_LINES = 1;
 /**
  * Calendar formats used when displaying the estimated completion time.
  */
-const ESTIMATED_DONE_CALENDAR_FORMATS = {
+const ESTIMATED_DONE_CALENDAR_FORMATS$1 = {
     sameDay: '[Today] h:mm',
     nextDay: '[Tomorrow] h:mm',
     nextWeek: 'dddd h:mm',
@@ -44292,15 +44449,15 @@ function buildProgressSnapshot(stats, startTime, initialDone) {
     const sessionTotal = sessionDone + stats.forAgent;
     const percentage = totalPrompts > 0 ? Math.round((completedPrompts / totalPrompts) * 100) : 0;
     const elapsedDuration = moment.duration(moment().diff(startTime));
-    const elapsedText = formatDurationBrief(elapsedDuration);
+    const elapsedText = formatDurationBrief$1(elapsedDuration);
     let estimatedTotalText = '—';
     let estimatedLabel = 'unknown';
     if (totalPrompts > 0 && completedPrompts > 0) {
         const estimatedTotalMs = (elapsedDuration.asMilliseconds() * totalPrompts) / completedPrompts;
         const estimatedTotalDuration = moment.duration(estimatedTotalMs);
         const estimatedCompletion = startTime.clone().add(estimatedTotalDuration);
-        estimatedTotalText = formatDurationBrief(estimatedTotalDuration);
-        estimatedLabel = estimatedCompletion.calendar(null, ESTIMATED_DONE_CALENDAR_FORMATS);
+        estimatedTotalText = formatDurationBrief$1(estimatedTotalDuration);
+        estimatedLabel = estimatedCompletion.calendar(null, ESTIMATED_DONE_CALENDAR_FORMATS$1);
     }
     return {
         totalPrompts,
@@ -44316,7 +44473,7 @@ function buildProgressSnapshot(stats, startTime, initialDone) {
 /**
  * Formats a duration into a compact string such as "3h 12m" or "45s".
  */
-function formatDurationBrief(duration) {
+function formatDurationBrief$1(duration) {
     const totalSeconds = Math.max(0, Math.round(duration.asSeconds()));
     const hours = Math.floor(totalSeconds / 3600);
     const minutes = Math.floor((totalSeconds % 3600) / 60);
@@ -44337,21 +44494,6 @@ function formatDurationBrief(duration) {
     return parts.join(' ');
 }
 
-/**
- * Appends optional coding context to a runner prompt.
- */
-function appendCoderContext(prompt, context) {
-    const normalizedContext = context === null || context === void 0 ? void 0 : context.trim();
-    if (!normalizedContext) {
-        return prompt;
-    }
-    const normalizedPrompt = prompt.trimEnd();
-    if (normalizedPrompt === '') {
-        return normalizedContext;
-    }
-    return `${normalizedPrompt}\n\n${normalizedContext}`;
-}
-
 /**
  * Git commands used to list changed and untracked files in the working tree.
  */
@@ -44621,7 +44763,7 @@ async function waitForEnter(prompt) {
 }
 
 /**
- * Constant for pause state.
+ * Current pause state.
  */
 let pauseState = 'RUNNING';
 /**
@@ -44658,17 +44800,48 @@ function listenForPause() {
 }
 /**
  * If the execution is paused, it will wait until it is resumed.
+ *
+ * @param options.silent - When `true`, suppresses console output (used when the terminal UI handles display).
+ * @param options.onPaused - Callback invoked when entering the PAUSED state.
+ * @param options.onResumed - Callback invoked when leaving the PAUSED state.
  */
-async function checkPause() {
+async function checkPause(options) {
+    var _a, _b;
     if (pauseState === 'PAUSING') {
         pauseState = 'PAUSED';
-        console.log(colors.bgWhite.black('Paused') + colors.gray(' (Press "p" to resume)'));
+        if (!(options === null || options === void 0 ? void 0 : options.silent)) {
+            console.log(colors.bgWhite.black('Paused') + colors.gray(' (Press "p" to resume)'));
+        }
+        (_a = options === null || options === void 0 ? void 0 : options.onPaused) === null || _a === void 0 ? void 0 : _a.call(options);
         while (pauseState === 'PAUSED') {
             await new Promise((resolve) => setTimeout(resolve, 100));
         }
-        console.log(colors.green('Resuming...'));
+        (_b = options === null || options === void 0 ? void 0 : options.onResumed) === null || _b === void 0 ? void 0 : _b.call(options);
+        if (!(options === null || options === void 0 ? void 0 : options.silent)) {
+            console.log(colors.green('Resuming...'));
+        }
     }
 }
+/**
+ * Returns the current pause state for external consumers such as the terminal UI.
+ */
+function getPauseState() {
+    return pauseState;
+}
+/**
+ * Requests a pause from an external controller (e.g. the Ink UI).
+ */
+function requestPause() {
+    if (pauseState === 'RUNNING') {
+        pauseState = 'PAUSING';
+    }
+}
+/**
+ * Resumes execution from an external controller after a pause.
+ */
+function requestResume() {
+    pauseState = 'RUNNING';
+}
 
 /**
  * Environment variable that configures the name used for agent commits.
@@ -45013,7 +45186,7 @@ function stringifyUnknownError$1(error) {
 
 /**
  * Commits staged changes with the provided message using the dedicated coding-agent identity when configured,
- * otherwise falls back to the default Git configuration.
+ * otherwise falls back to the default Git configuration. Remote pushing is opt-in via `options.autoPush`.
  */
 async function commitChanges(message, options) {
     const projectPath = process.cwd();
@@ -45033,7 +45206,7 @@ async function commitChanges(message, options) {
             cwd: projectPath,
             env: agentEnv,
         });
-        if (!(options === null || options === void 0 ? void 0 : options.noPush)) {
+        if (options === null || options === void 0 ? void 0 : options.autoPush) {
             await pushCommittedChanges(projectPath, agentEnv);
         }
     }
@@ -46626,6 +46799,19 @@ function formatUsagePrice(usage) {
     return `${prefix}$${price.toFixed(2)}`;
 }
 
+/**
+ * Formats optional attempt metadata stored in prompt status lines.
+ */
+function formatPromptAttemptMetadata(status, attemptCount) {
+    if (attemptCount <= 1) {
+        return '';
+    }
+    if (status === 'done') {
+        return `(${attemptCount} attempts) `;
+    }
+    return `(failed after ${attemptCount} attempts) `;
+}
+
 /**
  * Formats runner details for prompt status lines.
  */
@@ -46645,7 +46831,7 @@ function formatRunnerSignature(runnerName, modelName) {
 /**
  * Marks a prompt section as done and records usage pricing and runner details.
  */
-function markPromptDone(file, section, usage, runnerName, modelName, promptExecutionStartedDate) {
+function markPromptDone(file, section, usage, runnerName, modelName, promptExecutionStartedDate, attemptCount = 1) {
     if (section.statusLineIndex === undefined) {
         throw new Error(`Prompt ${section.index + 1} in ${file.name} does not have a status line.`);
     }
@@ -46655,16 +46841,17 @@ function markPromptDone(file, section, usage, runnerName, modelName, promptExecu
     }
     const priceString = formatUsagePrice(usage);
     const runnerSignature = formatRunnerSignature(runnerName, modelName);
+    const attemptMetadata = formatPromptAttemptMetadata('done', attemptCount);
     const duration = moment().diff(promptExecutionStartedDate);
     const durationString = moment.duration(duration).humanize();
     // Replace "[ ]" or "[ ] !!..." with "[x] $price duration by runner"
-    file.lines[section.statusLineIndex] = line.replace(/\[\s*\]\s*!*\s*$/, `[x] ${priceString} ${durationString} by ${runnerSignature}`);
+    file.lines[section.statusLineIndex] = line.replace(/\[\s*\]\s*!*\s*$/, `[x] ${attemptMetadata}${priceString} ${durationString} by ${runnerSignature}`);
 }
 
 /**
  * Marks a prompt section as failed and records runner details.
  */
-function markPromptFailed(file, section, runnerName, modelName, promptExecutionStartedDate) {
+function markPromptFailed(file, section, runnerName, modelName, promptExecutionStartedDate, attemptCount = 1) {
     if (section.statusLineIndex === undefined) {
         throw new Error(`Prompt ${section.index + 1} in ${file.name} does not have a status line.`);
     }
@@ -46673,9 +46860,11 @@ function markPromptFailed(file, section, runnerName, modelName, promptExecutionS
         throw new Error(`Prompt ${section.index + 1} in ${file.name} points to a missing status line.`);
     }
     const runnerSignature = formatRunnerSignature(runnerName, modelName);
+    const attemptMetadata = formatPromptAttemptMetadata('failed', attemptCount);
     const duration = moment().diff(promptExecutionStartedDate);
     const durationString = moment.duration(duration).humanize();
-    file.lines[section.statusLineIndex] = line.replace(/\[\s*\]\s*!*\s*$/, `[!] failed after ${durationString} by ${runnerSignature}`);
+    const failureDetails = attemptMetadata === '' ? `failed after ${durationString} by ${runnerSignature}` : `${attemptMetadata}${durationString} by ${runnerSignature}`;
+    file.lines[section.statusLineIndex] = line.replace(/\[\s*\]\s*!*\s*$/, `[!] ${failureDetails}`);
 }
 
 /**
@@ -46792,6 +46981,20 @@ async function waitForPromptStart(file, section, isFirstPrompt) {
     await waitForEnter(colors.bgWhite(`Press Enter to start the ${label}...`));
 }
 
+/**
+ * Formats one unknown error-like value into readable text for logs and feedback.
+ */
+function formatUnknownErrorDetails(error) {
+    if (error instanceof Error) {
+        return error.stack || error.message;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    const serializedError = JSON.stringify(error, null, 2);
+    return serializedError !== null && serializedError !== void 0 ? serializedError : String(error);
+}
+
 /**
  * Writes the failure details for a single prompt run next to the prompt markdown file.
  */
@@ -46799,7 +47002,7 @@ async function writePromptErrorLog(options) {
     const logPath = buildPromptErrorLogPath(options.file.path);
     const label = buildPromptLabelForDisplay(options.file, options.section);
     const summary = buildPromptSummary(options.file, options.section);
-    const details = buildErrorDetails(options.error);
+    const details = formatUnknownErrorDetails(options.error);
     const modelSuffix = options.modelName ? ` (${options.modelName})` : '';
     const runnerLabel = `${options.runnerName || 'unknown'}${modelSuffix}`;
     const log = [
@@ -46826,18 +47029,6 @@ function buildPromptErrorLogPath(promptPath) {
     }
     return `${promptPath}.error.log`;
 }
-/**
- * Formats unknown error values into a readable log payload.
- */
-function buildErrorDetails(error) {
-    if (error instanceof Error) {
-        return error.stack || error.message;
-    }
-    if (typeof error === 'string') {
-        return error;
-    }
-    return JSON.stringify(error, null, 2);
-}
 
 /**
  * Writes updated prompt file content to disk.
@@ -47896,6 +48087,647 @@ class OpencodeRunner {
     }
 }
 
+/**
+ * Runs the configured verification command inside the project root and returns its output.
+ */
+async function runPromptTestCommand(options) {
+    const projectPath = toPosixPath(options.projectPath);
+    return await $runGoScriptWithOutput({
+        scriptPath: options.scriptPath,
+        scriptContent: spaceTrim(`
+            cd "${projectPath}"
+            ${options.command}
+        `),
+    });
+}
+
+/**
+ * Maximum number of coding attempts allowed for the same prompt when verification keeps failing.
+ */
+const MAX_PROMPT_TEST_ATTEMPTS = 3;
+/**
+ * Maximum amount of verification output sent back to the coding agent as retry feedback.
+ */
+const MAX_TEST_FEEDBACK_OUTPUT_CHARS = 12000;
+/**
+ * Runs one coding prompt and, when configured, verifies it with a shell command that can feed failures back.
+ */
+async function runPromptWithTestFeedback(options) {
+    var _a, _b, _c, _d;
+    const normalizedTestCommand = (_a = options.testCommand) === null || _a === void 0 ? void 0 : _a.trim();
+    if (!normalizedTestCommand) {
+        (_b = options.onAttemptStarted) === null || _b === void 0 ? void 0 : _b.call(options, 1);
+        const result = await options.runner.runPrompt({
+            prompt: options.prompt,
+            scriptPath: options.scriptPath,
+            projectPath: options.projectPath,
+        });
+        return { ...result, attemptCount: 1 };
+    }
+    const runPromptTestCommandExecutor = (_c = options.runPromptTestCommandExecutor) !== null && _c !== void 0 ? _c : runPromptTestCommand;
+    let promptForCurrentAttempt = options.prompt;
+    for (let attemptCount = 1; attemptCount <= MAX_PROMPT_TEST_ATTEMPTS; attemptCount++) {
+        (_d = options.onAttemptStarted) === null || _d === void 0 ? void 0 : _d.call(options, attemptCount);
+        const result = await options.runner.runPrompt({
+            prompt: promptForCurrentAttempt,
+            scriptPath: options.scriptPath,
+            projectPath: options.projectPath,
+        });
+        console.info(colors.gray(`Running verification command after attempt #${attemptCount}: ${normalizedTestCommand}`));
+        try {
+            await runPromptTestCommandExecutor({
+                command: normalizedTestCommand,
+                projectPath: options.projectPath,
+                scriptPath: buildPromptTestScriptPath(options.scriptPath),
+            });
+            return { ...result, attemptCount };
+        }
+        catch (error) {
+            const fullVerificationOutput = formatUnknownErrorDetails(error);
+            const feedbackVerificationOutput = limitVerificationOutputForFeedback(fullVerificationOutput);
+            if (attemptCount >= MAX_PROMPT_TEST_ATTEMPTS) {
+                console.error(colors.red(`Verification failed for ${options.promptLabel} after ${attemptCount} attempts.`));
+                throw new Error(buildFinalVerificationFailureMessage({
+                    promptLabel: options.promptLabel,
+                    testCommand: normalizedTestCommand,
+                    attemptCount,
+                    verificationOutput: fullVerificationOutput,
+                }));
+            }
+            console.warn(colors.yellow(`Verification failed for ${options.promptLabel} on attempt #${attemptCount}. Sending feedback to ${options.runner.name} and retrying...`));
+            promptForCurrentAttempt = appendCoderContext(options.prompt, buildVerificationFeedback({
+                testCommand: normalizedTestCommand,
+                failedAttemptCount: attemptCount,
+                verificationOutput: feedbackVerificationOutput,
+            }));
+        }
+    }
+    throw new Error('Unexpected prompt verification state.');
+}
+/**
+ * Builds one feedback block appended to the next coding attempt after tests fail.
+ */
+function buildVerificationFeedback({ testCommand, failedAttemptCount, verificationOutput, }) {
+    const nextAttemptCount = failedAttemptCount + 1;
+    return spaceTrim((block) => `
+            The previous implementation did not pass the required verification command.
+
+            ## Automated verification feedback
+            - Retry attempt: ${nextAttemptCount} of ${MAX_PROMPT_TEST_ATTEMPTS}
+            - Verification command: \`${testCommand}\`
+            - Update the current implementation so the verification command passes without breaking the original task requirements.
+
+            ### Verification output
+            \`\`\`
+            ${block(verificationOutput)}
+            \`\`\`
+        `);
+}
+/**
+ * Builds the final error message written when verification still fails after all retries.
+ */
+function buildFinalVerificationFailureMessage({ promptLabel, testCommand, attemptCount, verificationOutput, }) {
+    return spaceTrim((block) => `
+            Verification command \`${testCommand}\` failed for \`${promptLabel}\` after ${attemptCount} attempts.
+
+            ### Verification output
+            \`\`\`
+            ${block(verificationOutput)}
+            \`\`\`
+        `);
+}
+/**
+ * Limits verification output before it is embedded back into the next coding prompt.
+ */
+function limitVerificationOutputForFeedback(verificationOutput) {
+    const normalizedVerificationOutput = verificationOutput.trim();
+    if (normalizedVerificationOutput.length <= MAX_TEST_FEEDBACK_OUTPUT_CHARS) {
+        return normalizedVerificationOutput;
+    }
+    return spaceTrim(`
+        [...verification output truncated to the last ${MAX_TEST_FEEDBACK_OUTPUT_CHARS} characters...]
+        ${normalizedVerificationOutput.slice(-MAX_TEST_FEEDBACK_OUTPUT_CHARS)}
+    `);
+}
+/**
+ * Derives a dedicated temp-script path for verification commands.
+ */
+function buildPromptTestScriptPath(scriptPath) {
+    if (scriptPath.toLowerCase().endsWith('.sh')) {
+        return `${scriptPath.slice(0, -3)}.test.sh`;
+    }
+    return `${scriptPath}.test.sh`;
+}
+
+/**
+ * Maximum number of agent output lines kept in the scrolling output area.
+ *
+ * @private internal constant of coder run UI
+ */
+const MAX_AGENT_OUTPUT_LINES = 12;
+/**
+ * Calendar formats used when displaying the estimated completion time.
+ *
+ * @private internal constant of coder run UI
+ */
+const ESTIMATED_DONE_CALENDAR_FORMATS = {
+    sameDay: '[Today] h:mm',
+    nextDay: '[Tomorrow] h:mm',
+    nextWeek: 'dddd h:mm',
+    lastDay: '[Yesterday] h:mm',
+    lastWeek: 'dddd h:mm',
+    sameElse: 'MMM D h:mm',
+};
+/**
+ * Reactive state manager for the coder run terminal UI.
+ *
+ * Holds all data the Ink components need and emits `'change'` events
+ * whenever any property is updated so the UI can re-render.
+ *
+ * @private internal utility of coder run UI
+ */
+class CoderRunUiState extends EventEmitter {
+    constructor(startTime) {
+        super();
+        this.config = { agentName: '', priority: 0 };
+        this.currentPromptLabel = '';
+        this.currentAttempt = 1;
+        this.maxAttempts = 3;
+        this.agentOutputLines = [];
+        this.phase = 'initializing';
+        this.statusMessage = 'Initializing...';
+        this.errors = [];
+        this.stats = { done: 0, forAgent: 0, belowMinimumPriority: 0, toBeWritten: 0 };
+        /**
+         * Total milliseconds the timer was paused/waiting (excluded from elapsed display).
+         */
+        this.pausedMs = 0;
+        this.startTime = startTime;
+        // Timer starts paused — callers call `resumeTimer()` when actual work begins.
+        this.pausedSince = startTime.clone();
+    }
+    /**
+     * Pauses the elapsed timer (e.g. while waiting for user input or paused state).
+     */
+    pauseTimer() {
+        if (this.pausedSince === undefined) {
+            this.pausedSince = moment();
+        }
+    }
+    /**
+     * Resumes the elapsed timer after a pause.
+     */
+    resumeTimer() {
+        if (this.pausedSince !== undefined) {
+            this.pausedMs += moment().diff(this.pausedSince);
+            this.pausedSince = undefined;
+        }
+    }
+    /**
+     * Replaces the configuration shown in the UI header.
+     */
+    setConfig(config) {
+        this.config = config;
+        this.emitChange();
+    }
+    /**
+     * Feeds new prompt statistics from the main loop so the progress bar updates.
+     */
+    updateProgress(stats) {
+        if (this.initialDone === undefined && (stats.done > 0 || stats.forAgent > 0 || stats.toBeWritten > 0)) {
+            this.initialDone = stats.done;
+        }
+        this.stats = stats;
+        this.emitChange();
+    }
+    /**
+     * Computes a progress snapshot on demand so elapsed time ticks with periodic re-renders.
+     */
+    getProgress() {
+        var _a;
+        const stats = this.stats;
+        const totalPrompts = stats.done + stats.forAgent + stats.toBeWritten;
+        const sessionDone = Math.max(0, stats.done - ((_a = this.initialDone) !== null && _a !== void 0 ? _a : stats.done));
+        const sessionTotal = sessionDone + stats.forAgent;
+        const percentage = totalPrompts > 0 ? Math.round((stats.done / totalPrompts) * 100) : 0;
+        const wallMs = moment().diff(this.startTime);
+        const currentPauseMs = this.pausedSince !== undefined ? moment().diff(this.pausedSince) : 0;
+        const activeMs = Math.max(0, wallMs - this.pausedMs - currentPauseMs);
+        const elapsedDuration = moment.duration(activeMs);
+        const elapsedText = formatDurationBrief(elapsedDuration);
+        let estimatedTotalText = '\u2014';
+        let estimatedLabel = 'unknown';
+        if (totalPrompts > 0 && stats.done > 0) {
+            const estimatedTotalMs = (elapsedDuration.asMilliseconds() * totalPrompts) / stats.done;
+            const estimatedRemainingMs = estimatedTotalMs - elapsedDuration.asMilliseconds();
+            const estimatedTotalDuration = moment.duration(estimatedTotalMs);
+            const estimatedCompletion = moment().add(estimatedRemainingMs, 'milliseconds');
+            estimatedTotalText = formatDurationBrief(estimatedTotalDuration);
+            estimatedLabel = estimatedCompletion.calendar(null, ESTIMATED_DONE_CALENDAR_FORMATS);
+        }
+        return {
+            totalPrompts,
+            sessionDone,
+            sessionTotal,
+            percentage,
+            elapsedText,
+            estimatedTotalText,
+            estimatedLabel,
+        };
+    }
+    /**
+     * Sets the label of the prompt currently being processed and resets per-prompt state.
+     */
+    setCurrentPrompt(label) {
+        this.currentPromptLabel = label;
+        this.agentOutputLines = [];
+        this.currentAttempt = 1;
+        this.emitChange();
+    }
+    /**
+     * Updates the current retry attempt number.
+     */
+    setAttempt(attempt) {
+        this.currentAttempt = attempt;
+        this.emitChange();
+    }
+    /**
+     * Appends raw agent output text, keeping only the last `MAX_AGENT_OUTPUT_LINES`.
+     */
+    addAgentOutput(text) {
+        const lines = text.split(/\r?\n/).filter((line) => line.trim() !== '');
+        if (lines.length === 0) {
+            return;
+        }
+        this.agentOutputLines.push(...lines);
+        if (this.agentOutputLines.length > MAX_AGENT_OUTPUT_LINES) {
+            this.agentOutputLines = this.agentOutputLines.slice(-MAX_AGENT_OUTPUT_LINES);
+        }
+        this.emitChange();
+    }
+    /**
+     * Transitions the execution phase shown in the UI.
+     */
+    setPhase(phase) {
+        this.phase = phase;
+        this.emitChange();
+    }
+    /**
+     * Updates the status message line beneath the current prompt label.
+     */
+    setStatusMessage(message) {
+        this.statusMessage = message;
+        this.emitChange();
+    }
+    /**
+     * Appends an error message to the error list shown in the UI.
+     */
+    addError(errorMessage) {
+        this.errors.push(errorMessage);
+        this.emitChange();
+    }
+    emitChange() {
+        this.emit('change');
+    }
+}
+/**
+ * Formats a duration into a compact string such as "3h 12m" or "45s".
+ *
+ * @private internal utility of coder run UI
+ */
+function formatDurationBrief(duration) {
+    const totalSeconds = Math.max(0, Math.round(duration.asSeconds()));
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const parts = [];
+    if (hours > 0) {
+        parts.push(`${hours}h`);
+    }
+    if (minutes > 0) {
+        parts.push(`${minutes}m`);
+    }
+    if (!parts.length && seconds > 0) {
+        parts.push(`${seconds}s`);
+    }
+    if (!parts.length) {
+        parts.push('0s');
+    }
+    return parts.join(' ');
+}
+
+/**
+ * Refresh interval for the terminal UI in milliseconds.
+ *
+ * @private internal constant of coder run UI
+ */
+const UI_REFRESH_INTERVAL_MS = 200;
+/**
+ * Character width used for the text progress bar.
+ *
+ * @private internal constant of coder run UI
+ */
+const PROGRESS_BAR_WIDTH = 40;
+/**
+ * Maximum number of output lines reserved for agent output in the UI.
+ *
+ * @private internal constant of coder run UI
+ */
+const MAX_VISIBLE_OUTPUT_LINES = 8;
+/**
+ * Spinner animation frames.
+ *
+ * @private internal constant of coder run UI
+ */
+const SPINNER_FRAMES = [
+    '\u280B',
+    '\u2819',
+    '\u2839',
+    '\u2838',
+    '\u283C',
+    '\u2834',
+    '\u2826',
+    '\u2827',
+    '\u2807',
+    '\u280F',
+];
+/**
+ * Strips ANSI escape codes from a string.
+ *
+ * @private internal utility of coder run UI
+ */
+function stripAnsi(text) {
+    // eslint-disable-next-line no-control-regex
+    return text.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+}
+/**
+ * Returns the usable terminal width, capped at 80.
+ *
+ * @private internal utility of coder run UI
+ */
+function getTerminalWidth() {
+    return Math.min(process.stdout.columns || 80, 80);
+}
+/**
+ * Builds a text progress bar string from a percentage.
+ *
+ * @private internal utility of coder run UI
+ */
+function buildProgressBar(percentage) {
+    const filled = Math.round((percentage / 100) * PROGRESS_BAR_WIDTH);
+    const empty = PROGRESS_BAR_WIDTH - filled;
+    return colors.green('\u2588'.repeat(filled)) + colors.gray('\u2591'.repeat(empty)) + ` ${percentage}%`;
+}
+/**
+ * Boots the ANSI terminal UI for `ptbk coder run`.
+ *
+ * The UI reserves a fixed number of terminal lines and repaints them periodically.
+ * Between repaints, any console output from runners is captured and fed into the
+ * scrolling agent-output area.
+ *
+ * On non-interactive (non-TTY) terminals the UI is skipped entirely and
+ * only the state object is provided.
+ *
+ * @private internal entry point of coder run UI
+ */
+function renderCoderRunUi(startTime) {
+    const state = new CoderRunUiState(startTime);
+    if (!process.stdout.isTTY) {
+        return {
+            state,
+            startCapturingAgentOutput: () => { },
+            stopCapturingAgentOutput: () => { },
+            cleanup: () => { },
+        };
+    }
+    // --- Console interception ---
+    const originalConsoleInfo = console.info;
+    const originalConsoleWarn = console.warn;
+    const originalConsoleError = console.error;
+    const originalConsoleLog = console.log;
+    let isCapturing = false;
+    console.info = (...args) => {
+        if (isCapturing) {
+            state.addAgentOutput(args.map(String).join(' '));
+        }
+        // In UI mode, non-captured output is intentionally suppressed
+        // so it does not interfere with the repainted frame.
+    };
+    console.warn = (...args) => {
+        if (isCapturing) {
+            state.addAgentOutput(args.map(String).join(' '));
+        }
+    };
+    console.error = (...args) => {
+        if (isCapturing) {
+            state.addError(args.map(String).join(' '));
+        }
+    };
+    console.log = (...args) => {
+        if (isCapturing) {
+            state.addAgentOutput(args.map(String).join(' '));
+        }
+    };
+    // --- Keyboard input (pause) ---
+    const readline = require('readline');
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+    }
+    const keypressHandler = (_str, key) => {
+        if (key.ctrl && key.name === 'c') {
+            cleanup();
+            process.exit(0);
+        }
+        if (key.name === 'p') {
+            const current = getPauseState();
+            if (current === 'RUNNING') {
+                requestPause();
+            }
+            else {
+                requestResume();
+            }
+        }
+    };
+    process.stdin.on('keypress', keypressHandler);
+    // --- Rendering ---
+    let spinnerFrame = 0;
+    let previousFrameLineCount = 0;
+    let isRendering = false;
+    let renderScheduled = false;
+    /**
+     * Schedules a render on the next tick if one isn't already pending.
+     * Prevents overlapping renders that cause cursor desync.
+     */
+    function scheduleRender() {
+        if (renderScheduled) {
+            return;
+        }
+        renderScheduled = true;
+        setImmediate(() => {
+            renderScheduled = false;
+            render();
+        });
+    }
+    /**
+     * Clears previously rendered lines and writes a new frame.
+     */
+    function render() {
+        if (isRendering) {
+            return;
+        }
+        isRendering = true;
+        try {
+            const lines = buildFrame();
+            // Move cursor up to clear the previous frame.
+            if (previousFrameLineCount > 0) {
+                process.stdout.write(`\x1b[${previousFrameLineCount}A`);
+            }
+            for (let i = 0; i < lines.length; i++) {
+                clearLine(process.stdout, 0);
+                cursorTo(process.stdout, 0);
+                process.stdout.write(lines[i]);
+                if (i < lines.length - 1) {
+                    process.stdout.write('\n');
+                }
+            }
+            // Clear any leftover lines from a previous longer frame.
+            if (lines.length < previousFrameLineCount) {
+                for (let i = lines.length; i < previousFrameLineCount; i++) {
+                    process.stdout.write('\n');
+                    clearLine(process.stdout, 0);
+                    cursorTo(process.stdout, 0);
+                }
+                // Move back up to the end of the current frame.
+                const overshoot = previousFrameLineCount - lines.length;
+                if (overshoot > 0) {
+                    process.stdout.write(`\x1b[${overshoot}A`);
+                }
+            }
+            previousFrameLineCount = lines.length;
+            spinnerFrame = (spinnerFrame + 1) % SPINNER_FRAMES.length;
+        }
+        finally {
+            isRendering = false;
+        }
+    }
+    /**
+     * Builds the complete frame as an array of terminal lines.
+     */
+    function buildFrame() {
+        const w = getTerminalWidth();
+        const sep = colors.gray('\u2500'.repeat(w - 2));
+        const spinner = SPINNER_FRAMES[spinnerFrame];
+        const { config, phase, currentPromptLabel, currentAttempt, maxAttempts, statusMessage, agentOutputLines, errors, } = state;
+        const progress = state.getProgress();
+        const isPaused = getPauseState() !== 'RUNNING';
+        const isActive = phase === 'running' || phase === 'verifying' || phase === 'loading';
+        const lines = [];
+        // --- Branding ---
+        lines.push(colors.bold.cyan('\u2728 Promptbook Coder'));
+        // --- Config ---
+        let configLine1 = `Agent: ${colors.bold.green(config.agentName)}`;
+        if (config.modelName) {
+            configLine1 += `  \u2502  Model: ${colors.bold(config.modelName)}`;
+        }
+        if (config.thinkingLevel) {
+            configLine1 += `  \u2502  Thinking: ${colors.bold(config.thinkingLevel)}`;
+        }
+        lines.push(configLine1);
+        let configLine2 = '';
+        if (config.context) {
+            configLine2 += `Context: ${colors.yellow(config.context)}  \u2502  `;
+        }
+        configLine2 += `Priority: \u2265${config.priority}`;
+        if (config.testCommand) {
+            configLine2 += `  \u2502  Test: ${colors.gray(config.testCommand)}`;
+        }
+        lines.push(configLine2);
+        // --- Separator ---
+        lines.push(sep);
+        // --- Progress ---
+        const progressSummary = [
+            `${progress.sessionDone}/${progress.sessionTotal} Prompts (${progress.totalPrompts} total)`,
+            `${progress.elapsedText}/${progress.estimatedTotalText}`,
+            `Est. done ${progress.estimatedLabel}`,
+        ].join(' \u2502 ');
+        lines.push(progressSummary);
+        lines.push(buildProgressBar(progress.percentage));
+        // --- Separator ---
+        lines.push(sep);
+        // --- Current prompt ---
+        if (currentPromptLabel) {
+            const spinnerPrefix = isActive ? colors.yellow(`${spinner} `) : '  ';
+            lines.push(spinnerPrefix + colors.bold(currentPromptLabel));
+            lines.push(colors.gray(`Attempt ${currentAttempt}/${maxAttempts} \u2502 ${statusMessage}`));
+        }
+        else {
+            lines.push(colors.gray(statusMessage));
+        }
+        // --- Agent output ---
+        if (agentOutputLines.length > 0) {
+            lines.push('');
+            lines.push(colors.gray.bold('Agent output:'));
+            const visibleLines = agentOutputLines.slice(-MAX_VISIBLE_OUTPUT_LINES);
+            for (const line of visibleLines) {
+                const cleanLine = stripAnsi(line);
+                // Truncate to terminal width.
+                const truncated = cleanLine.length > w - 2 ? cleanLine.slice(0, w - 5) + '...' : cleanLine;
+                lines.push(colors.gray(truncated));
+            }
+        }
+        // --- Errors ---
+        if (errors.length > 0) {
+            lines.push('');
+            for (const err of errors) {
+                lines.push(colors.red(`\u2717 ${err}`));
+            }
+        }
+        // --- Separator ---
+        lines.push(sep);
+        // --- Controls ---
+        const pauseLabel = isPaused
+            ? colors.bgYellow.black(' PAUSED ') + colors.gray(' [P] Resume  \u2502  Ctrl+C Exit')
+            : colors.gray('[P] Pause  \u2502  Ctrl+C Exit');
+        lines.push(pauseLabel);
+        return lines;
+    }
+    // Initial render.
+    process.stdout.write('\n');
+    render();
+    const interval = setInterval(scheduleRender, UI_REFRESH_INTERVAL_MS);
+    // Listen for state changes and schedule a re-render (debounced).
+    state.on('change', scheduleRender);
+    // --- Cleanup ---
+    function cleanup() {
+        clearInterval(interval);
+        state.off('change', scheduleRender);
+        process.stdin.off('keypress', keypressHandler);
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        isCapturing = false;
+        console.info = originalConsoleInfo;
+        console.warn = originalConsoleWarn;
+        console.error = originalConsoleError;
+        console.log = originalConsoleLog;
+        // Render one final frame so the user sees the last state.
+        render();
+        process.stdout.write('\n');
+    }
+    return {
+        state,
+        startCapturingAgentOutput() {
+            isCapturing = true;
+        },
+        stopCapturingAgentOutput() {
+            isCapturing = false;
+        },
+        cleanup,
+    };
+}
+// Note: [💞] Ignore a discrepancy between file name and entity name
+
 /**
  * Constant for prompts dir.
  */
@@ -47958,8 +48790,13 @@ async function runCodexPrompts(providedOptions) {
             `));
     }
     const runStartDate = moment();
-    const progressDisplay = options.dryRun ? undefined : new CliProgressDisplay(runStartDate);
-    listenForPause();
+    const isUiMode = !options.dryRun && Boolean(process.stdout.isTTY);
+    const progressDisplay = options.dryRun || isUiMode ? undefined : new CliProgressDisplay(runStartDate);
+    const uiHandle = isUiMode ? renderCoderRunUi(runStartDate) : undefined;
+    // When the Ink UI is active it handles keyboard input itself, so skip the raw stdin listener.
+    if (!isUiMode) {
+        listenForPause();
+    }
     try {
         const resolvedCoderContext = await resolveCoderContext(options.context, process.cwd());
         if (options.dryRun) {
@@ -48058,35 +48895,78 @@ async function runCodexPrompts(providedOptions) {
         }
         console.info(colors.green(`Running prompts with ${runner.name}`));
         const runnerMetadata = getRunnerMetadata(options, actualRunnerModel);
+        // Feed configuration into the terminal UI
+        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setConfig({
+            agentName: runner.name,
+            modelName: actualRunnerModel,
+            thinkingLevel: options.thinkingLevel,
+            context: options.context,
+            priority: options.priority,
+            testCommand: options.testCommand,
+        });
+        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('loading');
+        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage(`Running prompts with ${runner.name}`);
         let hasShownUpcomingTasks = false;
         let hasWaitedForStart = false;
         while (just(true)) {
-            await checkPause();
+            await checkPause({
+                silent: isUiMode,
+                onPaused: () => {
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.pauseTimer();
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('paused');
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage('Paused');
+                },
+                onResumed: () => {
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.resumeTimer();
+                },
+            });
+            if (isUiMode) {
+                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('loading');
+                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage('Loading prompts...');
+            }
             const promptFiles = await loadPromptFiles(PROMPTS_DIR$1);
             const stats = summarizePrompts(promptFiles, options.priority);
             progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.update(stats);
-            printStats(stats, options.priority);
+            uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.updateProgress(stats);
+            if (!isUiMode) {
+                printStats(stats, options.priority);
+            }
             const nextPrompt = findNextTodoPrompt(promptFiles, options.priority);
             if (!hasShownUpcomingTasks) {
-                if (stats.toBeWritten > 0) {
+                if (stats.toBeWritten > 0 && !isUiMode) {
                     console.info(colors.yellow('Following prompts need to be written:'));
                     printPromptsToBeWritten(promptFiles, options.priority);
                     console.info('');
                 }
-                printUpcomingTasks(listUpcomingTasks(promptFiles, options.priority));
+                if (!isUiMode) {
+                    printUpcomingTasks(listUpcomingTasks(promptFiles, options.priority));
+                }
                 hasShownUpcomingTasks = true;
             }
             if (!nextPrompt) {
                 if (stats.toBeWritten > 0) {
-                    console.info(colors.yellow('No prompts ready for agent.'));
+                    const message = 'No prompts ready for agent.';
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage(message);
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('done');
+                    if (!isUiMode) {
+                        console.info(colors.yellow(message));
+                    }
                 }
                 else {
-                    console.info(colors.green('All prompts are done.'));
+                    const message = 'All prompts are done.';
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage(message);
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('done');
+                    if (!isUiMode) {
+                        console.info(colors.green(message));
+                    }
                 }
                 return;
             }
             if (options.waitForUser) {
+                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.pauseTimer();
+                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage(hasWaitedForStart ? 'Waiting... Press Enter to continue' : 'Waiting... Press Enter to start');
                 await waitForPromptStart(nextPrompt.file, nextPrompt.section, !hasWaitedForStart);
+                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.resumeTimer();
                 hasWaitedForStart = true;
             }
             if (!options.ignoreGitChanges) {
@@ -48096,29 +48976,57 @@ async function runCodexPrompts(providedOptions) {
             const codexPrompt = appendCoderContext(buildCodexPrompt(nextPrompt.file, nextPrompt.section), resolvedCoderContext);
             const scriptPath = buildScriptPath(nextPrompt.file, nextPrompt.section);
             const promptLabel = buildPromptLabelForDisplay(nextPrompt.file, nextPrompt.section);
-            console.info(colors.blue(`Processing ${promptLabel}`));
+            if (isUiMode) {
+                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setCurrentPrompt(promptLabel);
+                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('running');
+                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage('Running');
+            }
+            else {
+                console.info(colors.blue(`Processing ${promptLabel}`));
+            }
             const promptExecutionStartedDate = moment();
+            let attemptCount = 1;
             const roundChangedFilesSnapshot = options.normalizeLineEndings
                 ? await captureChangedFilesSnapshot(process.cwd())
                 : undefined;
             try {
-                const result = await runner.runPrompt({
+                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.startCapturingAgentOutput();
+                const result = await runPromptWithTestFeedback({
+                    runner,
                     prompt: codexPrompt,
                     scriptPath,
                     projectPath: process.cwd(),
+                    promptLabel,
+                    testCommand: options.testCommand,
+                    onAttemptStarted: (nextAttemptCount) => {
+                        attemptCount = nextAttemptCount;
+                        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setAttempt(nextAttemptCount);
+                        if (nextAttemptCount > 1) {
+                            uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage(`Retrying (attempt ${nextAttemptCount})`);
+                            uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('verifying');
+                        }
+                    },
                 });
-                markPromptDone(nextPrompt.file, nextPrompt.section, result.usage, runnerMetadata.runnerName, runnerMetadata.modelName, promptExecutionStartedDate);
+                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.stopCapturingAgentOutput();
+                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage('Committing changes');
+                markPromptDone(nextPrompt.file, nextPrompt.section, result.usage, runnerMetadata.runnerName, runnerMetadata.modelName, promptExecutionStartedDate, result.attemptCount);
                 await writePromptFile(nextPrompt.file);
                 await normalizeLineEndingsForCurrentRound(options, roundChangedFilesSnapshot);
                 if (options.waitForUser) {
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.pauseTimer();
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage('Waiting... Press Enter to commit');
                     printCommitMessage(commitMessage);
                     await waitForEnter(colors.bgWhite('Press Enter to commit and continue...'));
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.resumeTimer();
                 }
-                await commitChanges(commitMessage, { noPush: options.noPush });
+                await commitChanges(commitMessage, { autoPush: options.autoPush });
                 await runPostPromptAutoMigrationIfEnabled(options);
             }
             catch (error) {
-                markPromptFailed(nextPrompt.file, nextPrompt.section, runnerMetadata.runnerName, runnerMetadata.modelName, promptExecutionStartedDate);
+                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.stopCapturingAgentOutput();
+                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('error');
+                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.addError(error instanceof Error ? error.message : String(error));
+                markPromptFailed(nextPrompt.file, nextPrompt.section, runnerMetadata.runnerName, runnerMetadata.modelName, promptExecutionStartedDate, attemptCount);
                 await writePromptFile(nextPrompt.file);
                 await writePromptErrorLog({
                     file: nextPrompt.file,
@@ -48134,6 +49042,7 @@ async function runCodexPrompts(providedOptions) {
     }
     finally {
         progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.stop();
+        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.cleanup();
         if (!options.dryRun) {
             printAgentGitIdentityTipIfNeeded();
         }
@@ -49756,7 +50665,7 @@ function promptbookifyAiText(text) {
 /**
  * Constant for default agent kit model name.
  */
-const DEFAULT_AGENT_KIT_MODEL_NAME = 'gpt-5.4-nano';
+const DEFAULT_AGENT_KIT_MODEL_NAME = 'gpt-5.4-mini';
 /**
  * Creates one structured log entry for streamed tool-call updates.
  *
@@ -50806,6 +51715,7 @@ class AgentLlmExecutionTools {
      * @param agentSource The agent source string that defines the agent's behavior
      */
     constructor(options) {
+        var _a;
         this.options = options;
         /**
          * Cached model requirements to avoid re-parsing the agent source
@@ -50815,6 +51725,7 @@ class AgentLlmExecutionTools {
          * Cached parsed agent information
          */
         this._cachedAgentInfo = null;
+        this.precomputedModelRequirements = (_a = options.precomputedModelRequirements) !== null && _a !== void 0 ? _a : null;
     }
     /**
      * Updates the agent source and clears the cache
@@ -50822,9 +51733,13 @@ class AgentLlmExecutionTools {
      * @param agentSource The new agent source string
      */
     updateAgentSource(agentSource) {
+        if (this.options.agentSource === agentSource) {
+            return;
+        }
         this.options.agentSource = agentSource;
         this._cachedAgentInfo = null;
         this._cachedModelRequirements = null;
+        this.precomputedModelRequirements = null;
     }
     /**
      * Get cached or parse agent information
@@ -50841,6 +51756,16 @@ class AgentLlmExecutionTools {
      * Note: [🐤] This is names `getModelRequirements` *(not `getAgentModelRequirements`)* because in future these two will be united
      */
     async getModelRequirements() {
+        var _a, _b;
+        if (this.precomputedModelRequirements !== null) {
+            if (this.options.isVerbose) {
+                console.info('[🤰]', 'Using precomputed agent model requirements', {
+                    agent: this.title,
+                    toolCount: (_b = (_a = this.precomputedModelRequirements.tools) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0,
+                });
+            }
+            return this.precomputedModelRequirements;
+        }
         if (this._cachedModelRequirements === null) {
             const preparationStartedAtMs = Date.now();
             if (this.options.isVerbose) {
@@ -50950,6 +51875,7 @@ class AgentLlmExecutionTools {
      * Resolves agent requirements, attachments, and runtime overrides into one forwarded chat prompt.
      */
     async prepareChatPrompt(prompt) {
+        var _a;
         const chatPrompt = this.requireChatPrompt(prompt);
         const { sanitizedRequirements, promptSuffix } = await this.getSanitizedAgentModelRequirements();
         const attachments = normalizeChatAttachments(chatPrompt.attachments);
@@ -50967,7 +51893,16 @@ class AgentLlmExecutionTools {
             mergedTools,
             knowledgeSourcesForAgent,
         });
-        console.log('!!!! promptWithAgentModelRequirements:', forwardedPrompt);
+        if (this.options.isVerbose) {
+            console.info('[🤰]', 'Prepared agent chat prompt', {
+                agent: this.title,
+                usedPrecomputedModelRequirements: this.precomputedModelRequirements !== null,
+                toolNames: mergedTools.map((tool) => tool.name),
+                knowledgeSourcesCount: (_a = knowledgeSourcesForAgent === null || knowledgeSourcesForAgent === void 0 ? void 0 : knowledgeSourcesForAgent.length) !== null && _a !== void 0 ? _a : 0,
+                promptSuffixLength: promptSuffix.length,
+                systemMessageLength: sanitizedRequirements.systemMessage.length,
+            });
+        }
         return {
             forwardedPrompt,
             sanitizedRequirements,
@@ -51154,6 +52089,7 @@ class AgentLlmExecutionTools {
      * Runs one prepared prompt through the deprecated OpenAI Assistant backend.
      */
     async callOpenAiAssistantChatModelStream(options) {
+        var _a, _b, _c, _d;
         const assistant = await this.getOrPrepareOpenAiAssistant({
             llmTools: options.llmTools,
             originalPrompt: options.originalPrompt,
@@ -51161,7 +52097,14 @@ class AgentLlmExecutionTools {
             onProgress: options.onProgress,
         });
         const promptWithAgentModelRequirementsForOpenAiAssistantExecutionTools = createOpenAiAssistantPrompt(options.preparedChatPrompt.forwardedPrompt);
-        console.log('!!!! promptWithAgentModelRequirementsForOpenAiAssistantExecutionTools:', promptWithAgentModelRequirementsForOpenAiAssistantExecutionTools);
+        if (this.options.isVerbose) {
+            console.info('[🤰]', 'Prepared OpenAI Assistant prompt', {
+                agent: this.title,
+                toolNames: (_b = (_a = promptWithAgentModelRequirementsForOpenAiAssistantExecutionTools.modelRequirements.tools) === null || _a === void 0 ? void 0 : _a.map((tool) => tool.name)) !== null && _b !== void 0 ? _b : [],
+                knowledgeSourcesCount: (_d = (_c = promptWithAgentModelRequirementsForOpenAiAssistantExecutionTools.modelRequirements
+                    .knowledgeSources) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0,
+            });
+        }
         return assistant.callChatModelStream(promptWithAgentModelRequirementsForOpenAiAssistantExecutionTools, options.onProgress, options.streamOptions);
     }
     /**
@@ -51852,7 +52795,8 @@ class Agent extends AgentLlmExecutionTools {
             isVerbose: options.isVerbose,
             llmTools: getSingleLlmExecutionTools(options.executionTools.llm),
             assistantPreparationMode: options.assistantPreparationMode,
-            agentSource: agentSource.value, // <- TODO: [🐱‍🚀] Allow to pass BehaviorSubject<string_book> OR refresh llmExecutionTools.callChat on agentSource change
+            agentSource: agentSource.value,
+            precomputedModelRequirements: options.precomputedModelRequirements,
         });
         this._agentName = undefined;
         /**