@promptbook/cli 0.114.0-4 → 0.114.0-5

package/README.md

@@ -526,7 +526,7 @@ Or you can install them separately:
 
 Promptbook Coder is **not another standalone coding model**. It is an orchestration layer over coding agents such as **GitHub Copilot**, **OpenAI Codex**, **Claude Code**, **Opencode**, **Cline**, and **Gemini CLI**. The difference is that Promptbook Coder adds a repeatable repository workflow on top of them:
 
--   prompt files with explicit statuses like `[ ]`, `[x]`, and `[-]`
+-   prompt files with explicit statuses like `[ ]`, `[^]`, `[x]`, and `[-]`
 -   automatic selection of the next runnable task, including priority support
 -   optional shared repo context loaded from a file such as `AGENTS.md`
 -   automatic `git add`, commit, and push after each successful prompt
@@ -541,11 +541,11 @@ In short: tools like Claude Code, Codex, or GitHub Copilot are the **engines**;
 1. `ptbk coder init` prepares the project for the coder workflow, seeds project-owned generic templates in `prompts/templates/`, creates a starter `AGENTS.md` context file, adds helper `npm run coder:*` scripts, ensures `.gitignore` ignores `/.promptbook`, and configures VS Code prompt screenshots in `prompts/screenshots/`.
 2. `ptbk coder generate-boilerplates` creates prompt files in `prompts/`.
 3. You replace placeholder `@@@` sections with real coding tasks.
-4. `ptbk coder run` sends the next ready `[ ]` prompt to the selected coding agent.
+4. `ptbk coder run` sends the next ready `[ ]` prompt to the selected coding agent and immediately marks it as in progress `[^]`, naming the harness, the model and the step which is running.
 5. Promptbook Coder marks the prompt as done `[x]`, records runner metadata, then stages, commits, and pushes the resulting changes.
 6. `ptbk coder verify` reviews completed prompts, archives finished files to `prompts/done/`, and appends a repair prompt when more work is needed.
 
-Prompts marked with `[-]` are not ready yet, prompts containing `@@@` are treated as not fully written, and prompts with more `!` markers have higher priority.
+Prompts marked with `[-]` are not ready yet, prompts containing `@@@` are treated as not fully written, and prompts with more `!` markers have higher priority. A prompt left as `[^]` was interrupted in the middle of its implementation — the in-progress status is never reverted, so a killed or crashed coder always leaves that signal behind.
 
 #### Features
 

package/esm/index.es.js

@@ -48,7 +48,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.114.0-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
@@ -29748,6 +29748,32 @@ function appendCoderContext(prompt, context) {
         `);
 }
 
+/**
+ * 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.
  */
@@ -29793,7 +29819,7 @@ const SHELL_SCRIPT_EXTENSION = '.sh';
 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);
@@ -29801,9 +29827,9 @@ async function runPromptWithTestFeedback(options) {
             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;
@@ -29814,7 +29840,7 @@ async function runPromptWithTestFeedback(options) {
             runOptions: options,
             prompt: promptForCurrentAttempt,
             kind: attemptCount === 1 ? 'implementation' : 'fixing',
-            steps,
+            stepTracker,
         });
         await waitForVerificationPauseCheckpoint(options.waitForPauseCheckpoint, normalizedTestCommand, attemptCount);
         console.info(colors.gray(`Running verification command after attempt #${attemptCount}: ${normalizedTestCommand}`));
@@ -29822,10 +29848,10 @@ async function runPromptWithTestFeedback(options) {
             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);
@@ -29851,7 +29877,8 @@ async function runPromptWithTestFeedback(options) {
  * 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,
@@ -29861,7 +29888,7 @@ async function runRunnerPromptStep(options) {
         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;
 }
 /**
@@ -29869,7 +29896,8 @@ async function runRunnerPromptStep(options) {
  * 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({
@@ -29885,7 +29913,7 @@ async function runVerificationStep(options) {
         return { error };
     }
     finally {
-        steps.push({ kind: 'testing', usage: null, durationMs: Date.now() - stepStartedTimeMs });
+        stepTracker.finishStep({ kind: 'testing', usage: null, durationMs: Date.now() - stepStartedTimeMs });
     }
 }
 /**
@@ -41172,6 +41200,45 @@ function normalizeCommandOptionValue(value) {
 // 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$1((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
  *
@@ -41191,21 +41258,27 @@ function $initializeCoderVerifyCommand(program) {
                 - 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 Option('--order <order>', spaceTrim$1((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.bgRed('Prompt verification failed:'), error);
@@ -70350,7 +70423,7 @@ function parsePromptFile(filePath, content) {
 }
 /**
  * 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;
@@ -70364,6 +70437,11 @@ function parseStatusLine(line) {
     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 };
@@ -72943,14 +73021,25 @@ const CODER_RUN_STEP_LABELS = {
     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.
@@ -72979,47 +73068,78 @@ function formatPromptAttemptMetadata(status, attemptCount) {
 }
 
 /**
- * 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$1(`
+                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$1(`
+                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().diff(promptExecutionStartedDate);
@@ -73027,7 +73147,18 @@ function markPromptFailed(file, section, runnerName, modelName, promptExecutionS
     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)}`);
 }
 
 /**
@@ -73136,6 +73267,13 @@ async function runPromptRound({ options, runner, runnerMetadata, nextPrompt, pro
                         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({
@@ -73187,6 +73325,30 @@ async function runPromptRound({ options, runner, runnerMetadata, nextPrompt, pro
         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.
  */
@@ -73847,19 +74009,9 @@ const PROMPT_STATUS_BOX_PATTERN = /^(?<indentation>\s*)\[[^\]]*\]/u;
  * 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$1(`
-                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$1(`
-                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)}`;
 }
 
 /**
@@ -74999,7 +75151,9 @@ function getPromptColumn(options) {
     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)) {
@@ -75016,6 +75170,10 @@ function buildPromptTags(options) {
     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: '@@@' });
     }
@@ -75045,7 +75203,7 @@ function getActivePrompt(uiState) {
  * 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;
@@ -75077,7 +75235,7 @@ function buildCoderServerRunState(uiState) {
  * 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`
  */
@@ -75358,6 +75516,7 @@ const CODER_SERVER_HTML = `<!DOCTYPE html>
       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; }
@@ -76088,6 +76247,33 @@ var runCodexPromptsServer$1 = /*#__PURE__*/Object.freeze({
     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.
  */
@@ -76116,8 +76302,8 @@ const DEFAULT_VERIFY_PROMPTS_OPTIONS = normalizeVerifyPromptsOptions(parseVerify
 async function verifyPrompts(options = DEFAULT_VERIFY_PROMPTS_OPTIONS) {
     const normalizedOptions = normalizeVerifyPromptsOptions(options);
     console.info(colors.cyan.bold('📋 Prompt verification helper'));
-    if (normalizedOptions.reverse) {
-        console.info(colors.gray('Processing files in reverse order'));
+    if (normalizedOptions.order !== DEFAULT_VERIFY_PROMPTS_ORDER) {
+        console.info(colors.gray(`Processing files ${VERIFY_PROMPTS_ORDER_DESCRIPTIONS[normalizedOptions.order]}`));
     }
     if (normalizedOptions.ignore.length > 0) {
         console.info(colors.gray(`Ignoring candidates matching: ${normalizedOptions.ignore.join(', ')}`));
@@ -76174,7 +76360,7 @@ async function $commitVerificationOutcome(gitSync, outcome) {
  */
 function parseVerifyPromptsCliOptions(args) {
     return {
-        reverse: args.includes('--reverse'),
+        order: parseVerifyPromptsOrder(readStringOption(args, '--order')),
         ignore: readRepeatableStringOption(args, '--ignore'),
         gitSync: {
             isCommitEnabled: args.includes('--commit'),
@@ -76189,10 +76375,7 @@ function parseVerifyPromptsCliOptions(args) {
 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.
@@ -76234,7 +76417,7 @@ async function prepareArchiveDirectory() {
 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,
     };
@@ -76259,6 +76442,13 @@ function normalizeIgnoreValues(ignoreValues) {
     }
     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.
  */
@@ -76320,8 +76510,9 @@ function displayTopLevelFileList(promptFiles) {
     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.cyan.bold(`🔍 ${doneCount} done [x] - NEEDS VERIFICATION`));
@@ -76330,6 +76521,9 @@ function displayTopLevelFileList(promptFiles) {
             if (todoCount > 0) {
                 statusParts.push(colors.yellow(`${todoCount} todo [ ]`));
             }
+            if (inProgressCount > 0) {
+                statusParts.push(colors.magenta(`${inProgressCount} in-progress [^]`));
+            }
             if (doneCount > 0) {
                 statusParts.push(colors.green(`${doneCount} done [x]`));
             }
@@ -76345,7 +76539,7 @@ function displayTopLevelFileList(promptFiles) {
     console.info(colors.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.
  */
@@ -76358,10 +76552,10 @@ function findFileWithAllDonePrompts(promptFiles, skippedFiles) {
         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;
     });
 }
 /**
@@ -76467,11 +76661,11 @@ function displayPromptOverview(promptFiles) {
     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.cyan(`  🔍 Files needing verification (${filesNeedingVerification.length}): ${formattedNames}`));