@promptbook/cli 0.114.0-0 → 0.114.0-10

package/umd/scripts/run-agent-messages/messages/buildAgentGoalChatPromptSection.d.ts

@@ -0,0 +1,8 @@
+import type { AgentServerRuntimePromptApi } from './AgentServerRuntimePromptApi';
+/**
+ * Builds the planned-message instructions available to an Agents Server-managed coding agent.
+ *
+ * Planned messages always target the agent's singleton goal chat, regardless of the chat in which
+ * the command is invoked.
+ */
+export declare function buildAgentGoalChatPromptSection(runtimeApi: AgentServerRuntimePromptApi | undefined): string;

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

@@ -1,8 +1,19 @@
+import type { AgentServerRuntimePromptApi } from './AgentServerRuntimePromptApi';
 import { type AgentProjectsPromptSectionOptions } from './buildAgentProjectsPromptSection';
+import { type AgentTeamPromptWorkspace } from './buildAgentTeamPromptSection';
 /**
  * Options adjusting the generated agent message prompt.
  */
-export type BuildAgentMessagePromptOptions = AgentProjectsPromptSectionOptions;
+export type BuildAgentMessagePromptOptions = AgentProjectsPromptSectionOptions & {
+    /**
+     * Optional local TEAM roster prepared by the Agents Server for this user turn.
+     */
+    teamWorkspace?: AgentTeamPromptWorkspace;
+    /**
+     * Internal API details used to manage planned messages in the agent's singleton goal chat.
+     */
+    goalChatRuntimeApi?: AgentServerRuntimePromptApi;
+};
 /**
  * Builds the prompt sent to the selected coding runner for one queued user-thread book.
  */

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

@@ -1,20 +1,8 @@
+import type { AgentServerRuntimePromptApi } from './AgentServerRuntimePromptApi';
 /**
  * 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;
-};
+export type AgentProjectRuntimePromptApi = AgentServerRuntimePromptApi;
 /**
  * Options of the projects prompt section shared by every coding harness.
  */

package/umd/scripts/run-agent-messages/messages/buildAgentTeamPromptSection.d.ts

@@ -0,0 +1,12 @@
+import { type AgentTeamConversationWorkspaceManifest } from '../../../src/book-3.0/AgentTeamConversationWorkspace';
+/**
+ * TEAM workspace information made visible to one coding-harness prompt.
+ */
+export type AgentTeamPromptWorkspace = {
+    readonly relativeWorkspacePath: string;
+    readonly manifest: AgentTeamConversationWorkspaceManifest;
+};
+/**
+ * Builds the optional single-run TEAM consultation instructions for a coding harness.
+ */
+export declare function buildAgentTeamPromptSection(workspace: AgentTeamPromptWorkspace | undefined): string;

package/umd/scripts/run-agent-messages/messages/finalizeAgentTeamConversationWorkspace.d.ts

@@ -0,0 +1,16 @@
+import type { AgentMessageFile } from './AgentMessageFile';
+import type { AgentTeamPromptWorkspace } from './buildAgentTeamPromptSection';
+/**
+ * TEAM transcript files retained next to the finished user message.
+ */
+export type FinishedAgentTeamConversationWorkspace = {
+    readonly relativePaths: ReadonlyArray<string>;
+};
+/**
+ * Moves harness-created TEAM conversation transcripts into the finished-message history.
+ */
+export declare function finalizeAgentTeamConversationWorkspace(options: {
+    readonly projectPath: string;
+    readonly queuedMessage: AgentMessageFile;
+    readonly workspace: AgentTeamPromptWorkspace | null;
+}): Promise<FinishedAgentTeamConversationWorkspace | null>;

package/umd/scripts/run-agent-messages/messages/loadAgentTeamConversationWorkspace.d.ts

@@ -0,0 +1,6 @@
+import type { AgentMessageFile } from './AgentMessageFile';
+import type { AgentTeamPromptWorkspace } from './buildAgentTeamPromptSection';
+/**
+ * Loads the optional TEAM roster snapshot for one queued message.
+ */
+export declare function loadAgentTeamConversationWorkspace(projectPath: string, queuedMessage: AgentMessageFile): Promise<AgentTeamPromptWorkspace | null>;

package/umd/scripts/run-codex-prompts/common/createCoderRunStepTracker.d.ts

@@ -0,0 +1,48 @@
+import type { CodexLoginMethod } from '../../../src/book-3.0/codexLoginMethod';
+import type { CoderRunStep, CoderRunStepKind } from './CoderRunStep';
+/**
+ * Progress of one prompt round, reported right before a new step starts.
+ */
+export type CoderRunStepProgress = {
+    /**
+     * Kind of the step which is about to start.
+     */
+    readonly startedStepKind: CoderRunStepKind;
+    /**
+     * Steps of the same prompt round which have already finished, in the order they ran.
+     */
+    readonly finishedSteps: ReadonlyArray<CoderRunStep>;
+    /**
+     * Authentication method the harness reported, as soon as one of the finished steps revealed it.
+     */
+    readonly loginMethod?: CodexLoginMethod;
+};
+/**
+ * Notified right before one coder run step starts.
+ */
+export type OnCoderRunStepStarted = (progress: CoderRunStepProgress) => Promise<void>;
+/**
+ * Collects the measured steps of one prompt round and announces every step which starts.
+ */
+export type CoderRunStepTracker = {
+    /**
+     * Steps which have finished so far, in the order they ran.
+     */
+    readonly steps: ReadonlyArray<CoderRunStep>;
+    /**
+     * Announces that one step is about to start.
+     */
+    readonly startStep: (kind: CoderRunStepKind) => Promise<void>;
+    /**
+     * Records one finished step together with the authentication method its runner reported.
+     */
+    readonly finishStep: (step: CoderRunStep, loginMethod?: CodexLoginMethod) => void;
+};
+/**
+ * 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.
+ */
+export declare function createCoderRunStepTracker(onStepStarted?: OnCoderRunStepStarted): CoderRunStepTracker;

package/umd/scripts/run-codex-prompts/common/normalizeLineEndingsInChangedFiles.d.ts

@@ -1,9 +1,8 @@
+import type { WorkingTreeChangesSnapshot } from '../git/workingTreeChanges';
 /**
  * Snapshot of file hashes for files that were already dirty before a coding round started.
  */
-export type ChangedFilesSnapshot = {
-    readonly changedFileHashes: ReadonlyMap<string, string>;
-};
+export type ChangedFilesSnapshot = WorkingTreeChangesSnapshot;
 /**
  * Options for normalizing line endings in files changed during one coding round.
  */

package/umd/scripts/run-codex-prompts/common/runGoScript/scriptExecutionLog.d.ts

@@ -2,6 +2,13 @@
  * Environment variable read by the shell wrapper to tee live output into the temporary runtime log file.
  */
 export declare const PTBK_CODER_LOG_FILE_ENV_NAME = "PTBK_CODER_LOG_FILE";
+/**
+ * Log line which separates the raw script input from the raw script output of one execution section.
+ *
+ * Readers of a runtime log split on this marker to look only at what the harness really produced,
+ * without the generated script and the prompt it embeds.
+ */
+export declare const SCRIPT_EXECUTION_LOG_RAW_OUTPUT_MARKER = "--- raw output ---";
 /**
  * Shapes one bash invocation that optionally mirrors live script output into a temporary log file.
  */

package/umd/scripts/run-codex-prompts/git/coderCommitScope.d.ts

@@ -0,0 +1,31 @@
+import type { WorkingTreeChangesSnapshot } from './workingTreeChanges';
+/**
+ * Working tree state captured right before one `ptbk coder` operation starts changing the project.
+ *
+ * Note: This is the single mechanism which every `ptbk coder` command uses to commit only the files relevant
+ *       for the operation it has just performed, instead of everything which happens to be changed in the project.
+ */
+export type CoderCommitScope = {
+    /**
+     * Project the operation runs in.
+     */
+    readonly projectPath: string;
+    /**
+     * Files which were already changed before the operation started.
+     */
+    readonly snapshotBeforeOperation: WorkingTreeChangesSnapshot;
+};
+/**
+ * Captures the working tree state before one `ptbk coder` operation changes anything.
+ *
+ * The captured scope is passed to the commit of the very same operation, which then commits exactly the files
+ * this operation has created, changed, moved or deleted.
+ */
+export declare function captureCoderCommitScope(projectPath: string): Promise<CoderCommitScope>;
+/**
+ * Resolves the repository-relative paths which one `ptbk coder` operation has really changed.
+ *
+ * Files which were already changed before the operation started and which the operation did not touch are
+ * never part of the result, so they stay in the working tree instead of being swept into the commit.
+ */
+export declare function resolveCoderCommitScopePaths(scope: CoderCommitScope): Promise<ReadonlyArray<string>>;

package/umd/scripts/run-codex-prompts/git/coderGitSync.d.ts

@@ -0,0 +1,56 @@
+import type { CoderCommitScope } from './coderCommitScope';
+/**
+ * Automatic git synchronization of the project changes made by one `ptbk coder` command.
+ *
+ * Note: This is the single place where pulling, committing and pushing of `ptbk coder` project changes is
+ *       implemented, every command which offers `--commit`, `--auto-push` and `--auto-pull` reuses it.
+ */
+export type CoderGitSyncOptions = {
+    /**
+     * Commit the changes made by the command.
+     */
+    readonly isCommitEnabled: boolean;
+    /**
+     * Push the created commit to the remote repository.
+     */
+    readonly isAutoPushEnabled: boolean;
+    /**
+     * Pull the latest changes from the remote repository before the command changes anything.
+     */
+    readonly isAutoPullEnabled: boolean;
+};
+/**
+ * Git synchronization which leaves the repository completely untouched.
+ *
+ * Note: This is the default for every command and helper which supports the git synchronization.
+ */
+export declare const DISABLED_CODER_GIT_SYNC_OPTIONS: CoderGitSyncOptions;
+/**
+ * Pulls the latest repository changes and captures the working tree state before a `ptbk coder` command
+ * changes the project.
+ *
+ * The returned scope is handed over to `$commitCoderChanges` of the very same command, which then commits
+ * exactly the files this command has changed.
+ */
+export declare function $startCoderGitSync(options: {
+    readonly gitSync: CoderGitSyncOptions;
+    readonly projectPath?: string;
+}): Promise<CoderCommitScope>;
+/**
+ * Pulls the latest repository changes before a `ptbk coder` command changes the project.
+ */
+export declare function $pullCoderChanges(options: {
+    readonly gitSync: CoderGitSyncOptions;
+    readonly projectPath?: string;
+}): Promise<void>;
+/**
+ * Commits - and when requested also pushes - the changes one `ptbk coder` command has just made.
+ *
+ * Note: Only the files this very command has changed are committed, everything else is left in the working tree.
+ * Note: A command which changed nothing is left alone instead of creating an empty commit.
+ */
+export declare function $commitCoderChanges(options: {
+    readonly gitSync: CoderGitSyncOptions;
+    readonly commitMessage: string;
+    readonly commitScope: CoderCommitScope;
+}): Promise<void>;

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

@@ -1,14 +1,23 @@
 /**
  * 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,
+ * `options.relevantPaths` restricts both the staging and the commit to the files of the current operation,
  * `options.excludePaths` can keep temporary artifacts out of the created commit and
  * `options.isEmptyCommitAllowed` keeps a round without any file change from failing.
+ *
+ * Note: The temporary commit message file is written inside the project, so it is always excluded from the commit
+ *       itself for projects which do not keep the Promptbook temporary directory out of version control.
  */
 export declare function commitChanges(message: string, options?: {
     autoPush?: boolean;
-    includePaths?: ReadonlyArray<string>;
-    onlyPaths?: ReadonlyArray<string>;
+    /**
+     * Repository-relative paths which are relevant for the current operation.
+     *
+     * Only these paths are staged and only they end up in the created commit, so unrelated changes of the
+     * project are left in the working tree. Everything is committed when the paths are not provided at all,
+     * while an empty list commits nothing but the file changes already staged before.
+     */
+    relevantPaths?: ReadonlyArray<string>;
     excludePaths?: ReadonlyArray<string>;
     projectPath?: string;
     isEmptyCommitAllowed?: boolean;

package/umd/scripts/run-codex-prompts/git/workingTreeChanges.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Snapshot of file hashes for files that were already dirty before one operation started.
+ *
+ * Note: This is the single source of truth about which files one `ptbk coder` operation has really changed,
+ *       used both for normalizing line endings and for committing only the relevant files.
+ */
+export type WorkingTreeChangesSnapshot = {
+    /**
+     * Hash of every dirty file at the moment the snapshot was taken.
+     *
+     * A file which was dirty but could not be hashed (a deleted file or a non-regular file) is stored as `null`,
+     * so it can be told apart from a file which was not dirty at all.
+     */
+    readonly changedFileHashes: ReadonlyMap<string, string | null>;
+};
+/**
+ * Captures hashes for files that are dirty before one operation starts.
+ */
+export declare function captureWorkingTreeChangesSnapshot(projectPath: string): Promise<WorkingTreeChangesSnapshot>;
+/**
+ * Lists the repository-relative paths which really changed since the snapshot was taken.
+ *
+ * A file which was already dirty before and was not touched afterwards is not listed, so the result contains
+ * exactly the files changed by the operation which the snapshot wraps.
+ */
+export declare function listFilesChangedSinceSnapshot(projectPath: string, snapshot: WorkingTreeChangesSnapshot): Promise<ReadonlyArray<string>>;
+/**
+ * Lists dirty tracked files and untracked files in the working tree.
+ */
+export declare function listWorkingTreeChangedFiles(projectPath: string): Promise<ReadonlyArray<string>>;
+/**
+ * Reads the content hash of one repository-relative working tree file.
+ *
+ * @returns Hash of a regular file, otherwise `null` for a deleted or non-regular file.
+ */
+export declare function readWorkingTreeFileHash(projectPath: string, relativePath: string): Promise<string | null>;
+/**
+ * Normalizes Git output paths for internal matching.
+ */
+export declare function normalizeGitFilePath(filePath: string): string;

package/umd/scripts/run-codex-prompts/main/resolvePromptRunner.d.ts

@@ -7,6 +7,13 @@ type RunnerMetadata = {
     runnerName: string;
     modelName?: string;
 };
+/**
+ * Subset of `RunOptions` which decides which prompt runner is created and how it is labeled.
+ *
+ * Commands that only need one configured harness — such as `ptbk coder ping` — pass just these
+ * fields instead of assembling a complete `RunOptions` for a run they never start.
+ */
+export type PromptRunnerSelectionOptions = Pick<RunOptions, 'agentName' | 'model' | 'thinkingLevel' | 'allowCredits' | 'isVerbose' | 'isMachineReadableProgressEnabled'>;
 /**
  * Resolved runner setup used by `runCodexPrompts`.
  */
@@ -20,5 +27,5 @@ type PromptRunnerResolution = {
  *
  * @private function of runCodexPrompts
  */
-export declare function resolvePromptRunner(options: RunOptions): PromptRunnerResolution;
+export declare function resolvePromptRunner(options: PromptRunnerSelectionOptions): PromptRunnerResolution;
 export {};

package/umd/scripts/run-codex-prompts/ping/buildCoderPingPrompt.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Marker the pinged harness is asked to prefix its answer with, so the reply can be recognized
+ * in the raw runner output of every supported harness.
+ *
+ * Note: The marker must stay free of regular-expression metacharacters, because
+ *       `extractCoderPingAnswer` builds its pattern from it.
+ */
+export declare const CODER_PING_ANSWER_MARKER = "PTBK-CODER-PING-ANSWER";
+/**
+ * Answer a working harness and model returns for the dummy work of `ptbk coder ping`.
+ */
+export declare const CODER_PING_EXPECTED_ANSWER: string;
+/**
+ * Builds the dummy prompt sent by `ptbk coder ping`.
+ *
+ * The work is intentionally the smallest possible one that still reaches the model: it spends a
+ * negligible amount of the harness quota, it needs no tool and it explicitly forbids touching the
+ * project, so a ping leaves the project exactly as it was.
+ */
+export declare function buildCoderPingPrompt(): string;

package/umd/scripts/run-codex-prompts/ping/extractCoderPingAnswer.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Extracts the answer of a pinged harness from the runtime log of its runner shell.
+ *
+ * Only the raw output of the last execution is searched, so the answer marker contained in the
+ * prompt of the raw input is never mistaken for the answer of the harness.
+ *
+ * @returns The answer of the harness, or `null` when the harness produced no recognizable answer
+ */
+export declare function extractCoderPingAnswer(runtimeLog: string): string | null;

package/umd/scripts/run-codex-prompts/ping/pingCoderHarness.d.ts

@@ -0,0 +1,23 @@
+import type { PromptRunnerSelectionOptions } from '../main/resolvePromptRunner';
+import type { CoderPingResult } from './CoderPingResult';
+/**
+ * Options for one `ptbk coder ping` round trip.
+ */
+export type PingCoderHarnessOptions = PromptRunnerSelectionOptions & {
+    /**
+     * Project the harness is started in. Defaults to the current working directory.
+     */
+    readonly projectPath?: string;
+    /**
+     * Mirrors the live harness output to the terminal instead of only reporting the compact result.
+     */
+    readonly shouldPrintLiveOutput?: boolean;
+};
+/**
+ * Sends one tiny dummy prompt through the selected harness and model and measures the round trip.
+ *
+ * The ping reuses the very same runner the coding queue uses, so it really exercises the configured
+ * harness, model, thinking level and authentication — including the retry behavior on rate limits.
+ * Both temporary artifacts it creates are removed again, so the project is left as it was.
+ */
+export declare function pingCoderHarness(options: PingCoderHarnessOptions): Promise<CoderPingResult>;

package/umd/scripts/run-codex-prompts/ping/printCoderPingResult.d.ts

@@ -0,0 +1,5 @@
+import type { CoderPingResult } from './CoderPingResult';
+/**
+ * Prints the compact summary of one finished `ptbk coder ping`.
+ */
+export declare function printCoderPingResult(result: CoderPingResult): void;

package/umd/scripts/run-codex-prompts/prompts/buildPromptStatusDetails.d.ts

@@ -0,0 +1,43 @@
+import { type CodexLoginMethod } from '../../../src/book-3.0/codexLoginMethod';
+import type { ThinkingLevel } from '../../../src/cli/cli-commands/coder/ThinkingLevel';
+import type { CoderRunStep, CoderRunStepKind } from '../common/CoderRunStep';
+/**
+ * Everything one prompt status line says after its checklist marker.
+ */
+export type BuildPromptStatusDetailsOptions = {
+    /**
+     * Steps of the prompt round which have already finished, each with its own price and duration.
+     */
+    readonly steps: ReadonlyArray<CoderRunStep>;
+    /**
+     * Step which has already started but has not finished yet, reported as `Implementation in progress`.
+     */
+    readonly inProgressStepKind?: CoderRunStepKind;
+    /**
+     * Harness which runs the prompt.
+     */
+    readonly runnerName: string | undefined;
+    /**
+     * Model the harness runs the prompt with.
+     */
+    readonly modelName: string | undefined;
+    /**
+     * How many coding attempts the prompt has taken so far.
+     */
+    readonly attemptCount: number;
+    /**
+     * Authentication method the harness reported, when it is already known.
+     */
+    readonly loginMethod?: CodexLoginMethod;
+    /**
+     * Reasoning effort the harness runs the prompt with.
+     */
+    readonly thinkingLevel?: ThinkingLevel;
+};
+/**
+ * Builds the shared body of a prompt status line, used by both the in-progress `[^]` and the done `[x]` status.
+ *
+ * Produces details such as
+ * ``by OpenAI Codex `gpt-5.6-luna` thinking `max` (ChatGPT account) - Implementation ~$0.2036 10 minutes``.
+ */
+export declare function buildPromptStatusDetails(options: BuildPromptStatusDetailsOptions): string;

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

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

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

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

package/umd/scripts/run-codex-prompts/prompts/isPromptCompatibleWithRunner.d.ts

@@ -0,0 +1,27 @@
+import type { PromptFile } from './types/PromptFile';
+import type { PromptSection } from './types/PromptSection';
+/**
+ * Names of the harness and model currently selected for a coder run.
+ */
+export type PromptRunnerIdentity = {
+    /**
+     * Stable harness identifier, for example `github-copilot`.
+     */
+    readonly harnessName?: string;
+    /**
+     * Effective model identifier, for example `gpt-5.5`.
+     */
+    readonly modelName?: string;
+};
+/**
+ * Checks whether a prompt is unrestricted or matches the selected harness/model.
+ *
+ * A prompt status line can contain one or more backtick-delimited model or harness
+ * names. Matching is intentionally based on normalized substrings so a token such as
+ * `gpt` selects any `gpt-*` model and `opus` selects a `claude-opus-*` model.
+ */
+export declare function isPromptCompatibleWithRunner(file: PromptFile, section: PromptSection, promptRunnerIdentity?: PromptRunnerIdentity): boolean;
+/**
+ * Extracts model and harness tokens from a prompt status line.
+ */
+export declare function extractPromptRunnerTokens(statusLine: string): string[];

package/umd/scripts/run-codex-prompts/prompts/isPromptSectionUnfinished.d.ts

@@ -0,0 +1,8 @@
+import type { PromptSection } from './types/PromptSection';
+/**
+ * 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.
+ */
+export declare function isPromptSectionUnfinished(section: PromptSection): boolean;

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { type CodexLoginMethod } from '../../../src/book-3.0/codexLoginMethod';
+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';

package/umd/scripts/run-codex-prompts/prompts/markPromptInProgress.d.ts

@@ -0,0 +1,27 @@
+import { type BuildPromptStatusDetailsOptions } from './buildPromptStatusDetails';
+import type { PromptFile } from './types/PromptFile';
+import type { PromptSection } from './types/PromptSection';
+/**
+ * Input for marking one prompt section as being implemented right now.
+ */
+export type MarkPromptInProgressOptions = BuildPromptStatusDetailsOptions & {
+    /**
+     * Prompt file the marked section belongs to.
+     */
+    readonly file: PromptFile;
+    /**
+     * Section which is being implemented right now.
+     */
+    readonly section: PromptSection;
+    /**
+     * Step which has just started, always present because a prompt is only in progress while a step runs.
+     */
+    readonly inProgressStepKind: NonNullable<BuildPromptStatusDetailsOptions['inProgressStepKind']>;
+};
+/**
+ * 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.
+ */
+export declare function markPromptInProgress(options: MarkPromptInProgressOptions): void;

package/umd/scripts/run-codex-prompts/prompts/resolvePromptStatusLine.d.ts

@@ -0,0 +1,19 @@
+import type { PromptFile } from './types/PromptFile';
+import type { PromptSection } from './types/PromptSection';
+/**
+ * Status line of one prompt section together with the index it lives on.
+ */
+export type ResolvedPromptStatusLine = {
+    /**
+     * Index of the status line within `file.lines`.
+     */
+    readonly statusLineIndex: number;
+    /**
+     * Current content of the status line, including its indentation and checklist marker.
+     */
+    readonly line: string;
+};
+/**
+ * Resolves the status line of one prompt section so it can be rewritten.
+ */
+export declare function resolvePromptStatusLine(file: PromptFile, section: PromptSection): ResolvedPromptStatusLine;

package/umd/scripts/run-codex-prompts/prompts/writePromptStatusLine.d.ts

@@ -0,0 +1,9 @@
+import type { PromptFile } from './types/PromptFile';
+import type { PromptSection } from './types/PromptSection';
+/**
+ * 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.
+ */
+export declare function writePromptStatusLine(file: PromptFile, section: PromptSection, replacementStatusLine: string): void;

package/umd/scripts/run-codex-prompts/server/buildCoderServerPromptResponse.d.ts

@@ -10,7 +10,7 @@ export type CoderServerBoardColumn = 'backlog' | 'low-priority' | 'todo' | 'in-p
  * UI tag attached to one prompt card.
  */
 export type CoderServerPromptTag = {
-    readonly id: 'not-ready' | 'unwritten' | 'implementing' | 'verifying';
+    readonly id: 'not-ready' | 'unwritten' | 'left-in-progress' | 'implementing' | 'verifying';
     readonly label: string;
 };
 /**