@promptbook/cli 0.114.0-5 → 0.114.0-50

package/esm/scripts/run-codex-prompts/ping/pingCoderHarnessPeriodically.d.ts

@@ -0,0 +1,22 @@
+import type { PingCoderHarnessOptions } from './pingCoderHarness';
+/**
+ * Options for the endless `ptbk coder ping --period <duration>` loop.
+ */
+export type PingCoderHarnessPeriodicallyOptions = PingCoderHarnessOptions & {
+    /**
+     * How long one ping period lasts, in milliseconds.
+     *
+     * The period is measured from the start of one ping to the start of the next one, so the pings
+     * really happen once per period instead of once per period plus the duration of the ping itself.
+     */
+    readonly periodMs: number;
+};
+/**
+ * Pings the selected harness and model once per period until the process is stopped.
+ *
+ * This keeps the quota window of the harness refreshing without any real work, so the window is
+ * always open by the time you need it. The loop never ends on its own — it is stopped with `CTRL+C`
+ * or by killing the process — therefore a failing ping is reported and the next period is started
+ * instead of tearing the whole loop down.
+ */
+export declare function pingCoderHarnessPeriodically(options: PingCoderHarnessPeriodicallyOptions): Promise<never>;

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

@@ -0,0 +1,6 @@
+import type { PromptFile } from './types/PromptFile';
+import type { PromptSection } from './types/PromptSection';
+/**
+ * Builds a label that identifies the prompt section by index.
+ */
+export declare function buildPromptLabel(file: PromptFile, section: PromptSection, projectPath?: string): string;

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

@@ -3,4 +3,4 @@ import type { PromptSection } from './types/PromptSection';
 /**
  * Builds a display label using the prompt line number for easier navigation.
  */
-export declare function buildPromptLabelForDisplay(file: PromptFile, section: PromptSection): string;
+export declare function buildPromptLabelForDisplay(file: PromptFile, section: PromptSection, projectPath?: string): string;

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

@@ -0,0 +1,70 @@
+import moment from 'moment';
+import { type CodexLoginMethod } from '../../../src/book-3.0/codexLoginMethod';
+import type { CoderRunStep } from '../common/CoderRunStep';
+import { type FormatRunnerSignatureOptions } from './formatRunnerSignature';
+import type { PromptFile } from './types/PromptFile';
+import type { PromptSection } from './types/PromptSection';
+import type { CoderPhaseCommitResult } from '../git/CoderPhasePersistence';
+/**
+ * How one prompt round the trace describes has ended.
+ *
+ * A successful round reports the steps it is made of, a failed round reports the error which ended it.
+ */
+export type PromptRunTraceOutcome = {
+    readonly kind: 'succeeded';
+    /**
+     * Ordered steps of the round, each with its own price and duration.
+     */
+    readonly steps: ReadonlyArray<CoderRunStep>;
+    /**
+     * Authentication method the harness reported, when it could be determined.
+     */
+    readonly loginMethod?: CodexLoginMethod;
+} | {
+    readonly kind: 'failed';
+    /**
+     * Error which ended the round after its last retry.
+     */
+    readonly error: unknown;
+};
+/**
+ * Everything one run trace says about the prompt round it describes.
+ */
+export type BuildPromptRunTraceContentOptions = FormatRunnerSignatureOptions & {
+    /** Selected execution project used for trace links, including in temporary worktrees. */
+    readonly projectPath?: string;
+    readonly file: PromptFile;
+    readonly section: PromptSection;
+    /**
+     * Aggregate check command the round ran after each coding attempt, when one is configured.
+     */
+    readonly checkCommand?: string;
+    /**
+     * How many coding attempts the round has taken.
+     */
+    readonly attemptCount: number;
+    /**
+     * Moment the round started at.
+     */
+    readonly startedDate: moment.Moment;
+    /**
+     * Moment the round was recorded as finished or failed at.
+     */
+    readonly finishedDate: moment.Moment;
+    readonly outcome: PromptRunTraceOutcome;
+    /**
+     * Raw runtime log of the round, holding the generated shell scripts and everything the harness and the
+     * check command have written. Empty when the round produced no readable runtime log.
+     */
+    readonly runtimeLog: string;
+    /** Chronological local phase persistence; no-commit phases retain an absent commit identity. */
+    readonly phaseCommits?: ReadonlyArray<CoderPhaseCommitResult>;
+};
+/**
+ * Renders the markdown run trace of one finished or failed prompt round.
+ *
+ * The trace pairs the metadata of the round - which agent, harness, model and thinking level ran it, how long
+ * each of its steps took and what it cost - with the untouched runtime log, so a finished round can still be
+ * analyzed after its temporary artifacts are cleaned up.
+ */
+export declare function buildPromptRunTraceContent(options: BuildPromptRunTraceContentOptions): string;

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

@@ -0,0 +1,10 @@
+import type { PromptFile } from './types/PromptFile';
+import type { PromptSection } from './types/PromptSection';
+/**
+ * Builds the path of the run trace which belongs to one prompt section.
+ *
+ * The trace is stored in the `traces` directory of the very same prompts directory the prompt itself lives in,
+ * and it carries the name of its prompt file. A prompt file holding more than one section appends the section
+ * suffix, exactly like the temporary scripts and the isolation worktrees of the same section do.
+ */
+export declare function buildPromptRunTracePath(file: PromptFile, section: PromptSection): string;

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

@@ -1,10 +1,11 @@
 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';
+import { type FormatRunnerSignatureOptions } from './formatRunnerSignature';
+import { type PromptRunnerAttribution } from './promptRunnerAttribution';
 /**
  * Everything one prompt status line says after its checklist marker.
  */
-export type BuildPromptStatusDetailsOptions = {
+export type BuildPromptStatusDetailsOptions = FormatRunnerSignatureOptions & {
     /**
      * Steps of the prompt round which have already finished, each with its own price and duration.
      */
@@ -14,13 +15,12 @@ export type BuildPromptStatusDetailsOptions = {
      */
     readonly inProgressStepKind?: CoderRunStepKind;
     /**
-     * Harness which runs the prompt.
+     * Chronological runner report read from a prompt left in the middle of its implementation.
+     *
+     * Present only for a prompt resumed through `--git-changes continue`, so each status rewrite preserves every
+     * preceding harness and appends the harness which is currently continuing the work.
      */
-    readonly runnerName: string | undefined;
-    /**
-     * Model the harness runs the prompt with.
-     */
-    readonly modelName: string | undefined;
+    readonly previousRunnerSignatures?: PromptRunnerAttribution;
     /**
      * How many coding attempts the prompt has taken so far.
      */
@@ -29,15 +29,11 @@ export type BuildPromptStatusDetailsOptions = {
      * 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``.
+ * ``by Developer on OpenAI Codex `gpt-5.6-luna` thinking `max` (ChatGPT account) - Implementation ~$0.2036 10 minutes``.
  */
 export declare function buildPromptStatusDetails(options: BuildPromptStatusDetailsOptions): string;

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

@@ -0,0 +1,6 @@
+/**
+ * Finds the first non-empty line within the inclusive bounds.
+ *
+ * @private internal utility of prompt parsing and status writing
+ */
+export declare function findFirstNonEmptyLineIndex(lines: readonly string[], startLine: number, endLine: number): number | undefined;

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

@@ -3,10 +3,10 @@ import type { CoderRunStep, CoderRunStepKind } from '../common/CoderRunStep';
  * 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
+ * `Implementation $8.01 6 hours; Checking 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`
+ * @param inProgressStepKind - Step which has started but has not finished yet, appended as `Checking in progress`
  */
 export declare function formatCoderRunSteps(steps: ReadonlyArray<CoderRunStep>, inProgressStepKind?: CoderRunStepKind): string;

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

@@ -1,5 +1,18 @@
 import type { ThinkingLevel } from '../../../src/cli/cli-commands/coder/ThinkingLevel';
+import type { PromptRunnerMetadata } from '../common/PromptRunnerMetadata';
+/**
+ * Everything one runner signature can name, as far as it is known when the signature is formatted.
+ */
+export type FormatRunnerSignatureOptions = Partial<PromptRunnerMetadata> & {
+    /**
+     * Reasoning effort the harness runs the prompt with.
+     */
+    readonly thinkingLevel?: ThinkingLevel;
+};
 /**
  * Formats runner details for prompt status lines.
+ *
+ * Produces `` OpenAI Codex `gpt-5.6-luna` thinking `max` `` for a plain run and
+ * `` Developer on OpenAI Codex `gpt-5.6-luna` thinking `max` `` for a run personalized with `--agent`.
  */
-export declare function formatRunnerSignature(runnerName: string | undefined, modelName: string | undefined, thinkingLevel?: ThinkingLevel): string;
+export declare function formatRunnerSignature(options: FormatRunnerSignatureOptions): string;

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

@@ -1,7 +1,7 @@
 import type { PromptFile } from './types/PromptFile';
 import type { PromptSection } from './types/PromptSection';
 /**
- * Names of the harness and model currently selected for a coder run.
+ * Names of the harness, model and Book agent currently selected for a coder run.
  */
 export type PromptRunnerIdentity = {
     /**
@@ -12,16 +12,21 @@ export type PromptRunnerIdentity = {
      * Effective model identifier, for example `gpt-5.5`.
      */
     readonly modelName?: string;
+    /**
+     * Equivalent agent path and name references, including the Book title from its first line.
+     */
+    readonly agentReferences?: ReadonlyArray<string>;
 };
 /**
- * Checks whether a prompt is unrestricted or matches the selected harness/model.
+ * Checks whether a prompt is unrestricted or matches the selected harness, model or Book agent.
  *
- * 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.
+ * A prompt status line can contain one or more backtick-delimited model, harness or agent
+ * references. Matching is intentionally based on normalized substrings so a token such as
+ * `gpt` selects any `gpt-*` model, `developer` selects an agent Book named `developer.book`,
+ * 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.
+ * Extracts model, harness and Book-agent tokens from a prompt status line.
  */
 export declare function extractPromptRunnerTokens(statusLine: string): string[];

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

@@ -0,0 +1,7 @@
+import type { PromptFile } from './types/PromptFile';
+import type { PromptSelection } from './types/PromptSelection';
+import type { PromptStatus } from './types/PromptStatus';
+/**
+ * Lists prompts in one checklist status across all files.
+ */
+export declare function listPromptsByStatus(files: PromptFile[], status: PromptStatus): PromptSelection[];

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

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

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

@@ -1,5 +1,13 @@
 import type { PromptFile } from './types/PromptFile';
 /**
- * Loads and parses prompt files from the prompts directory.
+ * HTML comment which excludes a Markdown file from all `ptbk coder` queues.
+ *
+ * @private internal constant of `loadPromptFiles`
  */
-export declare function loadPromptFiles(promptsDir: string): Promise<PromptFile[]>;
+export declare const PTBK_CODER_IGNORE_MARKER = "<!--ptbk-coder-ignore-->";
+/**
+ * Loads top-level PRDs, excluding the README and files marked for `ptbk coder` to ignore.
+ */
+export declare function loadPromptFiles(promptsDir: string, options?: {
+    readonly isMissingDirectoryAllowed?: boolean;
+}): Promise<PromptFile[]>;

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

@@ -1,9 +1,20 @@
-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 BuildPromptStatusDetailsOptions } from './buildPromptStatusDetails';
 import type { PromptFile } from './types/PromptFile';
 import type { PromptSection } from './types/PromptSection';
+/**
+ * Input for marking one prompt section as implemented, verified and committed.
+ */
+export type MarkPromptDoneOptions = BuildPromptStatusDetailsOptions & {
+    /**
+     * Prompt file the marked section belongs to.
+     */
+    readonly file: PromptFile;
+    /**
+     * Section which has just been finished.
+     */
+    readonly section: PromptSection;
+};
 /**
  * Marks a prompt section as done and records the per-step usage pricing and runner details.
  */
-export declare function markPromptDone(file: PromptFile, section: PromptSection, steps: ReadonlyArray<CoderRunStep>, runnerName: string | undefined, modelName: string | undefined, attemptCount?: number, loginMethod?: CodexLoginMethod, thinkingLevel?: ThinkingLevel): void;
+export declare function markPromptDone(options: MarkPromptDoneOptions): void;

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

@@ -1,7 +1,34 @@
 import moment from 'moment';
+import { type FormatRunnerSignatureOptions } from './formatRunnerSignature';
+import { type PromptRunnerAttribution } from './promptRunnerAttribution';
 import type { PromptFile } from './types/PromptFile';
 import type { PromptSection } from './types/PromptSection';
+/**
+ * Input for marking one prompt section as failed.
+ */
+export type MarkPromptFailedOptions = FormatRunnerSignatureOptions & {
+    /**
+     * Prompt file the marked section belongs to.
+     */
+    readonly file: PromptFile;
+    /**
+     * Section which could not be implemented.
+     */
+    readonly section: PromptSection;
+    /**
+     * Chronological runner report read from a prompt left in the middle of its implementation.
+     */
+    readonly previousRunnerSignatures?: PromptRunnerAttribution;
+    /**
+     * Moment the failed prompt round started, used to report how long the attempt took.
+     */
+    readonly promptExecutionStartedDate: moment.Moment;
+    /**
+     * How many coding attempts the prompt has taken before it was given up on.
+     */
+    readonly attemptCount: number;
+};
 /**
  * Marks a prompt section as failed and records runner details.
  */
-export declare function markPromptFailed(file: PromptFile, section: PromptSection, runnerName: string | undefined, modelName: string | undefined, promptExecutionStartedDate: moment.Moment, attemptCount?: number): void;
+export declare function markPromptFailed(options: MarkPromptFailedOptions): void;

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

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

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

@@ -0,0 +1,30 @@
+/**
+ * Ordered runner signatures recorded in a prompt status line.
+ *
+ * The first signature started the work and every following signature continued an interrupted run.
+ */
+export type PromptRunnerAttribution = ReadonlyArray<string>;
+/**
+ * Formats who worked on one prompt for its status line.
+ *
+ * Produces `` by Claude Code `claude-opus-5` `` for a prompt implemented by a single harness and
+ * `` by OpenAI Codex `gpt-5.6-luna`, interrupted, continued by Claude Code `claude-opus-5` `` for a
+ * prompt which one harness started and another one continued through `--git-changes continue`.
+ */
+export declare function formatPromptRunnerAttribution(options: {
+    /**
+     * Harness which runs the prompt right now, already formatted as a runner signature.
+     */
+    readonly currentRunnerSignature: string;
+    /**
+     * Chronological runner report read from the interrupted prompt before its status line is rewritten.
+     */
+    readonly previousRunnerSignatures?: PromptRunnerAttribution;
+}): string;
+/**
+ * Reads the chronological harness report recorded on one prompt status line.
+ *
+ * A line written by a single harness produces one signature. A line which has already been continued produces
+ * every signature in the order in which it worked on the prompt, so another continuation can append to it.
+ */
+export declare function parsePromptRunnerAttribution(statusLine: string): PromptRunnerAttribution | undefined;

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

@@ -0,0 +1,6 @@
+import type { PromptSelection } from './types/PromptSelection';
+/**
+ * Refreshes on-disk task content before a Coder status write. The caller owns a validated mutation boundary;
+ * agent/check edits to the task body must survive status persistence just like edits to any other file.
+ */
+export declare function refreshPromptSelection(selection: PromptSelection): Promise<void>;

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

@@ -0,0 +1,9 @@
+import type { PromptFile } from './types/PromptFile';
+import type { PromptSelection } from './types/PromptSelection';
+/**
+ * Resolves the one prompt which `--git-changes continue` resumes.
+ *
+ * A coder which was killed or crashed leaves exactly one prompt behind in the in-progress `[^]` status,
+ * so anything else means the working tree changes cannot be attributed to a single interrupted prompt.
+ */
+export declare function resolveInterruptedPrompt(files: PromptFile[]): PromptSelection;

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

@@ -16,4 +16,8 @@ type WritePromptErrorLogOptions = {
  * Returns the path of the written log so callers can include it in a commit.
  */
 export declare function writePromptErrorLog(options: WritePromptErrorLogOptions): Promise<string>;
+/**
+ * Returns the failure log path for a prompt markdown file.
+ */
+export declare function buildPromptErrorLogPath(promptPath: string): string;
 export {};

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

@@ -3,3 +3,5 @@ import type { PromptFile } from './types/PromptFile';
  * Writes updated prompt file content to disk.
  */
 export declare function writePromptFile(file: PromptFile): Promise<void>;
+/** Serializes a status candidate identically for private-tree persistence and ordinary prompt writes. */
+export declare function buildPromptFileContent(file: PromptFile): string;

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

@@ -0,0 +1,21 @@
+import { type BuildPromptRunTraceContentOptions } from './buildPromptRunTraceContent';
+/**
+ * Everything needed to persist the run trace of one prompt round.
+ *
+ * The runtime log is not passed as text but as the path of the live log the round has been writing into, because
+ * the trace is the only place where that log survives - it is deleted as soon as the round is over.
+ */
+export type WritePromptRunTraceOptions = Omit<BuildPromptRunTraceContentOptions, 'runtimeLog'> & {
+    /**
+     * Path of the temporary live runtime log of the round, when the round has one.
+     */
+    readonly logPath?: string;
+    /** Defers publication until the completion tree is persisted by the shared Git service. */
+    readonly writeContent?: (path: string, content: string) => Promise<void>;
+};
+/**
+ * Writes the run trace of one prompt round into the `traces` directory of the prompts directory.
+ *
+ * Returns the path of the written trace so callers can include it in a commit.
+ */
+export declare function writePromptRunTrace(options: WritePromptRunTraceOptions): Promise<string>;

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

@@ -3,7 +3,8 @@ 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.
+ * An unmarked prompt is implicitly a todo, so its first live status line is inserted immediately before its content.
+ * Only a todo `[ ]` or an in-progress `[^]` status line is otherwise 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/esm/scripts/run-codex-prompts/runners/claude-code/ClaudeCodeRunner.d.ts

@@ -1,17 +1,29 @@
 import type { PromptRunOptions } from '../types/PromptRunOptions';
 import type { PromptRunResult } from '../types/PromptRunResult';
 import type { PromptRunner } from '../types/PromptRunner';
+import { type HarnessSubscriptionUsage } from '../types/HarnessSubscriptionUsage';
 import type { ClaudeCodeRunnerOptions } from './ClaudeCodeRunnerOptions';
 /**
  * Runs prompts via the Claude Code CLI.
  */
 export declare class ClaudeCodeRunner implements PromptRunner {
     private readonly options;
+    /** TEAM uses this harness's existing command tool, with the same permissions as its caller. */
+    readonly teamCapability: "command-tools";
     readonly name = "claude-code";
+    private subscriptionUsage;
     /**
      * Creates a new Claude Code runner.
      */
     constructor(options?: ClaudeCodeRunnerOptions);
+    /**
+     * Returns the latest subscription-limit snapshot emitted by this Claude Code session.
+     *
+     * Claude exposes these values in the normal stream, so no separate quota-only model call is made. The snapshot is
+     * kept current while the prompt is still running, which is what lets the dashboard poll it instead of showing the
+     * values of the previous prompt for the whole round.
+     */
+    getSubscriptionUsage(): Promise<HarnessSubscriptionUsage | undefined>;
     /**
      * Runs the prompt using Claude Code and parses usage output.
      */
@@ -20,4 +32,19 @@ export declare class ClaudeCodeRunner implements PromptRunner {
      * Runs one Claude Code CLI process and returns its raw output.
      */
     private runClaudeCodeOnce;
+    /**
+     * Keeps the snapshot current from one line of the stream which is still being written.
+     *
+     * A coding prompt can run for hours, and a subscription window keeps moving during all of it. Only a rate-limit
+     * event can change the snapshot, so the far more frequent tool and message lines are recognized by their type and
+     * skipped before anything is parsed.
+     */
+    private updateSubscriptionUsageFromOutputLine;
+    /**
+     * Keeps the newest usable Claude subscription-limit values reported by the stream.
+     *
+     * A stream can omit these values for API-key users or unsupported plan types; retaining the prior snapshot avoids
+     * a temporary omission erasing a still-valid dashboard value while a long queue is running.
+     */
+    private updateSubscriptionUsage;
 }

package/esm/scripts/run-codex-prompts/runners/claude-code/parseClaudeCodeOutputEvents.d.ts

@@ -12,7 +12,10 @@ export type ClaudeCodeOutputEvent = {
     readonly rate_limit_info?: {
         readonly status?: string;
         readonly resetsAt?: number;
+        readonly resets_at?: number;
         readonly rateLimitType?: string;
+        readonly rate_limit_type?: string;
+        readonly utilization?: number;
     };
     readonly usage?: {
         readonly input_tokens?: number;

package/esm/scripts/run-codex-prompts/runners/claude-code/parseClaudeCodeSubscriptionUsage.d.ts

@@ -0,0 +1,11 @@
+import type { HarnessSubscriptionUsage } from '../types/HarnessSubscriptionUsage';
+/**
+ * Converts Claude Code stream-json rate-limit events into the shared subscription-usage snapshot.
+ *
+ * Claude Code can emit one event for each applicable limit, so the parser preserves every distinct window instead of
+ * assuming the familiar 5-hour and seven-day pair. This lets a new vendor-side limit appear in the dashboard without
+ * changing its renderer.
+ *
+ * @private internal utility of the Claude Code runner
+ */
+export declare function parseClaudeCodeSubscriptionUsage(output: string): HarnessSubscriptionUsage | undefined;

package/esm/scripts/run-codex-prompts/runners/cline/ClineRunner.d.ts

@@ -7,6 +7,8 @@ import type { ClineRunnerOptions } from './ClineRunnerOptions';
  */
 export declare class ClineRunner implements PromptRunner {
     private readonly options;
+    /** TEAM uses this harness's existing command tool, with the same permissions as its caller. */
+    readonly teamCapability: "command-tools";
     readonly name = "cline";
     /**
      * Creates a new Cline runner.

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

@@ -0,0 +1,20 @@
+import type { PromptRunnerHarnessName } from '../../../../src/cli/cli-commands/common/promptRunnerCliOptions';
+import { AuthenticationError } from '../../../../src/errors/AuthenticationError';
+/**
+ * Options for building the error reported when a harness is not logged in.
+ */
+type BuildHarnessAuthenticationErrorOptions = {
+    /**
+     * Harness which refused to work.
+     */
+    readonly harnessName: PromptRunnerHarnessName;
+    /**
+     * Short reason the harness itself reported, as extracted from its output.
+     */
+    readonly reason: string;
+};
+/**
+ * Builds the branded error which tells the user that the selected harness has to be signed in again.
+ */
+export declare function buildHarnessAuthenticationError(options: BuildHarnessAuthenticationErrorOptions): AuthenticationError;
+export {};

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

@@ -0,0 +1,11 @@
+import type { PromptRunnerHarnessName } from '../../../../src/cli/cli-commands/common/promptRunnerCliOptions';
+import type { PromptRunner } from '../types/PromptRunner';
+/**
+ * Wraps one prompt runner so a failure caused by a missing or expired harness login is reported as a branded
+ * `AuthenticationError` which tells the user how to sign in again.
+ *
+ * Each harness reports its own failures differently, but all of them report them by failing `runPrompt` with
+ * the raw CLI output as the message. Translating the failure here therefore keeps exactly one place which has
+ * to recognize an unauthenticated harness, for every harness and for every command which runs prompts.
+ */
+export declare function createAuthenticationAwarePromptRunner(runner: PromptRunner, harnessName: PromptRunnerHarnessName): PromptRunner;

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

@@ -0,0 +1,33 @@
+import type { Usage } from '../../../../src/execution/Usage';
+import type { ModelPricing } from './modelPricing';
+/**
+ * Options for estimating the usage of one harness run.
+ */
+export type EstimateUsageFromTextLengthOptions = {
+    /**
+     * Human-readable harness name used when the estimation itself fails.
+     */
+    readonly harnessLabel: string;
+    /**
+     * The prompt that was sent to the harness.
+     */
+    readonly prompt: string;
+    /**
+     * The output which the harness has printed.
+     */
+    readonly output: string;
+    /**
+     * Reads the pricing of the model which was used for this run.
+     *
+     * It is resolved lazily so that a broken pricing table degrades to an uncertain estimate
+     * instead of failing the coding round, because a price estimate must never block coding work.
+     */
+    readonly resolvePricing: () => ModelPricing;
+};
+/**
+ * Estimates the usage of one harness run from the length of its prompt and its output.
+ *
+ * Harnesses which do not report their own token counts are billed per token anyway, so the
+ * character counts are the only signal available for a price estimate.
+ */
+export declare function estimateUsageFromTextLength(options: EstimateUsageFromTextLengthOptions): Usage;

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

@@ -0,0 +1,9 @@
+/**
+ * Reads the reason why a harness refused to work because it is not logged in, from its raw CLI output.
+ *
+ * Messages the harness reports in machine-readable output are preferred over its raw output lines, so the
+ * reason is the sentence the harness wrote for a human and not the JSON event which transported it.
+ *
+ * @returns One short single-line reason, or `undefined` when the failure was not caused by authentication.
+ */
+export declare function extractHarnessAuthenticationFailureReason(harnessOutput: string): string | undefined;