@promptbook/cli 0.114.0-4 → 0.114.0-5

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.114.0-4';
+export const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version = '0.114.0-5';
 
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.114.0-3`).
+ * It follows semantic versioning (e.g., `0.114.0-4`).
  *
  * @generated
  */

package/src/versions.txt

@@ -1182,3 +1182,4 @@
 0.114.0-2
 0.114.0-3
 0.114.0-4
+0.114.0-5

package/umd/index.umd.js

@@ -58,7 +58,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.114.0-4';
+    const PROMPTBOOK_ENGINE_VERSION = '0.114.0-5';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -29758,6 +29758,32 @@
         `);
     }
 
+    /**
+     * Creates the step tracker of one prompt round.
+     *
+     * The tracker is the single place which knows which steps have finished and which one is running,
+     * so both the finished `[x]` status line and the intermediate `[^]` in-progress status lines are
+     * built from the very same data.
+     */
+    function createCoderRunStepTracker(onStepStarted) {
+        const steps = [];
+        let reportedLoginMethod;
+        return {
+            steps,
+            async startStep(kind) {
+                await (onStepStarted === null || onStepStarted === void 0 ? void 0 : onStepStarted({
+                    startedStepKind: kind,
+                    finishedSteps: [...steps],
+                    loginMethod: reportedLoginMethod,
+                }));
+            },
+            finishStep(step, loginMethod) {
+                steps.push(step);
+                reportedLoginMethod = loginMethod !== null && loginMethod !== void 0 ? loginMethod : reportedLoginMethod;
+            },
+        };
+    }
+
     /**
      * Maximum amount of test output embedded into an agent prompt.
      */
@@ -29803,7 +29829,7 @@
     async function runPromptWithTestFeedback(options) {
         var _a, _b, _c, _d;
         const normalizedTestCommand = (_a = options.testCommand) === null || _a === void 0 ? void 0 : _a.trim();
-        const steps = [];
+        const stepTracker = createCoderRunStepTracker(options.onStepStarted);
         if (!normalizedTestCommand) {
             (_b = options.onAttemptStarted) === null || _b === void 0 ? void 0 : _b.call(options, 1);
             await waitForPromptAttemptPauseCheckpoint(options.waitForPauseCheckpoint, options.runner.name, 1);
@@ -29811,9 +29837,9 @@
                 runOptions: options,
                 prompt: options.prompt,
                 kind: 'implementation',
-                steps,
+                stepTracker,
             });
-            return { ...result, attemptCount: 1, steps };
+            return { ...result, attemptCount: 1, steps: stepTracker.steps };
         }
         const runPromptTestCommandExecutor = (_c = options.runPromptTestCommandExecutor) !== null && _c !== void 0 ? _c : runPromptTestCommand;
         let promptForCurrentAttempt = options.prompt;
@@ -29824,7 +29850,7 @@
                 runOptions: options,
                 prompt: promptForCurrentAttempt,
                 kind: attemptCount === 1 ? 'implementation' : 'fixing',
-                steps,
+                stepTracker,
             });
             await waitForVerificationPauseCheckpoint(options.waitForPauseCheckpoint, normalizedTestCommand, attemptCount);
             console.info(colors__default["default"].gray(`Running verification command after attempt #${attemptCount}: ${normalizedTestCommand}`));
@@ -29832,10 +29858,10 @@
                 runPromptTestCommandExecutor,
                 testCommand: normalizedTestCommand,
                 runOptions: options,
-                steps,
+                stepTracker,
             });
             if (failedVerification === undefined) {
-                return { ...result, attemptCount, steps };
+                return { ...result, attemptCount, steps: stepTracker.steps };
             }
             const fullVerificationOutput = formatUnknownErrorDetails(failedVerification.error);
             const feedbackVerificationOutput = limitTestOutput(fullVerificationOutput);
@@ -29861,7 +29887,8 @@
      * Runs one coding attempt through the runner, timing it and recording it as an implementation or fixing step.
      */
     async function runRunnerPromptStep(options) {
-        const { runOptions, prompt, kind, steps } = options;
+        const { runOptions, prompt, kind, stepTracker } = options;
+        await stepTracker.startStep(kind);
         const stepStartedTimeMs = Date.now();
         const result = await runOptions.runner.runPrompt({
             prompt,
@@ -29871,7 +29898,7 @@
             preserveArtifactsOnSuccess: runOptions.preserveArtifactsOnSuccess,
             waitForPauseCheckpoint: runOptions.waitForPauseCheckpoint,
         });
-        steps.push({ kind, usage: result.usage, durationMs: Date.now() - stepStartedTimeMs });
+        stepTracker.finishStep({ kind, usage: result.usage, durationMs: Date.now() - stepStartedTimeMs }, result.loginMethod);
         return result;
     }
     /**
@@ -29879,7 +29906,8 @@
      * returns the failure (or `undefined` when the verification passed).
      */
     async function runVerificationStep(options) {
-        const { runPromptTestCommandExecutor, testCommand, runOptions, steps } = options;
+        const { runPromptTestCommandExecutor, testCommand, runOptions, stepTracker } = options;
+        await stepTracker.startStep('testing');
         const stepStartedTimeMs = Date.now();
         try {
             await runPromptTestCommandExecutor({
@@ -29895,7 +29923,7 @@
             return { error };
         }
         finally {
-            steps.push({ kind: 'testing', usage: null, durationMs: Date.now() - stepStartedTimeMs });
+            stepTracker.finishStep({ kind: 'testing', usage: null, durationMs: Date.now() - stepStartedTimeMs });
         }
     }
     /**
@@ -41182,6 +41210,45 @@
     // Note: [🟡] Code for CLI command [server](src/cli/cli-commands/coder/server.ts) should never be published outside of `@promptbook/cli`
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
+    /**
+     * Orders supported by `ptbk coder verify --order`.
+     */
+    const VERIFY_PROMPTS_ORDER_VALUES = ['from-earliest', 'from-latest', 'random'];
+    /**
+     * Order used when `--order` is not provided.
+     */
+    const DEFAULT_VERIFY_PROMPTS_ORDER = 'from-earliest';
+    /**
+     * Human-readable description of each supported order, shared by the CLI help and the verification output.
+     */
+    const VERIFY_PROMPTS_ORDER_DESCRIPTIONS = {
+        'from-earliest': 'from the earliest prompt file',
+        'from-latest': 'from the latest prompt file',
+        random: 'in random order',
+    };
+    /**
+     * Parses and validates one raw `--order` value.
+     *
+     * Note: `ptbk coder verify` lets Commander validate the value, this is used by the standalone script which parses the raw arguments itself
+     */
+    function parseVerifyPromptsOrder(orderValue) {
+        if (orderValue === undefined) {
+            return DEFAULT_VERIFY_PROMPTS_ORDER;
+        }
+        if (VERIFY_PROMPTS_ORDER_VALUES.includes(orderValue)) {
+            return orderValue;
+        }
+        throw new NotAllowed(_spaceTrim.spaceTrim((block) => `
+                Invalid value for \`--order\`: \`${orderValue}\`.
+
+                Use one of the supported orders:
+                ${block(VERIFY_PROMPTS_ORDER_VALUES.map((value) => `- \`${value}\` processes the prompt files ${VERIFY_PROMPTS_ORDER_DESCRIPTIONS[value]}`).join('\n'))}
+
+                Actionable hint:
+                - The removed \`--reverse\` flag is now \`--order from-latest\`.
+            `));
+    }
+
     /**
      * Initializes `coder verify` command for Promptbook CLI utilities
      *
@@ -41201,21 +41268,27 @@
                 - Auto-appends repair prompts for incomplete work
                 - Processes files with all-done prompts first
                 - Supports ignoring matching prompt candidates for one verification run
+                - Supports processing the prompt files from the earliest, from the latest or in random order
 
                 ${block(CODER_GIT_SYNC_DESCRIPTION)}
 
                 Note: The git synchronization is applied around each single verification, not once per run.
             `));
-        command.option('--reverse', 'Process prompt files in reverse order', false);
+        command.addOption(new commander.Option('--order <order>', _spaceTrim.spaceTrim((block) => `
+                    Order in which the prompt files are processed:
+                    ${block(VERIFY_PROMPTS_ORDER_VALUES.map((order) => `- ${order}: ${VERIFY_PROMPTS_ORDER_DESCRIPTIONS[order]}`).join('\n'))}
+                `))
+            .choices([...VERIFY_PROMPTS_ORDER_VALUES])
+            .default(DEFAULT_VERIFY_PROMPTS_ORDER));
         command.option('--ignore <candidate-text>', 'Ignore prompt files whose filename or first prompt line contains the given text (repeatable)', collectStringOption, []);
         addCoderGitSyncOptions(command);
         command.action(handleActionErrors(async (cliOptions) => {
-            const { reverse, ignore } = cliOptions;
+            const { order, ignore } = cliOptions;
             const gitSync = normalizeCoderGitSyncCliOptions(cliOptions);
             // Note: Import the main function dynamically to avoid loading heavy dependencies until needed
             const { verifyPrompts } = await Promise.resolve().then(function () { return verifyPrompts$1; });
             try {
-                await verifyPrompts({ reverse, ignore, gitSync });
+                await verifyPrompts({ order, ignore, gitSync });
             }
             catch (error) {
                 console.error(colors__default["default"].bgRed('Prompt verification failed:'), error);
@@ -70360,7 +70433,7 @@
     }
     /**
      * Parses a status line like "[ ] !!", "[ ] use `gpt` !!!!!" or "[-]" into status and priority.
-     * For [x] done and [!] failed prompts, allow metadata after the status marker.
+     * For [x] done, [!] failed and [^] in-progress prompts, allow metadata after the status marker.
      */
     function parseStatusLine(line) {
         var _a, _b, _c, _d;
@@ -70374,6 +70447,11 @@
         if (failedMatch) {
             return { status: 'failed', priority: 0 };
         }
+        // For in-progress prompts [^], allow any content after (for the steps recorded so far)
+        const inProgressMatch = line.match(/^\[(?<status>\^)\]/);
+        if (inProgressMatch) {
+            return { status: 'in-progress', priority: 0 };
+        }
         // For not-ready [-], keep the historical clean-line syntax.
         if (/^\[-\]\s*!*\s*$/u.test(line)) {
             return { status: 'not-ready', priority: 0 };
@@ -72953,14 +73031,25 @@
         fixing: 'Fixing',
     };
     /**
-     * Formats the per-step usage breakdown recorded for one finished prompt.
+     * Suffix marking the one step which has already started but has neither a price nor a duration yet.
+     */
+    const IN_PROGRESS_STEP_SUFFIX = 'in progress';
+    /**
+     * Formats the per-step usage breakdown recorded for one prompt.
      *
      * Produces a `; `-separated summary such as
      * `Implementation $8.01 6 hours; Testing 1 hour; Fixing $3.14 2 hours` where each coding step carries its
      * price and duration and each verification step carries only its duration.
+     *
+     * @param steps - Steps which have already finished
+     * @param inProgressStepKind - Step which has started but has not finished yet, appended as `Testing in progress`
      */
-    function formatCoderRunSteps(steps) {
-        return steps.map(formatCoderRunStep).join('; ');
+    function formatCoderRunSteps(steps, inProgressStepKind) {
+        const formattedSteps = steps.map(formatCoderRunStep);
+        if (inProgressStepKind !== undefined) {
+            formattedSteps.push(`${CODER_RUN_STEP_LABELS[inProgressStepKind]} ${IN_PROGRESS_STEP_SUFFIX}`);
+        }
+        return formattedSteps.join('; ');
     }
     /**
      * Formats one coder run step as `Label $price duration`, omitting the price for steps without model usage.
@@ -72989,47 +73078,78 @@
     }
 
     /**
-     * Replaces the complete todo status line while preserving its indentation.
+     * Builds the shared body of a prompt status line, used by both the in-progress `[^]` and the done `[x]` status.
      *
-     * The complete line is replaced because a todo status can contain a required
-     * model/harness token in addition to priority markers.
+     * Produces details such as
+     * ``by OpenAI Codex `gpt-5.6-luna` thinking `max` (ChatGPT account) - Implementation ~$0.2036 10 minutes``.
      */
-    function replacePromptTodoStatusLine(line, replacementStatusLine) {
-        return line.replace(/^(?<indentation>\s*)\[\s*\].*$/u, `$<indentation>${replacementStatusLine}`);
+    function buildPromptStatusDetails(options) {
+        const { steps, inProgressStepKind, runnerName, modelName, attemptCount, loginMethod, thinkingLevel } = options;
+        const runnerSignature = formatRunnerSignature(runnerName, modelName, thinkingLevel);
+        const attemptMetadata = formatPromptAttemptMetadata('done', attemptCount);
+        const loginMethodLabel = formatCodexLoginMethod(loginMethod);
+        const loginMethodSuffix = loginMethodLabel ? ` (${loginMethodLabel})` : '';
+        const stepsSummary = formatCoderRunSteps(steps, inProgressStepKind);
+        const stepsSuffix = stepsSummary === '' ? '' : ` - ${stepsSummary}`;
+        return `${attemptMetadata}by ${runnerSignature}${loginMethodSuffix}${stepsSuffix}`;
     }
 
     /**
-     * Marks a prompt section as done and records the per-step usage pricing and runner details.
+     * Resolves the status line of one prompt section so it can be rewritten.
      */
-    function markPromptDone(file, section, steps, runnerName, modelName, attemptCount = 1, loginMethod, thinkingLevel) {
+    function resolvePromptStatusLine(file, section) {
         if (section.statusLineIndex === undefined) {
-            throw new Error(`Prompt ${section.index + 1} in ${file.name} does not have a status line.`);
+            throw new UnexpectedError(_spaceTrim.spaceTrim(`
+                Prompt ${section.index + 1} in \`${file.name}\` does not have a status line.
+            `));
         }
         const line = file.lines[section.statusLineIndex];
         if (line === undefined) {
-            throw new Error(`Prompt ${section.index + 1} in ${file.name} points to a missing status line.`);
+            throw new UnexpectedError(_spaceTrim.spaceTrim(`
+                Prompt ${section.index + 1} in \`${file.name}\` points to a missing status line.
+            `));
         }
-        const runnerSignature = formatRunnerSignature(runnerName, modelName, thinkingLevel);
-        const attemptMetadata = formatPromptAttemptMetadata('done', attemptCount);
-        const loginMethodLabel = formatCodexLoginMethod(loginMethod);
-        const loginMethodSuffix = loginMethodLabel ? ` (${loginMethodLabel})` : '';
-        const stepsSummary = formatCoderRunSteps(steps);
-        const stepsSuffix = stepsSummary === '' ? '' : ` - ${stepsSummary}`;
-        // Replace the complete todo status, including any required model/harness token.
-        file.lines[section.statusLineIndex] = replacePromptTodoStatusLine(line, `[x] ${attemptMetadata}by ${runnerSignature}${loginMethodSuffix}${stepsSuffix}`);
+        return { statusLineIndex: section.statusLineIndex, line };
+    }
+
+    /**
+     * Matches a complete todo `[ ]` or in-progress `[^]` status line, capturing its indentation.
+     *
+     * The complete line is replaced because a todo status can contain a required model/harness token
+     * in addition to its priority markers, and an in-progress status already carries the metadata of
+     * the steps recorded so far.
+     */
+    const REWRITABLE_PROMPT_STATUS_LINE_PATTERN = /^(?<indentation>\s*)\[(?:\s*|\^)\].*$/u;
+    /**
+     * Rewrites the status line of one prompt section while preserving its indentation.
+     *
+     * Only a todo `[ ]` or an in-progress `[^]` status line is rewritten, so an already finalized
+     * `[x]`, `[!]` or `[-]` status is never overwritten by accident.
+     */
+    function writePromptStatusLine(file, section, replacementStatusLine) {
+        const { statusLineIndex, line } = resolvePromptStatusLine(file, section);
+        file.lines[statusLineIndex] = line.replace(REWRITABLE_PROMPT_STATUS_LINE_PATTERN, `$<indentation>${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}`);
     }
 
     /**
      * Marks a prompt section as failed and records runner details.
      */
     function markPromptFailed(file, section, runnerName, modelName, promptExecutionStartedDate, attemptCount = 1) {
-        if (section.statusLineIndex === undefined) {
-            throw new Error(`Prompt ${section.index + 1} in ${file.name} does not have a status line.`);
-        }
-        const line = file.lines[section.statusLineIndex];
-        if (line === undefined) {
-            throw new Error(`Prompt ${section.index + 1} in ${file.name} points to a missing status line.`);
-        }
         const runnerSignature = formatRunnerSignature(runnerName, modelName);
         const attemptMetadata = formatPromptAttemptMetadata('failed', attemptCount);
         const duration = moment__default["default"]().diff(promptExecutionStartedDate);
@@ -73037,7 +73157,18 @@
         const failureDetails = attemptMetadata === ''
             ? `failed after ${durationString} by ${runnerSignature}`
             : `${attemptMetadata}${durationString} by ${runnerSignature}`;
-        file.lines[section.statusLineIndex] = replacePromptTodoStatusLine(line, `[!] ${failureDetails}`);
+        writePromptStatusLine(file, section, `[!] ${failureDetails}`);
+    }
+
+    /**
+     * Marks a prompt section as being implemented right now and records the steps finished so far.
+     *
+     * The `[^]` status is deliberately never reverted: when the coder is killed or crashes, the status stays
+     * in the prompt file as the signal that this task was left in the middle of its implementation.
+     */
+    function markPromptInProgress(options) {
+        const { file, section, ...statusDetailsOptions } = options;
+        writePromptStatusLine(file, section, `[^] ${buildPromptStatusDetails(statusDetailsOptions)}`);
     }
 
     /**
@@ -73146,6 +73277,13 @@
                             attemptCount = nextAttemptCount;
                             uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setAttempt(nextAttemptCount);
                         },
+                        onStepStarted: (progress) => recordPromptRoundInProgress({
+                            nextPrompt,
+                            runnerMetadata,
+                            thinkingLevel: options.thinkingLevel,
+                            attemptCount,
+                            progress,
+                        }),
                         waitForPauseCheckpoint: waitForRequestedPause,
                     });
                     await finalizeSuccessfulPromptRound({
@@ -73197,6 +73335,30 @@
             throw lastError;
         }, { preserveArtifactsOnSuccess: options.preserveLogs });
     }
+    /**
+     * Records into the prompt file that the prompt is being implemented right now.
+     *
+     * The `[^]` in-progress status is written before every single step, so it always names the step which is
+     * running and the steps already finished. It is intentionally never reverted: a coder which is killed or
+     * 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;
+        markPromptInProgress({
+            file: nextPrompt.file,
+            section: nextPrompt.section,
+            steps: progress.finishedSteps,
+            inProgressStepKind: progress.startedStepKind,
+            runnerName: runnerMetadata.runnerName,
+            modelName: runnerMetadata.modelName,
+            attemptCount,
+            loginMethod: progress.loginMethod,
+            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);
+    }
     /**
      * Sleeps `options.waitAfterError` while keeping the rich UI and plain console in sync, then resets state for the retry.
      */
@@ -73857,19 +74019,9 @@
      * kept and only the status box turns from `[x]` into `[!]`, followed by the manual merge instructions.
      */
     function markPromptIsolationMergeFailed(file, section, worktree) {
-        if (section.statusLineIndex === undefined) {
-            throw new UnexpectedError(_spaceTrim.spaceTrim(`
-                Prompt ${section.index + 1} in \`${file.name}\` does not have a status line.
-            `));
-        }
-        const line = file.lines[section.statusLineIndex];
-        if (line === undefined) {
-            throw new UnexpectedError(_spaceTrim.spaceTrim(`
-                Prompt ${section.index + 1} in \`${file.name}\` points to a missing status line.
-            `));
-        }
+        const { statusLineIndex, line } = resolvePromptStatusLine(file, section);
         const failedStatusLine = line.replace(PROMPT_STATUS_BOX_PATTERN, '$<indentation>[!]');
-        file.lines[section.statusLineIndex] = `${failedStatusLine} - ${buildCoderIsolationMergeFailureStatusNote(worktree)}`;
+        file.lines[statusLineIndex] = `${failedStatusLine} - ${buildCoderIsolationMergeFailureStatusNote(worktree)}`;
     }
 
     /**
@@ -75009,7 +75161,9 @@
         if (section.status === 'not-ready' || isUnwritten) {
             return 'backlog';
         }
-        if (isActive) {
+        // Note: A prompt marked `[^]` stays in progress even when no agent is running it, because its
+        //       implementation was left in the middle
+        if (isActive || section.status === 'in-progress') {
             return 'in-progress';
         }
         if (!isPromptInPriorityFilter(section, priorityFilter)) {
@@ -75026,6 +75180,10 @@
         if (options.section.status === 'not-ready') {
             tags.push({ id: 'not-ready', label: '[-]' });
         }
+        // Note: A `[^]` prompt which no agent is running right now was left in the middle of its implementation
+        if (options.section.status === 'in-progress' && !options.isActive) {
+            tags.push({ id: 'left-in-progress', label: '[^]' });
+        }
         if (options.isUnwritten) {
             tags.push({ id: 'unwritten', label: '@@@' });
         }
@@ -75055,7 +75213,7 @@
      * Checks whether a parsed section is the prompt currently handled by the active agent.
      */
     function isPromptActive(promptFile, section, activePrompt) {
-        if (!activePrompt || section.status !== 'todo') {
+        if (!activePrompt || (section.status !== 'todo' && section.status !== 'in-progress')) {
             return false;
         }
         return buildPromptLabelForDisplay(promptFile, section) === activePrompt.label;
@@ -75087,7 +75245,7 @@
      * Overwrites the body of one prompt section with new content, preserving the status line.
      *
      * The `newContent` string is the prompt text without the status marker.
-     * The status line (`[ ]`, `[x]`, `[!]`, `[-]`) is kept intact.
+     * The status line (`[ ]`, `[^]`, `[x]`, `[!]`, `[-]`) is kept intact.
      *
      * @private internal utility of `ptbk coder server`
      */
@@ -75368,6 +75526,7 @@
       line-height: 1.35;
     }
     .tag-not-ready { background: #e2e8f0; color: #475569; }
+    .tag-left-in-progress { background: #ffe4e6; color: #9f1239; }
     .tag-unwritten { background: #fff4cc; color: #8a5a00; }
     .tag-implementing { background: #ede9fe; color: #5b21b6; }
     .tag-verifying { background: #fae8ff; color: #86198f; }
@@ -76098,6 +76257,33 @@
         runCodexPromptsServer: runCodexPromptsServer
     });
 
+    /**
+     * Checks whether one prompt section still has open coding work.
+     *
+     * A `[ ]` prompt has not been started at all and a `[^]` prompt was left in the middle of its
+     * implementation, so a file containing either of them is not finished yet.
+     */
+    function isPromptSectionUnfinished(section) {
+        return section.status === 'todo' || section.status === 'in-progress';
+    }
+
+    /**
+     * Orders the loaded prompt files for one verification pass.
+     *
+     * Note: `$` is used to indicate that this function is not a pure function - the `random` order is not deterministic
+     * Note: This function does NOT mutate the given array
+     */
+    function $orderPromptFiles(promptFiles, order) {
+        switch (order) {
+            case 'from-earliest':
+                return [...promptFiles];
+            case 'from-latest':
+                return [...promptFiles].reverse();
+            case 'random':
+                return [...$shuffleItems(...promptFiles)];
+        }
+    }
+
     /**
      * Path to the directory that holds the prompt markdown files.
      */
@@ -76126,8 +76312,8 @@
     async function verifyPrompts(options = DEFAULT_VERIFY_PROMPTS_OPTIONS) {
         const normalizedOptions = normalizeVerifyPromptsOptions(options);
         console.info(colors__default["default"].cyan.bold('📋 Prompt verification helper'));
-        if (normalizedOptions.reverse) {
-            console.info(colors__default["default"].gray('Processing files in reverse order'));
+        if (normalizedOptions.order !== DEFAULT_VERIFY_PROMPTS_ORDER) {
+            console.info(colors__default["default"].gray(`Processing files ${VERIFY_PROMPTS_ORDER_DESCRIPTIONS[normalizedOptions.order]}`));
         }
         if (normalizedOptions.ignore.length > 0) {
             console.info(colors__default["default"].gray(`Ignoring candidates matching: ${normalizedOptions.ignore.join(', ')}`));
@@ -76184,7 +76370,7 @@
      */
     function parseVerifyPromptsCliOptions(args) {
         return {
-            reverse: args.includes('--reverse'),
+            order: parseVerifyPromptsOrder(readStringOption(args, '--order')),
             ignore: readRepeatableStringOption(args, '--ignore'),
             gitSync: {
                 isCommitEnabled: args.includes('--commit'),
@@ -76199,10 +76385,7 @@
     async function loadPromptFilesForVerification(options) {
         const loadedPromptFiles = await loadPromptFiles(PROMPTS_DIR);
         const { promptFiles, ignoredPromptFiles } = partitionPromptFilesByIgnore(loadedPromptFiles, options.ignore);
-        if (options.reverse) {
-            promptFiles.reverse();
-        }
-        return { promptFiles, ignoredPromptFiles };
+        return { promptFiles: $orderPromptFiles(promptFiles, options.order), ignoredPromptFiles };
     }
     /**
      * Splits prompt files into files that should be verified now and files ignored for this run.
@@ -76244,7 +76427,7 @@
     function normalizeVerifyPromptsOptions(options) {
         var _a, _b, _c;
         return {
-            reverse: (_a = options.reverse) !== null && _a !== void 0 ? _a : false,
+            order: (_a = options.order) !== null && _a !== void 0 ? _a : DEFAULT_VERIFY_PROMPTS_ORDER,
             ignore: normalizeIgnoreValues((_b = options.ignore) !== null && _b !== void 0 ? _b : []),
             gitSync: (_c = options.gitSync) !== null && _c !== void 0 ? _c : DISABLED_CODER_GIT_SYNC_OPTIONS,
         };
@@ -76269,6 +76452,13 @@
         }
         return normalizedIgnoreValues;
     }
+    /**
+     * Reads one single-value string option from raw CLI arguments, keeping the last occurrence.
+     */
+    function readStringOption(args, flag) {
+        const values = readRepeatableStringOption(args, flag);
+        return values[values.length - 1];
+    }
     /**
      * Reads one repeatable string option from raw CLI arguments.
      */
@@ -76330,8 +76520,9 @@
         for (const file of promptFiles) {
             const doneCount = file.sections.filter((section) => section.status === 'done').length;
             const todoCount = file.sections.filter((section) => section.status === 'todo').length;
+            const inProgressCount = file.sections.filter((section) => section.status === 'in-progress').length;
             const notReadyCount = file.sections.filter((section) => section.status === 'not-ready').length;
-            const needsVerification = file.sections.length > 0 && todoCount === 0 && doneCount > 0;
+            const needsVerification = file.sections.length > 0 && !file.sections.some(isPromptSectionUnfinished) && doneCount > 0;
             const statusParts = [];
             if (needsVerification) {
                 statusParts.push(colors__default["default"].cyan.bold(`🔍 ${doneCount} done [x] - NEEDS VERIFICATION`));
@@ -76340,6 +76531,9 @@
                 if (todoCount > 0) {
                     statusParts.push(colors__default["default"].yellow(`${todoCount} todo [ ]`));
                 }
+                if (inProgressCount > 0) {
+                    statusParts.push(colors__default["default"].magenta(`${inProgressCount} in-progress [^]`));
+                }
                 if (doneCount > 0) {
                     statusParts.push(colors__default["default"].green(`${doneCount} done [x]`));
                 }
@@ -76355,7 +76549,7 @@
         console.info(colors__default["default"].gray('Goal: verify all done prompts, then process remaining todo prompts.'));
     }
     /**
-     * Finds the first file where at least one prompt is marked as done [x] and no prompts are todo [ ].
+     * Finds the first file where at least one prompt is marked as done [x] and no prompts are todo [ ] or in-progress [^].
      * Completely ignores not-ready prompts like [-], [.], [?], etc.
      * Also excludes files that have been skipped in this session.
      */
@@ -76368,10 +76562,10 @@
             if (skippedFiles.has(file.path)) {
                 return false;
             }
-            // File is ready for verification if it has at least one done prompt and no todo prompts
-            const hasTodoPrompts = file.sections.some((section) => section.status === 'todo');
+            // File is ready for verification if it has at least one done prompt and no unfinished prompts
+            const hasUnfinishedPrompts = file.sections.some(isPromptSectionUnfinished);
             const hasDonePrompts = file.sections.some((section) => section.status === 'done');
-            return !hasTodoPrompts && hasDonePrompts;
+            return !hasUnfinishedPrompts && hasDonePrompts;
         });
     }
     /**
@@ -76477,11 +76671,11 @@
         const filesNeedingVerification = promptFiles.filter((file) => {
             if (file.sections.length === 0)
                 return false;
-            const hasTodo = file.sections.some((section) => section.status === 'todo');
+            const hasUnfinished = file.sections.some(isPromptSectionUnfinished);
             const hasDone = file.sections.some((section) => section.status === 'done');
-            return !hasTodo && hasDone;
+            return !hasUnfinished && hasDone;
         });
-        const pendingFiles = promptFiles.filter((file) => file.sections.some((section) => section.status === 'todo'));
+        const pendingFiles = promptFiles.filter((file) => file.sections.some(isPromptSectionUnfinished));
         if (filesNeedingVerification.length) {
             const formattedNames = formatPendingFileNames(filesNeedingVerification.map((file) => file.name));
             console.info(colors__default["default"].cyan(`  🔍 Files needing verification (${filesNeedingVerification.length}): ${formattedNames}`));