@promptbook/cli 0.112.0-44 → 0.112.0-46

package/umd/index.umd.js

@@ -60,7 +60,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-44';
+    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-46';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -3007,6 +3007,8 @@
             Features:
             - Automatically stages and commits changes with agent identity
             - Optional post-commit git push with explicit --auto-push opt-in
+            - Optional --preserve-logs keeps temp prompt/log artifacts after successful rounds
+            - Optional --no-ui keeps plain streaming console output for logging and debugging
             - Supports GPG signing of commits
             - Optional post-prompt verification with test-feedback retries
             - Progress tracking and interactive controls
@@ -3022,19 +3024,21 @@
         `));
         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.option('--preserve-logs', 'Keep generated temp prompt/log artifacts after successful rounds for debugging and analytics', false);
+        command.option('--no-ui', 'Disable the rich terminal UI and keep plain streaming console output for logging and debugging');
         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('--preserve-logs', 'Keep generated runner shells and runtime logs after successful prompt rounds; failures keep them automatically', false);
         command.option('--no-normalize-line-endings', 'Disable automatic LF normalization for files changed in each coding round');
         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, test, thinkingLevel, priority, wait, ignoreGitChanges, allowCredits, preserveLogs, normalizeLineEndings, autoMigrate, allowDestructiveAutoMigrate, autoPush, } = cliOptions;
+            const { dryRun, agent, model, context, test, preserveLogs, ui, thinkingLevel, priority, wait, ignoreGitChanges, allowCredits, normalizeLineEndings, autoMigrate, allowDestructiveAutoMigrate, autoPush, } = cliOptions;
             const testCommand = normalizeCommandOptionValue(test);
+            const noUi = !ui;
             // Validate agent
             let agentName = undefined;
             if (agent) {
@@ -3064,11 +3068,12 @@
                 model,
                 context,
                 testCommand,
+                preserveLogs,
+                noUi,
                 thinkingLevel,
                 priority,
                 normalizeLineEndings,
                 allowCredits,
-                preserveLogs,
                 autoMigrate,
                 allowDestructiveAutoMigrate,
                 autoPush,
@@ -18388,7 +18393,7 @@
             DELETE Casual conversational style
             REMOVE All emoji usage
             GOAL Provide professional business communications
-            STYLE Use formal language and proper business etiquette
+            WRITING RULES Use formal language and proper business etiquette
             \`\`\`
 
             \`\`\`book
@@ -18399,7 +18404,7 @@
             DISCARD Technical jargon explanations
             CANCEL Advanced troubleshooting procedures
             GOAL Help users with simple, easy-to-follow solutions
-            STYLE Use plain language that anyone can understand
+            WRITING RULES Use plain language that anyone can understand
             \`\`\`
 
             \`\`\`book
@@ -18416,11 +18421,11 @@
             Concise Information Provider
 
             PERSONA You are a helpful assistant who provides detailed explanations
-            STYLE Include examples, analogies, and comprehensive context
+            WRITING RULES Include examples, analogies, and comprehensive context
             CANCEL Detailed explanation style
             DISCARD Examples and analogies
             GOAL Provide brief, direct answers without unnecessary elaboration
-            STYLE Be concise and to the point
+            WRITING RULES Be concise and to the point
             \`\`\`
         `);
         }
@@ -18604,7 +18609,7 @@
             PERSONA You are a data analysis expert
             FORMAT Present results in structured tables
             FORMAT Include confidence scores for all predictions
-            STYLE Be concise and precise in explanations
+            WRITING RULES Be concise and precise in explanations
             \`\`\`
         `);
         }
@@ -18998,7 +19003,7 @@
 
             GOAL Help students understand mathematical concepts clearly
             GOAL Ensure all explanations are age-appropriate and accessible
-            STYLE Use simple language and provide step-by-step explanations
+            WRITING RULES Use simple language and provide step-by-step explanations
             \`\`\`
 
             \`\`\`book
@@ -19412,7 +19417,7 @@
             KNOWLEDGE Academic research requires careful citation and verification
             KNOWLEDGE https://example.com/research-guidelines.pdf
             ACTION Can help with literature reviews and data analysis
-            STYLE Present information in clear, academic format
+            WRITING RULES Present information in clear, academic format
             \`\`\`
         `);
         }
@@ -21163,7 +21168,7 @@
 
             META IMAGE https://example.com/professional-avatar.jpg
             PERSONA You are a professional business assistant
-            STYLE Maintain a formal and courteous tone
+            WRITING RULES Maintain a formal and courteous tone
             \`\`\`
 
             \`\`\`book
@@ -21171,7 +21176,7 @@
 
             META IMAGE /assets/creative-bot-avatar.png
             PERSONA You are a creative and inspiring assistant
-            STYLE Be enthusiastic and encouraging
+            WRITING RULES Be enthusiastic and encouraging
             ACTION Can help with brainstorming and ideation
             \`\`\`
         `);
@@ -21330,7 +21335,7 @@
             META LINK https://twitter.com/devhandle
             PERSONA You are an experienced open source developer
             ACTION Can help with code reviews and architecture decisions
-            STYLE Be direct and technical in explanations
+            WRITING RULES Be direct and technical in explanations
             \`\`\`
         `);
         }
@@ -21536,7 +21541,7 @@
             MODEL TEMPERATURE 0.8
             MODEL TOP_P 0.9
             MODEL MAX_TOKENS 2048
-            STYLE Be imaginative and expressive
+            WRITING RULES Be imaginative and expressive
             ACTION Can help with storytelling and character development
             \`\`\`
 
@@ -21748,7 +21753,7 @@
             NOTE Uses RAG for accessing latest research papers
             PERSONA You are a knowledgeable research assistant
             ACTION Can help with literature reviews and citations
-            STYLE Present information in academic format
+            WRITING RULES Present information in academic format
             \`\`\`
         `);
         }
@@ -22042,7 +22047,7 @@
             RULE Always ask for clarification if the user's request is ambiguous
             RULE Be polite and professional in all interactions
             RULES Never provide medical or legal advice
-            STYLE Maintain a friendly and helpful tone
+            WRITING RULES Maintain a friendly and helpful tone
             \`\`\`
 
             \`\`\`book
@@ -22311,8 +22316,8 @@
     /**
      * STYLE commitment definition
      *
-     * The STYLE commitment defines how the agent should format and present its responses.
-     * This includes tone, writing style, formatting preferences, and communication patterns.
+     * Deprecated legacy writing-style commitment kept for backward compatibility.
+     * New books should prefer `WRITING RULES` for writing-only constraints.
      *
      * Example usage in agent source:
      *
@@ -22331,7 +22336,16 @@
          * Short one-line description of STYLE.
          */
         get description() {
-            return 'Control the tone and writing style of responses.';
+            return 'Deprecated legacy writing-style commitment. Prefer `WRITING RULES` for new books.';
+        }
+        /**
+         * Optional UI/docs-only deprecation metadata.
+         */
+        get deprecation() {
+            return {
+                message: 'Use `WRITING RULES` for writing-only constraints such as tone, length, formatting, or emoji usage.',
+                replacedBy: ['WRITING RULES'],
+            };
         }
         /**
          * Icon for this commitment.
@@ -22346,15 +22360,34 @@
             return _spaceTrim.spaceTrim(`
             # ${this.type}
 
-            Defines how the agent should format and present its responses (tone, writing style, formatting).
+            Deprecated legacy commitment for writing and presentation instructions.
+
+            ## Migration
+
+            - Existing \`${this.type}\` books still parse and compile.
+            - New books should prefer \`WRITING RULES\`.
+            - Use \`WRITING SAMPLE\` when you want to anchor voice by example instead of stating constraints directly.
+            - The plural alias \`STYLES\` is the same legacy commitment family.
 
             ## Key aspects
 
-            - Both terms work identically and can be used interchangeably.
+            - \`${this.type}\` remains functional for backward compatibility only.
             - Later style instructions can override earlier ones.
             - Style affects both tone and presentation format.
 
-            ## Examples
+            ## Preferred replacement
+
+            \`\`\`book
+            Technical Writer
+
+            GOAL Help the user understand technical topics with practical, accurate guidance.
+            WRITING RULES Write in a professional but friendly tone.
+            WRITING RULES Use bullet points for lists.
+            WRITING RULES Always provide code examples when explaining programming concepts.
+            FORMAT Use markdown formatting with clear headings
+            \`\`\`
+
+            ## Legacy compatibility examples
 
             \`\`\`book
             Technical Writer
@@ -23095,7 +23128,7 @@
 
             PERSONA You are a helpful customer support representative
             TEMPLATE Always structure your response with: 1) Acknowledgment, 2) Solution, 3) Follow-up question
-            STYLE Be professional and empathetic
+            WRITING RULES Be professional and empathetic
             \`\`\`
 
             \`\`\`book
@@ -23539,7 +23572,7 @@
 
             PERSONA You are a news analyst who stays up-to-date with current events
             USE BROWSER
-            STYLE Present news in a balanced and objective manner
+            WRITING RULES Present news in a balanced and objective manner
             ACTION Can search for and summarize news articles
             \`\`\`
 
@@ -44245,7 +44278,7 @@
     /**
      * CLI usage text for this script.
      */
-    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] [--preserve-logs] [--auto-migrate] [--allow-destructive-auto-migrate] [--no-wait] [--ignore-git-changes] [--no-normalize-line-endings] [--auto-push]';
+    const USAGE = 'Usage: run-codex-prompts [--dry-run] [--agent <agent-name>] [--model <model>] [--context <context-or-file>] [--test <test-command...>] [--preserve-logs] [--no-ui] [--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.
      */
@@ -44255,10 +44288,11 @@
         '--model',
         '--context',
         '--test',
+        '--preserve-logs',
+        '--no-ui',
         '--thinking-level',
         '--priority',
         '--allow-credits',
-        '--preserve-logs',
         '--auto-migrate',
         '--allow-destructive-auto-migrate',
         '--no-wait',
@@ -44288,6 +44322,8 @@
         const context = readOptionValue(args, '--context');
         const hasTestCommandFlag = args.includes('--test');
         const testCommand = readVariadicOptionValue(args, '--test');
+        const preserveLogs = args.includes('--preserve-logs');
+        const noUi = args.includes('--no-ui');
         const hasThinkingLevelFlag = args.includes('--thinking-level');
         const thinkingLevelValue = readOptionValue(args, '--thinking-level');
         const hasPriorityFlag = args.includes('--priority');
@@ -44295,7 +44331,6 @@
         const ignoreGitChanges = args.includes('--ignore-git-changes');
         const normalizeLineEndings = !args.includes('--no-normalize-line-endings');
         const allowCredits = args.includes('--allow-credits');
-        const preserveLogs = args.includes('--preserve-logs');
         const autoMigrate = args.includes('--auto-migrate');
         const allowDestructiveAutoMigrate = args.includes('--allow-destructive-auto-migrate');
         const autoPush = args.includes('--auto-push');
@@ -44321,10 +44356,11 @@
             ignoreGitChanges,
             normalizeLineEndings,
             allowCredits,
-            preserveLogs,
             autoMigrate,
             allowDestructiveAutoMigrate,
             autoPush,
+            preserveLogs,
+            noUi,
             agentName,
             model,
             context,
@@ -44405,18 +44441,10 @@
         return `${normalizedPrompt}\n\n${normalizedContext}`;
     }
 
-    /**
-     * Refresh interval for the progress header in milliseconds.
-     */
-    const PROGRESS_REFRESH_INTERVAL_MS = 1000;
-    /**
-     * Number of terminal lines reserved for the sticky progress header.
-     */
-    const PROGRESS_HEADER_RESERVED_LINES = 1;
     /**
      * Calendar formats used when displaying the estimated completion time.
      */
-    const ESTIMATED_DONE_CALENDAR_FORMATS$1 = {
+    const ESTIMATED_DONE_CALENDAR_FORMATS = {
         sameDay: '[Today] h:mm',
         nextDay: '[Tomorrow] h:mm',
         nextWeek: 'dddd h:mm',
@@ -44424,6 +44452,121 @@
         lastWeek: 'dddd h:mm',
         sameElse: 'MMM D h:mm',
     };
+    /**
+     * Formats a duration into a compact string such as "3h 12m" or "45s".
+     */
+    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(' ');
+    }
+
+    /**
+     * Builds a session-scoped progress snapshot from prompt stats and elapsed active time.
+     */
+    function buildCoderRunProgressSnapshot(stats, elapsedDuration, initialDone) {
+        const totalPrompts = stats.done + stats.forAgent + stats.toBeWritten;
+        const sessionDone = Math.max(0, stats.done - initialDone);
+        const sessionRemaining = stats.forAgent;
+        const sessionTotal = sessionDone + sessionRemaining;
+        const currentPromptIndex = sessionTotal > 0 ? Math.min(sessionDone + 1, sessionTotal) : 0;
+        const percentage = sessionTotal > 0 ? Math.round((sessionDone / sessionTotal) * 100) : 0;
+        const elapsedText = formatDurationBrief(elapsedDuration);
+        let estimatedTotalText = 'estimating...';
+        let estimatedLabel = 'after first completion';
+        let isEstimatedTotalKnown = false;
+        if (sessionTotal > 0 && sessionDone > 0) {
+            const estimatedTotalMs = (elapsedDuration.asMilliseconds() * sessionTotal) / sessionDone;
+            const estimatedRemainingMs = Math.max(0, 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);
+            isEstimatedTotalKnown = true;
+        }
+        return {
+            totalPrompts,
+            sessionDone,
+            sessionRemaining,
+            sessionTotal,
+            currentPromptIndex,
+            skippedPrompts: stats.belowMinimumPriority,
+            toBeWrittenPrompts: stats.toBeWritten,
+            percentage,
+            elapsedText,
+            estimatedTotalText,
+            estimatedLabel,
+            isEstimatedTotalKnown,
+        };
+    }
+
+    /**
+     * Tracks active coder-run time while excluding pauses and user-confirmation waits.
+     */
+    class CoderRunTimer {
+        /**
+         * Creates a timer anchored at the provided start time.
+         */
+        constructor(startTime, isPausedInitially = false) {
+            this.startTime = startTime;
+            /**
+             * Total milliseconds spent in paused state across the run.
+             */
+            this.pausedMs = 0;
+            if (isPausedInitially) {
+                this.pausedSince = startTime.clone();
+            }
+        }
+        /**
+         * Pauses active-time tracking until `resume()` is called.
+         */
+        pause() {
+            if (this.pausedSince === undefined) {
+                this.pausedSince = moment__default["default"]();
+            }
+        }
+        /**
+         * Resumes active-time tracking after a pause.
+         */
+        resume() {
+            if (this.pausedSince !== undefined) {
+                this.pausedMs += moment__default["default"]().diff(this.pausedSince);
+                this.pausedSince = undefined;
+            }
+        }
+        /**
+         * Returns the currently accumulated active duration.
+         */
+        getElapsedDuration() {
+            const wallMs = moment__default["default"]().diff(this.startTime);
+            const currentPauseMs = this.pausedSince !== undefined ? moment__default["default"]().diff(this.pausedSince) : 0;
+            return moment__default["default"].duration(Math.max(0, wallMs - this.pausedMs - currentPauseMs));
+        }
+    }
+
+    /**
+     * Refresh interval for the progress header in milliseconds.
+     */
+    const PROGRESS_REFRESH_INTERVAL_MS = 1000;
+    /**
+     * Number of terminal lines reserved for the sticky progress header.
+     */
+    const PROGRESS_HEADER_RESERVED_LINES = 3;
     /**
      * Compact CLI progress display that stays pinned at the top of the terminal.
      */
@@ -44431,11 +44574,12 @@
         /**
          * Creates a new display that uses the provided start time when computing estimates.
          */
-        constructor(startTime) {
-            this.startTime = startTime;
+        constructor(startTime, minimumPriority) {
+            this.minimumPriority = minimumPriority;
             this.stats = { done: 0, forAgent: 0, belowMinimumPriority: 0, toBeWritten: 0 };
             this.isHeaderReserved = false;
             this.isInteractive = Boolean(process.stdout.isTTY);
+            this.timer = new CoderRunTimer(startTime);
             if (!this.isInteractive) {
                 return;
             }
@@ -44454,6 +44598,20 @@
             this.stats = stats;
             this.render();
         }
+        /**
+         * Pauses the active timer while the runner is waiting for user input.
+         */
+        pauseTimer() {
+            this.timer.pause();
+            this.render();
+        }
+        /**
+         * Resumes the active timer after a pause.
+         */
+        resumeTimer() {
+            this.timer.resume();
+            this.render();
+        }
         /**
          * Stops the automatic refresh cycle and renders the final header once more.
          */
@@ -44471,14 +44629,17 @@
          * Repaint the header without disturbing the current cursor position.
          */
         render() {
+            var _a;
             if (!this.isInteractive) {
                 return;
             }
-            const line = this.buildProgressLine();
+            const lines = this.buildProgressLines();
             process.stdout.write('\x1b[s');
-            readline.cursorTo(process.stdout, 0, 0);
-            readline.clearLine(process.stdout, 0);
-            process.stdout.write(line);
+            for (let lineIndex = 0; lineIndex < PROGRESS_HEADER_RESERVED_LINES; lineIndex++) {
+                readline.cursorTo(process.stdout, 0, lineIndex);
+                readline.clearLine(process.stdout, 0);
+                process.stdout.write((_a = lines[lineIndex]) !== null && _a !== void 0 ? _a : '');
+            }
             process.stdout.write('\x1b[u');
         }
         /**
@@ -44492,72 +44653,74 @@
             this.isHeaderReserved = true;
         }
         /**
-         * Builds the coloured progress text padded to the terminal width.
+         * Builds the colored progress text padded to the terminal width.
          */
-        buildProgressLine() {
+        buildProgressLines() {
             var _a, _b;
-            const snapshot = buildProgressSnapshot(this.stats, this.startTime, (_a = this.initialDone) !== null && _a !== void 0 ? _a : this.stats.done);
-            const sessionLabel = `${snapshot.sessionDone}/${snapshot.sessionTotal} Prompts`;
-            const totalLabel = `(${snapshot.totalPrompts} total)`;
-            const baseLine = `${sessionLabel} ${totalLabel} | ${snapshot.percentage}% | ${snapshot.elapsedText}/${snapshot.estimatedTotalText} | Estimated done ${snapshot.estimatedLabel}`;
-            const columns = (_b = process.stdout.columns) !== null && _b !== void 0 ? _b : baseLine.length;
-            const padded = baseLine.padEnd(columns > baseLine.length ? columns : baseLine.length);
-            return colors__default["default"].bgWhite(colors__default["default"].black(padded));
+            const snapshot = buildCoderRunProgressSnapshot(this.stats, this.timer.getElapsedDuration(), (_a = this.initialDone) !== null && _a !== void 0 ? _a : this.stats.done);
+            const columns = Math.max(40, (_b = process.stdout.columns) !== null && _b !== void 0 ? _b : 80);
+            const workingLine = snapshot.sessionTotal > 0
+                ? [
+                    `Working on ${snapshot.currentPromptIndex}/${snapshot.sessionTotal} prompts`,
+                    `Priority >=${this.minimumPriority}`,
+                    `Repo total ${snapshot.totalPrompts}`,
+                ].join(' | ')
+                : [`No runnable prompts`, `Priority >=${this.minimumPriority}`, `Repo total ${snapshot.totalPrompts}`].join(' | ');
+            const detailParts = [
+                `Done ${snapshot.sessionDone}/${snapshot.sessionTotal} this run`,
+                `Elapsed ${snapshot.elapsedText} / ${snapshot.estimatedTotalText}`,
+                `Est. done ${snapshot.estimatedLabel}`,
+            ];
+            if (snapshot.skippedPrompts > 0) {
+                detailParts.splice(1, 0, `Skipping ${snapshot.skippedPrompts} prompts with Priority <${this.minimumPriority}`);
+            }
+            if (snapshot.toBeWrittenPrompts > 0) {
+                detailParts.splice(detailParts.length - 2, 0, `Write first ${formatPromptCount$1(snapshot.toBeWrittenPrompts)}`);
+            }
+            const progressLabel = `${snapshot.percentage}% complete (${snapshot.sessionDone}/${snapshot.sessionTotal} done)`;
+            const progressBar = buildProgressBar$1(snapshot.percentage, progressLabel, columns);
+            return [
+                colors__default["default"].bgCyan.black(padPlainText(workingLine, columns)),
+                colors__default["default"].bgBlack.white(padPlainText(detailParts.join(' | '), columns)),
+                colors__default["default"].bgBlack(progressBar),
+            ];
         }
     }
     /**
-     * Calculates progress metrics shown in the sticky header.
+     * Builds a colored progress bar with an explicit completion label.
      */
-    function buildProgressSnapshot(stats, startTime, initialDone) {
-        const totalPrompts = stats.done + stats.forAgent + stats.toBeWritten;
-        const completedPrompts = stats.done;
-        const sessionDone = Math.max(0, completedPrompts - initialDone);
-        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$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$1(estimatedTotalDuration);
-            estimatedLabel = estimatedCompletion.calendar(null, ESTIMATED_DONE_CALENDAR_FORMATS$1);
-        }
-        return {
-            totalPrompts,
-            completedPrompts,
-            sessionDone,
-            sessionTotal,
-            percentage,
-            elapsedText,
-            estimatedTotalText,
-            estimatedLabel,
-        };
+    function buildProgressBar$1(percentage, label, width) {
+        const safeLabel = ` ${label}`;
+        const barWidth = Math.max(10, width - safeLabel.length);
+        const filledWidth = Math.round((percentage / 100) * barWidth);
+        const emptyWidth = Math.max(0, barWidth - filledWidth);
+        return `${colors__default["default"].green('█'.repeat(filledWidth))}${colors__default["default"].gray('░'.repeat(emptyWidth))}${safeLabel}`;
     }
     /**
-     * Formats a duration into a compact string such as "3h 12m" or "45s".
+     * Pads or truncates one plain-text header line to the terminal width.
      */
-    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);
-        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');
+    function padPlainText(text, width) {
+        if (text.length > width) {
+            if (width <= 3) {
+                return '.'.repeat(width);
+            }
+            return `${text.slice(0, width - 3)}...`;
         }
-        return parts.join(' ');
+        return text.padEnd(width);
+    }
+    /**
+     * Formats a prompt count with the correct singular/plural noun.
+     */
+    function formatPromptCount$1(count) {
+        return `${count} prompt${count === 1 ? '' : 's'}`;
+    }
+
+    /**
+     * Formats commit message lines for console display.
+     */
+    function formatCommitMessageForDisplay(message) {
+        const lines = message.split(/\r?\n/);
+        return lines.map((line) => colors__default["default"].bgBlue.white(` ${line} `)).join('\n');
     }
 
     /**
@@ -44771,14 +44934,6 @@
         return normalized.subarray(0, writeIndex);
     }
 
-    /**
-     * Formats commit message lines for console display.
-     */
-    function formatCommitMessageForDisplay(message) {
-        const lines = message.split(/\r?\n/);
-        return lines.map((line) => colors__default["default"].bgBlue.white(` ${line} `)).join('\n');
-    }
-
     /**
      * Prints the formatted commit message preview.
      */
@@ -44824,82 +44979,36 @@
     }
 
     /**
-     * Runs one prompt-processing round with a dedicated temporary runtime log file and optionally defers cleanup to the round tracker.
+     * Decides whether one temporary prompt artifact should be deleted after a round finishes.
+     */
+    function shouldDeleteTemporaryArtifact({ preserveArtifactsOnSuccess, hasFailed, }) {
+        return !preserveArtifactsOnSuccess && !hasFailed;
+    }
+
+    /**
+     * Runs one prompt-processing round with a dedicated temporary runtime log file that is cleaned up only after successful non-preserved runs.
      */
-    async function withPromptRuntimeLog(scriptPath, handler, promptRoundArtifacts) {
+    async function withPromptRuntimeLog(scriptPath, handler, options) {
         const logPath = buildScriptLogPath(scriptPath);
+        let hasFailed = false;
         await promises.unlink(logPath).catch(() => undefined);
-        promptRoundArtifacts === null || promptRoundArtifacts === void 0 ? void 0 : promptRoundArtifacts.track(logPath, 'runtime-log');
         try {
             return await handler(logPath);
         }
+        catch (error) {
+            hasFailed = true;
+            throw error;
+        }
         finally {
-            if (!promptRoundArtifacts) {
+            if (shouldDeleteTemporaryArtifact({
+                preserveArtifactsOnSuccess: options === null || options === void 0 ? void 0 : options.preserveArtifactsOnSuccess,
+                hasFailed,
+            })) {
                 await promises.unlink(logPath).catch(() => undefined);
             }
         }
     }
 
-    /**
-     * Shared artifact kinds preserved for debugging when a prompt round fails.
-     */
-    const FAILURE_PRESERVED_ARTIFACT_KINDS = new Set(['runner-script', 'runtime-log']);
-    /**
-     * Shared artifact kinds preserved after a successful prompt round when explicitly requested.
-     */
-    const SUCCESS_PRESERVED_ARTIFACT_KINDS = new Set(['runner-script', 'runtime-log']);
-    /**
-     * Empty preserved-artifact set used for successful rounds without `--preserve-logs`.
-     */
-    const NO_PRESERVED_ARTIFACT_KINDS = new Set();
-    /**
-     * Tracks temporary prompt-round artifacts and deletes only those not preserved for the final round outcome.
-     */
-    class PromptRoundArtifacts {
-        /**
-         * Creates a new prompt-round artifact tracker.
-         */
-        constructor(preservedArtifactKindsByOutcome) {
-            this.preservedArtifactKindsByOutcome = preservedArtifactKindsByOutcome;
-            this.trackedArtifacts = new Map();
-        }
-        /**
-         * Registers one temporary artifact for round-final cleanup.
-         */
-        track(path, kind) {
-            this.trackedArtifacts.set(path, kind);
-        }
-        /**
-         * Cleans up all tracked artifacts that should not survive the final round outcome.
-         */
-        async cleanup(outcome) {
-            const preservedArtifactKinds = this.preservedArtifactKindsByOutcome[outcome];
-            const trackedArtifacts = [...this.trackedArtifacts.entries()];
-            this.trackedArtifacts.clear();
-            await Promise.all(trackedArtifacts.map(async ([path, kind]) => {
-                if (preservedArtifactKinds.has(kind)) {
-                    return;
-                }
-                await promises.unlink(path).catch(() => undefined);
-            }));
-        }
-    }
-    /**
-     * Creates the default artifact-retention policy used by `ptbk coder run`.
-     */
-    function createCoderRunPromptRoundArtifacts(isPreserveLogs) {
-        return new PromptRoundArtifacts({
-            success: isPreserveLogs ? SUCCESS_PRESERVED_ARTIFACT_KINDS : NO_PRESERVED_ARTIFACT_KINDS,
-            failure: FAILURE_PRESERVED_ARTIFACT_KINDS,
-        });
-    }
-    /**
-     * Derives the tracked artifact kind from one temporary shell path.
-     */
-    function getPromptRoundArtifactKindFromScriptPath(scriptPath) {
-        return scriptPath.toLowerCase().endsWith('.test.sh') ? 'test-script' : 'runner-script';
-    }
-
     /**
      * Waits for the user to press Enter before continuing.
      */
@@ -45337,7 +45446,8 @@
 
     /**
      * Commits staged changes with the provided message using the dedicated coding-agent identity when configured,
-     * otherwise falls back to the default Git configuration. Remote pushing is opt-in via `options.autoPush`.
+     * otherwise falls back to the default Git configuration. Remote pushing is opt-in via `options.autoPush`,
+     * while `options.excludePaths` can keep temporary artifacts out of the created commit.
      */
     async function commitChanges(message, options) {
         const projectPath = process.cwd();
@@ -45347,11 +45457,7 @@
         try {
             const agentEnv = buildAgentGitEnv();
             const signingFlag = buildAgentGitSigningFlag();
-            await runGitCommand({
-                command: 'git add .',
-                cwd: projectPath,
-                env: agentEnv,
-            });
+            await stageCommitChanges(projectPath, agentEnv, options === null || options === void 0 ? void 0 : options.excludePaths);
             await runGitCommand({
                 command: buildGitCommitCommand(commitMessagePath, signingFlag),
                 cwd: projectPath,
@@ -45365,6 +45471,56 @@
             await promises.unlink(commitMessagePath).catch(() => undefined);
         }
     }
+    /**
+     * Stages repository changes and optionally unstages temporary files that should not end up inside the commit.
+     */
+    async function stageCommitChanges(projectPath, agentEnv, excludePaths) {
+        await runGitCommand({
+            command: 'git add .',
+            cwd: projectPath,
+            env: agentEnv,
+        });
+        const excludedGitPaths = normalizeExcludedGitPaths(projectPath, excludePaths);
+        if (excludedGitPaths.length === 0) {
+            return;
+        }
+        await runGitCommand({
+            command: `git reset --quiet HEAD -- ${excludedGitPaths.map(quoteShellPath).join(' ')}`,
+            cwd: projectPath,
+            env: agentEnv,
+            isVerbose: false,
+        });
+    }
+    /**
+     * Converts excluded filesystem paths into unique repository-relative Git paths.
+     */
+    function normalizeExcludedGitPaths(projectPath, excludePaths) {
+        if (!excludePaths || excludePaths.length === 0) {
+            return [];
+        }
+        return [
+            ...new Set(excludePaths
+                .map((excludePath) => normalizeExcludedGitPath(projectPath, excludePath))
+                .filter((gitPath) => Boolean(gitPath))),
+        ];
+    }
+    /**
+     * Converts one excluded filesystem path into a Git-friendly repository-relative path.
+     */
+    function normalizeExcludedGitPath(projectPath, excludePath) {
+        const absoluteExcludePath = path.resolve(projectPath, excludePath);
+        const relativeExcludePath = path.relative(projectPath, absoluteExcludePath).replace(/\\/gu, '/');
+        if (relativeExcludePath === '' || relativeExcludePath === '.' || relativeExcludePath.startsWith('../')) {
+            return undefined;
+        }
+        return relativeExcludePath;
+    }
+    /**
+     * Quotes one Git path for safe shell execution.
+     */
+    function quoteShellPath(path) {
+        return JSON.stringify(path);
+    }
     /**
      * Branded error used when pushing committed changes fails.
      */
@@ -46739,6 +46895,15 @@
         return `${path.relative(process.cwd(), file.path).replace(/\\/g, '/')}#${section.startLine + 1}`;
     }
 
+    /**
+     * Extracts a short summary line from a prompt section.
+     */
+    function buildPromptSummary(file, section) {
+        const lines = buildCodexPrompt(file, section).split(/\r?\n/);
+        const firstLine = lines.find((line) => line.trim() !== '');
+        return (firstLine === null || firstLine === void 0 ? void 0 : firstLine.trim()) || '(empty prompt)';
+    }
+
     /**
      * Builds the script path for a prompt section.
      */
@@ -46798,15 +46963,6 @@
         return nextPrompt;
     }
 
-    /**
-     * Extracts a short summary line from a prompt section.
-     */
-    function buildPromptSummary(file, section) {
-        const lines = buildCodexPrompt(file, section).split(/\r?\n/);
-        const firstLine = lines.find((line) => line.trim() !== '');
-        return (firstLine === null || firstLine === void 0 ? void 0 : firstLine.trim()) || '(empty prompt)';
-    }
-
     /**
      * Lists upcoming tasks that are ready to run (no authoring placeholders).
      */
@@ -47358,25 +47514,29 @@ bash "$1"
     }
 
     /**
-     * Creates a temporary script file, runs a handler, and either cleans it up immediately or defers cleanup to the round tracker.
+     * Creates a temporary script file, runs a handler, and cleans it up unless preservation is requested or the run fails.
      */
     async function withTempScript(options, handler) {
-        const { scriptPath, scriptContent, promptRoundArtifacts } = options;
+        const { scriptPath, scriptContent } = options;
+        let hasFailed = false;
         await promises.mkdir(posix.dirname(scriptPath), { recursive: true });
         await promises.writeFile(scriptPath, scriptContent, 'utf-8');
-        promptRoundArtifacts === null || promptRoundArtifacts === void 0 ? void 0 : promptRoundArtifacts.track(scriptPath, getPromptRoundArtifactKindFromScriptPath(scriptPath));
         try {
             return await handler(scriptPath);
         }
+        catch (error) {
+            hasFailed = true;
+            throw error;
+        }
         finally {
-            if (!promptRoundArtifacts) {
+            if (shouldDeleteTemporaryArtifact({ preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess, hasFailed })) {
                 await promises.unlink(scriptPath).catch(() => undefined);
             }
         }
     }
 
     /**
-     * Creates a temporary script file, runs it, captures output, and cleans it up immediately unless a round tracker defers that cleanup.
+     * Creates a temporary script file, runs it, captures output, and cleans it up unless preservation is requested or the run fails.
      */
     async function $runGoScriptWithOutput(options) {
         return await withTempScript(options, async (scriptPath) => {
@@ -47479,7 +47639,7 @@ bash "$1"
                 scriptPath: options.scriptPath,
                 scriptContent,
                 logPath: options.logPath,
-                promptRoundArtifacts: options.promptRoundArtifacts,
+                preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
             });
             const usage = parseClaudeCodeJsonOutput(output);
             return { usage };
@@ -47487,7 +47647,7 @@ bash "$1"
     }
 
     /**
-     * Creates a temporary script file, runs it, and cleans it up immediately unless a round tracker defers that cleanup.
+     * Creates a temporary script file, runs it, and cleans it up unless preservation is requested or the run fails.
      */
     async function $runGoScript(options) {
         await withTempScript(options, async (scriptPath) => {
@@ -47543,7 +47703,7 @@ bash "$1"
                     scriptPath: options.scriptPath,
                     scriptContent,
                     logPath: options.logPath,
-                    promptRoundArtifacts: options.promptRoundArtifacts,
+                    preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
                 });
                 return { usage: UNCERTAIN_USAGE };
             }
@@ -47668,7 +47828,7 @@ bash "$1"
                 scriptPath: options.scriptPath,
                 scriptContent,
                 logPath: options.logPath,
-                promptRoundArtifacts: options.promptRoundArtifacts,
+                preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
             });
             const usage = parseGeminiUsageFromOutput(output, options.prompt, this.options.model);
             return { usage };
@@ -47725,7 +47885,7 @@ bash "$1"
                 scriptPath: options.scriptPath,
                 scriptContent,
                 logPath: options.logPath,
-                promptRoundArtifacts: options.promptRoundArtifacts,
+                preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
             });
             return { usage: UNCERTAIN_USAGE };
         }
@@ -47901,7 +48061,7 @@ bash "$1"
     }
 
     /**
-     * Creates a temporary script file, runs it, waits for a completion marker and idle time, and defers cleanup when a round tracker is provided.
+     * Creates a temporary script file, runs it, waits for a completion marker and idle time, and cleans it up unless preservation is requested or the run fails.
      * Returns the captured output for post-processing.
      */
     async function $runGoScriptUntilMarkerIdle(options) {
@@ -48290,7 +48450,7 @@ bash "$1"
                         completionLineMatcher: CODEX_COMPLETION_LINE,
                         idleTimeoutMs: CODEX_COMPLETION_IDLE_MS,
                         logPath: options.logPath,
-                        promptRoundArtifacts: options.promptRoundArtifacts,
+                        preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
                     });
                     this.rateLimitBackoff.reset();
                     return { usage: buildCodexUsageFromOutput(output, this.options.model) };
@@ -48425,7 +48585,7 @@ bash "$1"
                     scriptPath: options.scriptPath,
                     scriptContent,
                     logPath: options.logPath,
-                    promptRoundArtifacts: options.promptRoundArtifacts,
+                    preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
                 });
             }
             catch (error) {
@@ -48453,6 +48613,7 @@ bash "$1"
             ${options.command}
         `),
             logPath: options.logPath,
+            preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
         });
     }
 
@@ -48477,7 +48638,7 @@ bash "$1"
                 scriptPath: options.scriptPath,
                 projectPath: options.projectPath,
                 logPath: options.logPath,
-                promptRoundArtifacts: options.promptRoundArtifacts,
+                preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
             });
             return { ...result, attemptCount: 1 };
         }
@@ -48490,7 +48651,7 @@ bash "$1"
                 scriptPath: options.scriptPath,
                 projectPath: options.projectPath,
                 logPath: options.logPath,
-                promptRoundArtifacts: options.promptRoundArtifacts,
+                preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
             });
             console.info(colors__default["default"].gray(`Running verification command after attempt #${attemptCount}: ${normalizedTestCommand}`));
             try {
@@ -48499,6 +48660,7 @@ bash "$1"
                     projectPath: options.projectPath,
                     scriptPath: buildPromptTestScriptPath(options.scriptPath),
                     logPath: options.logPath,
+                    preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
                 });
                 return { ...result, attemptCount };
             }
@@ -48580,24 +48742,213 @@ bash "$1"
     }
 
     /**
-     * Maximum number of agent output lines kept in the scrolling output area.
-     *
-     * @private internal constant of coder run UI
+     * Maximum number of output lines reserved for agent output in the UI.
      */
-    const MAX_AGENT_OUTPUT_LINES = 12;
+    const MAX_VISIBLE_OUTPUT_LINES = 8;
     /**
-     * Calendar formats used when displaying the estimated completion time.
+     * Builds the complete boxed terminal frame for the rich `ptbk coder run` UI.
+     */
+    function buildCoderRunUiFrame(options) {
+        const totalWidth = Math.max(56, Math.min(options.terminalWidth, 96));
+        const isPromptActive = options.phase === 'running' || options.phase === 'verifying' || options.phase === 'loading';
+        const promptStatusPrefix = isPromptActive ? `${colors__default["default"].yellow(`${options.spinner} `)}` : '';
+        const sessionScopeLine = options.progress.sessionTotal > 0
+            ? `Working on ${options.progress.currentPromptIndex}/${options.progress.sessionTotal} prompts with Priority ≥${options.config.priority}`
+            : `No runnable prompts with Priority ≥${options.config.priority}`;
+        const sessionCountLine = `Done ${options.progress.sessionDone}/${options.progress.sessionTotal} this run  ·  Repo total ${options.progress.totalPrompts}`;
+        const sessionQueueParts = [];
+        if (options.progress.skippedPrompts > 0) {
+            sessionQueueParts.push(`Skipping ${formatPromptCount(options.progress.skippedPrompts)} with Priority <${options.config.priority}`);
+        }
+        if (options.progress.toBeWrittenPrompts > 0) {
+            sessionQueueParts.push(`Write first ${formatPromptCount(options.progress.toBeWrittenPrompts)}`);
+        }
+        const sessionLines = [
+            `${buildPhaseBadge(options.phase, options.pauseState)} ${fitPlainText(options.statusMessage, totalWidth - 18)}`,
+            sessionScopeLine,
+            sessionCountLine,
+            ...(sessionQueueParts.length > 0 ? [sessionQueueParts.join('  ·  ')] : []),
+            `Elapsed ${options.progress.elapsedText}  ·  Est. total ${options.progress.estimatedTotalText}  ·  Est. done ${options.progress.estimatedLabel}`,
+            buildProgressBar(options.progress.percentage, totalWidth - 6, `${options.progress.percentage}% complete (${options.progress.sessionDone}/${options.progress.sessionTotal} done)`),
+        ];
+        const metadataParts = [options.config.agentName || 'No agent selected'];
+        if (options.config.modelName) {
+            metadataParts.push(options.config.modelName);
+        }
+        if (options.config.thinkingLevel) {
+            metadataParts.push(`thinking ${options.config.thinkingLevel}`);
+        }
+        const runnerDetails = [
+            [`${colors__default["default"].bgCyan.black(' PTBK ')}`, colors__default["default"].bgBlue.white(' CODER '), colors__default["default"].bold.white(' Promptbook Coder')]
+                .join(''),
+            metadataParts.join('  ·  '),
+            buildConfigSummaryLine(options.config),
+        ];
+        const currentTaskLines = options.currentPromptLabel
+            ? [
+                `${promptStatusPrefix}${colors__default["default"].bold.white(fitPlainText(options.currentPromptLabel, totalWidth - 8))}`,
+                `Attempt ${options.currentAttempt}/${options.maxAttempts}  ·  ${options.statusMessage}`,
+                ...options.detailLines.map((detailLine) => `• ${detailLine}`),
+            ]
+            : [options.statusMessage, ...options.detailLines.map((detailLine) => `• ${detailLine}`)];
+        const visibleOutputLines = buildVisibleOutputLines(options.agentOutputLines);
+        const controls = buildControlPills(options.pauseState, options.pendingEnterLabel).join('  ');
+        const frame = [
+            ...renderBox('Brand', runnerDetails, totalWidth, colors__default["default"].cyan.bold),
+            ...renderBox('Session', sessionLines, totalWidth, colors__default["default"].yellow.bold),
+            ...renderBox(options.currentPromptLabel ? 'Current task' : 'Queue', currentTaskLines, totalWidth, colors__default["default"].magenta.bold),
+            ...renderBox('Live output', visibleOutputLines, totalWidth, colors__default["default"].green.bold),
+        ];
+        if (options.errors.length > 0) {
+            frame.push(...renderBox('Errors', options.errors.map((errorLine) => `${colors__default["default"].red('✗')} ${errorLine}`), totalWidth, colors__default["default"].red.bold));
+        }
+        frame.push(...renderBox('Controls', [controls], totalWidth, colors__default["default"].white.bold));
+        return frame;
+    }
+    /**
+     * Builds the fixed-height live output section so streaming updates do not keep resizing the frame.
+     */
+    function buildVisibleOutputLines(agentOutputLines) {
+        const visibleOutputLines = agentOutputLines.length > 0
+            ? agentOutputLines.slice(-MAX_VISIBLE_OUTPUT_LINES).map((line) => `› ${stripAnsi(line)}`)
+            : ['No live agent output yet.'];
+        while (visibleOutputLines.length < MAX_VISIBLE_OUTPUT_LINES) {
+            visibleOutputLines.push('');
+        }
+        return visibleOutputLines;
+    }
+    /**
+     * Renders a framed box with a colored title and padded body lines.
+     */
+    function renderBox(title, lines, totalWidth, colorizeTitle) {
+        const bodyWidth = Math.max(10, totalWidth - 4);
+        const titleText = ` ${title} `;
+        const topBorder = colors__default["default"].gray('┌') +
+            colorizeTitle(titleText) +
+            colors__default["default"].gray('─'.repeat(Math.max(0, totalWidth - 2 - titleText.length)) + '┐');
+        const body = lines.map((line) => {
+            const paddedLine = padAnsiText(line, bodyWidth);
+            return colors__default["default"].gray('│ ') + paddedLine + colors__default["default"].gray(' │');
+        });
+        const bottomBorder = colors__default["default"].gray(`└${'─'.repeat(totalWidth - 2)}┘`);
+        return [topBorder, ...body, bottomBorder];
+    }
+    /**
+     * Builds the compact config summary line shown in the branding box.
+     */
+    function buildConfigSummaryLine(config) {
+        const parts = [`Priority ≥${config.priority}`];
+        if (config.context) {
+            parts.unshift(`Context ${config.context}`);
+        }
+        if (config.testCommand) {
+            parts.push(`Test ${config.testCommand}`);
+        }
+        return parts.join('  ·  ');
+    }
+    /**
+     * Builds the colored phase badge shown in the session box.
+     */
+    function buildPhaseBadge(phase, pauseState) {
+        if (pauseState !== 'RUNNING' || phase === 'paused') {
+            return colors__default["default"].bgYellow.black(' PAUSED ');
+        }
+        switch (phase) {
+            case 'loading':
+            case 'initializing':
+                return colors__default["default"].bgCyan.black(' LOADING ');
+            case 'running':
+                return colors__default["default"].bgGreen.black(' RUNNING ');
+            case 'verifying':
+                return colors__default["default"].bgMagenta.white(' VERIFYING ');
+            case 'waiting':
+                return colors__default["default"].bgBlue.white(' WAITING ');
+            case 'done':
+                return colors__default["default"].bgGreen.black(' DONE ');
+            case 'error':
+                return colors__default["default"].bgRed.white(' ERROR ');
+            default:
+                return colors__default["default"].bgWhite.black(' READY ');
+        }
+    }
+    /**
+     * Builds the progress bar shown in the session box.
+     */
+    function buildProgressBar(percentage, availableWidth, label) {
+        const percentageLabel = label;
+        const barWidth = Math.max(10, availableWidth - percentageLabel.length - 1);
+        const filledWidth = Math.round((percentage / 100) * barWidth);
+        const emptyWidth = Math.max(0, barWidth - filledWidth);
+        return `${colors__default["default"].green('█'.repeat(filledWidth))}${colors__default["default"].gray('░'.repeat(emptyWidth))} ${percentageLabel}`;
+    }
+    /**
+     * Formats a prompt count with singular/plural wording.
+     */
+    function formatPromptCount(count) {
+        return `${count} prompt${count === 1 ? '' : 's'}`;
+    }
+    /**
+     * Builds the control pills shown in the footer box.
+     */
+    function buildControlPills(pauseState, pendingEnterLabel) {
+        const pills = [];
+        if (pendingEnterLabel) {
+            pills.push(colors__default["default"].bgWhite.black(' ENTER ') + colors__default["default"].white(` ${pendingEnterLabel}`));
+        }
+        pills.push(pauseState === 'RUNNING'
+            ? colors__default["default"].bgYellow.black(' P ') + colors__default["default"].white(' Pause')
+            : colors__default["default"].bgYellow.black(' P ') + colors__default["default"].white(' Resume'));
+        pills.push(colors__default["default"].bgRed.white(' CTRL+C ') + colors__default["default"].white(' Exit'));
+        return pills;
+    }
+    /**
+     * Pads or truncates a possibly ANSI-colored line to the target visible width.
+     */
+    function padAnsiText(text, width) {
+        const fittedText = fitAnsiText(text, width);
+        return fittedText + ' '.repeat(Math.max(0, width - visibleLength(fittedText)));
+    }
+    /**
+     * Truncates a possibly ANSI-colored line to the target visible width.
+     */
+    function fitAnsiText(text, width) {
+        if (visibleLength(text) <= width) {
+            return text;
+        }
+        return fitPlainText(stripAnsi(text), width);
+    }
+    /**
+     * Truncates a plain-text line to the target width with an ellipsis.
+     */
+    function fitPlainText(text, width) {
+        if (text.length <= width) {
+            return text;
+        }
+        if (width <= 3) {
+            return '.'.repeat(width);
+        }
+        return `${text.slice(0, width - 3)}...`;
+    }
+    /**
+     * Measures visible string width by stripping ANSI escape codes.
+     */
+    function visibleLength(text) {
+        return stripAnsi(text).length;
+    }
+    /**
+     * Strips ANSI escape codes from a string.
+     */
+    function stripAnsi(text) {
+        // eslint-disable-next-line no-control-regex
+        return text.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+    }
+
+    /**
+     * Maximum number of agent output lines kept in the scrolling output area.
      *
      * @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',
-    };
+    const MAX_AGENT_OUTPUT_LINES = 12;
     /**
      * Reactive state manager for the coder run terminal UI.
      *
@@ -48613,35 +48964,27 @@ bash "$1"
             this.currentPromptLabel = '';
             this.currentAttempt = 1;
             this.maxAttempts = 3;
+            this.detailLines = [];
             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();
+            this.timer = new CoderRunTimer(startTime, true);
         }
         /**
          * Pauses the elapsed timer (e.g. while waiting for user input or paused state).
          */
         pauseTimer() {
-            if (this.pausedSince === undefined) {
-                this.pausedSince = moment__default["default"]();
-            }
+            this.timer.pause();
+            this.emitChange();
         }
         /**
          * Resumes the elapsed timer after a pause.
          */
         resumeTimer() {
-            if (this.pausedSince !== undefined) {
-                this.pausedMs += moment__default["default"]().diff(this.pausedSince);
-                this.pausedSince = undefined;
-            }
+            this.timer.resume();
+            this.emitChange();
         }
         /**
          * Replaces the configuration shown in the UI header.
@@ -48665,41 +49008,15 @@ bash "$1"
          */
         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,
-            };
+            return buildCoderRunProgressSnapshot(this.stats, this.timer.getElapsedDuration(), (_a = this.initialDone) !== null && _a !== void 0 ? _a : this.stats.done);
         }
         /**
          * Sets the label of the prompt currently being processed and resets per-prompt state.
          */
         setCurrentPrompt(label) {
             this.currentPromptLabel = label;
+            this.detailLines = [];
+            this.pendingEnterLabel = undefined;
             this.agentOutputLines = [];
             this.currentAttempt = 1;
             this.emitChange();
@@ -48739,6 +49056,20 @@ bash "$1"
             this.statusMessage = message;
             this.emitChange();
         }
+        /**
+         * Replaces the contextual detail lines shown beneath the current prompt status.
+         */
+        setDetailLines(detailLines) {
+            this.detailLines = detailLines.filter((detailLine) => detailLine.trim() !== '');
+            this.emitChange();
+        }
+        /**
+         * Sets or clears the Enter-key action label shown in the controls panel.
+         */
+        setPendingEnterLabel(pendingEnterLabel) {
+            this.pendingEnterLabel = pendingEnterLabel;
+            this.emitChange();
+        }
         /**
          * Appends an error message to the error list shown in the UI.
          */
@@ -48750,50 +49081,35 @@ bash "$1"
             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.
+     * Refresh cadence used only while the rich coder UI needs animated updates.
      *
      * @private internal constant of coder run UI
      */
-    const UI_REFRESH_INTERVAL_MS = 200;
+    const ACTIVE_CODER_RUN_UI_REFRESH_INTERVAL_MS = 1000;
     /**
-     * Character width used for the text progress bar.
+     * Phases that still benefit from automatic refreshes because the frame can change
+     * over time even without new runner output.
      *
      * @private internal constant of coder run UI
      */
-    const PROGRESS_BAR_WIDTH = 40;
+    const AUTO_REFRESH_PHASES = ['initializing', 'loading', 'running', 'verifying'];
     /**
-     * Maximum number of output lines reserved for agent output in the UI.
+     * Returns the automatic refresh interval for the current UI state.
      *
-     * @private internal constant of coder run UI
+     * Waiting, paused, and completed states return `undefined` so the rich UI stays
+     * perfectly still until actual state changes arrive.
+     *
+     * @private internal utility of coder run UI
      */
-    const MAX_VISIBLE_OUTPUT_LINES = 8;
+    function getCoderRunUiAutoRefreshInterval(phase, pauseState) {
+        if (pauseState !== 'RUNNING') {
+            return undefined;
+        }
+        return AUTO_REFRESH_PHASES.includes(phase) ? ACTIVE_CODER_RUN_UI_REFRESH_INTERVAL_MS : undefined;
+    }
+
     /**
      * Spinner animation frames.
      *
@@ -48812,38 +49128,20 @@ bash "$1"
         '\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.
+     * Returns the usable terminal width, capped at 96.
      *
      * @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}%`;
+        return Math.min(process.stdout.columns || 80, 96);
     }
     /**
      * 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.
+     * The UI reserves a fixed number of terminal lines and refreshes them incrementally.
+     * While a prompt is actively running, it schedules lightweight timed refreshes for
+     * the spinner/progress area; otherwise it redraws only when real state changes arrive.
+     * 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.
@@ -48857,21 +49155,20 @@ bash "$1"
                 state,
                 startCapturingAgentOutput: () => { },
                 stopCapturingAgentOutput: () => { },
+                waitForEnter: async () => { },
                 cleanup: () => { },
             };
         }
-        // --- Console interception ---
         const originalConsoleInfo = console.info;
         const originalConsoleWarn = console.warn;
         const originalConsoleError = console.error;
         const originalConsoleLog = console.log;
         let isCapturing = false;
+        let pendingEnterResolver;
         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) {
@@ -48888,192 +49185,205 @@ bash "$1"
                 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 previousFrameLines = [];
         let isRendering = false;
         let renderScheduled = false;
+        let autoRefreshTimeout;
+        let isDisposed = 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) {
+            if (renderScheduled || isDisposed) {
                 return;
             }
             renderScheduled = true;
             setImmediate(() => {
                 renderScheduled = false;
+                if (isDisposed) {
+                    return;
+                }
                 render();
             });
         }
         /**
-         * Clears previously rendered lines and writes a new frame.
+         * Re-schedules automatic animation refreshes only while the frame can change by itself.
          */
-        function render() {
-            if (isRendering) {
+        function scheduleAutoRefresh() {
+            if (autoRefreshTimeout) {
+                clearTimeout(autoRefreshTimeout);
+                autoRefreshTimeout = undefined;
+            }
+            const autoRefreshInterval = getCoderRunUiAutoRefreshInterval(state.phase, getPauseState());
+            if (autoRefreshInterval === undefined) {
+                return;
+            }
+            autoRefreshTimeout = setTimeout(() => {
+                autoRefreshTimeout = undefined;
+                scheduleRender();
+            }, autoRefreshInterval);
+        }
+        /**
+         * Moves the cursor relative to the bottom of the current frame and rewrites one line in place.
+         */
+        function rewriteFrameLine(frameLineCount, lineIndex, line) {
+            const linesUpFromBottom = Math.max(0, frameLineCount - 1 - lineIndex);
+            if (linesUpFromBottom > 0) {
+                process.stdout.write(`\x1b[${linesUpFromBottom}A`);
+            }
+            readline.clearLine(process.stdout, 0);
+            readline.cursorTo(process.stdout, 0);
+            process.stdout.write(line);
+            readline.cursorTo(process.stdout, 0);
+            if (linesUpFromBottom > 0) {
+                process.stdout.write(`\x1b[${linesUpFromBottom}B`);
+                readline.cursorTo(process.stdout, 0);
+            }
+        }
+        /**
+         * Fully rewrites the reserved frame area.
+         */
+        function renderFullFrame(lines) {
+            var _a;
+            const previousFrameLineCount = previousFrameLines.length;
+            const linesToRewriteCount = Math.max(previousFrameLineCount, lines.length);
+            if (previousFrameLineCount > 1) {
+                process.stdout.write(`\x1b[${previousFrameLineCount - 1}A`);
+            }
+            for (let i = 0; i < linesToRewriteCount; i++) {
+                readline.clearLine(process.stdout, 0);
+                readline.cursorTo(process.stdout, 0);
+                process.stdout.write((_a = lines[i]) !== null && _a !== void 0 ? _a : '');
+                if (i < linesToRewriteCount - 1) {
+                    process.stdout.write('\n');
+                }
+            }
+            const clearedTrailingLines = linesToRewriteCount - lines.length;
+            if (clearedTrailingLines > 0) {
+                process.stdout.write(`\x1b[${clearedTrailingLines}A`);
+            }
+            readline.cursorTo(process.stdout, 0);
+        }
+        /**
+         * Updates only the frame rows whose visible content changed.
+         */
+        function renderChangedLines(lines) {
+            for (let i = 0; i < lines.length; i++) {
+                if (previousFrameLines[i] === lines[i]) {
+                    continue;
+                }
+                rewriteFrameLine(lines.length, i, lines[i]);
+            }
+        }
+        /**
+         * Builds the current frame snapshot from the latest state.
+         */
+        function buildFrameLines() {
+            return buildCoderRunUiFrame({
+                terminalWidth: getTerminalWidth(),
+                spinner: SPINNER_FRAMES[spinnerFrame],
+                pauseState: getPauseState(),
+                config: state.config,
+                phase: state.phase,
+                currentPromptLabel: state.currentPromptLabel,
+                currentAttempt: state.currentAttempt,
+                maxAttempts: state.maxAttempts,
+                statusMessage: state.statusMessage,
+                detailLines: state.detailLines,
+                pendingEnterLabel: state.pendingEnterLabel,
+                agentOutputLines: state.agentOutputLines,
+                errors: state.errors,
+                progress: state.getProgress(),
+            });
+        }
+        /**
+         * Clears previously rendered lines and writes a new frame only where needed.
+         */
+        function render(options) {
+            if (isRendering || isDisposed) {
                 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');
-                    }
+                const lines = buildFrameLines();
+                if (previousFrameLines.length === 0 || previousFrameLines.length !== lines.length) {
+                    renderFullFrame(lines);
                 }
-                // 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`);
-                    }
+                else {
+                    renderChangedLines(lines);
                 }
-                previousFrameLineCount = lines.length;
+                previousFrameLines = [...lines];
                 spinnerFrame = (spinnerFrame + 1) % SPINNER_FRAMES.length;
+                if (!(options === null || options === void 0 ? void 0 : options.skipAutoRefresh)) {
+                    scheduleAutoRefresh();
+                }
             }
             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}`));
+        const keypressHandler = (_str, key) => {
+            if (key.ctrl && key.name === 'c') {
+                cleanup();
+                process.exit(0);
             }
-            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.
+            if (key.name === 'p') {
+                if (getPauseState() === 'RUNNING') {
+                    requestPause();
+                }
+                else {
+                    requestResume();
+                }
+                scheduleRender();
+                return;
+            }
+            if ((key.name === 'return' || key.name === 'enter') && pendingEnterResolver) {
+                const resolvePendingEnter = pendingEnterResolver;
+                pendingEnterResolver = undefined;
+                state.setPendingEnterLabel(undefined);
+                resolvePendingEnter();
+            }
+        };
+        process.stdin.on('keypress', keypressHandler);
+        process.stdout.on('resize', scheduleRender);
         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 ---
+        /**
+         * Tears down the terminal UI and restores console / stdin state.
+         */
         function cleanup() {
-            clearInterval(interval);
+            if (isDisposed) {
+                return;
+            }
+            if (autoRefreshTimeout) {
+                clearTimeout(autoRefreshTimeout);
+                autoRefreshTimeout = undefined;
+            }
             state.off('change', scheduleRender);
             process.stdin.off('keypress', keypressHandler);
+            process.stdout.off('resize', scheduleRender);
             if (process.stdin.isTTY) {
                 process.stdin.setRawMode(false);
             }
+            const resolvePendingEnter = pendingEnterResolver;
+            pendingEnterResolver = undefined;
+            resolvePendingEnter === null || resolvePendingEnter === void 0 ? void 0 : resolvePendingEnter();
             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();
+            render({ skipAutoRefresh: true });
             process.stdout.write('\n');
+            isDisposed = true;
         }
         return {
             state,
@@ -49083,6 +49393,19 @@ bash "$1"
             stopCapturingAgentOutput() {
                 isCapturing = false;
             },
+            waitForEnter(actionLabel) {
+                if (pendingEnterResolver) {
+                    throw new Error('Coder run UI is already waiting for Enter.');
+                }
+                state.setPendingEnterLabel(actionLabel);
+                scheduleRender();
+                return new Promise((resolve) => {
+                    pendingEnterResolver = () => {
+                        scheduleRender();
+                        resolve();
+                    };
+                });
+            },
             cleanup,
         };
     }
@@ -49150,11 +49473,11 @@ bash "$1"
             `));
         }
         const runStartDate = moment__default["default"]();
-        const isUiMode = !options.dryRun && Boolean(process.stdout.isTTY);
-        const progressDisplay = options.dryRun || isUiMode ? undefined : new CliProgressDisplay(runStartDate);
-        const uiHandle = isUiMode ? renderCoderRunUi(runStartDate) : undefined;
+        const isRichUiEnabled = !options.dryRun && !options.noUi && Boolean(process.stdout.isTTY);
+        const progressDisplay = options.dryRun || options.noUi || isRichUiEnabled ? undefined : new CliProgressDisplay(runStartDate, options.priority);
+        const uiHandle = isRichUiEnabled ? renderCoderRunUi(runStartDate) : undefined;
         // When the Ink UI is active it handles keyboard input itself, so skip the raw stdin listener.
-        if (!isUiMode) {
+        if (!isRichUiEnabled) {
             listenForPause();
         }
         try {
@@ -49270,17 +49593,19 @@ bash "$1"
             let hasWaitedForStart = false;
             while (just(true)) {
                 await checkPause({
-                    silent: isUiMode,
+                    silent: isRichUiEnabled,
                     onPaused: () => {
+                        progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.pauseTimer();
                         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: () => {
+                        progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.resumeTimer();
                         uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.resumeTimer();
                     },
                 });
-                if (isUiMode) {
+                if (isRichUiEnabled) {
                     uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('loading');
                     uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage('Loading prompts...');
                 }
@@ -49288,17 +49613,17 @@ bash "$1"
                 const stats = summarizePrompts(promptFiles, options.priority);
                 progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.update(stats);
                 uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.updateProgress(stats);
-                if (!isUiMode) {
+                if (!isRichUiEnabled) {
                     printStats(stats, options.priority);
                 }
                 const nextPrompt = findNextTodoPrompt(promptFiles, options.priority);
                 if (!hasShownUpcomingTasks) {
-                    if (stats.toBeWritten > 0 && !isUiMode) {
+                    if (stats.toBeWritten > 0 && !isRichUiEnabled) {
                         console.info(colors__default["default"].yellow('Following prompts need to be written:'));
                         printPromptsToBeWritten(promptFiles, options.priority);
                         console.info('');
                     }
-                    if (!isUiMode) {
+                    if (!isRichUiEnabled) {
                         printUpcomingTasks(listUpcomingTasks(promptFiles, options.priority));
                     }
                     hasShownUpcomingTasks = true;
@@ -49308,7 +49633,7 @@ bash "$1"
                         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) {
+                        if (!isRichUiEnabled) {
                             console.info(colors__default["default"].yellow(message));
                         }
                     }
@@ -49316,16 +49641,28 @@ bash "$1"
                         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) {
+                        if (!isRichUiEnabled) {
                             console.info(colors__default["default"].green(message));
                         }
                     }
                     return;
                 }
+                const promptLabel = buildPromptLabelForDisplay(nextPrompt.file, nextPrompt.section);
                 if (options.waitForUser) {
+                    progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.pauseTimer();
                     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.setCurrentPrompt(promptLabel);
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('waiting');
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage(hasWaitedForStart ? 'Waiting for confirmation to continue' : 'Waiting for confirmation to start');
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setDetailLines([buildPromptSummary(nextPrompt.file, nextPrompt.section)]);
+                    if (isRichUiEnabled) {
+                        await (uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.waitForEnter(hasWaitedForStart ? 'Continue' : 'Start'));
+                    }
+                    else {
+                        await waitForPromptStart(nextPrompt.file, nextPrompt.section, !hasWaitedForStart);
+                    }
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setDetailLines([]);
+                    progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.resumeTimer();
                     uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.resumeTimer();
                     hasWaitedForStart = true;
                 }
@@ -49335,9 +49672,7 @@ bash "$1"
                 const commitMessage = buildCommitMessage(nextPrompt.file, nextPrompt.section);
                 const codexPrompt = appendCoderContext(buildCodexPrompt(nextPrompt.file, nextPrompt.section), resolvedCoderContext);
                 const scriptPath = buildScriptPath(nextPrompt.file, nextPrompt.section);
-                const promptLabel = buildPromptLabelForDisplay(nextPrompt.file, nextPrompt.section);
-                const promptRoundArtifacts = createCoderRunPromptRoundArtifacts(options.preserveLogs);
-                if (isUiMode) {
+                if (isRichUiEnabled) {
                     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');
@@ -49347,69 +49682,78 @@ bash "$1"
                 }
                 const promptExecutionStartedDate = moment__default["default"]();
                 let attemptCount = 1;
-                let promptRoundOutcome = 'failure';
                 const roundChangedFilesSnapshot = options.normalizeLineEndings
                     ? await captureChangedFilesSnapshot(process.cwd())
                     : undefined;
-                try {
-                    await withPromptRuntimeLog(scriptPath, async (logPath) => {
-                        try {
-                            uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.startCapturingAgentOutput();
-                            const result = await runPromptWithTestFeedback({
-                                runner,
-                                prompt: codexPrompt,
-                                scriptPath,
-                                projectPath: process.cwd(),
-                                promptLabel,
-                                testCommand: options.testCommand,
-                                logPath,
-                                promptRoundArtifacts,
-                                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');
-                                    }
-                                },
-                            });
-                            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');
+                await withPromptRuntimeLog(scriptPath, async (logPath) => {
+                    try {
+                        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.startCapturingAgentOutput();
+                        const result = await runPromptWithTestFeedback({
+                            runner,
+                            prompt: codexPrompt,
+                            scriptPath,
+                            projectPath: process.cwd(),
+                            promptLabel,
+                            testCommand: options.testCommand,
+                            preserveArtifactsOnSuccess: options.preserveLogs,
+                            logPath,
+                            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');
+                                }
+                            },
+                        });
+                        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) {
+                            progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.pauseTimer();
+                            uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.pauseTimer();
+                            uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('waiting');
+                            uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage('Review the commit preview and confirm to continue');
+                            if (isRichUiEnabled) {
+                                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setDetailLines(formatCommitMessageForDisplay(commitMessage)
+                                    .split(/\r?\n/)
+                                    .map((line) => line.trim()));
+                                await (uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.waitForEnter('Commit'));
+                                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setDetailLines([]);
+                            }
+                            else {
                                 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, { autoPush: options.autoPush });
-                            await runPostPromptAutoMigrationIfEnabled(options);
-                            promptRoundOutcome = 'success';
-                        }
-                        catch (error) {
-                            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,
-                                section: nextPrompt.section,
-                                runnerName: runnerMetadata.runnerName,
-                                modelName: runnerMetadata.modelName,
-                                error,
-                            });
-                            await normalizeLineEndingsForCurrentRound(options, roundChangedFilesSnapshot);
-                            throw error;
+                            progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.resumeTimer();
+                            uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.resumeTimer();
                         }
-                    }, promptRoundArtifacts);
-                }
-                finally {
-                    await promptRoundArtifacts.cleanup(promptRoundOutcome);
-                }
+                        await commitChanges(commitMessage, {
+                            autoPush: options.autoPush,
+                            // Keep the live runtime log out of default commits because it is deleted after a successful round.
+                            excludePaths: options.preserveLogs ? undefined : [logPath],
+                        });
+                        await runPostPromptAutoMigrationIfEnabled(options);
+                    }
+                    catch (error) {
+                        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,
+                            section: nextPrompt.section,
+                            runnerName: runnerMetadata.runnerName,
+                            modelName: runnerMetadata.modelName,
+                            error,
+                        });
+                        await normalizeLineEndingsForCurrentRound(options, roundChangedFilesSnapshot);
+                        throw error;
+                    }
+                }, { preserveArtifactsOnSuccess: options.preserveLogs });
             }
         }
         finally {