@promptbook/cli 0.114.0-19 → 0.114.0-20

package/umd/index.umd.js

@@ -58,7 +58,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.114.0-19';
+    const PROMPTBOOK_ENGINE_VERSION = '0.114.0-20';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -1760,6 +1760,32 @@
      */
     const PTBK_THINKING_LEVEL_ENV = 'PTBK_THINKING_LEVEL';
 
+    /**
+     * Supported values of the `--git-changes` option, which decides what happens with a dirty working tree.
+     *
+     * - `fail` — refuse to start while the working tree has uncommitted changes
+     * - `ignore` — start anyway and leave the uncommitted changes where they are
+     * - `continue` — resume the single prompt which was left in the middle of its implementation
+     *
+     * @private internal shared utility of `ptbk coder run`
+     */
+    const GIT_CHANGES_MODE_VALUES = ['fail', 'ignore', 'continue'];
+    /**
+     * Mode applied when `--git-changes` is not used at all.
+     *
+     * @private internal shared utility of `ptbk coder run`
+     */
+    const DEFAULT_GIT_CHANGES_MODE = 'fail';
+    /**
+     * Checks whether a value is a supported `--git-changes` mode.
+     *
+     * @private internal shared utility of `ptbk coder run`
+     */
+    function isGitChangesMode(value) {
+        return GIT_CHANGES_MODE_VALUES.includes(value);
+    }
+    // Note: [🟡] Code for CLI command [run](src/cli/cli-commands/coder/run.ts) should never be published outside of `@promptbook/cli`
+
     /**
      * Supported thinking-level CLI values for coding-agent runners with configurable reasoning effort.
      *
@@ -1818,6 +1844,17 @@
 
     OpenAI examples: gpt-5.2-codex, default
     Gemini examples: gemini-3-flash-preview, default
+`);
+    /**
+     * Commander description for the `--git-changes` option.
+     *
+     * @private internal utility of `promptbookCli`
+     */
+    const GIT_CHANGES_OPTION_DESCRIPTION = _spaceTrim.spaceTrim(`
+    Decide what happens when the working tree has uncommitted changes before a prompt starts:
+    - fail: refuse to start and ask for a commit or a stash (the default)
+    - ignore: start anyway and leave the uncommitted changes where they are
+    - continue: resume the single prompt which was left in the middle of its implementation
 `);
     /**
      * Registers runner selection flags on a command.
@@ -1848,7 +1885,9 @@
     function addPromptRunnerExecutionOptions(command) {
         addPromptRunnerRuntimeOptions(command);
         command.option('--no-commit', 'Leave successful changes in the working directory instead of creating git commits');
-        command.option('--ignore-git-changes', 'Skip clean working tree check before running prompts', false);
+        command.addOption(new commander.Option('--git-changes <mode>', GIT_CHANGES_OPTION_DESCRIPTION)
+            .choices([...GIT_CHANGES_MODE_VALUES])
+            .default(DEFAULT_GIT_CHANGES_MODE));
         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-pull', 'Automatically git pull before the first and each subsequent prompt', false);
@@ -1859,11 +1898,12 @@
      * @private internal utility of `promptbookCli`
      */
     function normalizePromptRunnerCliOptions(cliOptions, options) {
+        var _a;
         const selectionOptions = normalizePromptRunnerSelectionCliOptions(cliOptions, options);
         return {
             ...selectionOptions,
             noCommit: !cliOptions.commit,
-            ignoreGitChanges: cliOptions.ignoreGitChanges,
+            gitChanges: (_a = cliOptions.gitChanges) !== null && _a !== void 0 ? _a : DEFAULT_GIT_CHANGES_MODE,
             normalizeLineEndings: cliOptions.normalizeLineEndings,
             autoPush: cliOptions.autoPush,
             autoPull: cliOptions.autoPull,
@@ -22762,7 +22802,7 @@
             Git working tree has changes outside of \`${normalizeGitPath(AGENT_QUEUED_MESSAGES_DIRECTORY_PATH)}/\`.
 
             Please commit or stash unrelated changes before running \`ptbk agent-folder\`
-            OR run with \`--ignore-git-changes\`.
+            OR run with \`--git-changes ignore\`.
 
             Unrelated changed files:
             ${unrelatedChangedFiles.map((relativePath) => `- \`${relativePath}\``).join('\n')}
@@ -22818,7 +22858,7 @@
      * Runs the clean working tree guard unless the user explicitly disabled it.
      */
     async function ensureCleanQueueIfNeeded(projectPath, options) {
-        if (options.ignoreGitChanges) {
+        if (options.gitChanges !== 'fail') {
             return;
         }
         await ensureWorkingTreeCleanForAgentQueue(projectPath);
@@ -23340,6 +23380,58 @@
      */
     const WAITING_FOR_MESSAGE_LABEL = 'Waiting for the message';
 
+    /**
+     * Colors of the key badges, so one control key looks the same in its pill and in its answer.
+     *
+     * @private internal constant of `ptbk coder` terminal controls
+     */
+    const CODER_RUN_CONTROL_KEY_BADGE_COLORIZERS = {
+        P: (badgeText) => colors__default["default"].bgYellow.black(badgeText),
+        S: (badgeText) => colors__default["default"].bgCyan.black(badgeText),
+        X: (badgeText) => colors__default["default"].bgBlue.white(badgeText),
+    };
+    /**
+     * Builds the colored badge of one control key, for example ` S `.
+     *
+     * @private internal utility of `ptbk coder` terminal controls
+     */
+    function buildCoderRunControlKeyBadge(controlKey) {
+        return CODER_RUN_CONTROL_KEY_BADGE_COLORIZERS[controlKey](` ${controlKey} `);
+    }
+
+    /**
+     * Marker printed before every control answer so it stands out from the runner output.
+     *
+     * @private internal constant of `ptbk coder` terminal controls
+     */
+    const CODER_RUN_CONTROL_FEEDBACK_MARKER = '»';
+    /**
+     * Colors of the control answers by their meaning.
+     *
+     * @private internal constant of `ptbk coder` terminal controls
+     */
+    const CODER_RUN_CONTROL_FEEDBACK_COLORIZERS = {
+        success: (message) => colors__default["default"].green(message),
+        info: (message) => colors__default["default"].cyan(message),
+        warning: (message) => colors__default["default"].yellow(message),
+    };
+    /**
+     * Formats one control answer as a single colored terminal line.
+     *
+     * The same line is printed by the plain console listener and rendered inside the `Controls` box of the
+     * rich terminal UI, so both modes answer a pressed control key identically.
+     *
+     * @param feedback Answer of the runner to the pressed control key.
+     * @param repeatCount How many times this exact answer was given in a row, rendered from the second time on.
+     *
+     * @private internal utility of `ptbk coder` terminal controls
+     */
+    function formatCoderRunControlFeedback(feedback, repeatCount = 1) {
+        const colorizeMessage = CODER_RUN_CONTROL_FEEDBACK_COLORIZERS[feedback.tone];
+        const repeatSuffix = repeatCount > 1 ? colors__default["default"].gray(` (×${repeatCount})`) : '';
+        return `${colors__default["default"].gray(CODER_RUN_CONTROL_FEEDBACK_MARKER)} ${buildCoderRunControlKeyBadge(feedback.controlKey)} ${colorizeMessage(feedback.message)}${repeatSuffix}`;
+    }
+
     /**
      * Centers an ANSI-colored line within the available frame width.
      *
@@ -23514,7 +23606,8 @@
         return {
             badge: buildRunningPhaseBadge(phase),
             stateMessage: statusMessage,
-            pauseControl: colors__default["default"].bgYellow.black(' P ') + colors__default["default"].white(' Pause'),
+            // Note: The two paused variants above deliberately recolor the `P` badge, everything else uses the shared one
+            pauseControl: buildCoderRunControlKeyBadge('P') + colors__default["default"].white(' Pause'),
         };
     }
     /**
@@ -23555,20 +23648,34 @@
             ],
         });
     }
+    /**
+     * Builds the body of the `Controls` box.
+     *
+     * The pills are always shown, and right after a control key was pressed the answer of the runner to
+     * that key is shown underneath, so no key press ever leaves the frame unchanged.
+     */
+    function buildControlsBoxLines(options) {
+        const { controlPills, controlFeedback } = options;
+        const controlPillsLine = controlPills.join('  ');
+        if (controlFeedback === undefined) {
+            return [controlPillsLine];
+        }
+        return [controlPillsLine, formatCoderRunControlFeedback(controlFeedback, controlFeedback.repeatCount)];
+    }
     /**
      * Builds the `S` wait-skip control label.
      */
     function buildSkipCurrentWaitControl() {
-        return colors__default["default"].bgCyan.black(' S ') + colors__default["default"].white(' Skip current waiting');
+        return buildCoderRunControlKeyBadge('S') + colors__default["default"].white(' Skip current waiting');
     }
     /**
      * Builds the dynamic `X` control label.
      */
     function buildEndAfterCurrentPromptControl(isEndAfterCurrentPromptRequested, sessionTotal) {
         if (isEndAfterCurrentPromptRequested) {
-            return colors__default["default"].bgBlue.white(' X ') + colors__default["default"].white(` Do all ${formatControlPromptCount(sessionTotal)}`);
+            return buildCoderRunControlKeyBadge('X') + colors__default["default"].white(` Do all ${formatControlPromptCount(sessionTotal)}`);
         }
-        return colors__default["default"].bgBlue.white(' X ') + colors__default["default"].white(' End with this prompt');
+        return buildCoderRunControlKeyBadge('X') + colors__default["default"].white(' End with this prompt');
     }
     /**
      * Formats one prompt count for the `X` control.
@@ -23786,10 +23893,13 @@
             : [options.statusMessage, ...options.detailLines.map((detailLine) => `• ${detailLine}`)];
         const userMessageBoxes = buildUserMessageBoxes(options, totalWidth);
         const visibleOutputLines = buildVisibleOutputLines(options.agentOutputLines);
-        const controls = buildControlPills({
-            pauseControl: pausePresentation.pauseControl,
-            pendingEnterLabel: options.pendingEnterLabel,
-        }).join('  ');
+        const controlsBoxLines = buildControlsBoxLines({
+            controlPills: buildControlPills({
+                pauseControl: pausePresentation.pauseControl,
+                pendingEnterLabel: options.pendingEnterLabel,
+            }),
+            controlFeedback: options.controlFeedback,
+        });
         const frame = [
             ...buildAgentRunInitialsVisual(options.config.localAgentName || 'Local Agent', totalWidth),
             '',
@@ -23802,7 +23912,7 @@
         if (options.errors.length > 0) {
             frame.push(...renderBox('Errors', options.errors.map((errorLine) => `${colors__default["default"].red('✗')} ${errorLine}`), totalWidth, colors__default["default"].red.bold));
         }
-        frame.push(...renderBox('Controls', [controls], totalWidth, colors__default["default"].white.bold));
+        frame.push(...renderBox('Controls', controlsBoxLines, totalWidth, colors__default["default"].white.bold));
         return frame;
     }
     /**
@@ -25124,6 +25234,254 @@
         });
     }
 
+    /**
+     * Default label used before the next pause checkpoint is known.
+     */
+    const DEFAULT_PAUSE_TARGET_LABEL = 'the next task';
+    /**
+     * Current pause state.
+     */
+    let pauseState = 'RUNNING';
+    /**
+     * Label of the next checkpoint where the requested pause will take effect.
+     */
+    let pauseTargetLabel = DEFAULT_PAUSE_TARGET_LABEL;
+    /**
+     * Token of the currently active timed wait, if the runner is inside one.
+     */
+    let activeSkippableWaitToken;
+    /**
+     * Whether the user requested the active timed wait to end immediately.
+     */
+    let isSkipCurrentWaitRequested = false;
+    /**
+     * Whether the runner should stop after the current prompt round reaches its normal boundary.
+     */
+    let isEndAfterCurrentPromptRequested$1 = false;
+    /**
+     * Promise resolvers waiting for the active timed wait to be skipped.
+     */
+    const SKIP_CURRENT_WAIT_RESOLVERS = new Map();
+    /**
+     * Stores one new pause state in the shared runner controller.
+     */
+    function setPauseState(nextPauseState) {
+        pauseState = nextPauseState;
+    }
+    /**
+     * Stores one new pause target label in the shared runner controller.
+     */
+    function setPauseTargetLabel(nextPauseTargetLabel) {
+        pauseTargetLabel = nextPauseTargetLabel.trim() || DEFAULT_PAUSE_TARGET_LABEL;
+    }
+    /**
+     * Stores the dynamic end-after-current-prompt state.
+     */
+    function setEndAfterCurrentPromptRequested(isRequested) {
+        isEndAfterCurrentPromptRequested$1 = isRequested;
+    }
+    /**
+     * Applies the same three-state toggle used by the `P` hotkey.
+     */
+    function togglePauseState() {
+        if (pauseState === 'RUNNING') {
+            setPauseState('PAUSING');
+            return 'REQUESTED_PAUSE';
+        }
+        if (pauseState === 'PAUSING') {
+            setPauseState('RUNNING');
+            resetPauseTargetLabel();
+            return 'CANCELLED_PAUSE';
+        }
+        setPauseState('RUNNING');
+        resetPauseTargetLabel();
+        return 'RESUMED';
+    }
+    /**
+     * Applies the two-state toggle used by the `X` hotkey.
+     */
+    function toggleEndAfterCurrentPromptState() {
+        if (!isEndAfterCurrentPromptRequested$1) {
+            setEndAfterCurrentPromptRequested(true);
+            return 'REQUESTED_END';
+        }
+        setEndAfterCurrentPromptRequested(false);
+        return 'CANCELLED_END';
+    }
+    /**
+     * Returns whether the dynamic end-after-current-prompt control is active.
+     */
+    function getEndAfterCurrentPromptState() {
+        return isEndAfterCurrentPromptRequested$1;
+    }
+    /**
+     * Starts one timed wait which can be skipped by the `S` hotkey.
+     */
+    function beginSkippableWait() {
+        const waitToken = Symbol('coder-run-skippable-wait');
+        activeSkippableWaitToken = waitToken;
+        isSkipCurrentWaitRequested = false;
+        SKIP_CURRENT_WAIT_RESOLVERS.clear();
+        return waitToken;
+    }
+    /**
+     * Finishes one timed wait and clears any skip request that belonged to it.
+     */
+    function finishSkippableWait(waitToken) {
+        if (activeSkippableWaitToken !== waitToken) {
+            return;
+        }
+        activeSkippableWaitToken = undefined;
+        isSkipCurrentWaitRequested = false;
+        resolveSkipCurrentWaitResolvers(waitToken);
+        SKIP_CURRENT_WAIT_RESOLVERS.delete(waitToken);
+    }
+    /**
+     * Requests that the currently active timed wait ends immediately.
+     */
+    function requestSkipCurrentWait() {
+        if (activeSkippableWaitToken === undefined) {
+            return 'NO_ACTIVE_WAIT';
+        }
+        isSkipCurrentWaitRequested = true;
+        resolveSkipCurrentWaitResolvers(activeSkippableWaitToken);
+        return 'REQUESTED_SKIP';
+    }
+    /**
+     * Returns whether one timed wait should end early.
+     */
+    function shouldSkipCurrentWait(waitToken) {
+        return activeSkippableWaitToken === waitToken && isSkipCurrentWaitRequested;
+    }
+    /**
+     * Waits for either a timeout or an `S` hotkey skip request.
+     */
+    async function waitForSkippableMilliseconds(waitToken, durationMs) {
+        if (durationMs <= 0 || shouldSkipCurrentWait(waitToken)) {
+            return;
+        }
+        await new Promise((resolve) => {
+            let timeout = setTimeout(resolveWait, durationMs);
+            const resolver = () => resolveWait();
+            const resolvers = getSkipCurrentWaitResolvers(waitToken);
+            resolvers.add(resolver);
+            function resolveWait() {
+                if (timeout !== undefined) {
+                    clearTimeout(timeout);
+                    timeout = undefined;
+                }
+                resolvers.delete(resolver);
+                if (resolvers.size === 0) {
+                    SKIP_CURRENT_WAIT_RESOLVERS.delete(waitToken);
+                }
+                resolve();
+            }
+        });
+    }
+    /**
+     * Restores all shared terminal controls to their default state.
+     */
+    function resetCoderRunControls() {
+        setPauseState('RUNNING');
+        resetPauseTargetLabel();
+        setEndAfterCurrentPromptRequested(false);
+        if (activeSkippableWaitToken !== undefined) {
+            resolveSkipCurrentWaitResolvers(activeSkippableWaitToken);
+        }
+        activeSkippableWaitToken = undefined;
+        isSkipCurrentWaitRequested = false;
+        SKIP_CURRENT_WAIT_RESOLVERS.clear();
+    }
+    /**
+     * If the execution is paused, it will wait until it is resumed.
+     *
+     * @param options.silent - When `true`, suppresses console output (used when the terminal UI handles display).
+     * @param options.onPaused - Callback invoked when entering the PAUSED state.
+     * @param options.onResumed - Callback invoked when leaving the PAUSED state.
+     */
+    async function checkPause(options) {
+        var _a, _b;
+        if (pauseState === 'PAUSING') {
+            setPauseState('PAUSED');
+            if (!(options === null || options === void 0 ? void 0 : options.silent)) {
+                console.log(colors__default["default"].bgWhite.black(`Paused before ${getPauseTargetLabel()}`) +
+                    colors__default["default"].gray(' (Press "p" to resume)'));
+            }
+            (_a = options === null || options === void 0 ? void 0 : options.onPaused) === null || _a === void 0 ? void 0 : _a.call(options);
+            while (getPauseState() === 'PAUSED') {
+                await new Promise((resolve) => setTimeout(resolve, 100));
+            }
+            (_b = options === null || options === void 0 ? void 0 : options.onResumed) === null || _b === void 0 ? void 0 : _b.call(options);
+            if (!(options === null || options === void 0 ? void 0 : options.silent)) {
+                console.log(colors__default["default"].green('Resuming...'));
+            }
+        }
+    }
+    /**
+     * Returns the current pause state for external consumers such as the terminal UI.
+     */
+    function getPauseState() {
+        return pauseState;
+    }
+    /**
+     * Returns the label of the next checkpoint where pausing will take effect.
+     */
+    function getPauseTargetLabel() {
+        return pauseTargetLabel;
+    }
+    /**
+     * Updates the label of the next pause checkpoint.
+     */
+    function announcePauseTargetLabel(nextPauseTargetLabel) {
+        setPauseTargetLabel(nextPauseTargetLabel);
+    }
+    /**
+     * Restores the default generic pause target label.
+     */
+    function resetPauseTargetLabel() {
+        setPauseTargetLabel(DEFAULT_PAUSE_TARGET_LABEL);
+    }
+    /**
+     * Requests a pause from an external controller (e.g. the Ink UI).
+     */
+    function requestPause() {
+        if (pauseState === 'RUNNING') {
+            setPauseState('PAUSING');
+        }
+    }
+    /**
+     * Resumes execution from an external controller after a pause.
+     */
+    function requestResume() {
+        setPauseState('RUNNING');
+        resetPauseTargetLabel();
+    }
+    /**
+     * Gets or creates the resolver set for one timed wait.
+     */
+    function getSkipCurrentWaitResolvers(waitToken) {
+        const existingResolvers = SKIP_CURRENT_WAIT_RESOLVERS.get(waitToken);
+        if (existingResolvers !== undefined) {
+            return existingResolvers;
+        }
+        const resolvers = new Set();
+        SKIP_CURRENT_WAIT_RESOLVERS.set(waitToken, resolvers);
+        return resolvers;
+    }
+    /**
+     * Resolves all pending skip waiters for one timed wait.
+     */
+    function resolveSkipCurrentWaitResolvers(waitToken) {
+        const resolvers = SKIP_CURRENT_WAIT_RESOLVERS.get(waitToken);
+        if (resolvers === undefined) {
+            return;
+        }
+        for (const resolver of resolvers) {
+            resolver();
+        }
+        resolvers.clear();
+    }
+
     /**
      * Minimum timer duration used to avoid a zero-millisecond polling loop.
      */
@@ -25173,6 +25531,32 @@
         await new Promise((resolve) => setTimeout(resolve, durationMs));
     }
 
+    /**
+     * Waits until one wall-clock deadline has passed, or until the user skips the wait with the `S` control.
+     *
+     * This is the single way `ptbk coder` waits for a deadline the user is allowed to cut short, so every
+     * wait which shows the `S  Skip current waiting` control really reacts to it: the pacing waits between
+     * prompts, the cool-down after an error, the harness session-limit waits and the server keep-alive poll.
+     *
+     * @private internal utility of `ptbk coder` wait handling
+     */
+    async function waitForSkippableWorldTimeDeadline(options) {
+        const { deadlineTimeMs, pollIntervalMs, onTick } = options;
+        const waitToken = beginSkippableWait();
+        try {
+            await waitUntilWorldTimeDeadline({
+                deadlineTimeMs,
+                pollIntervalMs,
+                onTick,
+                shouldStopWaiting: () => shouldSkipCurrentWait(waitToken),
+                waitForMilliseconds: (waitDurationMs) => waitForSkippableMilliseconds(waitToken, waitDurationMs),
+            });
+        }
+        finally {
+            finishSkippableWait(waitToken);
+        }
+    }
+
     /**
      * Base delimiter used for passing large prompts through stdin.
      */
@@ -25580,6 +25964,10 @@
     }
     /**
      * Waits until the Claude Code session can be resumed, keeping terminal status clear.
+     *
+     * The wait runs in the `waiting` phase, where the terminal UI offers `S  Skip current waiting`, so it is
+     * a skippable wait: pressing `S` resumes the session with `--resume` immediately instead of sitting out
+     * the reset window.
      */
     async function waitForClaudeCodeSessionLimitReset(sessionLimit, resurrectionCount, options) {
         var _a, _b;
@@ -25590,7 +25978,7 @@
         if ((_a = options.shouldPrintLiveOutput) !== null && _a !== void 0 ? _a : true) {
             console.warn(colors__default["default"].yellow(`[claude-code] Session limit detected for ${sessionLimit.sessionId}. Resurrection #${resurrectionCount} will resume with --resume after ${formatDurationMs(delayMs)}. ${resetSummary}`));
         }
-        await waitUntilWorldTimeDeadline({
+        await waitForSkippableWorldTimeDeadline({
             deadlineTimeMs: resetDeadlineTimeMs,
             pollIntervalMs: CLAUDE_CODE_SESSION_RESURRECTION_POLL_MS,
             onTick: async (remainingDelayMs) => {
@@ -27029,292 +27417,100 @@
     }
 
     /**
-     * Default label used before the next pause checkpoint is known.
-     */
-    const DEFAULT_PAUSE_TARGET_LABEL = 'the next task';
-    /**
-     * Current pause state.
-     */
-    let pauseState = 'RUNNING';
-    /**
-     * Label of the next checkpoint where the requested pause will take effect.
-     */
-    let pauseTargetLabel = DEFAULT_PAUSE_TARGET_LABEL;
-    /**
-     * Token of the currently active timed wait, if the runner is inside one.
-     */
-    let activeSkippableWaitToken;
-    /**
-     * Whether the user requested the active timed wait to end immediately.
-     */
-    let isSkipCurrentWaitRequested = false;
-    /**
-     * Whether the runner should stop after the current prompt round reaches its normal boundary.
-     */
-    let isEndAfterCurrentPromptRequested$1 = false;
-    /**
-     * Promise resolvers waiting for the active timed wait to be skipped.
-     */
-    const SKIP_CURRENT_WAIT_RESOLVERS = new Map();
-    /**
-     * Stores one new pause state in the shared runner controller.
-     */
-    function setPauseState(nextPauseState) {
-        pauseState = nextPauseState;
-    }
-    /**
-     * Stores one new pause target label in the shared runner controller.
-     */
-    function setPauseTargetLabel(nextPauseTargetLabel) {
-        pauseTargetLabel = nextPauseTargetLabel.trim() || DEFAULT_PAUSE_TARGET_LABEL;
-    }
-    /**
-     * Stores the dynamic end-after-current-prompt state.
-     */
-    function setEndAfterCurrentPromptRequested(isRequested) {
-        isEndAfterCurrentPromptRequested$1 = isRequested;
-    }
-    /**
-     * Applies the same three-state toggle used by the `P` hotkey.
-     */
-    function togglePauseState() {
-        if (pauseState === 'RUNNING') {
-            setPauseState('PAUSING');
-            return 'REQUESTED_PAUSE';
-        }
-        if (pauseState === 'PAUSING') {
-            setPauseState('RUNNING');
-            resetPauseTargetLabel();
-            return 'CANCELLED_PAUSE';
-        }
-        setPauseState('RUNNING');
-        resetPauseTargetLabel();
-        return 'RESUMED';
-    }
-    /**
-     * Applies the two-state toggle used by the `X` hotkey.
-     */
-    function toggleEndAfterCurrentPromptState() {
-        if (!isEndAfterCurrentPromptRequested$1) {
-            setEndAfterCurrentPromptRequested(true);
-            return 'REQUESTED_END';
-        }
-        setEndAfterCurrentPromptRequested(false);
-        return 'CANCELLED_END';
-    }
-    /**
-     * Returns whether the dynamic end-after-current-prompt control is active.
-     */
-    function getEndAfterCurrentPromptState() {
-        return isEndAfterCurrentPromptRequested$1;
-    }
-    /**
-     * Starts one timed wait which can be skipped by the `S` hotkey.
-     */
-    function beginSkippableWait() {
-        const waitToken = Symbol('coder-run-skippable-wait');
-        activeSkippableWaitToken = waitToken;
-        isSkipCurrentWaitRequested = false;
-        SKIP_CURRENT_WAIT_RESOLVERS.clear();
-        return waitToken;
-    }
-    /**
-     * Finishes one timed wait and clears any skip request that belonged to it.
-     */
-    function finishSkippableWait(waitToken) {
-        if (activeSkippableWaitToken !== waitToken) {
-            return;
-        }
-        activeSkippableWaitToken = undefined;
-        isSkipCurrentWaitRequested = false;
-        resolveSkipCurrentWaitResolvers(waitToken);
-        SKIP_CURRENT_WAIT_RESOLVERS.delete(waitToken);
-    }
-    /**
-     * Requests that the currently active timed wait ends immediately.
-     */
-    function requestSkipCurrentWait() {
-        if (activeSkippableWaitToken === undefined) {
-            return 'NO_ACTIVE_WAIT';
-        }
-        isSkipCurrentWaitRequested = true;
-        resolveSkipCurrentWaitResolvers(activeSkippableWaitToken);
-        return 'REQUESTED_SKIP';
-    }
-    /**
-     * Returns whether one timed wait should end early.
-     */
-    function shouldSkipCurrentWait(waitToken) {
-        return activeSkippableWaitToken === waitToken && isSkipCurrentWaitRequested;
-    }
-    /**
-     * Waits for either a timeout or an `S` hotkey skip request.
+     * Applies the terminal control bound to one pressed key and describes what that key press did.
+     *
+     * This is the single place where the `P`, `S` and `X` keys are turned into runner actions, so the
+     * plain console listener and the rich terminal UI always perform the same action and always answer
+     * the user, even when the pressed control changed nothing.
+     *
+     * @param keyName Name of the pressed key as reported by the `keypress` event.
+     * @returns The answer shown to the user, or `undefined` when the key is not a control key.
+     *
+     * @private internal utility of `ptbk coder` terminal controls
      */
-    async function waitForSkippableMilliseconds(waitToken, durationMs) {
-        if (durationMs <= 0 || shouldSkipCurrentWait(waitToken)) {
-            return;
+    function applyCoderRunControlKey(keyName) {
+        switch (keyName) {
+            case 'p':
+                return describePauseToggle(togglePauseState());
+            case 's':
+                return describeSkipCurrentWait(requestSkipCurrentWait());
+            case 'x':
+                return describeEndAfterCurrentPrompt(toggleEndAfterCurrentPromptState());
+            default:
+                return undefined;
         }
-        await new Promise((resolve) => {
-            let timeout = setTimeout(resolveWait, durationMs);
-            const resolver = () => resolveWait();
-            const resolvers = getSkipCurrentWaitResolvers(waitToken);
-            resolvers.add(resolver);
-            function resolveWait() {
-                if (timeout !== undefined) {
-                    clearTimeout(timeout);
-                    timeout = undefined;
-                }
-                resolvers.delete(resolver);
-                if (resolvers.size === 0) {
-                    SKIP_CURRENT_WAIT_RESOLVERS.delete(waitToken);
-                }
-                resolve();
-            }
-        });
     }
     /**
-     * Restores all shared terminal controls to their default state.
+     * Describes what pressing `P` did.
+     *
+     * @private helper of `applyCoderRunControlKey`
      */
-    function resetCoderRunControls() {
-        setPauseState('RUNNING');
-        resetPauseTargetLabel();
-        setEndAfterCurrentPromptRequested(false);
-        if (activeSkippableWaitToken !== undefined) {
-            resolveSkipCurrentWaitResolvers(activeSkippableWaitToken);
+    function describePauseToggle(toggleResult) {
+        if (toggleResult === 'REQUESTED_PAUSE') {
+            return {
+                controlKey: 'P',
+                message: `Pause requested, pausing before ${getPauseTargetLabel()}`,
+                tone: 'warning',
+            };
         }
-        activeSkippableWaitToken = undefined;
-        isSkipCurrentWaitRequested = false;
-        SKIP_CURRENT_WAIT_RESOLVERS.clear();
-    }
-    /**
-     * Listens for the terminal control keys.
-     */
-    function listenForCoderRunControls() {
-        if (!process.stdin.isTTY) {
-            return;
+        if (toggleResult === 'CANCELLED_PAUSE') {
+            return {
+                controlKey: 'P',
+                message: 'Pause cancelled, the run continues',
+                tone: 'success',
+            };
         }
-        readline__namespace.emitKeypressEvents(process.stdin);
-        process.stdin.setRawMode(true);
-        process.stdin.on('keypress', (str, key) => {
-            if (key.ctrl && key.name === 'c') {
-                process.exit();
-            }
-            if (key.name === 'p') {
-                const toggleResult = togglePauseState();
-                if (toggleResult === 'REQUESTED_PAUSE') {
-                    // Note: Using console.log here which adds a new line.
-                    // This is intentional to prevent the message from being overwritten.
-                    console.log(colors__default["default"].bgWhite('Pausing...'));
-                }
-                else if (toggleResult === 'CANCELLED_PAUSE') {
-                    console.log(colors__default["default"].green('Pause cancelled. Resuming...'));
-                }
-            }
-            if (key.name === 's') {
-                if (requestSkipCurrentWait() === 'REQUESTED_SKIP') {
-                    console.log(colors__default["default"].green('Skipping current wait...'));
-                }
-            }
-            if (key.name === 'x') {
-                const toggleResult = toggleEndAfterCurrentPromptState();
-                if (toggleResult === 'REQUESTED_END') {
-                    console.log(colors__default["default"].yellow('Will end after the current prompt finishes.'));
-                }
-                else {
-                    console.log(colors__default["default"].green('End request cancelled. Continuing all prompts.'));
-                }
-            }
-        });
+        return {
+            controlKey: 'P',
+            message: 'Resuming the run',
+            tone: 'success',
+        };
     }
     /**
-     * If the execution is paused, it will wait until it is resumed.
+     * Describes what pressing `S` did.
      *
-     * @param options.silent - When `true`, suppresses console output (used when the terminal UI handles display).
-     * @param options.onPaused - Callback invoked when entering the PAUSED state.
-     * @param options.onResumed - Callback invoked when leaving the PAUSED state.
-     */
-    async function checkPause(options) {
-        var _a, _b;
-        if (pauseState === 'PAUSING') {
-            setPauseState('PAUSED');
-            if (!(options === null || options === void 0 ? void 0 : options.silent)) {
-                console.log(colors__default["default"].bgWhite.black(`Paused before ${getPauseTargetLabel()}`) +
-                    colors__default["default"].gray(' (Press "p" to resume)'));
-            }
-            (_a = options === null || options === void 0 ? void 0 : options.onPaused) === null || _a === void 0 ? void 0 : _a.call(options);
-            while (getPauseState() === 'PAUSED') {
-                await new Promise((resolve) => setTimeout(resolve, 100));
-            }
-            (_b = options === null || options === void 0 ? void 0 : options.onResumed) === null || _b === void 0 ? void 0 : _b.call(options);
-            if (!(options === null || options === void 0 ? void 0 : options.silent)) {
-                console.log(colors__default["default"].green('Resuming...'));
-            }
-        }
-    }
-    /**
-     * Returns the current pause state for external consumers such as the terminal UI.
+     * @private helper of `applyCoderRunControlKey`
      */
-    function getPauseState() {
-        return pauseState;
-    }
-    /**
-     * Returns the label of the next checkpoint where pausing will take effect.
-     */
-    function getPauseTargetLabel() {
-        return pauseTargetLabel;
-    }
-    /**
-     * Updates the label of the next pause checkpoint.
-     */
-    function announcePauseTargetLabel(nextPauseTargetLabel) {
-        setPauseTargetLabel(nextPauseTargetLabel);
-    }
-    /**
-     * Restores the default generic pause target label.
-     */
-    function resetPauseTargetLabel() {
-        setPauseTargetLabel(DEFAULT_PAUSE_TARGET_LABEL);
-    }
-    /**
-     * Requests a pause from an external controller (e.g. the Ink UI).
-     */
-    function requestPause() {
-        if (pauseState === 'RUNNING') {
-            setPauseState('PAUSING');
+    function describeSkipCurrentWait(skipResult) {
+        if (skipResult === 'REQUESTED_SKIP') {
+            return {
+                controlKey: 'S',
+                message: 'Skipping the current waiting, continuing right now',
+                tone: 'success',
+            };
         }
+        return {
+            controlKey: 'S',
+            message: 'Nothing to skip, the coder is not waiting right now',
+            tone: 'info',
+        };
     }
     /**
-     * Resumes execution from an external controller after a pause.
-     */
-    function requestResume() {
-        setPauseState('RUNNING');
-        resetPauseTargetLabel();
-    }
-    /**
-     * Gets or creates the resolver set for one timed wait.
+     * Describes what pressing `X` did.
+     *
+     * @private helper of `applyCoderRunControlKey`
      */
-    function getSkipCurrentWaitResolvers(waitToken) {
-        const existingResolvers = SKIP_CURRENT_WAIT_RESOLVERS.get(waitToken);
-        if (existingResolvers !== undefined) {
-            return existingResolvers;
+    function describeEndAfterCurrentPrompt(toggleResult) {
+        if (toggleResult === 'REQUESTED_END') {
+            return {
+                controlKey: 'X',
+                message: 'Ending after the current prompt finishes',
+                tone: 'warning',
+            };
         }
-        const resolvers = new Set();
-        SKIP_CURRENT_WAIT_RESOLVERS.set(waitToken, resolvers);
-        return resolvers;
+        return {
+            controlKey: 'X',
+            message: 'End cancelled, the whole queue will be processed',
+            tone: 'success',
+        };
     }
+
     /**
-     * Resolves all pending skip waiters for one timed wait.
+     * How long one control answer stays visible in the rich terminal UI.
+     *
+     * @private internal constant of `ptbk coder` terminal controls
      */
-    function resolveSkipCurrentWaitResolvers(waitToken) {
-        const resolvers = SKIP_CURRENT_WAIT_RESOLVERS.get(waitToken);
-        if (resolvers === undefined) {
-            return;
-        }
-        for (const resolver of resolvers) {
-            resolver();
-        }
-        resolvers.clear();
-    }
+    const CODER_RUN_CONTROL_FEEDBACK_DURATION_MS = 5000;
 
     /**
      * Human-readable label for a priority scope without any bounds.
@@ -27439,85 +27635,696 @@
     // Note: [🟡] Code for priority filtering [priorityFilter](scripts/run-codex-prompts/prompts/priorityFilter.ts) should never be published outside of `@promptbook/cli`
 
     /**
-     * Fixed left-side head used across all octopus frames.
+     * Minimum width used for the rich coder-run frame.
      */
-    const OCTOPUS_HEAD_LINES = [
-        colors__default["default"].magenta.bold('      .-""""-.'),
-        colors__default["default"].magenta.bold("    .'  .-.  '."),
-        `${colors__default["default"].magenta.bold('   /   (')}${colors__default["default"].yellow.bold('o o')}${colors__default["default"].magenta.bold(')   \\')}`,
-        colors__default["default"].magenta.bold('  |      ^      |'),
-        colors__default["default"].magenta.bold('  |   \\___/     |'),
-        colors__default["default"].magenta.bold('   \\___________/'),
-    ];
+    const MIN_FRAME_WIDTH = 56;
     /**
-     * Gap between the head silhouette and the animated tentacles.
+     * Maximum width used for the rich coder-run frame.
      */
-    const OCTOPUS_HEAD_TO_TENTACLE_GAP = '   ';
+    const MAX_FRAME_WIDTH = 96;
     /**
-     * Animated right-side tentacle poses.
+     * Builds the complete boxed terminal frame for the rich `ptbk coder run` UI.
      */
-    const OCTOPUS_TENTACLE_FRAMES = [
-        [
-            `                 ${colors__default["default"].green.bold('ptbk.io')}`,
-            colors__default["default"].cyan('          __      __'),
-            colors__default["default"].cyan('   _/\\/\\/  \\_/\\/  \\_/\\_'),
-            colors__default["default"].cyan('_/\\/  _   /\\/  _  /\\/\\__'),
-            colors__default["default"].cyan('\\__/ /_/\\/  \\_/ \\_/  \\_/'),
-            colors__default["default"].cyan('   /_/   \\__/   \\__/  /'),
-        ],
-        [
-            `                 ${colors__default["default"].green.bold('ptbk.io')}`,
-            colors__default["default"].cyan('          __      __'),
-            colors__default["default"].cyan('   _/\\/  \\_/\\/\\_  \\_/\\_'),
-            colors__default["default"].cyan('_/\\/  _  /\\/  _ \\/\\/  \\__'),
-            colors__default["default"].cyan('\\__/ /_/\\/  \\_/  \\_ /\\_/'),
-            colors__default["default"].cyan('     /_/  \\__/   \\__/  /'),
-        ],
-        [
-            `                 ${colors__default["default"].green.bold('ptbk.io')}`,
-            colors__default["default"].cyan('          __      __'),
-            colors__default["default"].cyan('   _/\\/\\/  \\_/\\_  \\_/\\_'),
-            colors__default["default"].cyan('_/\\/  _   /\\/  _  /\\/  \\_'),
-            colors__default["default"].cyan('\\__/ /_/\\/  \\_/ \\_/  _/'),
-            colors__default["default"].cyan('   /_/    \\__/    \\__/'),
-        ],
-        [
-            `                 ${colors__default["default"].green.bold('ptbk.io')}`,
-            colors__default["default"].cyan('          __      __'),
-            colors__default["default"].cyan('   _/\\/  \\_/\\/  \\_/\\/\\_'),
-            colors__default["default"].cyan('_/\\/  _  /\\/  _  /\\/\\  \\'),
-            colors__default["default"].cyan('\\__/ /_/\\/  \\_/ \\_  \\_/'),
-            colors__default["default"].cyan('    /_/   \\__/   \\__\\_/'),
-        ],
-    ];
+    function buildCoderRunUiFrame(options) {
+        const totalWidth = Math.max(MIN_FRAME_WIDTH, Math.min(options.terminalWidth, MAX_FRAME_WIDTH));
+        const isPromptActive = options.phase === 'running' || options.phase === 'verifying' || options.phase === 'loading';
+        const promptStatusPrefix = isPromptActive ? `${colors__default["default"].yellow(`${options.spinner} `)}` : '';
+        const pausePresentation = buildPausePresentation(options.phase, options.pauseState, options.pauseTargetLabel, options.statusMessage);
+        const sessionLines = buildSessionLines(options, totalWidth, pausePresentation);
+        const currentTaskLines = options.currentPromptLabel
+            ? [
+                `${promptStatusPrefix}${colors__default["default"].bold.white(fitPlainText(options.currentPromptLabel, totalWidth - 8))}`,
+                `Attempt ${options.currentAttempt}/${options.maxAttempts}  ·  ${options.statusMessage}`,
+                ...options.detailLines.map((detailLine) => `• ${detailLine}`),
+            ]
+            : [options.statusMessage, ...options.detailLines.map((detailLine) => `• ${detailLine}`)];
+        const visibleOutputLines = buildVisibleOutputLines(options.agentOutputLines);
+        const controlsBoxLines = buildControlsBoxLines({
+            controlPills: buildCoderRunControlPills({
+                phase: options.phase,
+                pauseControl: pausePresentation.pauseControl,
+                pendingEnterLabel: options.pendingEnterLabel,
+                isEndAfterCurrentPromptRequested: options.isEndAfterCurrentPromptRequested,
+                sessionTotal: options.progress.sessionTotal,
+            }),
+            controlFeedback: options.controlFeedback,
+        });
+        const frame = [
+            ...buildFrameHeaderVisual(options, totalWidth),
+            '',
+            ...renderBox('Session', sessionLines, totalWidth, colors__default["default"].yellow.bold),
+            ...renderBox(options.currentPromptLabel ? 'Current task' : 'Queue', currentTaskLines, totalWidth, colors__default["default"].magenta.bold),
+            ...renderBox('Live output', visibleOutputLines, totalWidth, colors__default["default"].green.bold),
+        ];
+        if (options.errors.length > 0) {
+            const bodyWidth = Math.max(10, totalWidth - 4);
+            frame.push(...renderBox('Errors', buildErrorDisplayLines(options.errors, bodyWidth), totalWidth, colors__default["default"].red.bold));
+        }
+        frame.push(...renderBox('Controls', controlsBoxLines, totalWidth, colors__default["default"].white.bold));
+        return frame;
+    }
     /**
-     * Builds the horizontal octopus illustration shown above the coder-run dashboard.
+     * Builds the header visual above the dashboard boxes.
+     *
+     * Shows the ASCII-art `--agent` avatar visual as soon as one is available. Until the avatar is
+     * loaded - and when no avatar can be rendered at all - the header stays empty, because the
+     * placeholder ASCII `PTBK.IO` wordmark only added terminal noise while nothing was rendered yet.
+     */
+    function buildFrameHeaderVisual(options, totalWidth) {
+        if (options.agentVisualLines !== undefined && options.agentVisualLines.length > 0) {
+            return options.agentVisualLines.map((agentVisualLine) => centerAnsiText(agentVisualLine, totalWidth));
+        }
+        if (options.agentVisual !== undefined) {
+            const agentVisualLines = options.agentVisual.renderFrame({
+                animationTimeMs: options.animationTimeMs,
+            });
+            if (agentVisualLines.length > 0) {
+                return agentVisualLines.map((agentVisualLine) => centerAnsiText(agentVisualLine, totalWidth));
+            }
+        }
+        return [];
+    }
+    /**
+     * Builds the structured session lines that combine state, runner, queue, and timing metadata.
+     */
+    function buildSessionLines(options, totalWidth, pausePresentation) {
+        const bodyWidth = Math.max(10, totalWidth - 4);
+        return buildSessionRows(options, bodyWidth, pausePresentation).map((sessionRow) => buildLabeledSessionLine(sessionRow.label, sessionRow.value, bodyWidth));
+    }
+    /**
+     * Builds the session rows so the renderer can keep one consistent structure without duplicating labels.
+     */
+    function buildSessionRows(options, bodyWidth, pausePresentation) {
+        const runnerParts = [options.config.agentName || 'No agent selected'];
+        if (options.config.modelName) {
+            runnerParts.push(options.config.modelName);
+        }
+        if (options.config.thinkingLevel) {
+            runnerParts.push(`thinking ${options.config.thinkingLevel}`);
+        }
+        const configurationRows = [
+            ...buildOptionalSessionRow('Context', options.config.context),
+            ...buildOptionalSessionRow('Server', options.config.serverUrl
+                ? buildTerminalUrlLink(options.config.serverUrl, bodyWidth - SESSION_LABEL_WIDTH - 1)
+                : undefined),
+            ...buildOptionalSessionRow('Test', options.config.testCommand),
+        ];
+        return [
+            {
+                label: 'State',
+                value: `${pausePresentation.badge} ${pausePresentation.stateMessage}`,
+            },
+            {
+                label: 'Runner',
+                value: runnerParts.join('  ·  '),
+            },
+            ...configurationRows,
+            ...buildScriptPathSessionRows(options.currentScriptPaths || [], bodyWidth),
+            {
+                label: 'This run',
+                value: buildThisRunSummary(options.progress),
+            },
+            {
+                label: 'Backlog',
+                value: buildBacklogSummary(options.progress),
+            },
+            {
+                label: 'Scope',
+                value: buildScopeSummary(options.progress, options.config),
+            },
+            {
+                label: 'Timing',
+                value: buildTimingSummary(options.progress),
+            },
+            {
+                label: 'Progress',
+                value: buildProgressBar$1(options.progress.percentage, bodyWidth - SESSION_LABEL_WIDTH - 1, `${options.progress.percentage}% complete (${options.progress.sessionDone}/${options.progress.sessionTotal} done)`),
+            },
+        ];
+    }
+    /**
+     * Builds zero or one structured session row for optional metadata.
+     */
+    function buildOptionalSessionRow(label, value) {
+        if (!value) {
+            return [];
+        }
+        return [{ label, value }];
+    }
+    /**
+     * Builds the active-session summary shown in the session box.
+     */
+    function buildThisRunSummary(progress) {
+        if (progress.sessionTotal === 0) {
+            return 'No runnable prompts in current scope';
+        }
+        return `Task ${progress.currentPromptIndex}/${progress.sessionTotal}  ·  ${progress.sessionDone} done  ·  ${progress.sessionRemaining} left`;
+    }
+    /**
+     * Builds the backlog/filter summary shown in the session box.
+     */
+    function buildBacklogSummary(progress) {
+        const parts = [`Repo ${progress.totalPrompts} total`];
+        if (progress.skippedPrompts > 0) {
+            parts.push(`${formatPromptCount$1(progress.skippedPrompts)} outside priority scope`);
+        }
+        return parts.join('  ·  ');
+    }
+    /**
+     * Builds the priority/write-order summary shown in the session box.
+     */
+    function buildScopeSummary(progress, config) {
+        var _a;
+        const parts = [formatPriorityFilter((_a = config.priorityFilter) !== null && _a !== void 0 ? _a : {})];
+        if (config.limit !== undefined) {
+            parts.push(`Limit ${formatPromptRunCount(config.limit)}`);
+        }
+        if (progress.toBeWrittenPrompts > 0) {
+            parts.push(`Write ${formatPromptCount$1(progress.toBeWrittenPrompts)} first`);
+        }
+        return parts.join('  ·  ');
+    }
+    /**
+     * Builds the elapsed/estimate summary shown in the session box.
+     */
+    function buildTimingSummary(progress) {
+        return `Elapsed ${progress.elapsedText}  ·  Total ${progress.estimatedTotalText}  ·  ETA ${progress.estimatedLabel}`;
+    }
+    /**
+     * Formats a prompt count with singular/plural wording.
+     */
+    function formatPromptCount$1(count) {
+        return `${count} prompt${count === 1 ? '' : 's'}`;
+    }
+    /**
+     * Formats a configured successful prompt-run limit with singular/plural wording.
+     */
+    function formatPromptRunCount(count) {
+        return `${count} prompt run${count === 1 ? '' : 's'}`;
+    }
+
+    /**
+     * ANSI sequence that clears the current terminal row.
+     *
+     * @private internal constant of coder run UI
+     */
+    const CLEAR_CURRENT_LINE = '\x1b[2K';
+    /**
+     * ANSI control character that moves the cursor to the start of its current row.
+     *
+     * @private internal constant of coder run UI
+     */
+    const MOVE_CURSOR_TO_LINE_START = '\r';
+    /**
+     * Builds one atomic ANSI update that changes the displayed coder-run terminal frame.
+     *
+     * A change in frame height requires a full rewrite to reserve or clear rows correctly. Frames with
+     * the same height only rewrite contiguous groups of changed rows, returning to the frame bottom
+     * between groups so each group can be assembled into the same output payload safely.
+     *
+     * @returns One terminal output payload, or `undefined` when the frame is already up to date.
      *
      * @private internal utility of coder run UI
      */
-    function buildCoderRunOctopusVisual(options) {
-        const tentacleFrame = OCTOPUS_TENTACLE_FRAMES[((options.animationFrame % OCTOPUS_TENTACLE_FRAMES.length) + OCTOPUS_TENTACLE_FRAMES.length) %
-            OCTOPUS_TENTACLE_FRAMES.length];
-        const visualLines = OCTOPUS_HEAD_LINES.map((headLine, lineIndex) => `${headLine}${OCTOPUS_HEAD_TO_TENTACLE_GAP}${tentacleFrame[lineIndex]}`);
-        const visualWidth = visualLines.reduce((maxWidth, line) => Math.max(maxWidth, visibleLength(line)), 0);
-        visualLines.map((line) => centerAnsiText(padAnsiText(line, visualWidth), options.totalWidth));
-        /*
-        Note: Octopus art should look better, now using just text
-        https://www.google.com/search?sca_esv=52e84acb78c558cc&sxsrf=ANbL-n7DVKf71T1HSPRpM-2skfMss0jh7w:1776693767588&udm=2&fbs=ADc_l-ZseckkBJUFopaGDNYa-HGjo4_b6b_a7pIHTL5Y9QnExg6xJqXbG7aOLcH8CWqOtkzCrjxXWZVmrIhYPvZzFDVUIb7oTJfuJ6idsCc5GA1j5KGoi2q3sW0uDBWWfYgbuxGWTQPZMetvj33BdP833wZm47mxW-6rC3bTQWluwJdOsgloPieyQvTfF2uNgIZ_K0KZ-WzpL1An8GuRrKqHdvl8T306FA&q=octopus&sa=X&ved=2ahUKEwil7ZCHzPyTAxUghP0HHY-_Js8QtKgLegQIOhAB&biw=1745&bih=903&dpr=1.1#sv=CAMSVhoyKhBlLVl1bHNmeVhneml6a1dNMg5ZdWxzZnlYZ3ppemtXTToOTVJvdXhTdk5STkZ4d00gBCocCgZtb3NhaWMSEGUtWXVsc2Z5WGd6aXprV00YADABGAcg46LBxA9KCBABGAEgASgB
-        https://www.mrgoodfish.com/wp-content/uploads/2022/09/Eledone_moschata__.png
-        https://fish-commercial-names.ec.europa.eu/fish-names/jakarta.faces.resource/pictograms/octopus_vulgaris.jpg.xhtml?ln=images
-        https://www.asciiart.eu/image-to-ascii
-        */
-        // Note: Created by https://patorjk.com/software/taag/#p=display&f=ANSI+Compact&t=ptbk.io&x=none&v=4&h=4&w=80&we=false
-        return _spaceTrim__default["default"](`                        
-                                   
-        ▄▄▄▄ ▄▄▄▄▄▄ ▄▄▄▄  ▄▄ ▄▄   ▄▄  ▄▄▄  
-        ██▄█▀  ██   ██▄██ ██▄█▀   ██ ██▀██ 
-        ██     ██   ██▄█▀ ██ ██ ▄ ██ ▀███▀ 
-                                            
-    `)
-            .split('\n')
-            .map((line) => centerAnsiText(line, options.totalWidth));
+    function buildCoderRunUiTerminalFrameUpdate(options) {
+        const { previousFrameLines, nextFrameLines } = options;
+        if (previousFrameLines.length === 0 && nextFrameLines.length === 0) {
+            return undefined;
+        }
+        if (previousFrameLines.length === 0 || previousFrameLines.length !== nextFrameLines.length) {
+            return buildFullCoderRunUiTerminalFrameUpdate(previousFrameLines, nextFrameLines);
+        }
+        return buildChangedCoderRunUiTerminalFrameUpdate(previousFrameLines, nextFrameLines);
+    }
+    /**
+     * Builds an ANSI update which completely rewrites the reserved terminal frame area.
+     *
+     * @private helper of `buildCoderRunUiTerminalFrameUpdate`
+     */
+    function buildFullCoderRunUiTerminalFrameUpdate(previousFrameLines, nextFrameLines) {
+        var _a;
+        const previousFrameLineCount = previousFrameLines.length;
+        const lineCountToRewrite = Math.max(previousFrameLineCount, nextFrameLines.length);
+        const outputParts = [];
+        if (previousFrameLineCount > 1) {
+            outputParts.push(moveCursorUp(previousFrameLineCount - 1));
+        }
+        for (let lineIndex = 0; lineIndex < lineCountToRewrite; lineIndex++) {
+            outputParts.push(CLEAR_CURRENT_LINE, MOVE_CURSOR_TO_LINE_START, (_a = nextFrameLines[lineIndex]) !== null && _a !== void 0 ? _a : '');
+            if (lineIndex < lineCountToRewrite - 1) {
+                outputParts.push('\n');
+            }
+        }
+        const clearedTrailingLineCount = lineCountToRewrite - nextFrameLines.length;
+        if (clearedTrailingLineCount > 0) {
+            outputParts.push(moveCursorUp(clearedTrailingLineCount));
+        }
+        outputParts.push(MOVE_CURSOR_TO_LINE_START);
+        return outputParts.join('');
+    }
+    /**
+     * Builds an ANSI update that rewrites only contiguous groups of rows which changed.
+     *
+     * @private helper of `buildCoderRunUiTerminalFrameUpdate`
+     */
+    function buildChangedCoderRunUiTerminalFrameUpdate(previousFrameLines, nextFrameLines) {
+        const outputParts = [];
+        let lineIndex = 0;
+        while (lineIndex < nextFrameLines.length) {
+            if (previousFrameLines[lineIndex] === nextFrameLines[lineIndex]) {
+                lineIndex++;
+                continue;
+            }
+            const changedRangeStartLineIndex = lineIndex;
+            while (lineIndex + 1 < nextFrameLines.length &&
+                previousFrameLines[lineIndex + 1] !== nextFrameLines[lineIndex + 1]) {
+                lineIndex++;
+            }
+            appendChangedCoderRunUiTerminalFrameRange({
+                outputParts,
+                frameLineCount: nextFrameLines.length,
+                changedRangeStartLineIndex,
+                changedRangeEndLineIndex: lineIndex,
+                nextFrameLines,
+            });
+            lineIndex++;
+        }
+        return outputParts.length === 0 ? undefined : outputParts.join('');
+    }
+    /**
+     * Appends the cursor movements and row rewrites for one contiguous changed frame range.
+     *
+     * @private helper of `buildChangedCoderRunUiTerminalFrameUpdate`
+     */
+    function appendChangedCoderRunUiTerminalFrameRange(options) {
+        const { outputParts, frameLineCount, changedRangeStartLineIndex, changedRangeEndLineIndex, nextFrameLines } = options;
+        const linesUpFromFrameBottom = frameLineCount - 1 - changedRangeStartLineIndex;
+        if (linesUpFromFrameBottom > 0) {
+            outputParts.push(moveCursorUp(linesUpFromFrameBottom));
+        }
+        for (let lineIndex = changedRangeStartLineIndex; lineIndex <= changedRangeEndLineIndex; lineIndex++) {
+            outputParts.push(CLEAR_CURRENT_LINE, MOVE_CURSOR_TO_LINE_START, nextFrameLines[lineIndex]);
+            if (lineIndex < changedRangeEndLineIndex) {
+                outputParts.push('\n');
+            }
+        }
+        const linesDownToFrameBottom = frameLineCount - 1 - changedRangeEndLineIndex;
+        if (linesDownToFrameBottom > 0) {
+            outputParts.push(moveCursorDown(linesDownToFrameBottom));
+        }
+        outputParts.push(MOVE_CURSOR_TO_LINE_START);
+    }
+    /**
+     * Builds an ANSI sequence which moves the terminal cursor up by a positive number of rows.
+     *
+     * @private helper of `buildCoderRunUiTerminalFrameUpdate`
+     */
+    function moveCursorUp(lineCount) {
+        return `\x1b[${lineCount}A`;
+    }
+    /**
+     * Builds an ANSI sequence which moves the terminal cursor down by a positive number of rows.
+     *
+     * @private helper of `buildCoderRunUiTerminalFrameUpdate`
+     */
+    function moveCursorDown(lineCount) {
+        return `\x1b[${lineCount}B`;
+    }
+
+    /**
+     * Calendar formats used when displaying the estimated completion time.
+     *
+     * Uses 24-hour format (`HH:mm`) so estimates are unambiguous (for example `17:30` instead of `5:30`).
+     */
+    const ESTIMATED_DONE_CALENDAR_FORMATS = {
+        sameDay: '[Today] HH:mm',
+        nextDay: '[Tomorrow] HH:mm',
+        nextWeek: 'dddd HH:mm',
+        lastDay: '[Yesterday] HH:mm',
+        lastWeek: 'dddd HH:mm',
+        sameElse: 'MMM D HH: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.
+     *
+     * When the current session has not finished any prompt yet but a `cachedAveragePromptDurationMs` is
+     * provided (loaded from the per-config estimate cache stored in the temp folder), the snapshot uses
+     * that historical average to project the remaining work instead of waiting for the first completion.
+     */
+    function buildCoderRunProgressSnapshot(stats, elapsedDuration, initialDone, cachedAveragePromptDurationMs, runLimit) {
+        const totalPrompts = stats.done + stats.forAgent + stats.toBeWritten;
+        const completedSessionPrompts = Math.max(0, stats.done - initialDone);
+        const availableSessionTotal = completedSessionPrompts + stats.forAgent;
+        const sessionTotal = resolveSessionTotal(availableSessionTotal, runLimit);
+        const sessionDone = Math.min(completedSessionPrompts, sessionTotal);
+        const sessionRemaining = Math.max(0, sessionTotal - sessionDone);
+        const currentPromptIndex = sessionTotal > 0 ? Math.min(sessionDone + 1, sessionTotal) : 0;
+        const percentage = sessionTotal > 0 ? Math.round((sessionDone / sessionTotal) * 100) : 0;
+        const elapsedText = formatDurationBrief(elapsedDuration);
+        const elapsedMs = elapsedDuration.asMilliseconds();
+        let estimatedTotalText = 'estimating...';
+        let estimatedLabel = 'after first completion';
+        let isEstimatedTotalKnown = false;
+        let estimatedTotalMs;
+        if (sessionTotal > 0 && sessionDone > 0) {
+            estimatedTotalMs = (elapsedMs * sessionTotal) / sessionDone;
+        }
+        else if (sessionTotal > 0 &&
+            cachedAveragePromptDurationMs !== undefined &&
+            cachedAveragePromptDurationMs > 0) {
+            const projectedRemainingMs = sessionRemaining * cachedAveragePromptDurationMs;
+            estimatedTotalMs = elapsedMs + projectedRemainingMs;
+        }
+        if (estimatedTotalMs !== undefined) {
+            const estimatedRemainingMs = Math.max(0, estimatedTotalMs - elapsedMs);
+            const estimatedTotalDuration = moment__default["default"].duration(estimatedTotalMs);
+            const estimatedCompletion = moment__default["default"]().add(estimatedRemainingMs, 'milliseconds');
+            estimatedTotalText = formatDurationBrief(estimatedTotalDuration);
+            estimatedLabel = estimatedCompletion.calendar(null, ESTIMATED_DONE_CALENDAR_FORMATS);
+            isEstimatedTotalKnown = true;
+        }
+        return {
+            totalPrompts,
+            sessionDone,
+            sessionRemaining,
+            sessionTotal,
+            currentPromptIndex,
+            skippedPrompts: stats.outsidePriorityRange,
+            toBeWrittenPrompts: stats.toBeWritten,
+            percentage,
+            elapsedText,
+            estimatedTotalText,
+            estimatedLabel,
+            isEstimatedTotalKnown,
+        };
+    }
+    /**
+     * Resolves the number of prompt runs represented by the current session progress.
+     */
+    function resolveSessionTotal(availableSessionTotal, runLimit) {
+        if (runLimit === undefined) {
+            return availableSessionTotal;
+        }
+        return Math.min(availableSessionTotal, runLimit);
+    }
+
+    /**
+     * Tracks active coder-run time while excluding pauses and user-confirmation waits.
+     */
+    class CoderRunTimer {
+        /**
+         * Creates a timer anchored at the provided start time.
+         */
+        constructor(startTime, isPausedInitially = false) {
+            this.startTime = startTime;
+            /**
+             * Total milliseconds spent in paused state across the run.
+             */
+            this.pausedMs = 0;
+            if (isPausedInitially) {
+                this.pausedSince = startTime.clone();
+            }
+        }
+        /**
+         * Pauses active-time tracking until `resume()` is called.
+         */
+        pause() {
+            if (this.pausedSince === undefined) {
+                this.pausedSince = moment__default["default"]();
+            }
+        }
+        /**
+         * Resumes active-time tracking after a pause.
+         */
+        resume() {
+            if (this.pausedSince !== undefined) {
+                this.pausedMs += moment__default["default"]().diff(this.pausedSince);
+                this.pausedSince = undefined;
+            }
+        }
+        /**
+         * Returns the currently accumulated active duration.
+         */
+        getElapsedDuration() {
+            const wallMs = moment__default["default"]().diff(this.startTime);
+            const currentPauseMs = this.pausedSince !== undefined ? moment__default["default"]().diff(this.pausedSince) : 0;
+            return moment__default["default"].duration(Math.max(0, wallMs - this.pausedMs - currentPauseMs));
+        }
+    }
+
+    /**
+     * Maximum number of agent output lines kept in the scrolling output area.
+     *
+     * @private internal constant of coder run UI
+     */
+    const MAX_AGENT_OUTPUT_LINES = 12;
+    /**
+     * Reactive state manager for the coder run terminal UI.
+     *
+     * Holds all data the Ink components need and emits `'change'` events
+     * whenever any property is updated so the UI can re-render.
+     *
+     * @private internal utility of coder run UI
+     */
+    class CoderRunUiState extends events.EventEmitter {
+        constructor(startTime) {
+            super();
+            this.config = { agentName: '' };
+            this.currentPromptLabel = '';
+            this.currentScriptPaths = [];
+            this.currentAttempt = 1;
+            this.maxAttempts = 3;
+            this.detailLines = [];
+            this.messagePreviewLines = [];
+            this.messagePreviewSections = [];
+            this.agentStatusLines = [];
+            this.agentStatusTableRows = [];
+            this.agentOutputLines = [];
+            this.phase = 'initializing';
+            this.statusMessage = 'Initializing...';
+            this.errors = [];
+            this.stats = { done: 0, forAgent: 0, outsidePriorityRange: 0, toBeWritten: 0 };
+            // Match the plain CLI progress header and count active run time from startup.
+            // Explicit waits/pauses are excluded later through `pauseTimer()` / `resumeTimer()`.
+            this.timer = new CoderRunTimer(startTime);
+        }
+        /**
+         * Pauses the elapsed timer (e.g. while waiting for user input or paused state).
+         */
+        pauseTimer() {
+            this.timer.pause();
+            this.emitChange();
+        }
+        /**
+         * Resumes the elapsed timer after a pause.
+         */
+        resumeTimer() {
+            this.timer.resume();
+            this.emitChange();
+        }
+        /**
+         * Replaces the configuration shown in the UI header.
+         */
+        setConfig(config) {
+            this.config = config;
+            this.emitChange();
+        }
+        /**
+         * Replaces the ASCII-art agent visual renderer shown above the dashboard boxes.
+         */
+        setAgentVisual(agentVisual) {
+            this.agentVisual = agentVisual;
+            this.emitChange();
+        }
+        /**
+         * Feeds new prompt statistics from the main loop so the progress bar updates.
+         */
+        updateProgress(stats) {
+            if (this.initialDone === undefined && (stats.done > 0 || stats.forAgent > 0 || stats.toBeWritten > 0)) {
+                this.initialDone = stats.done;
+            }
+            this.stats = stats;
+            this.emitChange();
+        }
+        /**
+         * Sets the cached average prompt duration (in milliseconds) loaded from the temp-folder estimate cache.
+         *
+         * Used to project completion estimates before the first prompt of the current session finishes.
+         */
+        setCachedAveragePromptDurationMs(cachedAveragePromptDurationMs) {
+            this.cachedAveragePromptDurationMs = cachedAveragePromptDurationMs;
+            this.emitChange();
+        }
+        /**
+         * Computes a progress snapshot on demand so elapsed time ticks with periodic re-renders.
+         */
+        getProgress() {
+            var _a;
+            return buildCoderRunProgressSnapshot(this.stats, this.timer.getElapsedDuration(), (_a = this.initialDone) !== null && _a !== void 0 ? _a : this.stats.done, this.cachedAveragePromptDurationMs, this.config.limit);
+        }
+        /**
+         * Sets the label of the prompt currently being processed and resets per-prompt state.
+         */
+        setCurrentPrompt(label) {
+            this.currentPromptLabel = label;
+            this.currentScriptPaths = [];
+            this.detailLines = [];
+            this.messagePreviewLines = [];
+            this.messagePreviewSections = [];
+            this.pendingEnterLabel = undefined;
+            this.agentOutputLines = [];
+            this.currentAttempt = 1;
+            this.emitChange();
+        }
+        /**
+         * Sets the temporary shell script currently used by the active prompt.
+         */
+        setCurrentScriptPath(scriptPath) {
+            this.currentScriptPaths = scriptPath ? [scriptPath] : [];
+            this.emitChange();
+        }
+        /**
+         * Sets multiple temporary shell scripts used by a shared multi-agent session.
+         */
+        setCurrentScriptPaths(scriptPaths) {
+            this.currentScriptPaths = [...scriptPaths];
+            this.emitChange();
+        }
+        /**
+         * Updates the current retry attempt number.
+         */
+        setAttempt(attempt) {
+            this.currentAttempt = attempt;
+            this.emitChange();
+        }
+        /**
+         * Appends raw agent output text, keeping only the last `MAX_AGENT_OUTPUT_LINES`.
+         */
+        addAgentOutput(text) {
+            const lines = text.split(/\r?\n/).filter((line) => line.trim() !== '');
+            if (lines.length === 0) {
+                return;
+            }
+            this.agentOutputLines.push(...lines);
+            if (this.agentOutputLines.length > MAX_AGENT_OUTPUT_LINES) {
+                this.agentOutputLines = this.agentOutputLines.slice(-MAX_AGENT_OUTPUT_LINES);
+            }
+            this.emitChange();
+        }
+        /**
+         * Transitions the execution phase shown in the UI.
+         */
+        setPhase(phase) {
+            this.phase = phase;
+            this.emitChange();
+        }
+        /**
+         * Updates the status message line beneath the current prompt label.
+         */
+        setStatusMessage(message) {
+            this.statusMessage = message;
+            this.emitChange();
+        }
+        /**
+         * Replaces the contextual detail lines shown beneath the current prompt status.
+         */
+        setDetailLines(detailLines) {
+            this.detailLines = detailLines.filter((detailLine) => detailLine.trim() !== '');
+            this.emitChange();
+        }
+        /**
+         * Replaces the exact user-message preview lines shown in agent-specific panels.
+         */
+        setMessagePreviewLines(messagePreviewLines) {
+            this.messagePreviewLines = [...messagePreviewLines];
+            this.emitChange();
+        }
+        /**
+         * Replaces the structured user-message panels shown in agent-specific dashboards.
+         */
+        setMessagePreviewSections(messagePreviewSections) {
+            this.messagePreviewSections = [...messagePreviewSections];
+            this.emitChange();
+        }
+        /**
+         * Replaces agent status rows shown by agent-specific terminal frames.
+         */
+        setAgentStatusLines(agentStatusLines) {
+            this.agentStatusLines = [...agentStatusLines];
+            this.emitChange();
+        }
+        /**
+         * Replaces structured agent status rows shown by agent-specific terminal frames.
+         */
+        setAgentStatusTableRows(agentStatusTableRows) {
+            this.agentStatusTableRows = [...agentStatusTableRows];
+            this.emitChange();
+        }
+        /**
+         * Sets or clears the Enter-key action label shown in the controls panel.
+         */
+        setPendingEnterLabel(pendingEnterLabel) {
+            this.pendingEnterLabel = pendingEnterLabel;
+            this.emitChange();
+        }
+        /**
+         * Shows the answer of the runner to one pressed control key, or clears the currently shown one.
+         *
+         * Pressing one control twice in a row can produce the very same answer, for example when there is
+         * nothing to skip. The repeat count is therefore tracked here, so that even such a press changes the
+         * rendered frame and the user always sees that the key arrived.
+         */
+        setControlFeedback(controlFeedback) {
+            this.controlFeedback =
+                controlFeedback === undefined
+                    ? undefined
+                    : { ...controlFeedback, repeatCount: this.countControlFeedbackRepeat(controlFeedback) };
+            this.emitChange();
+        }
+        /**
+         * Appends an error message to the error list shown in the UI.
+         */
+        addError(errorMessage) {
+            this.errors.push(errorMessage);
+            this.emitChange();
+        }
+        /**
+         * Counts how many times the shown answer repeats the previously shown one.
+         */
+        countControlFeedbackRepeat(controlFeedback) {
+            const previousControlFeedback = this.controlFeedback;
+            const isSameControlFeedback = previousControlFeedback !== undefined &&
+                previousControlFeedback.controlKey === controlFeedback.controlKey &&
+                previousControlFeedback.message === controlFeedback.message;
+            return isSameControlFeedback ? previousControlFeedback.repeatCount + 1 : 1;
+        }
+        emitChange() {
+            this.emit('change');
+        }
     }
 
     /**
@@ -28187,807 +28994,139 @@
      * @param options Agent source, canvas factory, and optional terminal color settings.
      * @returns Runtime terminal avatar visual renderer.
      *
-     * @private shared helper for terminal avatar rendering
-     */
-    function createTerminalAgentAvatarVisual(options) {
-        const renderInputs = createTerminalAgentAvatarVisualRenderInputs(options.agentSource, options.defaultAvatarVisualId || DEFAULT_AGENT_AVATAR_VISUAL_ID);
-        return {
-            isAnimated: renderInputs.resolvedAvatarRenderDefinition.avatarVisual.isAnimated,
-            renderFrame({ animationTimeMs }) {
-                return renderTerminalAgentAvatarVisualFrame({
-                    ...renderInputs,
-                    animationTimeMs,
-                    colorDepth: options.colorDepth,
-                    createCanvas: options.createCanvas,
-                });
-            },
-        };
-    }
-    /**
-     * Creates stable avatar render inputs from one agent source.
-     *
-     * @private shared helper for terminal avatar rendering
-     */
-    function createTerminalAgentAvatarVisualRenderInputs(agentSource, defaultAvatarVisualId) {
-        const agentBasicInformation = parseAgentSource(agentSource);
-        const avatarDefinition = createAvatarDefinitionFromAgentBasicInformation(agentBasicInformation);
-        const avatarVisualId = resolveTerminalAgentAvatarVisualIdFromAgentBasicInformation(agentBasicInformation, defaultAvatarVisualId);
-        const resolvedAvatarRenderDefinition = resolveAvatarRenderDefinition({
-            avatarDefinition,
-            visualId: avatarVisualId,
-            surface: 'transparent',
-        });
-        return {
-            avatarDefinition,
-            avatarVisualId,
-            resolvedAvatarRenderDefinition,
-        };
-    }
-    /**
-     * Resolves the terminal avatar visual id from already parsed agent information.
-     *
-     * @private shared helper for terminal avatar rendering
-     */
-    function resolveTerminalAgentAvatarVisualIdFromAgentBasicInformation(agentBasicInformation, defaultAvatarVisualId) {
-        return resolveAgentAvatarVisualId(agentBasicInformation, resolveAvatarVisualId(agentBasicInformation.meta.visual) || defaultAvatarVisualId);
-    }
-    /**
-     * Renders one terminal avatar frame through the shared avatar-to-ASCII pipeline.
-     *
-     * Visuals which are made of characters themselves, for example `AsciiOctopus`, paint the terminal
-     * character grid directly, because rasterizing them into half-block ASCII art averages every glyph
-     * away and makes them indistinguishable from the other blob-shaped visuals.
-     *
-     * @private shared helper for terminal avatar rendering
-     */
-    function renderTerminalAgentAvatarVisualFrame(options) {
-        const terminalTextLines = renderAvatarVisualTerminalTextLines({
-            avatarDefinition: options.avatarDefinition,
-            visualId: options.avatarVisualId,
-            surface: 'transparent',
-            columns: TERMINAL_AGENT_AVATAR_VISUAL_COLUMNS,
-            rows: TERMINAL_AGENT_AVATAR_VISUAL_ROWS,
-            colorDepth: options.colorDepth,
-            timeMs: options.animationTimeMs,
-            resolvedAvatarRenderDefinition: options.resolvedAvatarRenderDefinition,
-        });
-        if (terminalTextLines !== null) {
-            return terminalTextLines;
-        }
-        if (options.createCanvas === undefined) {
-            // Note: A pixel-based visual cannot be rasterized without a canvas, so the caller keeps its default banner
-            return [];
-        }
-        return renderAvatarVisualAsciiArt({
-            avatarDefinition: options.avatarDefinition,
-            visualId: options.avatarVisualId,
-            surface: 'transparent',
-            columns: TERMINAL_AGENT_AVATAR_VISUAL_COLUMNS,
-            rows: TERMINAL_AGENT_AVATAR_VISUAL_ROWS,
-            canvasWidth: TERMINAL_AGENT_AVATAR_VISUAL_CANVAS_WIDTH,
-            canvasHeight: TERMINAL_AGENT_AVATAR_VISUAL_CANVAS_HEIGHT,
-            colorDepth: options.colorDepth,
-            timeMs: options.animationTimeMs,
-            createCanvas: options.createCanvas,
-            resolvedAvatarRenderDefinition: options.resolvedAvatarRenderDefinition,
-        });
-    }
-
-    /**
-     * Refresh cadence used only while the rich coder UI needs animated updates.
-     *
-     * @private internal constant of coder run UI
-     */
-    const ACTIVE_CODER_RUN_UI_REFRESH_INTERVAL_MS = TERMINAL_AGENT_AVATAR_VISUAL_REFRESH_INTERVAL_MS;
-    /**
-     * 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 AUTO_REFRESH_PHASES = ['initializing', 'loading', 'running', 'verifying'];
-    /**
-     * Phases where an animated `--agent` visual should keep rendering like it does on the web.
-     *
-     * @private internal constant of coder run UI
-     */
-    const AGENT_VISUAL_AUTO_REFRESH_PHASES = [...AUTO_REFRESH_PHASES, 'waiting'];
-    /**
-     * Returns whether the rich coder UI should keep animating on its own.
-     *
-     * @private internal utility of coder run UI
-     */
-    function isCoderRunUiAutoRefreshing(phase, pauseState, isAgentVisualAnimated = false) {
-        // `PAUSING` still means the current task is winding down, so keep active
-        // animations/timers running until the runner reaches the fully paused state.
-        if (pauseState === 'PAUSED') {
-            return false;
-        }
-        if (isAgentVisualAnimated) {
-            return AGENT_VISUAL_AUTO_REFRESH_PHASES.includes(phase);
-        }
-        return AUTO_REFRESH_PHASES.includes(phase);
-    }
-    /**
-     * Returns the automatic refresh interval for the current UI state.
-     *
-     * 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
-     */
-    function getCoderRunUiAutoRefreshInterval(phase, pauseState, isAgentVisualAnimated = false) {
-        return isCoderRunUiAutoRefreshing(phase, pauseState, isAgentVisualAnimated)
-            ? ACTIVE_CODER_RUN_UI_REFRESH_INTERVAL_MS
-            : undefined;
-    }
-
-    /**
-     * Minimum width used for the rich coder-run frame.
-     */
-    const MIN_FRAME_WIDTH = 56;
-    /**
-     * Maximum width used for the rich coder-run frame.
-     */
-    const MAX_FRAME_WIDTH = 96;
-    /**
-     * Builds the complete boxed terminal frame for the rich `ptbk coder run` UI.
-     */
-    function buildCoderRunUiFrame(options) {
-        const totalWidth = Math.max(MIN_FRAME_WIDTH, Math.min(options.terminalWidth, MAX_FRAME_WIDTH));
-        const isPromptActive = options.phase === 'running' || options.phase === 'verifying' || options.phase === 'loading';
-        const promptStatusPrefix = isPromptActive ? `${colors__default["default"].yellow(`${options.spinner} `)}` : '';
-        const octopusAnimationFrame = isCoderRunUiAutoRefreshing(options.phase, options.pauseState)
-            ? options.animationFrame
-            : 0;
-        const pausePresentation = buildPausePresentation(options.phase, options.pauseState, options.pauseTargetLabel, options.statusMessage);
-        const sessionLines = buildSessionLines(options, totalWidth, pausePresentation);
-        const currentTaskLines = options.currentPromptLabel
-            ? [
-                `${promptStatusPrefix}${colors__default["default"].bold.white(fitPlainText(options.currentPromptLabel, totalWidth - 8))}`,
-                `Attempt ${options.currentAttempt}/${options.maxAttempts}  ·  ${options.statusMessage}`,
-                ...options.detailLines.map((detailLine) => `• ${detailLine}`),
-            ]
-            : [options.statusMessage, ...options.detailLines.map((detailLine) => `• ${detailLine}`)];
-        const visibleOutputLines = buildVisibleOutputLines(options.agentOutputLines);
-        const controls = buildCoderRunControlPills({
-            phase: options.phase,
-            pauseControl: pausePresentation.pauseControl,
-            pendingEnterLabel: options.pendingEnterLabel,
-            isEndAfterCurrentPromptRequested: options.isEndAfterCurrentPromptRequested,
-            sessionTotal: options.progress.sessionTotal,
-        }).join('  ');
-        const frame = [
-            ...buildFrameHeaderVisual(options, totalWidth, octopusAnimationFrame),
-            '',
-            ...renderBox('Session', sessionLines, totalWidth, colors__default["default"].yellow.bold),
-            ...renderBox(options.currentPromptLabel ? 'Current task' : 'Queue', currentTaskLines, totalWidth, colors__default["default"].magenta.bold),
-            ...renderBox('Live output', visibleOutputLines, totalWidth, colors__default["default"].green.bold),
-        ];
-        if (options.errors.length > 0) {
-            const bodyWidth = Math.max(10, totalWidth - 4);
-            frame.push(...renderBox('Errors', buildErrorDisplayLines(options.errors, bodyWidth), totalWidth, colors__default["default"].red.bold));
-        }
-        frame.push(...renderBox('Controls', [controls], totalWidth, colors__default["default"].white.bold));
-        return frame;
-    }
-    /**
-     * Builds the header visual above the dashboard boxes.
-     *
-     * Shows the ASCII-art `--agent` avatar visual when one is available and
-     * falls back to the default brand banner otherwise.
-     */
-    function buildFrameHeaderVisual(options, totalWidth, octopusAnimationFrame) {
-        if (options.agentVisualLines !== undefined && options.agentVisualLines.length > 0) {
-            return options.agentVisualLines.map((agentVisualLine) => centerAnsiText(agentVisualLine, totalWidth));
-        }
-        if (options.agentVisual !== undefined) {
-            const agentVisualLines = options.agentVisual.renderFrame({
-                animationTimeMs: options.animationTimeMs,
-            });
-            if (agentVisualLines.length > 0) {
-                return agentVisualLines.map((agentVisualLine) => centerAnsiText(agentVisualLine, totalWidth));
-            }
-        }
-        return buildCoderRunOctopusVisual({ totalWidth, animationFrame: octopusAnimationFrame });
-    }
-    /**
-     * Builds the structured session lines that combine state, runner, queue, and timing metadata.
-     */
-    function buildSessionLines(options, totalWidth, pausePresentation) {
-        const bodyWidth = Math.max(10, totalWidth - 4);
-        return buildSessionRows(options, bodyWidth, pausePresentation).map((sessionRow) => buildLabeledSessionLine(sessionRow.label, sessionRow.value, bodyWidth));
-    }
-    /**
-     * Builds the session rows so the renderer can keep one consistent structure without duplicating labels.
-     */
-    function buildSessionRows(options, bodyWidth, pausePresentation) {
-        const runnerParts = [options.config.agentName || 'No agent selected'];
-        if (options.config.modelName) {
-            runnerParts.push(options.config.modelName);
-        }
-        if (options.config.thinkingLevel) {
-            runnerParts.push(`thinking ${options.config.thinkingLevel}`);
-        }
-        const configurationRows = [
-            ...buildOptionalSessionRow('Context', options.config.context),
-            ...buildOptionalSessionRow('Server', options.config.serverUrl
-                ? buildTerminalUrlLink(options.config.serverUrl, bodyWidth - SESSION_LABEL_WIDTH - 1)
-                : undefined),
-            ...buildOptionalSessionRow('Test', options.config.testCommand),
-        ];
-        return [
-            {
-                label: 'State',
-                value: `${pausePresentation.badge} ${pausePresentation.stateMessage}`,
-            },
-            {
-                label: 'Runner',
-                value: runnerParts.join('  ·  '),
-            },
-            ...configurationRows,
-            ...buildScriptPathSessionRows(options.currentScriptPaths || [], bodyWidth),
-            {
-                label: 'This run',
-                value: buildThisRunSummary(options.progress),
-            },
-            {
-                label: 'Backlog',
-                value: buildBacklogSummary(options.progress),
-            },
-            {
-                label: 'Scope',
-                value: buildScopeSummary(options.progress, options.config),
-            },
-            {
-                label: 'Timing',
-                value: buildTimingSummary(options.progress),
-            },
-            {
-                label: 'Progress',
-                value: buildProgressBar$1(options.progress.percentage, bodyWidth - SESSION_LABEL_WIDTH - 1, `${options.progress.percentage}% complete (${options.progress.sessionDone}/${options.progress.sessionTotal} done)`),
-            },
-        ];
-    }
-    /**
-     * Builds zero or one structured session row for optional metadata.
-     */
-    function buildOptionalSessionRow(label, value) {
-        if (!value) {
-            return [];
-        }
-        return [{ label, value }];
-    }
-    /**
-     * Builds the active-session summary shown in the session box.
-     */
-    function buildThisRunSummary(progress) {
-        if (progress.sessionTotal === 0) {
-            return 'No runnable prompts in current scope';
-        }
-        return `Task ${progress.currentPromptIndex}/${progress.sessionTotal}  ·  ${progress.sessionDone} done  ·  ${progress.sessionRemaining} left`;
-    }
-    /**
-     * Builds the backlog/filter summary shown in the session box.
-     */
-    function buildBacklogSummary(progress) {
-        const parts = [`Repo ${progress.totalPrompts} total`];
-        if (progress.skippedPrompts > 0) {
-            parts.push(`${formatPromptCount$1(progress.skippedPrompts)} outside priority scope`);
-        }
-        return parts.join('  ·  ');
-    }
-    /**
-     * Builds the priority/write-order summary shown in the session box.
-     */
-    function buildScopeSummary(progress, config) {
-        var _a;
-        const parts = [formatPriorityFilter((_a = config.priorityFilter) !== null && _a !== void 0 ? _a : {})];
-        if (config.limit !== undefined) {
-            parts.push(`Limit ${formatPromptRunCount(config.limit)}`);
-        }
-        if (progress.toBeWrittenPrompts > 0) {
-            parts.push(`Write ${formatPromptCount$1(progress.toBeWrittenPrompts)} first`);
-        }
-        return parts.join('  ·  ');
-    }
-    /**
-     * Builds the elapsed/estimate summary shown in the session box.
-     */
-    function buildTimingSummary(progress) {
-        return `Elapsed ${progress.elapsedText}  ·  Total ${progress.estimatedTotalText}  ·  ETA ${progress.estimatedLabel}`;
-    }
-    /**
-     * Formats a prompt count with singular/plural wording.
-     */
-    function formatPromptCount$1(count) {
-        return `${count} prompt${count === 1 ? '' : 's'}`;
-    }
-    /**
-     * Formats a configured successful prompt-run limit with singular/plural wording.
-     */
-    function formatPromptRunCount(count) {
-        return `${count} prompt run${count === 1 ? '' : 's'}`;
-    }
-
-    /**
-     * ANSI sequence that clears the current terminal row.
-     *
-     * @private internal constant of coder run UI
-     */
-    const CLEAR_CURRENT_LINE = '\x1b[2K';
-    /**
-     * ANSI control character that moves the cursor to the start of its current row.
-     *
-     * @private internal constant of coder run UI
-     */
-    const MOVE_CURSOR_TO_LINE_START = '\r';
-    /**
-     * Builds one atomic ANSI update that changes the displayed coder-run terminal frame.
-     *
-     * A change in frame height requires a full rewrite to reserve or clear rows correctly. Frames with
-     * the same height only rewrite contiguous groups of changed rows, returning to the frame bottom
-     * between groups so each group can be assembled into the same output payload safely.
-     *
-     * @returns One terminal output payload, or `undefined` when the frame is already up to date.
-     *
-     * @private internal utility of coder run UI
-     */
-    function buildCoderRunUiTerminalFrameUpdate(options) {
-        const { previousFrameLines, nextFrameLines } = options;
-        if (previousFrameLines.length === 0 && nextFrameLines.length === 0) {
-            return undefined;
-        }
-        if (previousFrameLines.length === 0 || previousFrameLines.length !== nextFrameLines.length) {
-            return buildFullCoderRunUiTerminalFrameUpdate(previousFrameLines, nextFrameLines);
-        }
-        return buildChangedCoderRunUiTerminalFrameUpdate(previousFrameLines, nextFrameLines);
-    }
-    /**
-     * Builds an ANSI update which completely rewrites the reserved terminal frame area.
-     *
-     * @private helper of `buildCoderRunUiTerminalFrameUpdate`
-     */
-    function buildFullCoderRunUiTerminalFrameUpdate(previousFrameLines, nextFrameLines) {
-        var _a;
-        const previousFrameLineCount = previousFrameLines.length;
-        const lineCountToRewrite = Math.max(previousFrameLineCount, nextFrameLines.length);
-        const outputParts = [];
-        if (previousFrameLineCount > 1) {
-            outputParts.push(moveCursorUp(previousFrameLineCount - 1));
-        }
-        for (let lineIndex = 0; lineIndex < lineCountToRewrite; lineIndex++) {
-            outputParts.push(CLEAR_CURRENT_LINE, MOVE_CURSOR_TO_LINE_START, (_a = nextFrameLines[lineIndex]) !== null && _a !== void 0 ? _a : '');
-            if (lineIndex < lineCountToRewrite - 1) {
-                outputParts.push('\n');
-            }
-        }
-        const clearedTrailingLineCount = lineCountToRewrite - nextFrameLines.length;
-        if (clearedTrailingLineCount > 0) {
-            outputParts.push(moveCursorUp(clearedTrailingLineCount));
-        }
-        outputParts.push(MOVE_CURSOR_TO_LINE_START);
-        return outputParts.join('');
-    }
-    /**
-     * Builds an ANSI update that rewrites only contiguous groups of rows which changed.
-     *
-     * @private helper of `buildCoderRunUiTerminalFrameUpdate`
-     */
-    function buildChangedCoderRunUiTerminalFrameUpdate(previousFrameLines, nextFrameLines) {
-        const outputParts = [];
-        let lineIndex = 0;
-        while (lineIndex < nextFrameLines.length) {
-            if (previousFrameLines[lineIndex] === nextFrameLines[lineIndex]) {
-                lineIndex++;
-                continue;
-            }
-            const changedRangeStartLineIndex = lineIndex;
-            while (lineIndex + 1 < nextFrameLines.length &&
-                previousFrameLines[lineIndex + 1] !== nextFrameLines[lineIndex + 1]) {
-                lineIndex++;
-            }
-            appendChangedCoderRunUiTerminalFrameRange({
-                outputParts,
-                frameLineCount: nextFrameLines.length,
-                changedRangeStartLineIndex,
-                changedRangeEndLineIndex: lineIndex,
-                nextFrameLines,
-            });
-            lineIndex++;
-        }
-        return outputParts.length === 0 ? undefined : outputParts.join('');
-    }
-    /**
-     * Appends the cursor movements and row rewrites for one contiguous changed frame range.
-     *
-     * @private helper of `buildChangedCoderRunUiTerminalFrameUpdate`
-     */
-    function appendChangedCoderRunUiTerminalFrameRange(options) {
-        const { outputParts, frameLineCount, changedRangeStartLineIndex, changedRangeEndLineIndex, nextFrameLines } = options;
-        const linesUpFromFrameBottom = frameLineCount - 1 - changedRangeStartLineIndex;
-        if (linesUpFromFrameBottom > 0) {
-            outputParts.push(moveCursorUp(linesUpFromFrameBottom));
-        }
-        for (let lineIndex = changedRangeStartLineIndex; lineIndex <= changedRangeEndLineIndex; lineIndex++) {
-            outputParts.push(CLEAR_CURRENT_LINE, MOVE_CURSOR_TO_LINE_START, nextFrameLines[lineIndex]);
-            if (lineIndex < changedRangeEndLineIndex) {
-                outputParts.push('\n');
-            }
-        }
-        const linesDownToFrameBottom = frameLineCount - 1 - changedRangeEndLineIndex;
-        if (linesDownToFrameBottom > 0) {
-            outputParts.push(moveCursorDown(linesDownToFrameBottom));
-        }
-        outputParts.push(MOVE_CURSOR_TO_LINE_START);
-    }
-    /**
-     * Builds an ANSI sequence which moves the terminal cursor up by a positive number of rows.
-     *
-     * @private helper of `buildCoderRunUiTerminalFrameUpdate`
-     */
-    function moveCursorUp(lineCount) {
-        return `\x1b[${lineCount}A`;
-    }
-    /**
-     * Builds an ANSI sequence which moves the terminal cursor down by a positive number of rows.
-     *
-     * @private helper of `buildCoderRunUiTerminalFrameUpdate`
-     */
-    function moveCursorDown(lineCount) {
-        return `\x1b[${lineCount}B`;
-    }
-
-    /**
-     * Calendar formats used when displaying the estimated completion time.
-     *
-     * Uses 24-hour format (`HH:mm`) so estimates are unambiguous (for example `17:30` instead of `5:30`).
-     */
-    const ESTIMATED_DONE_CALENDAR_FORMATS = {
-        sameDay: '[Today] HH:mm',
-        nextDay: '[Tomorrow] HH:mm',
-        nextWeek: 'dddd HH:mm',
-        lastDay: '[Yesterday] HH:mm',
-        lastWeek: 'dddd HH:mm',
-        sameElse: 'MMM D HH: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.
-     *
-     * When the current session has not finished any prompt yet but a `cachedAveragePromptDurationMs` is
-     * provided (loaded from the per-config estimate cache stored in the temp folder), the snapshot uses
-     * that historical average to project the remaining work instead of waiting for the first completion.
-     */
-    function buildCoderRunProgressSnapshot(stats, elapsedDuration, initialDone, cachedAveragePromptDurationMs, runLimit) {
-        const totalPrompts = stats.done + stats.forAgent + stats.toBeWritten;
-        const completedSessionPrompts = Math.max(0, stats.done - initialDone);
-        const availableSessionTotal = completedSessionPrompts + stats.forAgent;
-        const sessionTotal = resolveSessionTotal(availableSessionTotal, runLimit);
-        const sessionDone = Math.min(completedSessionPrompts, sessionTotal);
-        const sessionRemaining = Math.max(0, sessionTotal - sessionDone);
-        const currentPromptIndex = sessionTotal > 0 ? Math.min(sessionDone + 1, sessionTotal) : 0;
-        const percentage = sessionTotal > 0 ? Math.round((sessionDone / sessionTotal) * 100) : 0;
-        const elapsedText = formatDurationBrief(elapsedDuration);
-        const elapsedMs = elapsedDuration.asMilliseconds();
-        let estimatedTotalText = 'estimating...';
-        let estimatedLabel = 'after first completion';
-        let isEstimatedTotalKnown = false;
-        let estimatedTotalMs;
-        if (sessionTotal > 0 && sessionDone > 0) {
-            estimatedTotalMs = (elapsedMs * sessionTotal) / sessionDone;
-        }
-        else if (sessionTotal > 0 &&
-            cachedAveragePromptDurationMs !== undefined &&
-            cachedAveragePromptDurationMs > 0) {
-            const projectedRemainingMs = sessionRemaining * cachedAveragePromptDurationMs;
-            estimatedTotalMs = elapsedMs + projectedRemainingMs;
-        }
-        if (estimatedTotalMs !== undefined) {
-            const estimatedRemainingMs = Math.max(0, estimatedTotalMs - elapsedMs);
-            const estimatedTotalDuration = moment__default["default"].duration(estimatedTotalMs);
-            const estimatedCompletion = moment__default["default"]().add(estimatedRemainingMs, 'milliseconds');
-            estimatedTotalText = formatDurationBrief(estimatedTotalDuration);
-            estimatedLabel = estimatedCompletion.calendar(null, ESTIMATED_DONE_CALENDAR_FORMATS);
-            isEstimatedTotalKnown = true;
-        }
+     * @private shared helper for terminal avatar rendering
+     */
+    function createTerminalAgentAvatarVisual(options) {
+        const renderInputs = createTerminalAgentAvatarVisualRenderInputs(options.agentSource, options.defaultAvatarVisualId || DEFAULT_AGENT_AVATAR_VISUAL_ID);
         return {
-            totalPrompts,
-            sessionDone,
-            sessionRemaining,
-            sessionTotal,
-            currentPromptIndex,
-            skippedPrompts: stats.outsidePriorityRange,
-            toBeWrittenPrompts: stats.toBeWritten,
-            percentage,
-            elapsedText,
-            estimatedTotalText,
-            estimatedLabel,
-            isEstimatedTotalKnown,
+            isAnimated: renderInputs.resolvedAvatarRenderDefinition.avatarVisual.isAnimated,
+            renderFrame({ animationTimeMs }) {
+                return renderTerminalAgentAvatarVisualFrame({
+                    ...renderInputs,
+                    animationTimeMs,
+                    colorDepth: options.colorDepth,
+                    createCanvas: options.createCanvas,
+                });
+            },
         };
     }
     /**
-     * Resolves the number of prompt runs represented by the current session progress.
+     * Creates stable avatar render inputs from one agent source.
+     *
+     * @private shared helper for terminal avatar rendering
      */
-    function resolveSessionTotal(availableSessionTotal, runLimit) {
-        if (runLimit === undefined) {
-            return availableSessionTotal;
-        }
-        return Math.min(availableSessionTotal, runLimit);
+    function createTerminalAgentAvatarVisualRenderInputs(agentSource, defaultAvatarVisualId) {
+        const agentBasicInformation = parseAgentSource(agentSource);
+        const avatarDefinition = createAvatarDefinitionFromAgentBasicInformation(agentBasicInformation);
+        const avatarVisualId = resolveTerminalAgentAvatarVisualIdFromAgentBasicInformation(agentBasicInformation, defaultAvatarVisualId);
+        const resolvedAvatarRenderDefinition = resolveAvatarRenderDefinition({
+            avatarDefinition,
+            visualId: avatarVisualId,
+            surface: 'transparent',
+        });
+        return {
+            avatarDefinition,
+            avatarVisualId,
+            resolvedAvatarRenderDefinition,
+        };
     }
-
     /**
-     * Tracks active coder-run time while excluding pauses and user-confirmation waits.
+     * Resolves the terminal avatar visual id from already parsed agent information.
+     *
+     * @private shared helper for terminal avatar rendering
      */
-    class CoderRunTimer {
-        /**
-         * Creates a timer anchored at the provided start time.
-         */
-        constructor(startTime, isPausedInitially = false) {
-            this.startTime = startTime;
-            /**
-             * Total milliseconds spent in paused state across the run.
-             */
-            this.pausedMs = 0;
-            if (isPausedInitially) {
-                this.pausedSince = startTime.clone();
-            }
-        }
-        /**
-         * Pauses active-time tracking until `resume()` is called.
-         */
-        pause() {
-            if (this.pausedSince === undefined) {
-                this.pausedSince = moment__default["default"]();
-            }
-        }
-        /**
-         * Resumes active-time tracking after a pause.
-         */
-        resume() {
-            if (this.pausedSince !== undefined) {
-                this.pausedMs += moment__default["default"]().diff(this.pausedSince);
-                this.pausedSince = undefined;
-            }
+    function resolveTerminalAgentAvatarVisualIdFromAgentBasicInformation(agentBasicInformation, defaultAvatarVisualId) {
+        return resolveAgentAvatarVisualId(agentBasicInformation, resolveAvatarVisualId(agentBasicInformation.meta.visual) || defaultAvatarVisualId);
+    }
+    /**
+     * Renders one terminal avatar frame through the shared avatar-to-ASCII pipeline.
+     *
+     * Visuals which are made of characters themselves, for example `AsciiOctopus`, paint the terminal
+     * character grid directly, because rasterizing them into half-block ASCII art averages every glyph
+     * away and makes them indistinguishable from the other blob-shaped visuals.
+     *
+     * @private shared helper for terminal avatar rendering
+     */
+    function renderTerminalAgentAvatarVisualFrame(options) {
+        const terminalTextLines = renderAvatarVisualTerminalTextLines({
+            avatarDefinition: options.avatarDefinition,
+            visualId: options.avatarVisualId,
+            surface: 'transparent',
+            columns: TERMINAL_AGENT_AVATAR_VISUAL_COLUMNS,
+            rows: TERMINAL_AGENT_AVATAR_VISUAL_ROWS,
+            colorDepth: options.colorDepth,
+            timeMs: options.animationTimeMs,
+            resolvedAvatarRenderDefinition: options.resolvedAvatarRenderDefinition,
+        });
+        if (terminalTextLines !== null) {
+            return terminalTextLines;
         }
-        /**
-         * Returns the currently accumulated active duration.
-         */
-        getElapsedDuration() {
-            const wallMs = moment__default["default"]().diff(this.startTime);
-            const currentPauseMs = this.pausedSince !== undefined ? moment__default["default"]().diff(this.pausedSince) : 0;
-            return moment__default["default"].duration(Math.max(0, wallMs - this.pausedMs - currentPauseMs));
+        if (options.createCanvas === undefined) {
+            // Note: A pixel-based visual cannot be rasterized without a canvas, so the caller renders no avatar
+            return [];
         }
+        return renderAvatarVisualAsciiArt({
+            avatarDefinition: options.avatarDefinition,
+            visualId: options.avatarVisualId,
+            surface: 'transparent',
+            columns: TERMINAL_AGENT_AVATAR_VISUAL_COLUMNS,
+            rows: TERMINAL_AGENT_AVATAR_VISUAL_ROWS,
+            canvasWidth: TERMINAL_AGENT_AVATAR_VISUAL_CANVAS_WIDTH,
+            canvasHeight: TERMINAL_AGENT_AVATAR_VISUAL_CANVAS_HEIGHT,
+            colorDepth: options.colorDepth,
+            timeMs: options.animationTimeMs,
+            createCanvas: options.createCanvas,
+            resolvedAvatarRenderDefinition: options.resolvedAvatarRenderDefinition,
+        });
     }
 
     /**
-     * Maximum number of agent output lines kept in the scrolling output area.
+     * Refresh cadence used only while the rich coder UI needs animated updates.
      *
      * @private internal constant of coder run UI
      */
-    const MAX_AGENT_OUTPUT_LINES = 12;
+    const ACTIVE_CODER_RUN_UI_REFRESH_INTERVAL_MS = TERMINAL_AGENT_AVATAR_VISUAL_REFRESH_INTERVAL_MS;
     /**
-     * Reactive state manager for the coder run terminal UI.
+     * Phases that still benefit from automatic refreshes because the frame can change
+     * over time even without new runner output.
      *
-     * Holds all data the Ink components need and emits `'change'` events
-     * whenever any property is updated so the UI can re-render.
+     * @private internal constant of coder run UI
+     */
+    const AUTO_REFRESH_PHASES = ['initializing', 'loading', 'running', 'verifying'];
+    /**
+     * Phases where an animated `--agent` visual should keep rendering like it does on the web.
+     *
+     * @private internal constant of coder run UI
+     */
+    const AGENT_VISUAL_AUTO_REFRESH_PHASES = [...AUTO_REFRESH_PHASES, 'waiting'];
+    /**
+     * Returns whether the rich coder UI should keep animating on its own.
      *
      * @private internal utility of coder run UI
      */
-    class CoderRunUiState extends events.EventEmitter {
-        constructor(startTime) {
-            super();
-            this.config = { agentName: '' };
-            this.currentPromptLabel = '';
-            this.currentScriptPaths = [];
-            this.currentAttempt = 1;
-            this.maxAttempts = 3;
-            this.detailLines = [];
-            this.messagePreviewLines = [];
-            this.messagePreviewSections = [];
-            this.agentStatusLines = [];
-            this.agentStatusTableRows = [];
-            this.agentOutputLines = [];
-            this.phase = 'initializing';
-            this.statusMessage = 'Initializing...';
-            this.errors = [];
-            this.stats = { done: 0, forAgent: 0, outsidePriorityRange: 0, toBeWritten: 0 };
-            // Match the plain CLI progress header and count active run time from startup.
-            // Explicit waits/pauses are excluded later through `pauseTimer()` / `resumeTimer()`.
-            this.timer = new CoderRunTimer(startTime);
-        }
-        /**
-         * Pauses the elapsed timer (e.g. while waiting for user input or paused state).
-         */
-        pauseTimer() {
-            this.timer.pause();
-            this.emitChange();
-        }
-        /**
-         * Resumes the elapsed timer after a pause.
-         */
-        resumeTimer() {
-            this.timer.resume();
-            this.emitChange();
-        }
-        /**
-         * Replaces the configuration shown in the UI header.
-         */
-        setConfig(config) {
-            this.config = config;
-            this.emitChange();
-        }
-        /**
-         * Replaces the ASCII-art agent visual renderer shown instead of the default brand banner.
-         */
-        setAgentVisual(agentVisual) {
-            this.agentVisual = agentVisual;
-            this.emitChange();
-        }
-        /**
-         * Feeds new prompt statistics from the main loop so the progress bar updates.
-         */
-        updateProgress(stats) {
-            if (this.initialDone === undefined && (stats.done > 0 || stats.forAgent > 0 || stats.toBeWritten > 0)) {
-                this.initialDone = stats.done;
-            }
-            this.stats = stats;
-            this.emitChange();
-        }
-        /**
-         * Sets the cached average prompt duration (in milliseconds) loaded from the temp-folder estimate cache.
-         *
-         * Used to project completion estimates before the first prompt of the current session finishes.
-         */
-        setCachedAveragePromptDurationMs(cachedAveragePromptDurationMs) {
-            this.cachedAveragePromptDurationMs = cachedAveragePromptDurationMs;
-            this.emitChange();
-        }
-        /**
-         * Computes a progress snapshot on demand so elapsed time ticks with periodic re-renders.
-         */
-        getProgress() {
-            var _a;
-            return buildCoderRunProgressSnapshot(this.stats, this.timer.getElapsedDuration(), (_a = this.initialDone) !== null && _a !== void 0 ? _a : this.stats.done, this.cachedAveragePromptDurationMs, this.config.limit);
-        }
-        /**
-         * Sets the label of the prompt currently being processed and resets per-prompt state.
-         */
-        setCurrentPrompt(label) {
-            this.currentPromptLabel = label;
-            this.currentScriptPaths = [];
-            this.detailLines = [];
-            this.messagePreviewLines = [];
-            this.messagePreviewSections = [];
-            this.pendingEnterLabel = undefined;
-            this.agentOutputLines = [];
-            this.currentAttempt = 1;
-            this.emitChange();
-        }
-        /**
-         * Sets the temporary shell script currently used by the active prompt.
-         */
-        setCurrentScriptPath(scriptPath) {
-            this.currentScriptPaths = scriptPath ? [scriptPath] : [];
-            this.emitChange();
-        }
-        /**
-         * Sets multiple temporary shell scripts used by a shared multi-agent session.
-         */
-        setCurrentScriptPaths(scriptPaths) {
-            this.currentScriptPaths = [...scriptPaths];
-            this.emitChange();
-        }
-        /**
-         * Updates the current retry attempt number.
-         */
-        setAttempt(attempt) {
-            this.currentAttempt = attempt;
-            this.emitChange();
-        }
-        /**
-         * Appends raw agent output text, keeping only the last `MAX_AGENT_OUTPUT_LINES`.
-         */
-        addAgentOutput(text) {
-            const lines = text.split(/\r?\n/).filter((line) => line.trim() !== '');
-            if (lines.length === 0) {
-                return;
-            }
-            this.agentOutputLines.push(...lines);
-            if (this.agentOutputLines.length > MAX_AGENT_OUTPUT_LINES) {
-                this.agentOutputLines = this.agentOutputLines.slice(-MAX_AGENT_OUTPUT_LINES);
-            }
-            this.emitChange();
-        }
-        /**
-         * Transitions the execution phase shown in the UI.
-         */
-        setPhase(phase) {
-            this.phase = phase;
-            this.emitChange();
-        }
-        /**
-         * Updates the status message line beneath the current prompt label.
-         */
-        setStatusMessage(message) {
-            this.statusMessage = message;
-            this.emitChange();
-        }
-        /**
-         * Replaces the contextual detail lines shown beneath the current prompt status.
-         */
-        setDetailLines(detailLines) {
-            this.detailLines = detailLines.filter((detailLine) => detailLine.trim() !== '');
-            this.emitChange();
-        }
-        /**
-         * Replaces the exact user-message preview lines shown in agent-specific panels.
-         */
-        setMessagePreviewLines(messagePreviewLines) {
-            this.messagePreviewLines = [...messagePreviewLines];
-            this.emitChange();
-        }
-        /**
-         * Replaces the structured user-message panels shown in agent-specific dashboards.
-         */
-        setMessagePreviewSections(messagePreviewSections) {
-            this.messagePreviewSections = [...messagePreviewSections];
-            this.emitChange();
-        }
-        /**
-         * Replaces agent status rows shown by agent-specific terminal frames.
-         */
-        setAgentStatusLines(agentStatusLines) {
-            this.agentStatusLines = [...agentStatusLines];
-            this.emitChange();
-        }
-        /**
-         * Replaces structured agent status rows shown by agent-specific terminal frames.
-         */
-        setAgentStatusTableRows(agentStatusTableRows) {
-            this.agentStatusTableRows = [...agentStatusTableRows];
-            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.
-         */
-        addError(errorMessage) {
-            this.errors.push(errorMessage);
-            this.emitChange();
+    function isCoderRunUiAutoRefreshing(phase, pauseState, isAgentVisualAnimated = false) {
+        // `PAUSING` still means the current task is winding down, so keep active
+        // animations/timers running until the runner reaches the fully paused state.
+        if (pauseState === 'PAUSED') {
+            return false;
         }
-        emitChange() {
-            this.emit('change');
+        if (isAgentVisualAnimated) {
+            return AGENT_VISUAL_AUTO_REFRESH_PHASES.includes(phase);
         }
+        return AUTO_REFRESH_PHASES.includes(phase);
+    }
+    /**
+     * Returns the automatic refresh interval for the current UI state.
+     *
+     * 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
+     */
+    function getCoderRunUiAutoRefreshInterval(phase, pauseState, isAgentVisualAnimated = false) {
+        return isCoderRunUiAutoRefreshing(phase, pauseState, isAgentVisualAnimated)
+            ? ACTIVE_CODER_RUN_UI_REFRESH_INTERVAL_MS
+            : undefined;
     }
 
     /**
@@ -29085,6 +29224,7 @@
         let isRendering = false;
         let renderScheduled = false;
         let autoRefreshTimeout;
+        let controlFeedbackTimeout;
         let isDisposed = false;
         /**
          * Schedules a render on the next tick if one isn't already pending.
@@ -29150,9 +29290,32 @@
                 pendingEnterLabel: state.pendingEnterLabel,
                 agentOutputLines: state.agentOutputLines,
                 errors: state.errors,
+                controlFeedback: state.controlFeedback,
                 progress: state.getProgress(),
             });
         }
+        /**
+         * Answers one pressed control key in the frame and hides that answer again after a short moment.
+         */
+        function showControlFeedback(controlFeedback) {
+            clearControlFeedbackTimeout();
+            // Note: Every state change re-renders the frame, so the answer appears with the very next frame
+            state.setControlFeedback(controlFeedback);
+            controlFeedbackTimeout = setTimeout(() => {
+                controlFeedbackTimeout = undefined;
+                state.setControlFeedback(undefined);
+            }, CODER_RUN_CONTROL_FEEDBACK_DURATION_MS);
+        }
+        /**
+         * Stops the timer which hides the currently shown control answer.
+         */
+        function clearControlFeedbackTimeout() {
+            if (controlFeedbackTimeout === undefined) {
+                return;
+            }
+            clearTimeout(controlFeedbackTimeout);
+            controlFeedbackTimeout = undefined;
+        }
         /**
          * Clears previously rendered lines and writes a new frame only where needed.
          */
@@ -29185,19 +29348,10 @@
                 cleanup();
                 process.exit(0);
             }
-            if (key.name === 'p') {
-                togglePauseState();
-                scheduleRender();
-                return;
-            }
-            if (key.name === 's') {
-                requestSkipCurrentWait();
-                scheduleRender();
-                return;
-            }
-            if (key.name === 'x') {
-                toggleEndAfterCurrentPromptState();
-                scheduleRender();
+            // Note: [🏹] The very same key handling is shared with the plain console mode, see `applyCoderRunControlKey`
+            const controlFeedback = applyCoderRunControlKey(key.name);
+            if (controlFeedback !== undefined) {
+                showControlFeedback(controlFeedback);
                 return;
             }
             if ((key.name === 'return' || key.name === 'enter') && pendingEnterResolver) {
@@ -29223,6 +29377,7 @@
                 clearTimeout(autoRefreshTimeout);
                 autoRefreshTimeout = undefined;
             }
+            clearControlFeedbackTimeout();
             state.off('change', scheduleRender);
             process.stdin.off('keypress', keypressHandler);
             process.stdout.off('resize', scheduleRender);
@@ -29283,7 +29438,7 @@
             waitBetweenPrompts: 0,
             waitAfterError: 0,
             noCommit: options.noCommit,
-            ignoreGitChanges: options.ignoreGitChanges,
+            gitChanges: options.gitChanges,
             normalizeLineEndings: options.normalizeLineEndings,
             allowCredits: options.allowCredits,
             autoMigrate: false,
@@ -39851,11 +40006,11 @@
      * Validates constraints specific to never-ending agent watch loops.
      */
     function validateAgentWatchOptions(commandDisplayName, options) {
-        if (!options.noCommit || options.ignoreGitChanges) {
+        if (!options.noCommit || options.gitChanges !== 'fail') {
             return;
         }
         throw new NotAllowed(_spaceTrim.spaceTrim(`
-            Flag \`--no-commit\` requires \`--ignore-git-changes\` when used with \`${commandDisplayName}\`.
+            Flag \`--no-commit\` requires \`--git-changes ignore\` when used with \`${commandDisplayName}\`.
 
             Without commits, answered messages remain in the working tree and the next message round would fail the clean
             working tree check.
@@ -40168,7 +40323,7 @@
             noUi: options.noUi,
             thinkingLevel: options.thinkingLevel,
             noCommit: true,
-            ignoreGitChanges: true,
+            gitChanges: 'ignore',
             normalizeLineEndings: false,
             allowCredits: options.allowCredits,
             autoPush: false,
@@ -43766,6 +43921,8 @@
             Features:
             - Automatically stages and commits changes with agent identity unless --no-commit is used
             - Commits only the prompt file and the files the coding agent has changed, leaving unrelated changes alone
+            - Refuses to start on a dirty working tree unless --git-changes says what should happen with the changes
+            - Optional --git-changes continue resumes the single prompt an interrupted coder left in the [^] status
             - Optional post-commit git push with explicit --auto-push opt-in
             - Optional pre-prompt git pull with explicit --auto-pull opt-in
             - Optional --isolate runs every prompt in its own temporary git worktree and merges it back when verified
@@ -43846,7 +44003,7 @@
                 waitBetweenPrompts,
                 waitAfterError,
                 noCommit: runnerOptions.noCommit,
-                ignoreGitChanges: runnerOptions.ignoreGitChanges,
+                gitChanges: runnerOptions.gitChanges,
                 agentName: runnerOptions.agentName,
                 model: runnerOptions.model,
                 agent,
@@ -43987,7 +44144,7 @@
                 waitBetweenPrompts,
                 waitAfterError,
                 noCommit: runnerOptions.noCommit,
-                ignoreGitChanges: runnerOptions.ignoreGitChanges,
+                gitChanges: runnerOptions.gitChanges,
                 agentName: runnerOptions.agentName,
                 model: runnerOptions.model,
                 agent,
@@ -67418,7 +67575,7 @@
             waitBetweenPrompts: 0,
             waitAfterError: 0,
             noCommit: true,
-            ignoreGitChanges: true,
+            gitChanges: 'ignore',
             normalizeLineEndings: false,
             allowCredits: options.allowCredits,
             isVerbose: options.isVerbose,
@@ -73211,13 +73368,13 @@
     }
 
     /**
-     * Lists todo prompts across all files.
+     * Lists prompts in one checklist status across all files.
      */
-    function listTodoPrompts(files) {
+    function listPromptsByStatus(files, status) {
         const prompts = [];
         for (const file of files) {
             for (const section of file.sections) {
-                if (section.status === 'todo') {
+                if (section.status === status) {
                     prompts.push({ file, section });
                 }
             }
@@ -73225,6 +73382,13 @@
         return prompts;
     }
 
+    /**
+     * Lists todo prompts across all files.
+     */
+    function listTodoPrompts(files) {
+        return listPromptsByStatus(files, 'todo');
+    }
+
     /**
      * Lists todo prompts that still contain authoring placeholders.
      */
@@ -73802,7 +73966,7 @@
     /**
      * CLI usage text for this script.
      */
-    const USAGE = 'Usage: run-codex-prompts [--dry-run] [--harness <harness-name>] [--model <model>] [--context <context-or-file>] [--test <test-command...>] [--test-before <no|yes-and-fail|yes-and-fix>] [--preserve-logs] [--isolate] [--no-ui] [--thinking-level <thinking-level>] [--priority <minimum-priority>] [--min-priority <minimum-priority>] [--max-priority <maximum-priority>] [--limit <run-count>] [--allow-credits] [--auto-migrate] [--allow-destructive-auto-migrate] [--wait-after-prompt <duration>] [--wait-between-prompts <duration>] [--wait-after-error <duration>] [--no-auto] [--no-commit] [--ignore-git-changes] [--no-normalize-line-endings] [--auto-push] [--auto-pull]';
+    const USAGE = 'Usage: run-codex-prompts [--dry-run] [--harness <harness-name>] [--model <model>] [--context <context-or-file>] [--test <test-command...>] [--test-before <no|yes-and-fail|yes-and-fix>] [--preserve-logs] [--isolate] [--no-ui] [--thinking-level <thinking-level>] [--priority <minimum-priority>] [--min-priority <minimum-priority>] [--max-priority <maximum-priority>] [--limit <run-count>] [--allow-credits] [--auto-migrate] [--allow-destructive-auto-migrate] [--wait-after-prompt <duration>] [--wait-between-prompts <duration>] [--wait-after-error <duration>] [--no-auto] [--no-commit] [--git-changes <fail|ignore|continue>] [--no-normalize-line-endings] [--auto-push] [--auto-pull]';
     /**
      * Top-level flags supported by this command.
      */
@@ -73829,7 +73993,7 @@
         '--wait-after-error',
         '--no-auto',
         '--no-commit',
-        '--ignore-git-changes',
+        '--git-changes',
         '--no-normalize-line-endings',
         '--auto-push',
         '--auto-pull',
@@ -73873,7 +74037,8 @@
         const hasLimitFlag = args.includes('--limit');
         const limit = parseLimit(readOptionValue(args, '--limit'), hasLimitFlag);
         const noCommit = args.includes('--no-commit');
-        const ignoreGitChanges = args.includes('--ignore-git-changes');
+        const hasGitChangesFlag = args.includes('--git-changes');
+        const gitChanges = parseGitChangesOption(readOptionValue(args, '--git-changes'), hasGitChangesFlag);
         const normalizeLineEndings = !args.includes('--no-normalize-line-endings');
         const allowCredits = args.includes('--allow-credits');
         const autoMigrate = args.includes('--auto-migrate');
@@ -73911,7 +74076,7 @@
             waitBetweenPrompts,
             waitAfterError,
             noCommit,
-            ignoreGitChanges,
+            gitChanges,
             normalizeLineEndings,
             allowCredits,
             autoMigrate,
@@ -73949,6 +74114,21 @@
         }
         return value;
     }
+    /**
+     * Parses and validates the requested behavior for a dirty working tree.
+     */
+    function parseGitChangesOption(value, hasGitChangesFlag) {
+        if (value === undefined) {
+            if (hasGitChangesFlag) {
+                exitWithUsageError(`Missing value for --git-changes. Use one of: ${GIT_CHANGES_MODE_VALUES.join(', ')}.`);
+            }
+            return DEFAULT_GIT_CHANGES_MODE;
+        }
+        if (!isGitChangesMode(value)) {
+            exitWithUsageError(`Invalid value for --git-changes: "${value}". Use one of: ${GIT_CHANGES_MODE_VALUES.join(', ')}.`);
+        }
+        return value;
+    }
     /**
      * Reads a duration-typed CLI flag, applying the provided default when the flag is absent.
      */
@@ -74406,27 +74586,19 @@
             return;
         }
         const deadlineTimeMs = (_a = options.deadlineTimeMs) !== null && _a !== void 0 ? _a : Date.now() + durationMs;
-        const waitToken = beginSkippableWait();
-        try {
-            await waitUntilWorldTimeDeadline({
-                deadlineTimeMs,
-                pollIntervalMs: WAIT_COUNTDOWN_UPDATE_INTERVAL_MS,
-                shouldStopWaiting: () => shouldSkipCurrentWait(waitToken),
-                waitForMilliseconds: (waitDurationMs) => waitForSkippableMilliseconds(waitToken, waitDurationMs),
-                onTick: (remainingDurationMs) => {
-                    const visibleRemainingDurationMs = Math.min(remainingDurationMs, durationMs);
-                    const statusMessage = describeCoderRunWait(waitKind, visibleRemainingDurationMs, durationMs);
-                    if (!isRichUiEnabled) {
-                        console.info(colors__default["default"].gray(`${statusMessage}...`));
-                        return;
-                    }
-                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage(`${statusMessage}...`);
-                },
-            });
-        }
-        finally {
-            finishSkippableWait(waitToken);
-        }
+        await waitForSkippableWorldTimeDeadline({
+            deadlineTimeMs,
+            pollIntervalMs: WAIT_COUNTDOWN_UPDATE_INTERVAL_MS,
+            onTick: (remainingDurationMs) => {
+                const visibleRemainingDurationMs = Math.min(remainingDurationMs, durationMs);
+                const statusMessage = describeCoderRunWait(waitKind, visibleRemainingDurationMs, durationMs);
+                if (!isRichUiEnabled) {
+                    console.info(colors__default["default"].gray(`${statusMessage}...`));
+                    return;
+                }
+                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage(`${statusMessage}...`);
+            },
+        });
     }
 
     /**
@@ -74441,6 +74613,36 @@
         });
     }
 
+    /**
+     * Listens for the terminal control keys while the plain console output is used.
+     *
+     * Every recognized key press is answered with one printed line, because the plain mode has no frame
+     * which could show the new state on its own. The rich terminal UI installs its own listener in
+     * [`renderCoderRunUi`](../ui/renderCoderRunUi.ts) and shares the very same key handling through
+     * [`applyCoderRunControlKey`](./applyCoderRunControlKey.ts).
+     *
+     * @private internal utility of `ptbk coder` terminal controls
+     */
+    function listenForCoderRunControls() {
+        if (!process.stdin.isTTY) {
+            return;
+        }
+        readline__namespace.emitKeypressEvents(process.stdin);
+        process.stdin.setRawMode(true);
+        process.stdin.on('keypress', (_pressedText, key) => {
+            if (key.ctrl && key.name === 'c') {
+                process.exit();
+            }
+            const controlFeedback = applyCoderRunControlKey(key.name);
+            if (controlFeedback === undefined) {
+                return;
+            }
+            // Note: Using console.log here which adds a new line.
+            // This is intentional to prevent the message from being overwritten.
+            console.log(formatCoderRunControlFeedback(controlFeedback));
+        });
+    }
+
     /**
      * Checks working tree clean.
      */
@@ -74459,12 +74661,14 @@
     async function ensureWorkingTreeClean() {
         const isClean = await isWorkingTreeClean(process.cwd());
         if (!isClean) {
-            throw new Error(_spaceTrim.spaceTrim(`
+            throw new NotAllowed(_spaceTrim.spaceTrim(`
                 Git working tree is not clean.
 
                 Please commit or stash your changes before running this script
-                OR run script with flag --ignore-git-changes
-            
+                OR decide what should happen with them:
+
+                - \`--git-changes ignore\` leaves the changes where they are and starts the next prompt anyway
+                - \`--git-changes continue\` resumes the single prompt which was left in the middle of its implementation
 
                 Aborting
             `));
@@ -76031,6 +76235,51 @@
         return `(failed after ${attemptCount} attempts) `;
     }
 
+    /**
+     * Separator which introduces the harness that started a prompt another harness has taken over.
+     *
+     * It is used both for writing and for reading the attribution, so the status line of a continued prompt
+     * stays parseable when yet another harness continues it later.
+     */
+    const STARTED_BY_SEPARATOR = ', started by ';
+    /**
+     * Matches the attribution of one status line, which reaches from `by ` up to the step summary.
+     */
+    const PROMPT_RUNNER_ATTRIBUTION_PATTERN = /(?:^|\s)by (?<attribution>.*?)(?: - |$)/u;
+    /**
+     * Formats who worked on one prompt for its status line.
+     *
+     * Produces `` by Claude Code `claude-opus-5` `` for a prompt implemented by a single harness and
+     * `` by Claude Code `claude-opus-5`, started by OpenAI Codex `gpt-5.6-luna` `` for a prompt which one
+     * harness started and another one continued through `--git-changes continue`.
+     */
+    function formatPromptRunnerAttribution(options) {
+        const { currentRunnerSignature, startedByRunnerSignature } = options;
+        if (startedByRunnerSignature === undefined || startedByRunnerSignature === currentRunnerSignature) {
+            return `by ${currentRunnerSignature}`;
+        }
+        return `by ${currentRunnerSignature}${STARTED_BY_SEPARATOR}${startedByRunnerSignature}`;
+    }
+    /**
+     * Reads which harness started the work recorded on one prompt status line.
+     *
+     * A line written by a single harness names that harness, and a line of a prompt which was already taken
+     * over keeps naming the harness which started it, so the original author survives any number of takeovers.
+     */
+    function parsePromptStartedByRunnerSignature(statusLine) {
+        var _a, _b, _c;
+        const attribution = (_c = (_b = (_a = statusLine.match(PROMPT_RUNNER_ATTRIBUTION_PATTERN)) === null || _a === void 0 ? void 0 : _a.groups) === null || _b === void 0 ? void 0 : _b.attribution) === null || _c === void 0 ? void 0 : _c.trim();
+        if (!attribution) {
+            return undefined;
+        }
+        const startedBySeparatorIndex = attribution.indexOf(STARTED_BY_SEPARATOR);
+        if (startedBySeparatorIndex === -1) {
+            return attribution;
+        }
+        return attribution.slice(startedBySeparatorIndex + STARTED_BY_SEPARATOR.length).trim() || undefined;
+    }
+    // Note: [💞] Ignore a discrepancy between file name and exported helper names
+
     /**
      * Builds the shared body of a prompt status line, used by both the in-progress `[^]` and the done `[x]` status.
      *
@@ -76038,14 +76287,18 @@
      * ``by OpenAI Codex `gpt-5.6-luna` thinking `max` (ChatGPT account) - Implementation ~$0.2036 10 minutes``.
      */
     function buildPromptStatusDetails(options) {
-        const { steps, inProgressStepKind, runnerName, modelName, attemptCount, loginMethod, thinkingLevel } = options;
+        const { steps, inProgressStepKind, runnerName, modelName, startedByRunnerSignature, attemptCount, loginMethod, thinkingLevel, } = options;
         const runnerSignature = formatRunnerSignature(runnerName, modelName, thinkingLevel);
         const attemptMetadata = formatPromptAttemptMetadata('done', attemptCount);
         const loginMethodLabel = formatCodexLoginMethod(loginMethod);
         const loginMethodSuffix = loginMethodLabel ? ` (${loginMethodLabel})` : '';
+        const attribution = formatPromptRunnerAttribution({
+            currentRunnerSignature: `${runnerSignature}${loginMethodSuffix}`,
+            startedByRunnerSignature,
+        });
         const stepsSummary = formatCoderRunSteps(steps, inProgressStepKind);
         const stepsSuffix = stepsSummary === '' ? '' : ` - ${stepsSummary}`;
-        return `${attemptMetadata}by ${runnerSignature}${loginMethodSuffix}${stepsSuffix}`;
+        return `${attemptMetadata}${attribution}${stepsSuffix}`;
     }
 
     /**
@@ -76088,29 +76341,26 @@
     /**
      * Marks a prompt section as done and records the per-step usage pricing and runner details.
      */
-    function markPromptDone(file, section, steps, runnerName, modelName, attemptCount = 1, loginMethod, thinkingLevel) {
-        const statusDetails = buildPromptStatusDetails({
-            steps,
-            runnerName,
-            modelName,
-            attemptCount,
-            loginMethod,
-            thinkingLevel,
-        });
-        writePromptStatusLine(file, section, `[x] ${statusDetails}`);
+    function markPromptDone(options) {
+        const { file, section, ...statusDetailsOptions } = options;
+        writePromptStatusLine(file, section, `[x] ${buildPromptStatusDetails(statusDetailsOptions)}`);
     }
 
     /**
      * Marks a prompt section as failed and records runner details.
      */
-    function markPromptFailed(file, section, runnerName, modelName, promptExecutionStartedDate, attemptCount = 1) {
-        const runnerSignature = formatRunnerSignature(runnerName, modelName);
+    function markPromptFailed(options) {
+        const { file, section, runnerName, modelName, startedByRunnerSignature, promptExecutionStartedDate, attemptCount } = options;
+        const attribution = formatPromptRunnerAttribution({
+            currentRunnerSignature: formatRunnerSignature(runnerName, modelName),
+            startedByRunnerSignature,
+        });
         const attemptMetadata = formatPromptAttemptMetadata('failed', attemptCount);
         const duration = moment__default["default"]().diff(promptExecutionStartedDate);
         const durationString = moment__default["default"].duration(duration).humanize();
         const failureDetails = attemptMetadata === ''
-            ? `failed after ${durationString} by ${runnerSignature}`
-            : `${attemptMetadata}${durationString} by ${runnerSignature}`;
+            ? `failed after ${durationString} ${attribution}`
+            : `${attemptMetadata}${durationString} ${attribution}`;
         writePromptStatusLine(file, section, `[!] ${failureDetails}`);
     }
 
@@ -76202,6 +76452,12 @@
         const codexPrompt = appendCoderContext(promptWithAgent, resolvedCoderContext);
         // Note: Temporary scripts and runtime logs stay in the original project so they outlive an isolated worktree
         const scriptPath = buildScriptPath(nextPrompt.file, nextPrompt.section);
+        // Note: Read before the first `[^]` rewrite of this round, which would overwrite the harness recorded so far
+        const startedByRunnerSignature = resolveStartedByRunnerSignature({
+            nextPrompt,
+            runnerMetadata,
+            thinkingLevel: options.thinkingLevel,
+        });
         setPromptRoundRunningState({ isRichUiEnabled, promptLabel, scriptPath, uiHandle });
         await waitForRequestedPause({
             checkpointLabel: 'preparing the current prompt execution',
@@ -76234,6 +76490,7 @@
                         onStepStarted: (progress) => recordPromptRoundInProgress({
                             nextPrompt,
                             runnerMetadata,
+                            startedByRunnerSignature,
                             thinkingLevel: options.thinkingLevel,
                             attemptCount,
                             progress,
@@ -76244,6 +76501,7 @@
                         options,
                         nextPrompt,
                         runnerMetadata,
+                        startedByRunnerSignature,
                         promptExecutionStartedDate,
                         result,
                         commitMessage,
@@ -76277,6 +76535,7 @@
             await finalizeFailedPromptRound({
                 nextPrompt,
                 runnerMetadata,
+                startedByRunnerSignature,
                 promptExecutionStartedDate,
                 attemptCount,
                 error: lastError,
@@ -76289,6 +76548,23 @@
             throw lastError;
         }, { preserveArtifactsOnSuccess: options.preserveLogs });
     }
+    /**
+     * Reads which harness left the prompt of this round in the middle of its implementation.
+     *
+     * Only a prompt resumed through `--git-changes continue` still carries the in-progress `[^]` status when its
+     * round starts, so every other round reports no earlier harness. A harness which continues its own work is
+     * reported as no earlier harness either, because the status line would just name it twice.
+     */
+    function resolveStartedByRunnerSignature(options) {
+        const { nextPrompt, runnerMetadata, thinkingLevel } = options;
+        if (nextPrompt.section.status !== 'in-progress') {
+            return undefined;
+        }
+        const { line } = resolvePromptStatusLine(nextPrompt.file, nextPrompt.section);
+        const startedByRunnerSignature = parsePromptStartedByRunnerSignature(line);
+        const currentRunnerSignature = formatRunnerSignature(runnerMetadata.runnerName, runnerMetadata.modelName, thinkingLevel);
+        return startedByRunnerSignature === currentRunnerSignature ? undefined : startedByRunnerSignature;
+    }
     /**
      * Records into the prompt file that the prompt is being implemented right now.
      *
@@ -76297,7 +76573,7 @@
      * crashes leaves the `[^]` status behind as the signal that this task was left in the middle.
      */
     async function recordPromptRoundInProgress(options) {
-        const { nextPrompt, runnerMetadata, thinkingLevel, attemptCount, progress } = options;
+        const { nextPrompt, runnerMetadata, startedByRunnerSignature, thinkingLevel, attemptCount, progress } = options;
         markPromptInProgress({
             file: nextPrompt.file,
             section: nextPrompt.section,
@@ -76305,6 +76581,7 @@
             inProgressStepKind: progress.startedStepKind,
             runnerName: runnerMetadata.runnerName,
             modelName: runnerMetadata.modelName,
+            startedByRunnerSignature,
             attemptCount,
             loginMethod: progress.loginMethod,
             thinkingLevel,
@@ -76362,14 +76639,24 @@
      * Finalizes a successful prompt round, including prompt bookkeeping and commit flow.
      */
     async function finalizeSuccessfulPromptRound(options) {
-        const { options: runOptions, nextPrompt, runnerMetadata, promptExecutionStartedDate, result, commitMessage, logPath, roundCommitScope, isRichUiEnabled, progressDisplay, uiHandle, waitForRequestedPause, roundProjectPath, } = options;
+        const { options: runOptions, nextPrompt, runnerMetadata, startedByRunnerSignature, promptExecutionStartedDate, result, commitMessage, logPath, roundCommitScope, isRichUiEnabled, progressDisplay, uiHandle, waitForRequestedPause, roundProjectPath, } = options;
         uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.stopCapturingAgentOutput();
         await waitForRequestedPause({
             checkpointLabel: 'recording the successful prompt result',
             phase: 'running',
             statusMessage: 'Recording prompt result',
         });
-        markPromptDone(nextPrompt.file, nextPrompt.section, result.steps, runnerMetadata.runnerName, runnerMetadata.modelName, result.attemptCount, result.loginMethod, runOptions.thinkingLevel);
+        markPromptDone({
+            file: nextPrompt.file,
+            section: nextPrompt.section,
+            steps: result.steps,
+            runnerName: runnerMetadata.runnerName,
+            modelName: runnerMetadata.modelName,
+            startedByRunnerSignature,
+            attemptCount: result.attemptCount,
+            loginMethod: result.loginMethod,
+            thinkingLevel: runOptions.thinkingLevel,
+        });
         // Note: The prompt status is always written into the original project, an isolated round transports
         //       its own changes back through the merge instead
         await writePromptFile(nextPrompt.file);
@@ -76420,7 +76707,7 @@
      * Finalizes a failed prompt round, persisting prompt failure metadata before rethrowing.
      */
     async function finalizeFailedPromptRound(options) {
-        const { nextPrompt, runnerMetadata, promptExecutionStartedDate, attemptCount, error, options: runOptions, roundCommitScope, uiHandle, waitForRequestedPause, roundProjectPath, } = options;
+        const { nextPrompt, runnerMetadata, startedByRunnerSignature, promptExecutionStartedDate, attemptCount, error, options: runOptions, roundCommitScope, uiHandle, waitForRequestedPause, roundProjectPath, } = options;
         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));
@@ -76429,7 +76716,15 @@
             phase: 'error',
             statusMessage: 'Recording prompt failure',
         });
-        markPromptFailed(nextPrompt.file, nextPrompt.section, runnerMetadata.runnerName, runnerMetadata.modelName, promptExecutionStartedDate, attemptCount);
+        markPromptFailed({
+            file: nextPrompt.file,
+            section: nextPrompt.section,
+            runnerName: runnerMetadata.runnerName,
+            modelName: runnerMetadata.modelName,
+            startedByRunnerSignature,
+            promptExecutionStartedDate,
+            attemptCount,
+        });
         await writePromptFile(nextPrompt.file);
         await writePromptErrorLog({
             file: nextPrompt.file,
@@ -77182,6 +77477,50 @@
         }
     }
 
+    /**
+     * Builds a label that identifies the prompt section by index.
+     */
+    function buildPromptLabel(file, section) {
+        return `${path.relative(process.cwd(), file.path).replace(/\\/g, '/')}#${section.index + 1}`;
+    }
+
+    /**
+     * Resolves the one prompt which `--git-changes continue` resumes.
+     *
+     * A coder which was killed or crashed leaves exactly one prompt behind in the in-progress `[^]` status,
+     * so anything else means the working tree changes cannot be attributed to a single interrupted prompt.
+     */
+    function resolveInterruptedPrompt(files) {
+        const interruptedPrompts = listPromptsByStatus(files, 'in-progress');
+        if (interruptedPrompts.length === 0) {
+            throw new NotFoundError(_spaceTrim.spaceTrim(`
+                Flag \`--git-changes continue\` found no interrupted prompt to continue.
+
+                Continuing resumes the prompt an earlier coder left in the middle of its implementation, which is the
+                one marked with the in-progress \`[^]\` status. No prompt carries that status right now.
+
+                Use \`--git-changes ignore\` to start the next \`[ ]\` prompt with the current working tree changes
+                left in place, or \`--git-changes fail\` to commit or stash them first.
+            `));
+        }
+        if (interruptedPrompts.length > 1) {
+            throw new NotAllowed(_spaceTrim.spaceTrim((block) => `
+                    Flag \`--git-changes continue\` found ${interruptedPrompts.length} interrupted prompts, but it can
+                    continue only one.
+
+                    The working tree changes cannot be attributed to a single prompt while more than one of them carries
+                    the in-progress \`[^]\` status. Resolve the extra ones by marking them \`[x]\`, \`[!]\` or \`[ ]\`
+                    and run the coder again.
+
+                    Interrupted prompts:
+                    ${block(interruptedPrompts
+            .map(({ file, section }) => `- \`${buildPromptLabel(file, section)}\``)
+            .join('\n'))}
+                `));
+        }
+        return interruptedPrompts[0];
+    }
+
     /**
      * Prints a summary of the prompt that will run next.
      */
@@ -77248,7 +77587,7 @@
      * visuals are rendered through the shared canvas avatar pipeline into terminal ASCII art, using a
      * transparent horizontal canvas instead of the website's framed 1:1 surface.
      *
-     * The visual is decorative, so any failure returns `null` and the caller keeps the default brand banner.
+     * The visual is decorative, so any failure returns `null` and the caller renders no header visual at all.
      *
      * @param agentSource Source of the `--agent` book file.
      * @returns ANSI-colored ASCII-art renderer or `null` when the visual cannot be rendered.
@@ -77410,6 +77749,8 @@
             let previousRoundEndTime;
             let completedRunCount = 0;
             let hasRunTestBefore = false;
+            // Note: Only the very first round resumes the interrupted prompt, every later round starts from a clean tree
+            let isContinuingInterruptedPrompt = options.gitChanges === 'continue';
             while (just(true)) {
                 if (options.autoPull && !options.dryRun) {
                     await waitForRequestedPause({
@@ -77434,6 +77775,7 @@
                         progressDisplay,
                         uiHandle,
                         promptRunnerIdentity,
+                        isContinuingInterruptedPrompt,
                     });
                 }
                 if (!hasRunTestBefore) {
@@ -77448,6 +77790,7 @@
                         uiHandle,
                         waitForRequestedPause,
                         hasWaitedForStart,
+                        isContinuingInterruptedPrompt,
                     });
                     hasRunTestBefore = true;
                 }
@@ -77462,6 +77805,7 @@
                     progressDisplay,
                     uiHandle,
                     promptRunnerIdentity,
+                    isContinuingInterruptedPrompt,
                 });
                 hasShownUpcomingTasks || (hasShownUpcomingTasks = showUpcomingTasksOnce({
                     hasShownUpcomingTasks,
@@ -77482,7 +77826,12 @@
                     }
                     if (options.keepAlive) {
                         announceKeepAliveStatus(promptQueueSnapshot, isRichUiEnabled, uiHandle);
-                        await new Promise((resolve) => setTimeout(resolve, KEEP_ALIVE_POLL_INTERVAL_MS));
+                        // Note: The keep-alive poll runs in the `waiting` phase, where `S  Skip current waiting`
+                        //       is offered, so pressing `S` looks for new prompts right away
+                        await waitForSkippableWorldTimeDeadline({
+                            deadlineTimeMs: Date.now() + KEEP_ALIVE_POLL_INTERVAL_MS,
+                            pollIntervalMs: KEEP_ALIVE_POLL_INTERVAL_MS,
+                        });
                         continue;
                     }
                     finishWhenNoPromptIsAvailable(promptQueueSnapshot, isRichUiEnabled, uiHandle);
@@ -77518,7 +77867,7 @@
                     progressDisplay,
                     uiHandle,
                 });
-                if (!options.ignoreGitChanges) {
+                if (isCleanWorkingTreeRequired(options.gitChanges, isContinuingInterruptedPrompt)) {
                     await waitForRequestedPause({
                         checkpointLabel: 'checking the git working tree',
                         phase: 'loading',
@@ -77542,6 +77891,7 @@
                     uiHandle,
                     waitForRequestedPause,
                 });
+                isContinuingInterruptedPrompt = false;
                 previousRoundStartTime = currentRoundStartTime;
                 previousRoundEndTime = Date.now();
                 completedRunCount += 1;
@@ -77585,9 +77935,9 @@
                 Flag \`--allow-destructive-auto-migrate\` requires \`--auto-migrate\`.
             `));
         }
-        if (options.noCommit && !options.waitForUser && !options.ignoreGitChanges) {
+        if (options.noCommit && !options.waitForUser && options.gitChanges !== 'ignore') {
             throw new NotAllowed(_spaceTrim.spaceTrim(`
-                Flag \`--no-commit\` requires \`--ignore-git-changes\` when running in auto mode (the default; pass \`--no-auto\` for interactive confirmation).
+                Flag \`--no-commit\` requires \`--git-changes ignore\` when running in auto mode (the default; pass \`--no-auto\` for interactive confirmation).
 
                 Without commits, the next prompt round would fail the clean working tree check.
             `));
@@ -77606,6 +77956,13 @@
                 An isolated task is implemented in a temporary worktree and reaches the original branch only through a merge, which requires the round to end with a commit.
             `));
         }
+        if (options.isIsolated && options.gitChanges === 'continue') {
+            throw new NotAllowed(_spaceTrim.spaceTrim(`
+                Flag \`--isolate\` cannot be combined with \`--git-changes continue\`.
+
+                An isolated task is implemented in a fresh temporary worktree checked out from the last commit, so the uncommitted changes of the interrupted prompt would be left behind instead of being continued.
+            `));
+        }
         if (options.limit !== undefined && (!Number.isInteger(options.limit) || options.limit <= 0)) {
             throw new NotAllowed(_spaceTrim.spaceTrim(`
                 Flag \`--limit\` expects a positive integer.
@@ -77614,6 +77971,18 @@
             `));
         }
     }
+    /**
+     * Decides whether the working tree has to be verified clean before the next prompt starts.
+     *
+     * `--git-changes continue` waives the check for the single round which resumes the interrupted prompt,
+     * because that round is started exactly for the uncommitted changes the interrupted prompt left behind.
+     */
+    function isCleanWorkingTreeRequired(gitChanges, isContinuingInterruptedPrompt) {
+        if (gitChanges === 'ignore') {
+            return false;
+        }
+        return !isContinuingInterruptedPrompt;
+    }
     /**
      * Pulls the latest repository state before loading prompts when the feature is enabled.
      */
@@ -77672,7 +78041,7 @@
      * Runs the optional pre-coding verification and, when requested, its one repair prompt.
      */
     async function runTestBeforeIfNeeded(options) {
-        const { options: runOptions, runner, runnerMetadata, resolvedCoderContext, resolvedAgentSystemMessage, isRichUiEnabled, progressDisplay, uiHandle, waitForRequestedPause, hasWaitedForStart, } = options;
+        const { options: runOptions, runner, runnerMetadata, resolvedCoderContext, resolvedAgentSystemMessage, isRichUiEnabled, progressDisplay, uiHandle, waitForRequestedPause, hasWaitedForStart, isContinuingInterruptedPrompt, } = options;
         if (runOptions.testBefore === 'no') {
             return hasWaitedForStart;
         }
@@ -77683,7 +78052,7 @@
                 Pass one with ${'`--test <test-command>`'} or use the default ${'`npm test`'} command by providing the mode through the CLI.
             `));
         }
-        if (!runOptions.ignoreGitChanges) {
+        if (isCleanWorkingTreeRequired(runOptions.gitChanges, isContinuingInterruptedPrompt)) {
             await waitForRequestedPause({
                 checkpointLabel: 'checking the git working tree before testing',
                 phase: 'loading',
@@ -77852,9 +78221,9 @@
         uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage(`Running prompts with ${runnerName}`);
     }
     /**
-     * Prepares the `--agent` book avatar ASCII-art renderer and shows it instead of the default brand banner.
+     * Prepares the `--agent` book avatar ASCII-art renderer and shows it above the dashboard boxes.
      *
-     * Keeps the default banner when no agent is selected, the UI is disabled, or the visual cannot be rendered.
+     * Leaves the header empty when no agent is selected, the UI is disabled, or the visual cannot be rendered.
      */
     async function initializeRunUiAgentVisual(uiHandle, agentSource) {
         if (!uiHandle || !agentSource) {
@@ -77869,7 +78238,7 @@
      * Loads prompt files, updates progress displays, and selects the next runnable prompt.
      */
     async function loadPromptQueueSnapshot(options) {
-        const { options: runOptions, isRichUiEnabled, progressDisplay, uiHandle, promptRunnerIdentity } = options;
+        const { options: runOptions, isRichUiEnabled, progressDisplay, uiHandle, promptRunnerIdentity, isContinuingInterruptedPrompt, } = options;
         uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setCurrentScriptPath(undefined);
         const promptFiles = await loadPromptFiles(PROMPTS_DIR$1);
         const stats = summarizePrompts(promptFiles, runOptions.priorityFilter);
@@ -77881,7 +78250,11 @@
         return {
             promptFiles,
             stats,
-            nextPrompt: findNextTodoPrompt(promptFiles, runOptions.priorityFilter, promptRunnerIdentity),
+            // Note: A resumed prompt is picked by its `[^]` status alone, the priority and runner filters select
+            //       which prompt is started next, not which unfinished work is continued
+            nextPrompt: isContinuingInterruptedPrompt
+                ? resolveInterruptedPrompt(promptFiles)
+                : findNextTodoPrompt(promptFiles, runOptions.priorityFilter, promptRunnerIdentity),
         };
     }
     /**