@promptbook/cli 0.112.0-127 → 0.112.0-129

package/src/version.ts

@@ -16,11 +16,11 @@ export const BOOK_LANGUAGE_VERSION: string_semantic_version = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-export const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version = '0.112.0-127';
+export const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version = '0.112.0-129';
 
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.112.0-126`).
+ * It follows semantic versioning (e.g., `0.112.0-128`).
  *
  * @generated
  */

package/src/versions.txt

@@ -1156,4 +1156,5 @@
 0.112.0-122
 0.112.0-123
 0.112.0-126
-0.112.0-127
+0.112.0-128
+0.112.0-129

package/umd/index.umd.js

@@ -63,7 +63,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-127';
+    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-129';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -5197,7 +5197,9 @@
             noUi: options.noUi,
             thinkingLevel: options.thinkingLevel,
             waitForUser: false,
+            waitAfterPrompt: 0,
             waitBetweenPrompts: 0,
+            waitAfterError: 0,
             noCommit: options.noCommit,
             ignoreGitChanges: options.ignoreGitChanges,
             normalizeLineEndings: options.normalizeLineEndings,
@@ -39927,6 +39929,27 @@
         return parts.join(' ');
     }
 
+    /**
+     * Default wait duration applied before retrying a prompt round after an error (10 minutes).
+     *
+     * @private internal constant of `ptbk coder` wait handling
+     */
+    const DEFAULT_WAIT_AFTER_ERROR_MS$1 = 10 * 60 * 1000;
+    /**
+     * Parses an optional Commander duration string and returns the resolved milliseconds.
+     *
+     * Returns `defaultMs` when the flag was not provided or was provided without a non-empty value.
+     *
+     * @private internal utility of `ptbk coder` wait handling
+     */
+    function parseOptionalWaitDuration(value, defaultMs) {
+        if (typeof value !== 'string' || value === '') {
+            return defaultMs;
+        }
+        return parseDuration(value);
+    }
+    // Note: [💞] Ignore a discrepancy between file name and entity name
+
     /**
      * Initializes `coder run` command for Promptbook CLI utilities
      *
@@ -39960,31 +39983,46 @@
         command.option('--preserve-logs', 'Keep generated temp prompt/log artifacts after successful rounds for debugging and analytics', false);
         addPromptRunnerExecutionOptions(command);
         command.option('--priority <minimum-priority>', 'Filter prompts by minimum priority level', parseIntOption$1, 0);
-        command.option('--wait <duration>', _spaceTrim.spaceTrim(`
-            Wait this long between prompt rounds to avoid hitting rate limits of the harness.
-            Accepts durations like 1h, 30m, 5s.
+        command.option('--wait-after-prompt <duration>', _spaceTrim.spaceTrim(`
+            Wait this long after each prompt has been implemented, verified and committed before starting the next prompt.
+            Accepts durations like 1h, 30m, 5s. Defaults to 0 (no wait).
+        `));
+        command.option('--wait-between-prompts <duration>', _spaceTrim.spaceTrim(`
+            Pace prompts so that each next prompt starts at least this long after the previous one began.
+            If the previous prompt already took longer than this, the next prompt starts immediately.
+            Accepts durations like 1h, 30m, 5s. Defaults to 0 (no pacing).
+        `));
+        command.option('--wait-after-error <duration>', _spaceTrim.spaceTrim(`
+            Wait this long before retrying a prompt after an error occurs (up to 3 retries before giving up).
+            Accepts durations like 1h, 30m, 5s. Defaults to 10m.
         `));
         // Note: --no-auto disables the default auto behaviour and waits for user confirmation before each prompt
         command.option('--no-auto', 'Wait for user confirmation before each prompt instead of running automatically through the queue');
         command.option('--auto-migrate', 'Run testing-server database migrations automatically after each successfully processed prompt');
         command.option('--allow-destructive-auto-migrate', 'Allow auto-migrate even when heuristic SQL safety check flags destructive pending migrations');
         command.action(handleActionErrors(async (cliOptions) => {
-            const { dryRun, agent, context, test, preserveLogs, priority, wait, auto, autoMigrate, allowDestructiveAutoMigrate, } = cliOptions;
+            const { dryRun, agent, context, test, preserveLogs, priority, waitAfterPrompt: waitAfterPromptValue, waitBetweenPrompts: waitBetweenPromptsValue, waitAfterError: waitAfterErrorValue, auto, autoMigrate, allowDestructiveAutoMigrate, } = cliOptions;
             const testCommand = normalizeCommandOptionValue$1(test);
             const runnerOptions = normalizePromptRunnerCliOptions(cliOptions, {
                 isAgentRequired: !dryRun,
             });
-            // [1] Parse the --wait and --no-auto options:
-            //   default: run automatically through the queue (no waiting)
+            // [1] Parse the wait options and --no-auto:
+            //   default: run automatically through the queue (no waiting between prompts)
             //   --no-auto: wait for user confirmation before each prompt (interactive mode)
-            //   --wait <duration>: wait that long between prompt rounds to avoid rate limits
+            //   --wait-after-prompt: pause after a successful round before starting the next prompt
+            //   --wait-between-prompts: pace from start of one prompt to start of next
+            //   --wait-after-error: wait before retrying after an error (default 10m)
             const waitForUser = !auto;
-            const waitBetweenPrompts = typeof wait === 'string' && wait !== '' ? parseDuration(wait) : 0;
+            const waitAfterPrompt = parseOptionalWaitDuration(waitAfterPromptValue, 0);
+            const waitBetweenPrompts = parseOptionalWaitDuration(waitBetweenPromptsValue, 0);
+            const waitAfterError = parseOptionalWaitDuration(waitAfterErrorValue, DEFAULT_WAIT_AFTER_ERROR_MS$1);
             // Convert commander options to RunOptions format
             const runOptions = {
                 dryRun,
                 waitForUser,
+                waitAfterPrompt,
                 waitBetweenPrompts,
+                waitAfterError,
                 noCommit: runnerOptions.noCommit,
                 ignoreGitChanges: runnerOptions.ignoreGitChanges,
                 agentName: runnerOptions.agentName,
@@ -40092,28 +40130,41 @@
         command.option('--preserve-logs', 'Keep generated temp prompt/log artifacts after successful rounds for debugging and analytics', false);
         addPromptRunnerExecutionOptions(command);
         command.option('--priority <minimum-priority>', 'Filter prompts by minimum priority level', parseIntOption, 0);
-        command.option('--wait <duration>', _spaceTrim.spaceTrim(`
-            Wait this long between prompt rounds to avoid hitting rate limits of the harness.
-            Accepts durations like 1h, 30m, 5s.
+        command.option('--wait-after-prompt <duration>', _spaceTrim.spaceTrim(`
+            Wait this long after each prompt has been implemented, verified and committed before starting the next prompt.
+            Accepts durations like 1h, 30m, 5s. Defaults to 0 (no wait).
+        `));
+        command.option('--wait-between-prompts <duration>', _spaceTrim.spaceTrim(`
+            Pace prompts so that each next prompt starts at least this long after the previous one began.
+            If the previous prompt already took longer than this, the next prompt starts immediately.
+            Accepts durations like 1h, 30m, 5s. Defaults to 0 (no pacing).
+        `));
+        command.option('--wait-after-error <duration>', _spaceTrim.spaceTrim(`
+            Wait this long before retrying a prompt after an error occurs (up to 3 retries before giving up).
+            Accepts durations like 1h, 30m, 5s. Defaults to 10m.
         `));
         command.option('--no-auto', 'Wait for user confirmation before each prompt instead of running automatically through the queue');
         command.option('--auto-migrate', 'Run testing-server database migrations automatically after each successfully processed prompt');
         command.option('--allow-destructive-auto-migrate', 'Allow auto-migrate even when heuristic SQL safety check flags destructive pending migrations');
         command.action(handleActionErrors(async (cliOptions) => {
-            const { port: rawPort, dryRun, agent, context, test, preserveLogs, priority, wait, auto, autoMigrate, allowDestructiveAutoMigrate, } = cliOptions;
+            const { port: rawPort, dryRun, agent, context, test, preserveLogs, priority, waitAfterPrompt: waitAfterPromptValue, waitBetweenPrompts: waitBetweenPromptsValue, waitAfterError: waitAfterErrorValue, auto, autoMigrate, allowDestructiveAutoMigrate, } = cliOptions;
             const port = parseCoderServerPort(rawPort);
             const testCommand = normalizeCommandOptionValue(test);
             const runnerOptions = normalizePromptRunnerCliOptions(cliOptions, {
                 isAgentRequired: !dryRun,
             });
-            // [1] Parse the --wait and --no-auto options (same logic as `coder run`)
+            // [1] Parse the wait options and --no-auto (same logic as `coder run`)
             const waitForUser = !auto;
-            const waitBetweenPrompts = typeof wait === 'string' && wait !== '' ? parseDuration(wait) : 0;
+            const waitAfterPrompt = parseOptionalWaitDuration(waitAfterPromptValue, 0);
+            const waitBetweenPrompts = parseOptionalWaitDuration(waitBetweenPromptsValue, 0);
+            const waitAfterError = parseOptionalWaitDuration(waitAfterErrorValue, DEFAULT_WAIT_AFTER_ERROR_MS$1);
             const runOptions = {
                 port,
                 dryRun,
                 waitForUser,
+                waitAfterPrompt,
                 waitBetweenPrompts,
+                waitAfterError,
                 noCommit: runnerOptions.noCommit,
                 ignoreGitChanges: runnerOptions.ignoreGitChanges,
                 agentName: runnerOptions.agentName,
@@ -63588,7 +63639,9 @@
             noUi: options.noUi,
             thinkingLevel: options.thinkingLevel,
             waitForUser: false,
+            waitAfterPrompt: 0,
             waitBetweenPrompts: 0,
+            waitAfterError: 0,
             noCommit: true,
             ignoreGitChanges: true,
             normalizeLineEndings: false,
@@ -69423,10 +69476,14 @@
         findUnwrittenPrompts: findUnwrittenPrompts
     });
 
+    /**
+     * Default wait duration applied before retrying a failed prompt round.
+     */
+    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...>] [--preserve-logs] [--no-ui] [--thinking-level <thinking-level>] [--priority <minimum-priority>] [--allow-credits] [--auto-migrate] [--allow-destructive-auto-migrate] [--wait <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...>] [--preserve-logs] [--no-ui] [--thinking-level <thinking-level>] [--priority <minimum-priority>] [--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]';
     /**
      * Top-level flags supported by this command.
      */
@@ -69443,7 +69500,9 @@
         '--allow-credits',
         '--auto-migrate',
         '--allow-destructive-auto-migrate',
-        '--wait',
+        '--wait-after-prompt',
+        '--wait-between-prompts',
+        '--wait-after-error',
         '--no-auto',
         '--no-commit',
         '--ignore-git-changes',
@@ -69487,15 +69546,9 @@
         //   --no-auto: wait for user confirmation before each prompt (interactive mode)
         //   --wait 1h: wait 1h between prompt rounds to avoid rate limits
         const waitForUser = args.includes('--no-auto');
-        let waitBetweenPrompts = 0;
-        const hasWaitFlag = args.includes('--wait');
-        const waitValue = readOptionValue(args, '--wait');
-        if (hasWaitFlag) {
-            if (waitValue === undefined || waitValue.startsWith('-')) {
-                exitWithUsageError('Missing value for --wait. Use a duration like 1h, 30m, 5s.');
-            }
-            waitBetweenPrompts = parseDuration(waitValue);
-        }
+        const waitAfterPrompt = parseWaitOption(args, '--wait-after-prompt', 0);
+        const waitBetweenPrompts = parseWaitOption(args, '--wait-between-prompts', 0);
+        const waitAfterError = parseWaitOption(args, '--wait-after-error', DEFAULT_WAIT_AFTER_ERROR_MS);
         let thinkingLevel;
         if (hasTestCommandFlag && testCommand === undefined) {
             exitWithUsageError('Missing value for --test. Use a shell command such as `npm run test` and quote it when it contains top-level CLI flags.');
@@ -69515,7 +69568,9 @@
         return {
             dryRun,
             waitForUser,
+            waitAfterPrompt,
             waitBetweenPrompts,
+            waitAfterError,
             noCommit,
             ignoreGitChanges,
             normalizeLineEndings,
@@ -69534,6 +69589,19 @@
             priority,
         };
     }
+    /**
+     * Reads a duration-typed CLI flag, applying the provided default when the flag is absent.
+     */
+    function parseWaitOption(args, flag, defaultMs) {
+        if (!args.includes(flag)) {
+            return defaultMs;
+        }
+        const value = readOptionValue(args, flag);
+        if (value === undefined || value.startsWith('-')) {
+            exitWithUsageError(`Missing value for ${flag}. Use a duration like 1h, 30m, 5s.`);
+        }
+        return parseDuration(value);
+    }
     /**
      * Reads a value of a CLI option that follows a given flag.
      */
@@ -69770,6 +69838,58 @@
         return createAgentRunnerSystemMessage(agentSource);
     }
 
+    /**
+     * Refresh interval used by the countdown display while waiting.
+     *
+     * @private internal constant of `sleepWithCountdown`
+     */
+    const WAIT_COUNTDOWN_UPDATE_INTERVAL_MS = 30000;
+    /**
+     * Returns the human-readable status message used for one wait kind.
+     *
+     * @private internal utility of `sleepWithCountdown`
+     */
+    function describeCoderRunWait(waitKind, remainingMs, totalMs) {
+        const formattedRemaining = formatDurationMs(remainingMs);
+        const formattedTotal = totalMs !== undefined ? formatDurationMs(totalMs) : undefined;
+        const totalSuffix = formattedTotal !== undefined ? ` of ${formattedTotal}` : '';
+        switch (waitKind) {
+            case 'between-prompts':
+                return `Waiting ${formattedRemaining}${totalSuffix} between prompts (paced from previous start)`;
+            case 'after-prompt':
+                return `Waiting ${formattedRemaining}${totalSuffix} after previous prompt`;
+            case 'after-error':
+                return `Waiting ${formattedRemaining}${totalSuffix} before retrying after error`;
+        }
+    }
+    /**
+     * Sleeps the requested duration while refreshing the status message on a UI handle and the plain console.
+     *
+     * The wait kind is shown in the UI status so the user can distinguish `--wait-after-prompt`,
+     * `--wait-between-prompts`, and `--wait-after-error` waits at a glance.
+     *
+     * @public exported from `@promptbook/cli`
+     */
+    async function sleepWithCountdown(options) {
+        const { durationMs, waitKind, isRichUiEnabled, uiHandle } = options;
+        if (durationMs <= 0) {
+            return;
+        }
+        let remaining = durationMs;
+        while (remaining > 0) {
+            const statusMessage = describeCoderRunWait(waitKind, remaining, durationMs);
+            if (!isRichUiEnabled) {
+                console.info(colors__default["default"].gray(`${statusMessage}...`));
+            }
+            else {
+                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage(`${statusMessage}...`);
+            }
+            const sleepMs = Math.min(WAIT_COUNTDOWN_UPDATE_INTERVAL_MS, remaining);
+            await new Promise((resolve) => setTimeout(resolve, sleepMs));
+            remaining -= sleepMs;
+        }
+    }
+
     /**
      * Resolves optional coding context provided inline or via a file path.
      */
@@ -71500,6 +71620,13 @@
         await promises.writeFile(file.path, content, 'utf-8');
     }
 
+    /**
+     * Maximum number of retry attempts performed after a prompt round throws an error.
+     * After this many retries the round is finalized as failed.
+     *
+     * @private internal constant of `runPromptRound`
+     */
+    const MAX_RETRY_ATTEMPTS_AFTER_ERROR = 3;
     /**
      * Runs one prompt round from prompt construction through commit or failure logging.
      *
@@ -71532,54 +71659,101 @@
             ? await captureChangedFilesSnapshot(process.cwd())
             : undefined;
         await withPromptRuntimeLog(scriptPath, async (logPath) => {
-            try {
-                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.startCapturingAgentOutput();
-                const result = await runPromptWithTestFeedback({
-                    runner,
-                    prompt: codexPrompt,
-                    scriptPath,
-                    projectPath: process.cwd(),
-                    promptLabel,
-                    testCommand: options.testCommand,
-                    preserveArtifactsOnSuccess: options.preserveLogs,
-                    logPath,
-                    onAttemptStarted: (nextAttemptCount) => {
-                        attemptCount = nextAttemptCount;
-                        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setAttempt(nextAttemptCount);
-                    },
-                    waitForPauseCheckpoint: waitForRequestedPause,
-                });
-                await finalizeSuccessfulPromptRound({
-                    options,
-                    nextPrompt,
-                    runnerMetadata,
-                    promptExecutionStartedDate,
-                    result,
-                    commitMessage,
-                    logPath,
-                    roundChangedFilesSnapshot,
-                    isRichUiEnabled,
-                    progressDisplay,
-                    uiHandle,
-                    waitForRequestedPause,
-                });
-            }
-            catch (error) {
-                await finalizeFailedPromptRound({
-                    nextPrompt,
-                    runnerMetadata,
-                    promptExecutionStartedDate,
-                    attemptCount,
-                    error,
-                    options,
-                    roundChangedFilesSnapshot,
-                    uiHandle,
-                    waitForRequestedPause,
-                });
-                throw error;
+            let lastError;
+            for (let errorRetryAttempt = 0; errorRetryAttempt <= MAX_RETRY_ATTEMPTS_AFTER_ERROR; errorRetryAttempt++) {
+                try {
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.startCapturingAgentOutput();
+                    const result = await runPromptWithTestFeedback({
+                        runner,
+                        prompt: codexPrompt,
+                        scriptPath,
+                        projectPath: process.cwd(),
+                        promptLabel,
+                        testCommand: options.testCommand,
+                        preserveArtifactsOnSuccess: options.preserveLogs,
+                        logPath,
+                        onAttemptStarted: (nextAttemptCount) => {
+                            attemptCount = nextAttemptCount;
+                            uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setAttempt(nextAttemptCount);
+                        },
+                        waitForPauseCheckpoint: waitForRequestedPause,
+                    });
+                    await finalizeSuccessfulPromptRound({
+                        options,
+                        nextPrompt,
+                        runnerMetadata,
+                        promptExecutionStartedDate,
+                        result,
+                        commitMessage,
+                        logPath,
+                        roundChangedFilesSnapshot,
+                        isRichUiEnabled,
+                        progressDisplay,
+                        uiHandle,
+                        waitForRequestedPause,
+                    });
+                    return;
+                }
+                catch (error) {
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.stopCapturingAgentOutput();
+                    lastError = error;
+                    if (errorRetryAttempt >= MAX_RETRY_ATTEMPTS_AFTER_ERROR) {
+                        break;
+                    }
+                    await waitAfterErrorBeforeRetry({
+                        options,
+                        error,
+                        attemptedRetries: errorRetryAttempt + 1,
+                        isRichUiEnabled,
+                        progressDisplay,
+                        uiHandle,
+                        waitForRequestedPause,
+                    });
+                }
             }
+            await finalizeFailedPromptRound({
+                nextPrompt,
+                runnerMetadata,
+                promptExecutionStartedDate,
+                attemptCount,
+                error: lastError,
+                options,
+                roundChangedFilesSnapshot,
+                uiHandle,
+                waitForRequestedPause,
+            });
+            throw lastError;
         }, { preserveArtifactsOnSuccess: options.preserveLogs });
     }
+    /**
+     * Sleeps `options.waitAfterError` while keeping the rich UI and plain console in sync, then resets state for the retry.
+     */
+    async function waitAfterErrorBeforeRetry(options) {
+        const { options: runOptions, error, attemptedRetries, isRichUiEnabled, progressDisplay, uiHandle, waitForRequestedPause, } = options;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.addError(errorMessage);
+        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('waiting');
+        if (!isRichUiEnabled) {
+            console.warn(colors__default["default"].yellow(`Prompt round failed (retry ${attemptedRetries}/${MAX_RETRY_ATTEMPTS_AFTER_ERROR}): ${errorMessage}`));
+        }
+        await waitForRequestedPause({
+            checkpointLabel: 'waiting after error before retrying the prompt',
+            phase: 'waiting',
+            statusMessage: `Waiting before retry ${attemptedRetries}/${MAX_RETRY_ATTEMPTS_AFTER_ERROR} after error`,
+        });
+        progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.pauseTimer();
+        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.pauseTimer();
+        await sleepWithCountdown({
+            durationMs: runOptions.waitAfterError,
+            waitKind: 'after-error',
+            isRichUiEnabled,
+            uiHandle,
+        });
+        progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.resumeTimer();
+        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.resumeTimer();
+        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('running');
+        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage(`Retrying prompt (retry ${attemptedRetries}/${MAX_RETRY_ATTEMPTS_AFTER_ERROR})`);
+    }
     /**
      * Updates UI or console output to reflect that the selected prompt is being processed.
      */
@@ -71760,7 +71934,8 @@
             initializeRunUi(uiHandle, runner.name, actualRunnerModel, options);
             let hasShownUpcomingTasks = false;
             let hasWaitedForStart = false;
-            let hasRunAtLeastOneRound = false;
+            let previousRoundStartTime;
+            let previousRoundEndTime;
             while (just(true)) {
                 if (options.autoPull && !options.dryRun) {
                     await waitForRequestedPause({
@@ -71803,15 +71978,16 @@
                 const nextPrompt = promptQueueSnapshot.nextPrompt;
                 const promptLabel = buildPromptLabelForDisplay(nextPrompt.file, nextPrompt.section);
                 // Wait between prompt rounds (skipped for the first round)
-                if (hasRunAtLeastOneRound) {
+                if (previousRoundStartTime !== undefined && previousRoundEndTime !== undefined) {
                     await waitBetweenPromptRoundsIfNeeded({
                         options,
+                        previousRoundStartTime,
+                        previousRoundEndTime,
                         isRichUiEnabled,
                         progressDisplay,
                         uiHandle,
                     });
                 }
-                hasRunAtLeastOneRound = true;
                 hasWaitedForStart = await waitForPromptConfirmationIfNeeded({
                     options,
                     nextPrompt,
@@ -71829,6 +72005,7 @@
                     });
                     await ensureWorkingTreeClean();
                 }
+                const currentRoundStartTime = Date.now();
                 await runPromptRound({
                     options,
                     runner,
@@ -71842,6 +72019,8 @@
                     uiHandle,
                     waitForRequestedPause,
                 });
+                previousRoundStartTime = currentRoundStartTime;
+                previousRoundEndTime = Date.now();
             }
         }
         finally {
@@ -72066,39 +72245,50 @@
         uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.resumeTimer();
         return true;
     }
-    /**
-     * Countdown update interval for the between-rounds wait display.
-     */
-    const WAIT_COUNTDOWN_UPDATE_INTERVAL_MS = 30000;
     /**
      * Polling interval when in keepAlive server mode and no runnable prompts are available.
      */
     const KEEP_ALIVE_POLL_INTERVAL_MS = 5000;
     /**
-     * Waits the configured time between prompt rounds to avoid hitting harness rate limits.
-     * Does nothing when `waitBetweenPrompts` is zero.
+     * Waits between prompt rounds according to `--wait-between-prompts` (paced from the previous round's start)
+     * and `--wait-after-prompt` (measured from the previous round's end).
+     * Both phases are shown separately in the UI so the user can see which type of wait is active.
      */
     async function waitBetweenPromptRoundsIfNeeded(options) {
-        const { options: runOptions, isRichUiEnabled, progressDisplay, uiHandle } = options;
-        const { waitBetweenPrompts } = runOptions;
-        if (waitBetweenPrompts <= 0) {
+        const { options: runOptions, previousRoundStartTime, previousRoundEndTime, isRichUiEnabled, progressDisplay, uiHandle, } = options;
+        const { waitAfterPrompt, waitBetweenPrompts } = runOptions;
+        if (waitAfterPrompt <= 0 && waitBetweenPrompts <= 0) {
+            return;
+        }
+        const now = Date.now();
+        const waitBetweenPromptsEndTime = previousRoundStartTime + waitBetweenPrompts;
+        const waitAfterPromptEndTime = previousRoundEndTime + waitAfterPrompt;
+        // Phase 1: pace from start of previous prompt (`--wait-between-prompts`)
+        const phase1Duration = Math.max(0, waitBetweenPromptsEndTime - now);
+        // Phase 2: rest from end of previous prompt (`--wait-after-prompt`)
+        const phase2StartTime = Math.max(now, waitBetweenPromptsEndTime);
+        const phase2Duration = Math.max(0, waitAfterPromptEndTime - phase2StartTime);
+        if (phase1Duration <= 0 && phase2Duration <= 0) {
             return;
         }
         progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.pauseTimer();
         uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.pauseTimer();
         uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('waiting');
-        let remaining = waitBetweenPrompts;
-        while (remaining > 0) {
-            const statusMessage = `Waiting ${formatDurationMs(remaining)} before next prompt to avoid rate limits...`;
-            if (!isRichUiEnabled) {
-                console.info(colors__default["default"].gray(statusMessage));
-            }
-            else {
-                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage(statusMessage);
-            }
-            const sleepMs = Math.min(WAIT_COUNTDOWN_UPDATE_INTERVAL_MS, remaining);
-            await new Promise((resolve) => setTimeout(resolve, sleepMs));
-            remaining -= sleepMs;
+        if (phase1Duration > 0) {
+            await sleepWithCountdown({
+                durationMs: phase1Duration,
+                waitKind: 'between-prompts',
+                isRichUiEnabled,
+                uiHandle,
+            });
+        }
+        if (phase2Duration > 0) {
+            await sleepWithCountdown({
+                durationMs: phase2Duration,
+                waitKind: 'after-prompt',
+                isRichUiEnabled,
+                uiHandle,
+            });
         }
         progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.resumeTimer();
         uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.resumeTimer();