@promptbook/cli 0.113.0-9 → 0.114.0-0

package/esm/scripts/run-agent-messages/main/loadAgentMessageQueueSnapshot.d.ts

@@ -16,7 +16,7 @@ export declare function loadAgentMessageQueueSnapshot(projectPath: string): Prom
 export declare function createAgentQueueProgressSnapshot(queueSnapshot: AgentMessageQueueSnapshot): {
     done: number;
     forAgent: number;
-    belowMinimumPriority: number;
+    outsidePriorityRange: number;
     toBeWritten: number;
 };
 /**

package/esm/scripts/run-agent-messages/messages/buildAgentMessagePrompt.d.ts

@@ -1,4 +1,9 @@
+import { type AgentProjectsPromptSectionOptions } from './buildAgentProjectsPromptSection';
+/**
+ * Options adjusting the generated agent message prompt.
+ */
+export type BuildAgentMessagePromptOptions = AgentProjectsPromptSectionOptions;
 /**
  * Builds the prompt sent to the selected coding runner for one queued user-thread book.
  */
-export declare function buildAgentMessagePrompt(messageRelativePath: string, agentSystemMessage: string): string;
+export declare function buildAgentMessagePrompt(messageRelativePath: string, agentSystemMessage: string, options?: BuildAgentMessagePromptOptions): string;

package/esm/scripts/run-agent-messages/messages/buildAgentProjectsPromptSection.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Internal runtime API details available to Agents Server-managed local agents.
+ */
+export type AgentProjectRuntimePromptApi = {
+    /**
+     * Permanent id of the agent currently answering the message.
+     */
+    readonly agentPermanentId: string;
+    /**
+     * Environment variable containing the Agents Server origin.
+     */
+    readonly serverUrlEnvironmentVariableName: string;
+    /**
+     * Environment variable containing the internal worker token.
+     */
+    readonly tokenEnvironmentVariableName: string;
+};
+/**
+ * Options of the projects prompt section shared by every coding harness.
+ */
+export type AgentProjectsPromptSectionOptions = {
+    /**
+     * URL path of the agent projects file endpoint, for example `/agents/<agentId>/projects`.
+     *
+     * When known, the section teaches the agent how to link project files into the chat.
+     */
+    readonly projectsUrlPath?: string;
+    /**
+     * Internal runtime API details, when the agent is managed by Agents Server.
+     */
+    readonly projectRuntimeApi?: AgentProjectRuntimePromptApi;
+};
+/**
+ * Builds the `## Projects` prompt section explaining the agent-owned projects convention.
+ *
+ * The section is part of the prompt of every harness, so each coding agent knows it has its
+ * own isolated project folders it fully controls and how to reference them in the chat.
+ */
+export declare function buildAgentProjectsPromptSection(options?: AgentProjectsPromptSectionOptions): string;

package/esm/scripts/run-agent-messages/messages/resolveAgentProjectRuntimePromptApi.d.ts

@@ -0,0 +1,8 @@
+import type { AgentProjectRuntimePromptApi } from './buildAgentProjectsPromptSection';
+/**
+ * Resolves project-runtime prompt API details for one local agent runner folder.
+ *
+ * @param projectPath - Absolute path of the current agent runner folder.
+ * @returns Runtime prompt API details or `undefined` outside Agents Server-managed runs.
+ */
+export declare function resolveAgentProjectRuntimePromptApi(projectPath: string): AgentProjectRuntimePromptApi | undefined;

package/esm/scripts/run-agent-messages/messages/resolveAgentProjectsUrlPath.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Resolves the Agents Server projects URL path for one local agent runner folder.
+ *
+ * Agent runner folders managed by the Agents Server follow the `agent-<agentId>` naming
+ * convention, so the stable agent id can be derived from the folder name. For ad-hoc
+ * workspaces (for example `ptbk agent exec` sessions) no URL path is resolved and the
+ * prompt falls back to generic project references.
+ *
+ * @param projectPath - Absolute path of the agent runner folder.
+ * @returns Projects URL path like `/agents/<agentId>/projects`, or `undefined` when unknown.
+ */
+export declare function resolveAgentProjectsUrlPath(projectPath: string): string | undefined;

package/esm/scripts/run-agent-messages/messages/writeAgentMessageRunReport.d.ts

@@ -0,0 +1,22 @@
+import { type AgentMessageRunReport } from '../../../src/book-3.0/AgentMessageRunReport';
+/**
+ * Result of persisting one run report next to an answered message book.
+ */
+export type WrittenAgentMessageRunReport = {
+    readonly absolutePath: string;
+    readonly relativePath: string;
+};
+/**
+ * Writes the run report sidecar next to one answered message book.
+ *
+ * The report is best-effort telemetry — the answer itself is already persisted in the
+ * finished message book, so a failed report write only logs a warning instead of
+ * failing the whole answered message.
+ *
+ * @returns The written report paths, or `null` when the write failed.
+ */
+export declare function writeAgentMessageRunReport(options: {
+    readonly finishedMessageAbsolutePath: string;
+    readonly finishedMessageRelativePath: string;
+    readonly report: AgentMessageRunReport;
+}): Promise<WrittenAgentMessageRunReport | null>;

package/esm/scripts/run-agent-messages/ui/buildAgentRunUiFrame.d.ts

@@ -1,5 +1,10 @@
 import type { BuildCoderRunUiFrameOptions } from '../../run-codex-prompts/ui/buildCoderRunUiFrame';
+/**
+ * Snapshot consumed by the pure agent-run frame builder.
+ */
+type BuildAgentRunUiFrameOptions = Omit<BuildCoderRunUiFrameOptions, 'agentVisual' | 'agentVisualLines' | 'isEndAfterCurrentPromptRequested'>;
 /**
  * Builds the complete boxed terminal frame for the rich `ptbk agent-folder run` UI.
  */
-export declare function buildAgentRunUiFrame(options: BuildCoderRunUiFrameOptions): string[];
+export declare function buildAgentRunUiFrame(options: BuildAgentRunUiFrameOptions): string[];
+export {};

package/esm/scripts/run-codex-prompts/common/buildCoderRunProgressSnapshot.d.ts

@@ -24,4 +24,4 @@ export type CoderRunProgressSnapshot = {
  * provided (loaded from the per-config estimate cache stored in the temp folder), the snapshot uses
  * that historical average to project the remaining work instead of waiting for the first completion.
  */
-export declare function buildCoderRunProgressSnapshot(stats: PromptStats, elapsedDuration: moment.Duration, initialDone: number, cachedAveragePromptDurationMs?: number): CoderRunProgressSnapshot;
+export declare function buildCoderRunProgressSnapshot(stats: PromptStats, elapsedDuration: moment.Duration, initialDone: number, cachedAveragePromptDurationMs?: number, runLimit?: number): CoderRunProgressSnapshot;

package/esm/scripts/run-codex-prompts/common/cliProgressDisplay.d.ts

@@ -1,10 +1,12 @@
 import moment from 'moment';
+import { type PriorityFilter } from '../prompts/priorityFilter';
 import type { PromptStats } from '../prompts/types/PromptStats';
 /**
  * Compact CLI progress display that stays pinned at the top of the terminal.
  */
 export declare class CliProgressDisplay {
-    private readonly minimumPriority;
+    private readonly priorityFilter;
+    private readonly runLimit?;
     private stats;
     /**
      * Initial number of completed prompts when the session started.
@@ -19,7 +21,7 @@ export declare class CliProgressDisplay {
     /**
      * Creates a new display that uses the provided start time when computing estimates.
      */
-    constructor(startTime: moment.Moment, minimumPriority: number);
+    constructor(startTime: moment.Moment, priorityFilter?: PriorityFilter, runLimit?: number | undefined);
     /**
      * Sets the cached average prompt duration (in milliseconds) loaded from the temp-folder estimate cache.
      *

package/esm/scripts/run-codex-prompts/common/formatUnknownErrorMessage.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Formats one unknown error-like value into its readable message without the stack trace.
+ *
+ * Use this instead of `formatUnknownErrorDetails` whenever the text is shown to the user, for example
+ * inside a branded error, where the stack of the wrapped error would only bury the actual cause.
+ */
+export declare function formatUnknownErrorMessage(error: unknown): string;

package/esm/scripts/run-codex-prompts/common/sleepWithCountdown.d.ts

@@ -21,6 +21,7 @@ export declare function describeCoderRunWait(waitKind: CoderRunWaitKind, remaini
  */
 export declare function sleepWithCountdown(options: {
     durationMs: number;
+    deadlineTimeMs?: number;
     waitKind: CoderRunWaitKind;
     isRichUiEnabled: boolean;
     uiHandle?: CoderRunUiHandle;

package/esm/scripts/run-codex-prompts/common/waitForPause.d.ts

@@ -6,12 +6,60 @@ export type CoderRunPauseState = 'RUNNING' | 'PAUSING' | 'PAUSED';
  * Result of toggling the pause hotkey state.
  */
 export type CoderRunPauseToggleResult = 'REQUESTED_PAUSE' | 'CANCELLED_PAUSE' | 'RESUMED';
+/**
+ * Result of requesting a timed wait skip.
+ */
+export type CoderRunSkipCurrentWaitResult = 'REQUESTED_SKIP' | 'NO_ACTIVE_WAIT';
+/**
+ * Result of toggling the dynamic end-after-current-prompt state.
+ */
+export type CoderRunEndAfterCurrentPromptToggleResult = 'REQUESTED_END' | 'CANCELLED_END';
+/**
+ * Token that identifies one active timed wait which can be skipped by the user.
+ */
+export type CoderRunSkippableWaitToken = symbol;
 /**
  * Applies the same three-state toggle used by the `P` hotkey.
  */
 export declare function togglePauseState(): CoderRunPauseToggleResult;
 /**
- * Listens for the "p" key to pause and resume.
+ * Applies the two-state toggle used by the `X` hotkey.
+ */
+export declare function toggleEndAfterCurrentPromptState(): CoderRunEndAfterCurrentPromptToggleResult;
+/**
+ * Returns whether the dynamic end-after-current-prompt control is active.
+ */
+export declare function getEndAfterCurrentPromptState(): boolean;
+/**
+ * Starts one timed wait which can be skipped by the `S` hotkey.
+ */
+export declare function beginSkippableWait(): CoderRunSkippableWaitToken;
+/**
+ * Finishes one timed wait and clears any skip request that belonged to it.
+ */
+export declare function finishSkippableWait(waitToken: CoderRunSkippableWaitToken): void;
+/**
+ * Requests that the currently active timed wait ends immediately.
+ */
+export declare function requestSkipCurrentWait(): CoderRunSkipCurrentWaitResult;
+/**
+ * Returns whether one timed wait should end early.
+ */
+export declare function shouldSkipCurrentWait(waitToken: CoderRunSkippableWaitToken): boolean;
+/**
+ * Waits for either a timeout or an `S` hotkey skip request.
+ */
+export declare function waitForSkippableMilliseconds(waitToken: CoderRunSkippableWaitToken, durationMs: number): Promise<void>;
+/**
+ * Restores all shared terminal controls to their default state.
+ */
+export declare function resetCoderRunControls(): void;
+/**
+ * Listens for the terminal control keys.
+ */
+export declare function listenForCoderRunControls(): void;
+/**
+ * Backwards-compatible alias for the shared terminal controls listener.
  */
 export declare function listenForPause(): void;
 /**

package/esm/scripts/run-codex-prompts/common/waitUntilWorldTimeDeadline.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Callback called before each short sleep while waiting for a wall-clock deadline.
+ */
+export type WorldTimeDeadlineTick = (remainingDurationMs: number) => void | Promise<void>;
+/**
+ * Callback used to perform one wait segment.
+ */
+export type WorldTimeDeadlineWait = (durationMs: number) => Promise<void>;
+/**
+ * Callback that can stop the deadline wait before the wall-clock deadline is reached.
+ */
+export type WorldTimeDeadlineStopCheck = () => boolean;
+/**
+ * Waits until one wall-clock deadline has passed.
+ *
+ * The remaining time is recalculated from `Date.now()` after every poll and after every tick callback.
+ * This makes waits elapse while the process is paused at a checkpoint or the computer is asleep.
+ *
+ * @private internal utility of `ptbk coder` wait handling
+ */
+export declare function waitUntilWorldTimeDeadline(options: {
+    readonly deadlineTimeMs: number;
+    readonly pollIntervalMs: number;
+    readonly onTick?: WorldTimeDeadlineTick;
+    readonly shouldStopWaiting?: WorldTimeDeadlineStopCheck;
+    readonly waitForMilliseconds?: WorldTimeDeadlineWait;
+}): Promise<void>;

package/esm/scripts/run-codex-prompts/git/commitChanges.d.ts

@@ -2,7 +2,8 @@
  * Commits staged changes with the provided message using the dedicated coding-agent identity when configured,
  * otherwise falls back to the default Git configuration. Remote pushing is opt-in via `options.autoPush`,
  * `options.includePaths` can restrict staging, `options.onlyPaths` can restrict the commit pathspec,
- * and `options.excludePaths` can keep temporary artifacts out of the created commit.
+ * `options.excludePaths` can keep temporary artifacts out of the created commit and
+ * `options.isEmptyCommitAllowed` keeps a round without any file change from failing.
  */
 export declare function commitChanges(message: string, options?: {
     autoPush?: boolean;
@@ -10,4 +11,5 @@ export declare function commitChanges(message: string, options?: {
     onlyPaths?: ReadonlyArray<string>;
     excludePaths?: ReadonlyArray<string>;
     projectPath?: string;
+    isEmptyCommitAllowed?: boolean;
 }): Promise<void>;

package/esm/scripts/run-codex-prompts/git/gitBranchContext.d.ts

@@ -6,6 +6,10 @@ export declare function hasUpstreamBranch(projectPath: string, env?: Record<stri
  * Reads the current local branch name.
  */
 export declare function readCurrentBranchName(projectPath: string, env?: Record<string, string>): Promise<string>;
+/**
+ * Checks whether one local branch already exists in the repository.
+ */
+export declare function hasLocalBranch(branchName: string, projectPath: string, env?: Record<string, string>): Promise<boolean>;
 /**
  * Reads optional git config value; returns undefined when the key is missing.
  */

package/esm/scripts/run-codex-prompts/git/gitLongPathsSupport.d.ts

@@ -0,0 +1,17 @@
+import type { $side_effect } from '../../../src/utils/organization/$side_effect';
+/**
+ * Builds the environment variables which add `core.longpaths=true` to every Git process started with them.
+ *
+ * Git configuration passed through `GIT_CONFIG_COUNT` is inherited by child processes, so one single
+ * environment covers the Git commands of the coder, of the coding agent and of the verification command alike.
+ *
+ * Returns an empty record when the given environment already configures `core.longpaths`, which keeps an
+ * explicit user setting untouched and keeps repeated calls from stacking duplicate entries.
+ */
+export declare function buildGitLongPathsEnvironmentVariables(baseEnvironment: Readonly<Record<string, string | undefined>>): Record<string, string>;
+/**
+ * Enables Git long path support for every process started from the current one.
+ *
+ * Note: `$` is used to indicate that this function is not a pure function - it mutates `process.env`
+ */
+export declare function $enableGitLongPathsSupport(): $side_effect;

package/esm/scripts/run-codex-prompts/isolation/coderIsolationCheckoutFailureReport.d.ts

@@ -0,0 +1,9 @@
+import { EnvironmentMismatchError } from '../../../src/errors/EnvironmentMismatchError';
+import type { CoderIsolationWorktree } from './CoderIsolationWorktree';
+/**
+ * Builds the branded error describing why one isolated worktree could not be checked out.
+ *
+ * A failed checkout leaves nothing behind that could be inspected, so the raw git output is condensed
+ * down to the lines which name the actual reason and is paired with hints resolving it.
+ */
+export declare function buildCoderIsolationCheckoutFailureError(worktree: CoderIsolationWorktree, failureDetails: string): EnvironmentMismatchError;

package/esm/scripts/run-codex-prompts/isolation/coderIsolationMergeFailureReport.d.ts

@@ -0,0 +1,17 @@
+import { ConflictError } from '../../../src/errors/ConflictError';
+import type { CoderIsolationWorktree } from './CoderIsolationWorktree';
+/**
+ * Builds the single-line note appended to the prompt status line of a task which could not be merged.
+ *
+ * Status lines must stay on one line, so the full recovery instructions live in the commit message
+ * and in the error log next to the prompt file.
+ */
+export declare function buildCoderIsolationMergeFailureStatusNote(worktree: CoderIsolationWorktree): string;
+/**
+ * Builds the commit message of the commit which records a failed isolation merge in the original project.
+ */
+export declare function buildCoderIsolationMergeFailureCommitMessage(worktree: CoderIsolationWorktree): string;
+/**
+ * Builds the branded error describing one failed isolation merge, written into the prompt error log.
+ */
+export declare function buildCoderIsolationMergeFailureError(worktree: CoderIsolationWorktree, failureDetails: string): ConflictError;

package/esm/scripts/run-codex-prompts/isolation/coderIsolationNaming.d.ts

@@ -0,0 +1,26 @@
+import type { PromptFile } from '../prompts/types/PromptFile';
+import type { PromptSection } from '../prompts/types/PromptSection';
+/**
+ * Temporary subdirectory holding every worktree created by `ptbk coder run --isolate`.
+ */
+export declare const CODER_ISOLATION_WORKTREES_DIRECTORY_NAME = "coder-isolation-worktrees";
+/**
+ * Prefix of every git branch created by `ptbk coder run --isolate`.
+ */
+export declare const CODER_ISOLATION_BRANCH_PREFIX = "ptbk-coder-isolation";
+/**
+ * Builds the isolation task name of one prompt section, for example `2026-07-0700-ptbk-coder-timing`.
+ */
+export declare function buildCoderIsolationTaskName(file: PromptFile, section: PromptSection): string;
+/**
+ * Builds the git branch name used for one isolated task.
+ */
+export declare function buildCoderIsolationBranchName(taskName: string): string;
+/**
+ * Builds the absolute worktree path used for one isolated task.
+ */
+export declare function buildCoderIsolationWorktreePath(projectPath: string, taskName: string): string;
+/**
+ * Builds the project-relative worktree path of one isolated task, used in human-facing messages.
+ */
+export declare function buildCoderIsolationWorktreeDisplayPath(taskName: string): string;

package/esm/scripts/run-codex-prompts/isolation/copyCoderIsolationEnvironment.d.ts

@@ -0,0 +1,8 @@
+import type { CoderIsolationWorktree } from './CoderIsolationWorktree';
+/**
+ * Gives the isolated worktree its own copy of the project environment.
+ *
+ * The copy is intentionally a snapshot: changing the environment inside the worktree never leaks
+ * back into the project the coder was started from.
+ */
+export declare function copyCoderIsolationEnvironment(worktree: CoderIsolationWorktree): Promise<void>;

package/esm/scripts/run-codex-prompts/isolation/createCoderIsolationWorktree.d.ts

@@ -0,0 +1,22 @@
+import type { CoderIsolationWorktree } from './CoderIsolationWorktree';
+/**
+ * Options for creating one isolation worktree.
+ */
+type CreateCoderIsolationWorktreeOptions = {
+    /**
+     * Absolute path of the project the coder was started from.
+     */
+    readonly projectPath: string;
+    /**
+     * Name of the isolated task, for example `2026-07-0700-ptbk-coder-timing`.
+     */
+    readonly taskName: string;
+};
+/**
+ * Creates one temporary git worktree with its own branch and its own copy of the project environment.
+ *
+ * Leftovers of an earlier run of the same task are removed first so that a repeated task never fails
+ * on an already existing worktree directory or branch.
+ */
+export declare function createCoderIsolationWorktree(options: CreateCoderIsolationWorktreeOptions): Promise<CoderIsolationWorktree>;
+export {};

package/esm/scripts/run-codex-prompts/isolation/markPromptIsolationMergeFailed.d.ts

@@ -0,0 +1,10 @@
+import type { PromptFile } from '../prompts/types/PromptFile';
+import type { PromptSection } from '../prompts/types/PromptSection';
+import type { CoderIsolationWorktree } from './CoderIsolationWorktree';
+/**
+ * Rewrites the status of one prompt whose isolated implementation could not be merged back.
+ *
+ * The prompt has already been marked as done by the isolated round, so the recorded runner metadata is
+ * kept and only the status box turns from `[x]` into `[!]`, followed by the manual merge instructions.
+ */
+export declare function markPromptIsolationMergeFailed(file: PromptFile, section: PromptSection, worktree: CoderIsolationWorktree): void;

package/esm/scripts/run-codex-prompts/isolation/mergeCoderIsolationWorktree.d.ts

@@ -0,0 +1,24 @@
+import type { CoderIsolationWorktree } from './CoderIsolationWorktree';
+/**
+ * Outcome of merging one isolated task back into the branch the coder runs on.
+ */
+export type CoderIsolationMergeResult = {
+    readonly isMerged: true;
+} | {
+    readonly isMerged: false;
+    /**
+     * Raw git output explaining why the merge could not be completed.
+     */
+    readonly failureDetails: string;
+};
+/**
+ * Merges the isolated task back into the branch the coder runs on.
+ *
+ * The merge is squashed so that the isolated task produces exactly one commit on the original branch,
+ * exactly like a task processed without `--isolate`. The changes are only staged here; the caller
+ * creates the commit so that the prompt status update becomes part of the very same commit.
+ *
+ * A failed merge never leaves the original working tree in a conflicted state and is reported back
+ * instead of thrown, because a merge failure must not stop the coder from processing the next task.
+ */
+export declare function mergeCoderIsolationWorktree(worktree: CoderIsolationWorktree): Promise<CoderIsolationMergeResult>;

package/esm/scripts/run-codex-prompts/isolation/removeCoderIsolationWorktree.d.ts

@@ -0,0 +1,8 @@
+import type { CoderIsolationWorktree } from './CoderIsolationWorktree';
+/**
+ * Removes one isolation worktree together with its temporary branch.
+ *
+ * Returns `true` when the worktree directory or the temporary branch still existed and was removed,
+ * which lets callers report that leftovers of an earlier run were cleaned up.
+ */
+export declare function removeCoderIsolationWorktree(worktree: CoderIsolationWorktree): Promise<boolean>;

package/esm/scripts/run-codex-prompts/isolation/runIsolatedPromptRound.d.ts

@@ -0,0 +1,14 @@
+import type { RunPromptRoundOptions } from '../main/runPromptRound';
+/**
+ * Runs one prompt round inside a temporary git worktree and merges the result back afterwards.
+ *
+ * This is the `--isolate` counterpart of `runPromptRound`, so it accepts exactly the same input:
+ * - The coding agent, its verification command and the round commit all happen inside the worktree.
+ * - A verified task is squash-merged back into the branch the coder runs on and the worktree is deleted.
+ * - A task which cannot be merged is recorded as failed in the original project and its worktree is kept,
+ *   without stopping the coder from processing the next task.
+ * - A task whose round fails keeps its worktree too, so the work of the failed round can still be inspected.
+ *
+ * @private function of runCodexPrompts
+ */
+export declare function runIsolatedPromptRound(options: RunPromptRoundOptions): Promise<void>;

package/esm/scripts/run-codex-prompts/main/runPromptRound.d.ts

@@ -7,7 +7,7 @@ import type { CoderRunUiHandle } from '../ui/renderCoderRunUi';
 /**
  * Input required to execute one prompt-processing round.
  */
-type RunPromptRoundOptions = {
+export type RunPromptRoundOptions = {
     options: RunOptions;
     runner: PromptRunner;
     runnerMetadata: {
@@ -22,11 +22,17 @@ type RunPromptRoundOptions = {
     progressDisplay?: CliProgressDisplay;
     uiHandle?: CoderRunUiHandle;
     waitForRequestedPause: WaitForCoderRunPauseCheckpoint;
+    /**
+     * Working directory the coding agent, the verification command and the round commit run in.
+     *
+     * Defaults to the project the coder was started from and is the temporary worktree
+     * when the round is isolated through `--isolate`.
+     */
+    projectPath?: string;
 };
 /**
  * Runs one prompt round from prompt construction through commit or failure logging.
  *
  * @private function of runCodexPrompts
  */
-export declare function runPromptRound({ options, runner, runnerMetadata, nextPrompt, promptLabel, resolvedCoderContext, resolvedAgentSystemMessage, isRichUiEnabled, progressDisplay, uiHandle, waitForRequestedPause, }: RunPromptRoundOptions): Promise<void>;
-export {};
+export declare function runPromptRound({ options, runner, runnerMetadata, nextPrompt, promptLabel, resolvedCoderContext, resolvedAgentSystemMessage, isRichUiEnabled, progressDisplay, uiHandle, waitForRequestedPause, projectPath, }: RunPromptRoundOptions): Promise<void>;

package/esm/scripts/run-codex-prompts/prompts/buildPromptSectionSuffix.d.ts

@@ -0,0 +1,9 @@
+import type { PromptFile } from './types/PromptFile';
+import type { PromptSection } from './types/PromptSection';
+/**
+ * Builds the suffix which disambiguates one prompt section inside its prompt file.
+ *
+ * Prompt files holding exactly one section produce an empty suffix so that generated artifact
+ * names (temporary scripts, isolation worktrees, ...) stay identical to the prompt file name.
+ */
+export declare function buildPromptSectionSuffix(file: PromptFile, section: PromptSection): string;

package/esm/scripts/run-codex-prompts/prompts/findNextTodoPrompt.d.ts

@@ -1,6 +1,7 @@
 import type { PromptFile } from './types/PromptFile';
 import type { PromptSelection } from './types/PromptSelection';
+import type { PriorityFilter } from './priorityFilter';
 /**
  * Selects the next runnable prompt based on priority.
  */
-export declare function findNextTodoPrompt(files: PromptFile[], minimumPriority?: number): PromptSelection | undefined;
+export declare function findNextTodoPrompt(files: PromptFile[], priorityFilter?: PriorityFilter): PromptSelection | undefined;

package/esm/scripts/run-codex-prompts/prompts/formatCoderRunSteps.d.ts

@@ -0,0 +1,9 @@
+import type { CoderRunStep } from '../common/CoderRunStep';
+/**
+ * Formats the per-step usage breakdown recorded for one finished 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.
+ */
+export declare function formatCoderRunSteps(steps: ReadonlyArray<CoderRunStep>): string;

package/esm/scripts/run-codex-prompts/prompts/formatRunnerSignature.d.ts

@@ -1,4 +1,5 @@
+import type { ThinkingLevel } from '../../../src/cli/cli-commands/coder/ThinkingLevel';
 /**
  * Formats runner details for prompt status lines.
  */
-export declare function formatRunnerSignature(runnerName: string | undefined, modelName: string | undefined): string;
+export declare function formatRunnerSignature(runnerName: string | undefined, modelName: string | undefined, thinkingLevel?: ThinkingLevel): string;

package/esm/scripts/run-codex-prompts/prompts/isPromptInPriorityFilter.d.ts

@@ -0,0 +1,6 @@
+import { type PriorityFilter } from './priorityFilter';
+import type { PromptSection } from './types/PromptSection';
+/**
+ * Checks whether a prompt section matches the configured priority filter.
+ */
+export declare function isPromptInPriorityFilter(section: PromptSection, priorityFilter?: PriorityFilter): boolean;

package/esm/scripts/run-codex-prompts/prompts/listPromptsToBeWritten.d.ts

@@ -1,6 +1,7 @@
 import type { PromptFile } from './types/PromptFile';
 import type { PromptSelection } from './types/PromptSelection';
+import type { PriorityFilter } from './priorityFilter';
 /**
  * Lists todo prompts that still contain authoring placeholders.
  */
-export declare function listPromptsToBeWritten(files: PromptFile[], minimumPriority?: number): PromptSelection[];
+export declare function listPromptsToBeWritten(files: PromptFile[], priorityFilter?: PriorityFilter): PromptSelection[];

package/esm/scripts/run-codex-prompts/prompts/listRunnablePrompts.d.ts

@@ -1,6 +1,7 @@
 import type { PromptFile } from './types/PromptFile';
 import type { PromptSelection } from './types/PromptSelection';
+import type { PriorityFilter } from './priorityFilter';
 /**
  * Lists todo prompts that are ready to run (no authoring placeholders).
  */
-export declare function listRunnablePrompts(files: PromptFile[], minimumPriority?: number): PromptSelection[];
+export declare function listRunnablePrompts(files: PromptFile[], priorityFilter?: PriorityFilter): PromptSelection[];

package/esm/scripts/run-codex-prompts/prompts/listUpcomingTasks.d.ts

@@ -1,6 +1,7 @@
 import type { PromptFile } from './types/PromptFile';
 import type { UpcomingTask } from './types/UpcomingTask';
+import type { PriorityFilter } from './priorityFilter';
 /**
  * Lists upcoming tasks that are ready to run (no authoring placeholders).
  */
-export declare function listUpcomingTasks(files: PromptFile[], minimumPriority?: number): UpcomingTask[];
+export declare function listUpcomingTasks(files: PromptFile[], priorityFilter?: PriorityFilter): UpcomingTask[];

package/esm/scripts/run-codex-prompts/prompts/markPromptDone.d.ts

@@ -1,8 +1,9 @@
-import moment from 'moment';
-import type { Usage } from '../../../src/execution/Usage';
+import { type CodexLoginMethod } from '../../../src/book-3.0/codexLoginMethod';
+import type { ThinkingLevel } from '../../../src/cli/cli-commands/coder/ThinkingLevel';
+import type { CoderRunStep } from '../common/CoderRunStep';
 import type { PromptFile } from './types/PromptFile';
 import type { PromptSection } from './types/PromptSection';
 /**
- * Marks a prompt section as done and records usage pricing and runner details.
+ * Marks a prompt section as done and records the per-step usage pricing and runner details.
  */
-export declare function markPromptDone(file: PromptFile, section: PromptSection, usage: Usage, runnerName: string | undefined, modelName: string | undefined, promptExecutionStartedDate: moment.Moment, attemptCount?: number): void;
+export declare function markPromptDone(file: PromptFile, section: PromptSection, steps: ReadonlyArray<CoderRunStep>, runnerName: string | undefined, modelName: string | undefined, attemptCount?: number, loginMethod?: CodexLoginMethod, thinkingLevel?: ThinkingLevel): void;

package/esm/scripts/run-codex-prompts/prompts/printPromptsToBeWritten.d.ts

@@ -1,5 +1,6 @@
+import type { PriorityFilter } from './priorityFilter';
 import type { PromptFile } from './types/PromptFile';
 /**
  * Prints the list of prompts that still need to be written.
  */
-export declare function printPromptsToBeWritten(files: PromptFile[], minimumPriority?: number): void;
+export declare function printPromptsToBeWritten(files: PromptFile[], priorityFilter?: PriorityFilter): void;

package/esm/scripts/run-codex-prompts/prompts/printStats.d.ts

@@ -1,5 +1,6 @@
+import { type PriorityFilter } from './priorityFilter';
 import type { PromptStats } from './types/PromptStats';
 /**
  * Prints the summary stats line.
  */
-export declare function printStats(stats: PromptStats, minimumPriority?: number): void;
+export declare function printStats(stats: PromptStats, priorityFilter?: PriorityFilter): void;