@promptbook/cli 0.112.0-128 → 0.112.0-129

package/esm/index.es.js

@@ -58,7 +58,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.112.0-128';
+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
@@ -5192,7 +5192,9 @@ function createCoderRunOptionsForAgent(options) {
         noUi: options.noUi,
         thinkingLevel: options.thinkingLevel,
         waitForUser: false,
+        waitAfterPrompt: 0,
         waitBetweenPrompts: 0,
+        waitAfterError: 0,
         noCommit: options.noCommit,
         ignoreGitChanges: options.ignoreGitChanges,
         normalizeLineEndings: options.normalizeLineEndings,
@@ -39922,6 +39924,27 @@ function formatDurationMs(ms) {
     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
  *
@@ -39955,31 +39978,46 @@ function $initializeCoderRunCommand(program) {
     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$1(`
-            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$1(`
+            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$1(`
+            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$1(`
+            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,
@@ -40087,28 +40125,41 @@ function $initializeCoderServerCommand(program) {
     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$1(`
-            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$1(`
+            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$1(`
+            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$1(`
+            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,
@@ -63583,7 +63634,9 @@ function createPromptRunnerOptions(options) {
         noUi: options.noUi,
         thinkingLevel: options.thinkingLevel,
         waitForUser: false,
+        waitAfterPrompt: 0,
         waitBetweenPrompts: 0,
+        waitAfterError: 0,
         noCommit: true,
         ignoreGitChanges: true,
         normalizeLineEndings: false,
@@ -69418,10 +69471,14 @@ var findUnwrittenPrompts$1 = /*#__PURE__*/Object.freeze({
     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.
  */
@@ -69438,7 +69495,9 @@ const KNOWN_OPTION_FLAGS = new Set([
     '--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',
@@ -69482,15 +69541,9 @@ function parseRunOptions(args) {
     //   --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.');
@@ -69510,7 +69563,9 @@ function parseRunOptions(args) {
     return {
         dryRun,
         waitForUser,
+        waitAfterPrompt,
         waitBetweenPrompts,
+        waitAfterError,
         noCommit,
         ignoreGitChanges,
         normalizeLineEndings,
@@ -69529,6 +69584,19 @@ function parseRunOptions(args) {
         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.
  */
@@ -69765,6 +69833,58 @@ async function resolveAgentSystemMessage(agentPath, currentWorkingDirectory) {
     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.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.
  */
@@ -71495,6 +71615,13 @@ async function writePromptFile(file) {
     await 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.
  *
@@ -71527,54 +71654,101 @@ async function runPromptRound({ options, runner, runnerMetadata, nextPrompt, pro
         ? 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.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.
  */
@@ -71755,7 +71929,8 @@ async function runCodexPrompts(providedOptions) {
         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({
@@ -71798,15 +71973,16 @@ async function runCodexPrompts(providedOptions) {
             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,
@@ -71824,6 +72000,7 @@ async function runCodexPrompts(providedOptions) {
                 });
                 await ensureWorkingTreeClean();
             }
+            const currentRoundStartTime = Date.now();
             await runPromptRound({
                 options,
                 runner,
@@ -71837,6 +72014,8 @@ async function runCodexPrompts(providedOptions) {
                 uiHandle,
                 waitForRequestedPause,
             });
+            previousRoundStartTime = currentRoundStartTime;
+            previousRoundEndTime = Date.now();
         }
     }
     finally {
@@ -72061,39 +72240,50 @@ async function waitForPromptConfirmationIfNeeded(options) {
     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.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();