@promptbook/cli 0.112.0-44 → 0.112.0-46

package/esm/index.es.js

@@ -58,7 +58,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @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
@@ -3005,6 +3005,8 @@ function $initializeCoderRunCommand(program) {
             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
@@ -3020,19 +3022,21 @@ function $initializeCoderRunCommand(program) {
         `));
     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 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) {
@@ -3062,11 +3066,12 @@ function $initializeCoderRunCommand(program) {
             model,
             context,
             testCommand,
+            preserveLogs,
+            noUi,
             thinkingLevel,
             priority,
             normalizeLineEndings,
             allowCredits,
-            preserveLogs,
             autoMigrate,
             allowDestructiveAutoMigrate,
             autoPush,
@@ -18386,7 +18391,7 @@ class DeleteCommitmentDefinition extends BaseCommitmentDefinition {
             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
@@ -18397,7 +18402,7 @@ class DeleteCommitmentDefinition extends BaseCommitmentDefinition {
             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
@@ -18414,11 +18419,11 @@ class DeleteCommitmentDefinition extends BaseCommitmentDefinition {
             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
             \`\`\`
         `);
     }
@@ -18602,7 +18607,7 @@ class FormatCommitmentDefinition extends BaseCommitmentDefinition {
             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
             \`\`\`
         `);
     }
@@ -18996,7 +19001,7 @@ class GoalCommitmentDefinition extends BaseCommitmentDefinition {
 
             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
@@ -19410,7 +19415,7 @@ class KnowledgeCommitmentDefinition extends BaseCommitmentDefinition {
             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
             \`\`\`
         `);
     }
@@ -21161,7 +21166,7 @@ class MetaImageCommitmentDefinition extends BaseCommitmentDefinition {
 
             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
@@ -21169,7 +21174,7 @@ class MetaImageCommitmentDefinition extends BaseCommitmentDefinition {
 
             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
             \`\`\`
         `);
@@ -21328,7 +21333,7 @@ class MetaLinkCommitmentDefinition extends BaseCommitmentDefinition {
             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
             \`\`\`
         `);
     }
@@ -21534,7 +21539,7 @@ class ModelCommitmentDefinition extends BaseCommitmentDefinition {
             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
             \`\`\`
 
@@ -21746,7 +21751,7 @@ class NoteCommitmentDefinition extends BaseCommitmentDefinition {
             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
             \`\`\`
         `);
     }
@@ -22040,7 +22045,7 @@ class RuleCommitmentDefinition extends BaseCommitmentDefinition {
             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
@@ -22309,8 +22314,8 @@ class ScenarioCommitmentDefinition extends BaseCommitmentDefinition {
 /**
  * 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:
  *
@@ -22329,7 +22334,16 @@ class StyleCommitmentDefinition extends BaseCommitmentDefinition {
      * 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.
@@ -22344,15 +22358,34 @@ class StyleCommitmentDefinition extends BaseCommitmentDefinition {
         return spaceTrim$1(`
             # ${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
@@ -23093,7 +23126,7 @@ class TemplateCommitmentDefinition extends BaseCommitmentDefinition {
 
             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
@@ -23537,7 +23570,7 @@ class UseBrowserCommitmentDefinition extends BaseCommitmentDefinition {
 
             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
             \`\`\`
 
@@ -44243,7 +44276,7 @@ var findRefactorCandidates$1 = /*#__PURE__*/Object.freeze({
 /**
  * CLI usage text for this script.
  */
-const USAGE = 'Usage: run-codex-prompts [--dry-run] [--agent <agent-name>] [--model <model>] [--context <context-or-file>] [--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.
  */
@@ -44253,10 +44286,11 @@ const KNOWN_OPTION_FLAGS = new Set([
     '--model',
     '--context',
     '--test',
+    '--preserve-logs',
+    '--no-ui',
     '--thinking-level',
     '--priority',
     '--allow-credits',
-    '--preserve-logs',
     '--auto-migrate',
     '--allow-destructive-auto-migrate',
     '--no-wait',
@@ -44286,6 +44320,8 @@ function parseRunOptions(args) {
     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');
@@ -44293,7 +44329,6 @@ function parseRunOptions(args) {
     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');
@@ -44319,10 +44354,11 @@ function parseRunOptions(args) {
         ignoreGitChanges,
         normalizeLineEndings,
         allowCredits,
-        preserveLogs,
         autoMigrate,
         allowDestructiveAutoMigrate,
         autoPush,
+        preserveLogs,
+        noUi,
         agentName,
         model,
         context,
@@ -44403,18 +44439,10 @@ function appendCoderContext(prompt, context) {
     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',
@@ -44422,6 +44450,121 @@ const ESTIMATED_DONE_CALENDAR_FORMATS$1 = {
     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.duration(estimatedTotalMs);
+        const estimatedCompletion = moment().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();
+        }
+    }
+    /**
+     * Resumes active-time tracking after a pause.
+     */
+    resume() {
+        if (this.pausedSince !== undefined) {
+            this.pausedMs += moment().diff(this.pausedSince);
+            this.pausedSince = undefined;
+        }
+    }
+    /**
+     * Returns the currently accumulated active duration.
+     */
+    getElapsedDuration() {
+        const wallMs = moment().diff(this.startTime);
+        const currentPauseMs = this.pausedSince !== undefined ? moment().diff(this.pausedSince) : 0;
+        return moment.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.
  */
@@ -44429,11 +44572,12 @@ class CliProgressDisplay {
     /**
      * 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;
         }
@@ -44452,6 +44596,20 @@ class CliProgressDisplay {
         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.
      */
@@ -44469,14 +44627,17 @@ class CliProgressDisplay {
      * 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');
-        cursorTo(process.stdout, 0, 0);
-        clearLine(process.stdout, 0);
-        process.stdout.write(line);
+        for (let lineIndex = 0; lineIndex < PROGRESS_HEADER_RESERVED_LINES; lineIndex++) {
+            cursorTo(process.stdout, 0, lineIndex);
+            clearLine(process.stdout, 0);
+            process.stdout.write((_a = lines[lineIndex]) !== null && _a !== void 0 ? _a : '');
+        }
         process.stdout.write('\x1b[u');
     }
     /**
@@ -44490,72 +44651,74 @@ class CliProgressDisplay {
         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.bgWhite(colors.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.bgCyan.black(padPlainText(workingLine, columns)),
+            colors.bgBlack.white(padPlainText(detailParts.join(' | '), columns)),
+            colors.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.duration(moment().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.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.green('█'.repeat(filledWidth))}${colors.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.bgBlue.white(` ${line} `)).join('\n');
 }
 
 /**
@@ -44769,14 +44932,6 @@ function normalizeCrLfToLf(content) {
     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.bgBlue.white(` ${line} `)).join('\n');
-}
-
 /**
  * Prints the formatted commit message preview.
  */
@@ -44822,82 +44977,36 @@ function buildScriptLogPath(scriptPath) {
 }
 
 /**
- * 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 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 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 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.
  */
@@ -45335,7 +45444,8 @@ function stringifyUnknownError$1(error) {
 
 /**
  * Commits staged changes with the provided message using the dedicated coding-agent identity when configured,
- * otherwise falls back to the default Git configuration. 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();
@@ -45345,11 +45455,7 @@ async function commitChanges(message, options) {
     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,
@@ -45363,6 +45469,56 @@ async function commitChanges(message, options) {
         await 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 = resolve(projectPath, excludePath);
+    const relativeExcludePath = 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.
  */
@@ -46737,6 +46893,15 @@ function buildPromptLabelForDisplay(file, section) {
     return `${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.
  */
@@ -46796,15 +46961,6 @@ function findNextTodoPrompt(files, minimumPriority = 0) {
     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).
  */
@@ -47356,25 +47512,29 @@ async function runBashScriptWithOutput(options) {
 }
 
 /**
- * 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 mkdir(dirname$1(scriptPath), { recursive: true });
     await 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 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) => {
@@ -47477,7 +47637,7 @@ class ClaudeCodeRunner {
             scriptPath: options.scriptPath,
             scriptContent,
             logPath: options.logPath,
-            promptRoundArtifacts: options.promptRoundArtifacts,
+            preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
         });
         const usage = parseClaudeCodeJsonOutput(output);
         return { usage };
@@ -47485,7 +47645,7 @@ class ClaudeCodeRunner {
 }
 
 /**
- * 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) => {
@@ -47541,7 +47701,7 @@ class ClineRunner {
                 scriptPath: options.scriptPath,
                 scriptContent,
                 logPath: options.logPath,
-                promptRoundArtifacts: options.promptRoundArtifacts,
+                preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
             });
             return { usage: UNCERTAIN_USAGE };
         }
@@ -47666,7 +47826,7 @@ class GeminiRunner {
             scriptPath: options.scriptPath,
             scriptContent,
             logPath: options.logPath,
-            promptRoundArtifacts: options.promptRoundArtifacts,
+            preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
         });
         const usage = parseGeminiUsageFromOutput(output, options.prompt, this.options.model);
         return { usage };
@@ -47723,7 +47883,7 @@ class GitHubCopilotRunner {
             scriptPath: options.scriptPath,
             scriptContent,
             logPath: options.logPath,
-            promptRoundArtifacts: options.promptRoundArtifacts,
+            preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
         });
         return { usage: UNCERTAIN_USAGE };
     }
@@ -47899,7 +48059,7 @@ async function runScriptUntilMarkerIdle(options) {
 }
 
 /**
- * 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) {
@@ -48288,7 +48448,7 @@ class OpenAiCodexRunner {
                     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) };
@@ -48423,7 +48583,7 @@ class OpencodeRunner {
                 scriptPath: options.scriptPath,
                 scriptContent,
                 logPath: options.logPath,
-                promptRoundArtifacts: options.promptRoundArtifacts,
+                preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
             });
         }
         catch (error) {
@@ -48451,6 +48611,7 @@ async function runPromptTestCommand(options) {
             ${options.command}
         `),
         logPath: options.logPath,
+        preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
     });
 }
 
@@ -48475,7 +48636,7 @@ async function runPromptWithTestFeedback(options) {
             scriptPath: options.scriptPath,
             projectPath: options.projectPath,
             logPath: options.logPath,
-            promptRoundArtifacts: options.promptRoundArtifacts,
+            preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
         });
         return { ...result, attemptCount: 1 };
     }
@@ -48488,7 +48649,7 @@ async function runPromptWithTestFeedback(options) {
             scriptPath: options.scriptPath,
             projectPath: options.projectPath,
             logPath: options.logPath,
-            promptRoundArtifacts: options.promptRoundArtifacts,
+            preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
         });
         console.info(colors.gray(`Running verification command after attempt #${attemptCount}: ${normalizedTestCommand}`));
         try {
@@ -48497,6 +48658,7 @@ async function runPromptWithTestFeedback(options) {
                 projectPath: options.projectPath,
                 scriptPath: buildPromptTestScriptPath(options.scriptPath),
                 logPath: options.logPath,
+                preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
             });
             return { ...result, attemptCount };
         }
@@ -48578,24 +48740,213 @@ function buildPromptTestScriptPath(scriptPath) {
 }
 
 /**
- * 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.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.bgCyan.black(' PTBK ')}`, colors.bgBlue.white(' CODER '), colors.bold.white(' Promptbook Coder')]
+            .join(''),
+        metadataParts.join('  ·  '),
+        buildConfigSummaryLine(options.config),
+    ];
+    const currentTaskLines = options.currentPromptLabel
+        ? [
+            `${promptStatusPrefix}${colors.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.cyan.bold),
+        ...renderBox('Session', sessionLines, totalWidth, colors.yellow.bold),
+        ...renderBox(options.currentPromptLabel ? 'Current task' : 'Queue', currentTaskLines, totalWidth, colors.magenta.bold),
+        ...renderBox('Live output', visibleOutputLines, totalWidth, colors.green.bold),
+    ];
+    if (options.errors.length > 0) {
+        frame.push(...renderBox('Errors', options.errors.map((errorLine) => `${colors.red('✗')} ${errorLine}`), totalWidth, colors.red.bold));
+    }
+    frame.push(...renderBox('Controls', [controls], totalWidth, colors.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.gray('┌') +
+        colorizeTitle(titleText) +
+        colors.gray('─'.repeat(Math.max(0, totalWidth - 2 - titleText.length)) + '┐');
+    const body = lines.map((line) => {
+        const paddedLine = padAnsiText(line, bodyWidth);
+        return colors.gray('│ ') + paddedLine + colors.gray(' │');
+    });
+    const bottomBorder = colors.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.bgYellow.black(' PAUSED ');
+    }
+    switch (phase) {
+        case 'loading':
+        case 'initializing':
+            return colors.bgCyan.black(' LOADING ');
+        case 'running':
+            return colors.bgGreen.black(' RUNNING ');
+        case 'verifying':
+            return colors.bgMagenta.white(' VERIFYING ');
+        case 'waiting':
+            return colors.bgBlue.white(' WAITING ');
+        case 'done':
+            return colors.bgGreen.black(' DONE ');
+        case 'error':
+            return colors.bgRed.white(' ERROR ');
+        default:
+            return colors.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.green('█'.repeat(filledWidth))}${colors.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.bgWhite.black(' ENTER ') + colors.white(` ${pendingEnterLabel}`));
+    }
+    pills.push(pauseState === 'RUNNING'
+        ? colors.bgYellow.black(' P ') + colors.white(' Pause')
+        : colors.bgYellow.black(' P ') + colors.white(' Resume'));
+    pills.push(colors.bgRed.white(' CTRL+C ') + colors.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.
  *
@@ -48611,35 +48962,27 @@ class CoderRunUiState extends EventEmitter {
         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();
-        }
+        this.timer.pause();
+        this.emitChange();
     }
     /**
      * Resumes the elapsed timer after a pause.
      */
     resumeTimer() {
-        if (this.pausedSince !== undefined) {
-            this.pausedMs += moment().diff(this.pausedSince);
-            this.pausedSince = undefined;
-        }
+        this.timer.resume();
+        this.emitChange();
     }
     /**
      * Replaces the configuration shown in the UI header.
@@ -48663,41 +49006,15 @@ class CoderRunUiState extends EventEmitter {
      */
     getProgress() {
         var _a;
-        const stats = this.stats;
-        const totalPrompts = stats.done + stats.forAgent + stats.toBeWritten;
-        const sessionDone = Math.max(0, stats.done - ((_a = this.initialDone) !== null && _a !== void 0 ? _a : stats.done));
-        const sessionTotal = sessionDone + stats.forAgent;
-        const percentage = totalPrompts > 0 ? Math.round((stats.done / totalPrompts) * 100) : 0;
-        const wallMs = moment().diff(this.startTime);
-        const currentPauseMs = this.pausedSince !== undefined ? moment().diff(this.pausedSince) : 0;
-        const activeMs = Math.max(0, wallMs - this.pausedMs - currentPauseMs);
-        const elapsedDuration = moment.duration(activeMs);
-        const elapsedText = formatDurationBrief(elapsedDuration);
-        let estimatedTotalText = '\u2014';
-        let estimatedLabel = 'unknown';
-        if (totalPrompts > 0 && stats.done > 0) {
-            const estimatedTotalMs = (elapsedDuration.asMilliseconds() * totalPrompts) / stats.done;
-            const estimatedRemainingMs = estimatedTotalMs - elapsedDuration.asMilliseconds();
-            const estimatedTotalDuration = moment.duration(estimatedTotalMs);
-            const estimatedCompletion = moment().add(estimatedRemainingMs, 'milliseconds');
-            estimatedTotalText = formatDurationBrief(estimatedTotalDuration);
-            estimatedLabel = estimatedCompletion.calendar(null, ESTIMATED_DONE_CALENDAR_FORMATS);
-        }
-        return {
-            totalPrompts,
-            sessionDone,
-            sessionTotal,
-            percentage,
-            elapsedText,
-            estimatedTotalText,
-            estimatedLabel,
-        };
+        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();
@@ -48737,6 +49054,20 @@ class CoderRunUiState extends EventEmitter {
         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.
      */
@@ -48748,50 +49079,35 @@ class CoderRunUiState extends EventEmitter {
         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.
  *
@@ -48810,38 +49126,20 @@ const SPINNER_FRAMES = [
     '\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.green('\u2588'.repeat(filled)) + colors.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.
@@ -48855,21 +49153,20 @@ function renderCoderRunUi(startTime) {
             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) {
@@ -48886,192 +49183,205 @@ function renderCoderRunUi(startTime) {
             state.addAgentOutput(args.map(String).join(' '));
         }
     };
-    // --- Keyboard input (pause) ---
     const readline = require('readline');
     readline.emitKeypressEvents(process.stdin);
     if (process.stdin.isTTY) {
         process.stdin.setRawMode(true);
     }
-    const keypressHandler = (_str, key) => {
-        if (key.ctrl && key.name === 'c') {
-            cleanup();
-            process.exit(0);
-        }
-        if (key.name === 'p') {
-            const current = getPauseState();
-            if (current === 'RUNNING') {
-                requestPause();
-            }
-            else {
-                requestResume();
-            }
-        }
-    };
-    process.stdin.on('keypress', keypressHandler);
-    // --- Rendering ---
     let spinnerFrame = 0;
-    let previousFrameLineCount = 0;
+    let 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`);
+        }
+        clearLine(process.stdout, 0);
+        cursorTo(process.stdout, 0);
+        process.stdout.write(line);
+        cursorTo(process.stdout, 0);
+        if (linesUpFromBottom > 0) {
+            process.stdout.write(`\x1b[${linesUpFromBottom}B`);
+            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++) {
+            clearLine(process.stdout, 0);
+            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`);
+        }
+        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++) {
-                clearLine(process.stdout, 0);
-                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');
-                    clearLine(process.stdout, 0);
-                    cursorTo(process.stdout, 0);
-                }
-                // Move back up to the end of the current frame.
-                const overshoot = previousFrameLineCount - lines.length;
-                if (overshoot > 0) {
-                    process.stdout.write(`\x1b[${overshoot}A`);
-                }
+            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.gray('\u2500'.repeat(w - 2));
-        const spinner = SPINNER_FRAMES[spinnerFrame];
-        const { config, phase, currentPromptLabel, currentAttempt, maxAttempts, statusMessage, agentOutputLines, errors, } = state;
-        const progress = state.getProgress();
-        const isPaused = getPauseState() !== 'RUNNING';
-        const isActive = phase === 'running' || phase === 'verifying' || phase === 'loading';
-        const lines = [];
-        // --- Branding ---
-        lines.push(colors.bold.cyan('\u2728 Promptbook Coder'));
-        // --- Config ---
-        let configLine1 = `Agent: ${colors.bold.green(config.agentName)}`;
-        if (config.modelName) {
-            configLine1 += `  \u2502  Model: ${colors.bold(config.modelName)}`;
-        }
-        if (config.thinkingLevel) {
-            configLine1 += `  \u2502  Thinking: ${colors.bold(config.thinkingLevel)}`;
-        }
-        lines.push(configLine1);
-        let configLine2 = '';
-        if (config.context) {
-            configLine2 += `Context: ${colors.yellow(config.context)}  \u2502  `;
-        }
-        configLine2 += `Priority: \u2265${config.priority}`;
-        if (config.testCommand) {
-            configLine2 += `  \u2502  Test: ${colors.gray(config.testCommand)}`;
-        }
-        lines.push(configLine2);
-        // --- Separator ---
-        lines.push(sep);
-        // --- Progress ---
-        const progressSummary = [
-            `${progress.sessionDone}/${progress.sessionTotal} Prompts (${progress.totalPrompts} total)`,
-            `${progress.elapsedText}/${progress.estimatedTotalText}`,
-            `Est. done ${progress.estimatedLabel}`,
-        ].join(' \u2502 ');
-        lines.push(progressSummary);
-        lines.push(buildProgressBar(progress.percentage));
-        // --- Separator ---
-        lines.push(sep);
-        // --- Current prompt ---
-        if (currentPromptLabel) {
-            const spinnerPrefix = isActive ? colors.yellow(`${spinner} `) : '  ';
-            lines.push(spinnerPrefix + colors.bold(currentPromptLabel));
-            lines.push(colors.gray(`Attempt ${currentAttempt}/${maxAttempts} \u2502 ${statusMessage}`));
+    const keypressHandler = (_str, key) => {
+        if (key.ctrl && key.name === 'c') {
+            cleanup();
+            process.exit(0);
         }
-        else {
-            lines.push(colors.gray(statusMessage));
-        }
-        // --- Agent output ---
-        if (agentOutputLines.length > 0) {
-            lines.push('');
-            lines.push(colors.gray.bold('Agent output:'));
-            const visibleLines = agentOutputLines.slice(-MAX_VISIBLE_OUTPUT_LINES);
-            for (const line of visibleLines) {
-                const cleanLine = stripAnsi(line);
-                // Truncate to terminal width.
-                const truncated = cleanLine.length > w - 2 ? cleanLine.slice(0, w - 5) + '...' : cleanLine;
-                lines.push(colors.gray(truncated));
-            }
-        }
-        // --- Errors ---
-        if (errors.length > 0) {
-            lines.push('');
-            for (const err of errors) {
-                lines.push(colors.red(`\u2717 ${err}`));
-            }
-        }
-        // --- Separator ---
-        lines.push(sep);
-        // --- Controls ---
-        const pauseLabel = isPaused
-            ? colors.bgYellow.black(' PAUSED ') + colors.gray(' [P] Resume  \u2502  Ctrl+C Exit')
-            : colors.gray('[P] Pause  \u2502  Ctrl+C Exit');
-        lines.push(pauseLabel);
-        return lines;
-    }
-    // Initial render.
+        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,
@@ -49081,6 +49391,19 @@ function renderCoderRunUi(startTime) {
         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,
     };
 }
@@ -49148,11 +49471,11 @@ async function runCodexPrompts(providedOptions) {
             `));
     }
     const runStartDate = moment();
-    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 {
@@ -49268,17 +49591,19 @@ async function runCodexPrompts(providedOptions) {
         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...');
             }
@@ -49286,17 +49611,17 @@ async function runCodexPrompts(providedOptions) {
             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.yellow('Following prompts need to be written:'));
                     printPromptsToBeWritten(promptFiles, options.priority);
                     console.info('');
                 }
-                if (!isUiMode) {
+                if (!isRichUiEnabled) {
                     printUpcomingTasks(listUpcomingTasks(promptFiles, options.priority));
                 }
                 hasShownUpcomingTasks = true;
@@ -49306,7 +49631,7 @@ async function runCodexPrompts(providedOptions) {
                     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.yellow(message));
                     }
                 }
@@ -49314,16 +49639,28 @@ async function runCodexPrompts(providedOptions) {
                     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.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;
             }
@@ -49333,9 +49670,7 @@ async function runCodexPrompts(providedOptions) {
             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');
@@ -49345,69 +49680,78 @@ async function runCodexPrompts(providedOptions) {
             }
             const promptExecutionStartedDate = moment();
             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.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 {