@promptbook/cli 0.112.0-42 → 0.112.0-43

package/umd/index.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('colors'), require('commander'), require('spacetrim'), require('fs'), require('path'), require('fs/promises'), require('waitasecond'), require('prompts'), require('dotenv'), require('crypto-js/enc-hex'), require('crypto-js/sha256'), require('socket.io-client'), require('crypto-js'), require('jszip'), require('crypto'), require('@mozilla/readability'), require('jsdom'), require('showdown'), require('glob-promise'), require('moment'), require('express'), require('express-openapi-validator'), require('http'), require('socket.io'), require('swagger-ui-express'), require('react'), require('react-dom/server'), require('@anthropic-ai/sdk'), require('bottleneck'), require('@azure/openai'), require('typescript'), require('ignore'), require('readline'), require('child_process'), require('pg'), require('@supabase/supabase-js'), require('path/posix'), require('rxjs'), require('mime-types'), require('papaparse'), require('@openai/agents'), require('openai')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'colors', 'commander', 'spacetrim', 'fs', 'path', 'fs/promises', 'waitasecond', 'prompts', 'dotenv', 'crypto-js/enc-hex', 'crypto-js/sha256', 'socket.io-client', 'crypto-js', 'jszip', 'crypto', '@mozilla/readability', 'jsdom', 'showdown', 'glob-promise', 'moment', 'express', 'express-openapi-validator', 'http', 'socket.io', 'swagger-ui-express', 'react', 'react-dom/server', '@anthropic-ai/sdk', 'bottleneck', '@azure/openai', 'typescript', 'ignore', 'readline', 'child_process', 'pg', '@supabase/supabase-js', 'path/posix', 'rxjs', 'mime-types', 'papaparse', '@openai/agents', 'openai'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-cli"] = {}, global.colors, global.commander, global._spaceTrim, global.fs, global.path, global.promises, global.waitasecond, global.prompts, global.dotenv, global.hexEncoder, global.sha256, global.socket_ioClient, global.cryptoJs, global.JSZip, global.crypto, global.readability, global.jsdom, global.showdown, global.glob, global.moment, global.express, global.OpenApiValidator, global.http, global.socket_io, global.swaggerUi, global.react, global.server, global.Anthropic, global.Bottleneck, global.openai, global.ts, global.ignore, global.readline, global.child_process, global.pg, null, global.posix, global.rxjs, global.mimeTypes, global.papaparse, global.agents, global.OpenAI));
-})(this, (function (exports, colors, commander, _spaceTrim, fs, path, promises, waitasecond, prompts, dotenv, hexEncoder, sha256, socket_ioClient, cryptoJs, JSZip, crypto, readability, jsdom, showdown, glob, moment, express, OpenApiValidator, http, socket_io, swaggerUi, react, server, Anthropic, Bottleneck, openai, ts, ignore, readline, child_process, pg, supabaseJs, posix, rxjs, mimeTypes, papaparse, agents, OpenAI) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('colors'), require('commander'), require('spacetrim'), require('fs'), require('path'), require('fs/promises'), require('waitasecond'), require('prompts'), require('dotenv'), require('crypto-js/enc-hex'), require('crypto-js/sha256'), require('socket.io-client'), require('crypto-js'), require('jszip'), require('crypto'), require('@mozilla/readability'), require('jsdom'), require('showdown'), require('glob-promise'), require('moment'), require('express'), require('express-openapi-validator'), require('http'), require('socket.io'), require('swagger-ui-express'), require('react'), require('react-dom/server'), require('@anthropic-ai/sdk'), require('bottleneck'), require('@azure/openai'), require('typescript'), require('ignore'), require('readline'), require('child_process'), require('pg'), require('@supabase/supabase-js'), require('path/posix'), require('events'), require('rxjs'), require('mime-types'), require('papaparse'), require('@openai/agents'), require('openai')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'colors', 'commander', 'spacetrim', 'fs', 'path', 'fs/promises', 'waitasecond', 'prompts', 'dotenv', 'crypto-js/enc-hex', 'crypto-js/sha256', 'socket.io-client', 'crypto-js', 'jszip', 'crypto', '@mozilla/readability', 'jsdom', 'showdown', 'glob-promise', 'moment', 'express', 'express-openapi-validator', 'http', 'socket.io', 'swagger-ui-express', 'react', 'react-dom/server', '@anthropic-ai/sdk', 'bottleneck', '@azure/openai', 'typescript', 'ignore', 'readline', 'child_process', 'pg', '@supabase/supabase-js', 'path/posix', 'events', 'rxjs', 'mime-types', 'papaparse', '@openai/agents', 'openai'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-cli"] = {}, global.colors, global.commander, global._spaceTrim, global.fs, global.path, global.promises, global.waitasecond, global.prompts, global.dotenv, global.hexEncoder, global.sha256, global.socket_ioClient, global.cryptoJs, global.JSZip, global.crypto, global.readability, global.jsdom, global.showdown, global.glob, global.moment, global.express, global.OpenApiValidator, global.http, global.socket_io, global.swaggerUi, global.react, global.server, global.Anthropic, global.Bottleneck, global.openai, global.ts, global.ignore, global.readline, global.child_process, global.pg, null, global.posix, global.events, global.rxjs, global.mimeTypes, global.papaparse, global.agents, global.OpenAI));
+})(this, (function (exports, colors, commander, _spaceTrim, fs, path, promises, waitasecond, prompts, dotenv, hexEncoder, sha256, socket_ioClient, cryptoJs, JSZip, crypto, readability, jsdom, showdown, glob, moment, express, OpenApiValidator, http, socket_io, swaggerUi, react, server, Anthropic, Bottleneck, openai, ts, ignore, readline, child_process, pg, supabaseJs, posix, events, rxjs, mimeTypes, papaparse, agents, OpenAI) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -60,7 +60,7 @@
      * @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
@@ -2323,7 +2323,7 @@
             '',
             '## 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');
     }
@@ -2583,6 +2583,26 @@
     }
     // 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.
      */
@@ -2628,7 +2648,7 @@
         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.spaceTrim(`
@@ -2986,7 +3006,9 @@
 
             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
         `));
@@ -2999,17 +3021,19 @@
             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 commander.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) {
@@ -3038,13 +3062,14 @@
                 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; });
@@ -3073,6 +3098,19 @@
         }
         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
 
@@ -22559,6 +22597,15 @@
      * 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.
      */
@@ -22648,12 +22695,9 @@
                 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: {
@@ -22722,22 +22766,72 @@
     /**
      * 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.spaceTrim(`
-            ${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.
      */
@@ -40910,7 +41004,7 @@
             systemMessage: '',
             promptSuffix: '',
             // modelName: 'gpt-5',
-            modelName: 'gemini-2.5-flash-lite',
+            modelName: 'gpt-5.4-mini',
             temperature: 0.7,
             topP: 0.9,
             topK: 50,
@@ -44090,7 +44184,26 @@
     /**
      * 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.
      */
@@ -44111,6 +44224,8 @@
         }
         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');
@@ -44120,8 +44235,11 @@
         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(', ')}.`);
         }
@@ -44142,10 +44260,11 @@
             allowCredits,
             autoMigrate,
             allowDestructiveAutoMigrate,
-            noPush,
+            autoPush,
             agentName,
             model,
             context,
+            testCommand,
             thinkingLevel,
             priority,
         };
@@ -44160,6 +44279,28 @@
         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.
      */
@@ -44185,6 +44326,21 @@
         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.
      */
@@ -44196,7 +44352,7 @@
     /**
      * 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',
@@ -44295,15 +44451,15 @@
         const sessionTotal = sessionDone + stats.forAgent;
         const percentage = totalPrompts > 0 ? Math.round((completedPrompts / totalPrompts) * 100) : 0;
         const elapsedDuration = moment__default["default"].duration(moment__default["default"]().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__default["default"].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,
@@ -44319,7 +44475,7 @@
     /**
      * 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);
@@ -44340,21 +44496,6 @@
         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.
      */
@@ -44624,7 +44765,7 @@
     }
 
     /**
-     * Constant for pause state.
+     * Current pause state.
      */
     let pauseState = 'RUNNING';
     /**
@@ -44661,17 +44802,48 @@
     }
     /**
      * 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__default["default"].bgWhite.black('Paused') + colors__default["default"].gray(' (Press "p" to resume)'));
+            if (!(options === null || options === void 0 ? void 0 : options.silent)) {
+                console.log(colors__default["default"].bgWhite.black('Paused') + colors__default["default"].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__default["default"].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__default["default"].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.
@@ -45016,7 +45188,7 @@
 
     /**
      * 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();
@@ -45036,7 +45208,7 @@
                 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);
             }
         }
@@ -46629,6 +46801,19 @@
         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.
      */
@@ -46648,7 +46833,7 @@
     /**
      * 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.`);
         }
@@ -46658,16 +46843,17 @@
         }
         const priceString = formatUsagePrice(usage);
         const runnerSignature = formatRunnerSignature(runnerName, modelName);
+        const attemptMetadata = formatPromptAttemptMetadata('done', attemptCount);
         const duration = moment__default["default"]().diff(promptExecutionStartedDate);
         const durationString = moment__default["default"].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.`);
         }
@@ -46676,9 +46862,11 @@
             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__default["default"]().diff(promptExecutionStartedDate);
         const durationString = moment__default["default"].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}`);
     }
 
     /**
@@ -46795,6 +46983,20 @@
         await waitForEnter(colors__default["default"].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.
      */
@@ -46802,7 +47004,7 @@
         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 = [
@@ -46829,18 +47031,6 @@
         }
         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.
@@ -47899,6 +48089,647 @@
         }
     }
 
+    /**
+     * 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__default["default"].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__default["default"].red(`Verification failed for ${options.promptLabel} after ${attemptCount} attempts.`));
+                    throw new Error(buildFinalVerificationFailureMessage({
+                        promptLabel: options.promptLabel,
+                        testCommand: normalizedTestCommand,
+                        attemptCount,
+                        verificationOutput: fullVerificationOutput,
+                    }));
+                }
+                console.warn(colors__default["default"].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 events.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__default["default"]();
+            }
+        }
+        /**
+         * Resumes the elapsed timer after a pause.
+         */
+        resumeTimer() {
+            if (this.pausedSince !== undefined) {
+                this.pausedMs += moment__default["default"]().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__default["default"]().diff(this.startTime);
+            const currentPauseMs = this.pausedSince !== undefined ? moment__default["default"]().diff(this.pausedSince) : 0;
+            const activeMs = Math.max(0, wallMs - this.pausedMs - currentPauseMs);
+            const elapsedDuration = moment__default["default"].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__default["default"].duration(estimatedTotalMs);
+                const estimatedCompletion = moment__default["default"]().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__default["default"].green('\u2588'.repeat(filled)) + colors__default["default"].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$1 = require('readline');
+        readline$1.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++) {
+                    readline.clearLine(process.stdout, 0);
+                    readline.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');
+                        readline.clearLine(process.stdout, 0);
+                        readline.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__default["default"].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__default["default"].bold.cyan('\u2728 Promptbook Coder'));
+            // --- Config ---
+            let configLine1 = `Agent: ${colors__default["default"].bold.green(config.agentName)}`;
+            if (config.modelName) {
+                configLine1 += `  \u2502  Model: ${colors__default["default"].bold(config.modelName)}`;
+            }
+            if (config.thinkingLevel) {
+                configLine1 += `  \u2502  Thinking: ${colors__default["default"].bold(config.thinkingLevel)}`;
+            }
+            lines.push(configLine1);
+            let configLine2 = '';
+            if (config.context) {
+                configLine2 += `Context: ${colors__default["default"].yellow(config.context)}  \u2502  `;
+            }
+            configLine2 += `Priority: \u2265${config.priority}`;
+            if (config.testCommand) {
+                configLine2 += `  \u2502  Test: ${colors__default["default"].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__default["default"].yellow(`${spinner} `) : '  ';
+                lines.push(spinnerPrefix + colors__default["default"].bold(currentPromptLabel));
+                lines.push(colors__default["default"].gray(`Attempt ${currentAttempt}/${maxAttempts} \u2502 ${statusMessage}`));
+            }
+            else {
+                lines.push(colors__default["default"].gray(statusMessage));
+            }
+            // --- Agent output ---
+            if (agentOutputLines.length > 0) {
+                lines.push('');
+                lines.push(colors__default["default"].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__default["default"].gray(truncated));
+                }
+            }
+            // --- Errors ---
+            if (errors.length > 0) {
+                lines.push('');
+                for (const err of errors) {
+                    lines.push(colors__default["default"].red(`\u2717 ${err}`));
+                }
+            }
+            // --- Separator ---
+            lines.push(sep);
+            // --- Controls ---
+            const pauseLabel = isPaused
+                ? colors__default["default"].bgYellow.black(' PAUSED ') + colors__default["default"].gray(' [P] Resume  \u2502  Ctrl+C Exit')
+                : colors__default["default"].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.
      */
@@ -47961,8 +48792,13 @@
             `));
         }
         const runStartDate = moment__default["default"]();
-        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) {
@@ -48061,35 +48897,78 @@
             }
             console.info(colors__default["default"].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__default["default"].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__default["default"].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__default["default"].yellow(message));
+                        }
                     }
                     else {
-                        console.info(colors__default["default"].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__default["default"].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) {
@@ -48099,29 +48978,57 @@
                 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__default["default"].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__default["default"].blue(`Processing ${promptLabel}`));
+                }
                 const promptExecutionStartedDate = moment__default["default"]();
+                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__default["default"].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,
@@ -48137,6 +49044,7 @@
         }
         finally {
             progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.stop();
+            uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.cleanup();
             if (!options.dryRun) {
                 printAgentGitIdentityTipIfNeeded();
             }
@@ -49759,7 +50667,7 @@
     /**
      * 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.
      *
@@ -50809,6 +51717,7 @@
          * @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
@@ -50818,6 +51727,7 @@
              * 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
@@ -50825,9 +51735,13 @@
          * @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
@@ -50844,6 +51758,16 @@
          * 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) {
@@ -50953,6 +51877,7 @@
          * 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);
@@ -50970,7 +51895,16 @@
                 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,
@@ -51157,6 +52091,7 @@
          * 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,
@@ -51164,7 +52099,14 @@
                 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);
         }
         /**
@@ -51855,7 +52797,8 @@
                 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;
             /**