@promptbook/cli 0.114.0-19 → 0.114.0-20

package/esm/index.es.js

@@ -48,7 +48,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @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
@@ -1750,6 +1750,32 @@ const PTBK_MODEL_ENV = 'PTBK_MODEL';
  */
 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.
  *
@@ -1809,6 +1835,17 @@ const PROMPT_RUNNER_MODEL_OPTION_DESCRIPTION = spaceTrim$1(`
     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$1(`
+    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.
  *
@@ -1838,7 +1875,9 @@ function addPromptRunnerRuntimeOptions(command) {
 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 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);
@@ -1849,11 +1888,12 @@ function addPromptRunnerExecutionOptions(command) {
  * @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,
@@ -22752,7 +22792,7 @@ async function ensureWorkingTreeCleanForAgentQueue(projectPath) {
             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')}
@@ -22808,7 +22848,7 @@ async function pullLatestChangesForAgentQueueIfEnabled(options) {
  * 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);
@@ -23330,6 +23370,58 @@ function buildAgentMessageScriptPath(projectPath, messageFile) {
  */
 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.bgYellow.black(badgeText),
+    S: (badgeText) => colors.bgCyan.black(badgeText),
+    X: (badgeText) => colors.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.green(message),
+    info: (message) => colors.cyan(message),
+    warning: (message) => colors.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.gray(` (×${repeatCount})`) : '';
+    return `${colors.gray(CODER_RUN_CONTROL_FEEDBACK_MARKER)} ${buildCoderRunControlKeyBadge(feedback.controlKey)} ${colorizeMessage(feedback.message)}${repeatSuffix}`;
+}
+
 /**
  * Centers an ANSI-colored line within the available frame width.
  *
@@ -23504,7 +23596,8 @@ function buildPausePresentation(phase, pauseState, pauseTargetLabel, statusMessa
     return {
         badge: buildRunningPhaseBadge(phase),
         stateMessage: statusMessage,
-        pauseControl: colors.bgYellow.black(' P ') + colors.white(' Pause'),
+        // Note: The two paused variants above deliberately recolor the `P` badge, everything else uses the shared one
+        pauseControl: buildCoderRunControlKeyBadge('P') + colors.white(' Pause'),
     };
 }
 /**
@@ -23545,20 +23638,34 @@ function buildCoderRunControlPills(options) {
         ],
     });
 }
+/**
+ * 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.bgCyan.black(' S ') + colors.white(' Skip current waiting');
+    return buildCoderRunControlKeyBadge('S') + colors.white(' Skip current waiting');
 }
 /**
  * Builds the dynamic `X` control label.
  */
 function buildEndAfterCurrentPromptControl(isEndAfterCurrentPromptRequested, sessionTotal) {
     if (isEndAfterCurrentPromptRequested) {
-        return colors.bgBlue.white(' X ') + colors.white(` Do all ${formatControlPromptCount(sessionTotal)}`);
+        return buildCoderRunControlKeyBadge('X') + colors.white(` Do all ${formatControlPromptCount(sessionTotal)}`);
     }
-    return colors.bgBlue.white(' X ') + colors.white(' End with this prompt');
+    return buildCoderRunControlKeyBadge('X') + colors.white(' End with this prompt');
 }
 /**
  * Formats one prompt count for the `X` control.
@@ -23776,10 +23883,13 @@ function buildAgentRunUiFrame(options) {
         : [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),
         '',
@@ -23792,7 +23902,7 @@ function buildAgentRunUiFrame(options) {
     if (options.errors.length > 0) {
         frame.push(...renderBox('Errors', options.errors.map((errorLine) => `${colors.red('✗')} ${errorLine}`), totalWidth, colors.red.bold));
     }
-    frame.push(...renderBox('Controls', [controls], totalWidth, colors.white.bold));
+    frame.push(...renderBox('Controls', controlsBoxLines, totalWidth, colors.white.bold));
     return frame;
 }
 /**
@@ -25114,6 +25224,254 @@ async function $runGoScriptWithOutput(options) {
     });
 }
 
+/**
+ * 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.bgWhite.black(`Paused before ${getPauseTargetLabel()}`) +
+                colors.gray(' (Press "p" to resume)'));
+        }
+        (_a = options === null || options === void 0 ? void 0 : options.onPaused) === null || _a === void 0 ? void 0 : _a.call(options);
+        while (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.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.
  */
@@ -25163,6 +25521,32 @@ async function waitForRegularMilliseconds(durationMs) {
     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.
  */
@@ -25570,6 +25954,10 @@ class ClaudeCodeRunner {
 }
 /**
  * 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;
@@ -25580,7 +25968,7 @@ async function waitForClaudeCodeSessionLimitReset(sessionLimit, resurrectionCoun
     if ((_a = options.shouldPrintLiveOutput) !== null && _a !== void 0 ? _a : true) {
         console.warn(colors.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) => {
@@ -27019,292 +27407,100 @@ function exitForMissingModel(agentName, availableModels, exampleUsages) {
 }
 
 /**
- * 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.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.bgWhite('Pausing...'));
-            }
-            else if (toggleResult === 'CANCELLED_PAUSE') {
-                console.log(colors.green('Pause cancelled. Resuming...'));
-            }
-        }
-        if (key.name === 's') {
-            if (requestSkipCurrentWait() === 'REQUESTED_SKIP') {
-                console.log(colors.green('Skipping current wait...'));
-            }
-        }
-        if (key.name === 'x') {
-            const toggleResult = toggleEndAfterCurrentPromptState();
-            if (toggleResult === 'REQUESTED_END') {
-                console.log(colors.yellow('Will end after the current prompt finishes.'));
-            }
-            else {
-                console.log(colors.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.bgWhite.black(`Paused before ${getPauseTargetLabel()}`) +
-                colors.gray(' (Press "p" to resume)'));
-        }
-        (_a = options === null || options === void 0 ? void 0 : options.onPaused) === null || _a === void 0 ? void 0 : _a.call(options);
-        while (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.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.
@@ -27429,85 +27625,696 @@ function assertPriorityBoundary(optionName, priority) {
 // 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.magenta.bold('      .-""""-.'),
-    colors.magenta.bold("    .'  .-.  '."),
-    `${colors.magenta.bold('   /   (')}${colors.yellow.bold('o o')}${colors.magenta.bold(')   \\')}`,
-    colors.magenta.bold('  |      ^      |'),
-    colors.magenta.bold('  |   \\___/     |'),
-    colors.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.green.bold('ptbk.io')}`,
-        colors.cyan('          __      __'),
-        colors.cyan('   _/\\/\\/  \\_/\\/  \\_/\\_'),
-        colors.cyan('_/\\/  _   /\\/  _  /\\/\\__'),
-        colors.cyan('\\__/ /_/\\/  \\_/ \\_/  \\_/'),
-        colors.cyan('   /_/   \\__/   \\__/  /'),
-    ],
-    [
-        `                 ${colors.green.bold('ptbk.io')}`,
-        colors.cyan('          __      __'),
-        colors.cyan('   _/\\/  \\_/\\/\\_  \\_/\\_'),
-        colors.cyan('_/\\/  _  /\\/  _ \\/\\/  \\__'),
-        colors.cyan('\\__/ /_/\\/  \\_/  \\_ /\\_/'),
-        colors.cyan('     /_/  \\__/   \\__/  /'),
-    ],
-    [
-        `                 ${colors.green.bold('ptbk.io')}`,
-        colors.cyan('          __      __'),
-        colors.cyan('   _/\\/\\/  \\_/\\_  \\_/\\_'),
-        colors.cyan('_/\\/  _   /\\/  _  /\\/  \\_'),
-        colors.cyan('\\__/ /_/\\/  \\_/ \\_/  _/'),
-        colors.cyan('   /_/    \\__/    \\__/'),
-    ],
-    [
-        `                 ${colors.green.bold('ptbk.io')}`,
-        colors.cyan('          __      __'),
-        colors.cyan('   _/\\/  \\_/\\/  \\_/\\/\\_'),
-        colors.cyan('_/\\/  _  /\\/  _  /\\/\\  \\'),
-        colors.cyan('\\__/ /_/\\/  \\_/ \\_  \\_/'),
-        colors.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.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.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.yellow.bold),
+        ...renderBox(options.currentPromptLabel ? 'Current task' : 'Queue', currentTaskLines, totalWidth, colors.magenta.bold),
+        ...renderBox('Live output', visibleOutputLines, totalWidth, colors.green.bold),
+    ];
+    if (options.errors.length > 0) {
+        const bodyWidth = Math.max(10, totalWidth - 4);
+        frame.push(...renderBox('Errors', buildErrorDisplayLines(options.errors, bodyWidth), totalWidth, colors.red.bold));
+    }
+    frame.push(...renderBox('Controls', controlsBoxLines, totalWidth, colors.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(`                        
-                                   
-        ▄▄▄▄ ▄▄▄▄▄▄ ▄▄▄▄  ▄▄ ▄▄   ▄▄  ▄▄▄  
-        ██▄█▀  ██   ██▄██ ██▄█▀   ██ ██▀██ 
-        ██     ██   ██▄█▀ ██ ██ ▄ ██ ▀███▀ 
-                                            
-    `)
-        .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.duration(estimatedTotalMs);
+        const estimatedCompletion = moment().add(estimatedRemainingMs, 'milliseconds');
+        estimatedTotalText = formatDurationBrief(estimatedTotalDuration);
+        estimatedLabel = estimatedCompletion.calendar(null, ESTIMATED_DONE_CALENDAR_FORMATS);
+        isEstimatedTotalKnown = true;
+    }
+    return {
+        totalPrompts,
+        sessionDone,
+        sessionRemaining,
+        sessionTotal,
+        currentPromptIndex,
+        skippedPrompts: stats.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();
+        }
+    }
+    /**
+     * Resumes active-time tracking after a pause.
+     */
+    resume() {
+        if (this.pausedSince !== undefined) {
+            this.pausedMs += moment().diff(this.pausedSince);
+            this.pausedSince = undefined;
+        }
+    }
+    /**
+     * Returns the currently accumulated active duration.
+     */
+    getElapsedDuration() {
+        const wallMs = moment().diff(this.startTime);
+        const currentPauseMs = this.pausedSince !== undefined ? moment().diff(this.pausedSince) : 0;
+        return moment.duration(Math.max(0, wallMs - this.pausedMs - currentPauseMs));
+    }
+}
+
+/**
+ * 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 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');
+    }
 }
 
 /**
@@ -28177,807 +28984,139 @@ const TERMINAL_AGENT_AVATAR_VISUAL_CANVAS_HEIGHT = DEFAULT_AVATAR_SIZE;
  * @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.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.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.yellow.bold),
-        ...renderBox(options.currentPromptLabel ? 'Current task' : 'Queue', currentTaskLines, totalWidth, colors.magenta.bold),
-        ...renderBox('Live output', visibleOutputLines, totalWidth, colors.green.bold),
-    ];
-    if (options.errors.length > 0) {
-        const bodyWidth = Math.max(10, totalWidth - 4);
-        frame.push(...renderBox('Errors', buildErrorDisplayLines(options.errors, bodyWidth), totalWidth, colors.red.bold));
-    }
-    frame.push(...renderBox('Controls', [controls], totalWidth, colors.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.duration(estimatedTotalMs);
-        const estimatedCompletion = moment().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();
-        }
-    }
-    /**
-     * Resumes active-time tracking after a pause.
-     */
-    resume() {
-        if (this.pausedSince !== undefined) {
-            this.pausedMs += moment().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().diff(this.startTime);
-        const currentPauseMs = this.pausedSince !== undefined ? moment().diff(this.pausedSince) : 0;
-        return moment.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 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;
 }
 
 /**
@@ -29075,6 +29214,7 @@ function renderCoderRunUi(startTime, options = {}) {
     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.
@@ -29140,9 +29280,32 @@ function renderCoderRunUi(startTime, options = {}) {
             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.
      */
@@ -29175,19 +29338,10 @@ function renderCoderRunUi(startTime, options = {}) {
             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) {
@@ -29213,6 +29367,7 @@ function renderCoderRunUi(startTime, options = {}) {
             clearTimeout(autoRefreshTimeout);
             autoRefreshTimeout = undefined;
         }
+        clearControlFeedbackTimeout();
         state.off('change', scheduleRender);
         process.stdin.off('keypress', keypressHandler);
         process.stdout.off('resize', scheduleRender);
@@ -29273,7 +29428,7 @@ function createCoderRunOptionsForAgent(options) {
         waitBetweenPrompts: 0,
         waitAfterError: 0,
         noCommit: options.noCommit,
-        ignoreGitChanges: options.ignoreGitChanges,
+        gitChanges: options.gitChanges,
         normalizeLineEndings: options.normalizeLineEndings,
         allowCredits: options.allowCredits,
         autoMigrate: false,
@@ -39841,11 +39996,11 @@ class RunMultipleAgentMessageTaskScheduler {
  * 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$1(`
-            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.
@@ -40158,7 +40313,7 @@ function createLocalAgentRunOptions(options, localAgentRunnerLimits) {
         noUi: options.noUi,
         thinkingLevel: options.thinkingLevel,
         noCommit: true,
-        ignoreGitChanges: true,
+        gitChanges: 'ignore',
         normalizeLineEndings: false,
         allowCredits: options.allowCredits,
         autoPush: false,
@@ -43756,6 +43911,8 @@ function $initializeCoderRunCommand(program) {
             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
@@ -43836,7 +43993,7 @@ function $initializeCoderRunCommand(program) {
             waitBetweenPrompts,
             waitAfterError,
             noCommit: runnerOptions.noCommit,
-            ignoreGitChanges: runnerOptions.ignoreGitChanges,
+            gitChanges: runnerOptions.gitChanges,
             agentName: runnerOptions.agentName,
             model: runnerOptions.model,
             agent,
@@ -43977,7 +44134,7 @@ function $initializeCoderServerCommand(program) {
             waitBetweenPrompts,
             waitAfterError,
             noCommit: runnerOptions.noCommit,
-            ignoreGitChanges: runnerOptions.ignoreGitChanges,
+            gitChanges: runnerOptions.gitChanges,
             agentName: runnerOptions.agentName,
             model: runnerOptions.model,
             agent,
@@ -67408,7 +67565,7 @@ function createPromptRunnerOptions(options) {
         waitBetweenPrompts: 0,
         waitAfterError: 0,
         noCommit: true,
-        ignoreGitChanges: true,
+        gitChanges: 'ignore',
         normalizeLineEndings: false,
         allowCredits: options.allowCredits,
         isVerbose: options.isVerbose,
@@ -73201,13 +73358,13 @@ function isPromptToBeWritten(file, section) {
 }
 
 /**
- * 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 });
             }
         }
@@ -73215,6 +73372,13 @@ function listTodoPrompts(files) {
     return prompts;
 }
 
+/**
+ * Lists todo prompts across all files.
+ */
+function listTodoPrompts(files) {
+    return listPromptsByStatus(files, 'todo');
+}
+
 /**
  * Lists todo prompts that still contain authoring placeholders.
  */
@@ -73792,7 +73956,7 @@ const DEFAULT_WAIT_AFTER_ERROR_MS = 10 * 60 * 1000;
 /**
  * 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.
  */
@@ -73819,7 +73983,7 @@ const KNOWN_OPTION_FLAGS = new Set([
     '--wait-after-error',
     '--no-auto',
     '--no-commit',
-    '--ignore-git-changes',
+    '--git-changes',
     '--no-normalize-line-endings',
     '--auto-push',
     '--auto-pull',
@@ -73863,7 +74027,8 @@ function parseRunOptions(args) {
     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');
@@ -73901,7 +74066,7 @@ function parseRunOptions(args) {
         waitBetweenPrompts,
         waitAfterError,
         noCommit,
-        ignoreGitChanges,
+        gitChanges,
         normalizeLineEndings,
         allowCredits,
         autoMigrate,
@@ -73939,6 +74104,21 @@ function parseTestBeforeOption(value, hasTestBeforeFlag) {
     }
     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.
  */
@@ -74396,27 +74576,19 @@ async function sleepWithCountdown(options) {
         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.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.gray(`${statusMessage}...`));
+                return;
+            }
+            uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage(`${statusMessage}...`);
+        },
+    });
 }
 
 /**
@@ -74431,6 +74603,36 @@ async function resolveCoderContext(contextReference, currentWorkingDirectory) {
     });
 }
 
+/**
+ * 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.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.
  */
@@ -74449,12 +74651,14 @@ async function isWorkingTreeClean(path) {
 async function ensureWorkingTreeClean() {
     const isClean = await isWorkingTreeClean(process.cwd());
     if (!isClean) {
-        throw new Error(spaceTrim$1(`
+        throw new NotAllowed(spaceTrim$1(`
                 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
             `));
@@ -76021,6 +76225,51 @@ function formatPromptAttemptMetadata(status, attemptCount) {
     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.
  *
@@ -76028,14 +76277,18 @@ function formatPromptAttemptMetadata(status, attemptCount) {
  * ``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}`;
 }
 
 /**
@@ -76078,29 +76331,26 @@ function writePromptStatusLine(file, section, replacementStatusLine) {
 /**
  * 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().diff(promptExecutionStartedDate);
     const durationString = moment.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}`);
 }
 
@@ -76192,6 +76442,12 @@ async function runPromptRound({ options, runner, runnerMetadata, nextPrompt, pro
     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',
@@ -76224,6 +76480,7 @@ async function runPromptRound({ options, runner, runnerMetadata, nextPrompt, pro
                     onStepStarted: (progress) => recordPromptRoundInProgress({
                         nextPrompt,
                         runnerMetadata,
+                        startedByRunnerSignature,
                         thinkingLevel: options.thinkingLevel,
                         attemptCount,
                         progress,
@@ -76234,6 +76491,7 @@ async function runPromptRound({ options, runner, runnerMetadata, nextPrompt, pro
                     options,
                     nextPrompt,
                     runnerMetadata,
+                    startedByRunnerSignature,
                     promptExecutionStartedDate,
                     result,
                     commitMessage,
@@ -76267,6 +76525,7 @@ async function runPromptRound({ options, runner, runnerMetadata, nextPrompt, pro
         await finalizeFailedPromptRound({
             nextPrompt,
             runnerMetadata,
+            startedByRunnerSignature,
             promptExecutionStartedDate,
             attemptCount,
             error: lastError,
@@ -76279,6 +76538,23 @@ async function runPromptRound({ options, runner, runnerMetadata, nextPrompt, pro
         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.
  *
@@ -76287,7 +76563,7 @@ async function runPromptRound({ options, runner, runnerMetadata, nextPrompt, pro
  * 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,
@@ -76295,6 +76571,7 @@ async function recordPromptRoundInProgress(options) {
         inProgressStepKind: progress.startedStepKind,
         runnerName: runnerMetadata.runnerName,
         modelName: runnerMetadata.modelName,
+        startedByRunnerSignature,
         attemptCount,
         loginMethod: progress.loginMethod,
         thinkingLevel,
@@ -76352,14 +76629,24 @@ function setPromptRoundRunningState(options) {
  * 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);
@@ -76410,7 +76697,7 @@ async function finalizeSuccessfulPromptRound(options) {
  * 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));
@@ -76419,7 +76706,15 @@ async function finalizeFailedPromptRound(options) {
         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,
@@ -77172,6 +77467,50 @@ function printUpcomingTasks(tasks) {
     }
 }
 
+/**
+ * Builds a label that identifies the prompt section by index.
+ */
+function buildPromptLabel(file, section) {
+    return `${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$1(`
+                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$1((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.
  */
@@ -77238,7 +77577,7 @@ function $detectTerminalAnsiColorDepth() {
  * 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.
@@ -77400,6 +77739,8 @@ async function runCodexPrompts(providedOptions) {
         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({
@@ -77424,6 +77765,7 @@ async function runCodexPrompts(providedOptions) {
                     progressDisplay,
                     uiHandle,
                     promptRunnerIdentity,
+                    isContinuingInterruptedPrompt,
                 });
             }
             if (!hasRunTestBefore) {
@@ -77438,6 +77780,7 @@ async function runCodexPrompts(providedOptions) {
                     uiHandle,
                     waitForRequestedPause,
                     hasWaitedForStart,
+                    isContinuingInterruptedPrompt,
                 });
                 hasRunTestBefore = true;
             }
@@ -77452,6 +77795,7 @@ async function runCodexPrompts(providedOptions) {
                 progressDisplay,
                 uiHandle,
                 promptRunnerIdentity,
+                isContinuingInterruptedPrompt,
             });
             hasShownUpcomingTasks || (hasShownUpcomingTasks = showUpcomingTasksOnce({
                 hasShownUpcomingTasks,
@@ -77472,7 +77816,12 @@ async function runCodexPrompts(providedOptions) {
                 }
                 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);
@@ -77508,7 +77857,7 @@ async function runCodexPrompts(providedOptions) {
                 progressDisplay,
                 uiHandle,
             });
-            if (!options.ignoreGitChanges) {
+            if (isCleanWorkingTreeRequired(options.gitChanges, isContinuingInterruptedPrompt)) {
                 await waitForRequestedPause({
                     checkpointLabel: 'checking the git working tree',
                     phase: 'loading',
@@ -77532,6 +77881,7 @@ async function runCodexPrompts(providedOptions) {
                 uiHandle,
                 waitForRequestedPause,
             });
+            isContinuingInterruptedPrompt = false;
             previousRoundStartTime = currentRoundStartTime;
             previousRoundEndTime = Date.now();
             completedRunCount += 1;
@@ -77575,9 +77925,9 @@ function validateRunCodexPromptOptions(options) {
                 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$1(`
-                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.
             `));
@@ -77596,6 +77946,13 @@ function validateRunCodexPromptOptions(options) {
                 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$1(`
+                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$1(`
                 Flag \`--limit\` expects a positive integer.
@@ -77604,6 +77961,18 @@ function validateRunCodexPromptOptions(options) {
             `));
     }
 }
+/**
+ * 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.
  */
@@ -77662,7 +78031,7 @@ function normalizeRunOptions(options) {
  * 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;
     }
@@ -77673,7 +78042,7 @@ async function runTestBeforeIfNeeded(options) {
                 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',
@@ -77842,9 +78211,9 @@ function initializeRunUi(uiHandle, runnerName, actualRunnerModel, options) {
     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) {
@@ -77859,7 +78228,7 @@ async function initializeRunUiAgentVisual(uiHandle, agentSource) {
  * 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);
@@ -77871,7 +78240,11 @@ async function loadPromptQueueSnapshot(options) {
     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),
     };
 }
 /**