@promptbook/cli 0.114.0-3 → 0.114.0-30

package/esm/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/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): string;

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

@@ -0,0 +1,51 @@
+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 PromptRunnerAttribution } from './promptRunnerAttribution';
+/**
+ * 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;
+    /**
+     * 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 previousRunnerSignatures?: PromptRunnerAttribution;
+    /**
+     * 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/esm/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/esm/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/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/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,41 @@
 import moment from 'moment';
+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 = {
+    /**
+     * Prompt file the marked section belongs to.
+     */
+    readonly file: PromptFile;
+    /**
+     * Section which could not be implemented.
+     */
+    readonly section: PromptSection;
+    /**
+     * Harness which ran the prompt.
+     */
+    readonly runnerName: string | undefined;
+    /**
+     * Model the harness ran the prompt with.
+     */
+    readonly modelName: string | undefined;
+    /**
+     * 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/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/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/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/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/esm/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/esm/scripts/run-codex-prompts/runners/claude-code/ClaudeCodeRunner.d.ts

@@ -1,6 +1,7 @@
 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.
@@ -8,10 +9,17 @@ import type { ClaudeCodeRunnerOptions } from './ClaudeCodeRunnerOptions';
 export declare class ClaudeCodeRunner implements PromptRunner {
     private readonly options;
     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 after a response, so no separate quota-only model call is made.
+     */
+    getSubscriptionUsage(): Promise<HarnessSubscriptionUsage | undefined>;
     /**
      * Runs the prompt using Claude Code and parses usage output.
      */
@@ -20,4 +28,11 @@ export declare class ClaudeCodeRunner implements PromptRunner {
      * Runs one Claude Code CLI process and returns its raw output.
      */
     private runClaudeCodeOnce;
+    /**
+     * 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/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/modelPricing.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Price of one model per 1 million tokens in USD.
+ */
+export type ModelPricing = {
+    /**
+     * Price of 1 million input tokens in USD.
+     */
+    readonly input: number;
+    /**
+     * Price of 1 million output tokens in USD.
+     */
+    readonly output: number;
+};
+/**
+ * Pricing of all known models of one harness, keyed by the model identifier.
+ */
+export type ModelPricingTable = Readonly<Record<string, ModelPricing>>;
+/**
+ * Options for resolving the pricing of one model.
+ */
+export type ResolveModelPricingOptions = {
+    /**
+     * Pricing of all models known to one harness.
+     */
+    readonly pricingTable: ModelPricingTable;
+    /**
+     * Model whose pricing is used when the requested model is unknown.
+     */
+    readonly modelNameForEstimation: string;
+    /**
+     * Model requested for the run, or `undefined` when the harness picks its own model.
+     */
+    readonly modelName?: string;
+};
+/**
+ * Resolves the pricing of one model of one harness.
+ *
+ * It first tries exact match, then prefix match, then falls back to the pricing of a stable
+ * default model, because every harness names new models faster than the pricing tables grow.
+ */
+export declare function resolveModelPricing(options: ResolveModelPricingOptions): ModelPricing;

package/esm/scripts/run-codex-prompts/runners/gemini/gemini-pricing.d.ts

@@ -1,3 +1,4 @@
+import type { ModelPricing } from '../common/modelPricing';
 /**
  * The pricing for Gemini models per 1 million tokens in USD.
  *
@@ -6,30 +7,16 @@
  * @see https://ai.google.dev/pricing
  */
 export declare const GEMINI_PRICING: {
-    'gemini-1.5-flash': {
-        input: number;
-        output: number;
+    readonly 'gemini-1.5-flash': {
+        readonly input: 0.1125;
+        readonly output: 0.45;
     };
 };
 /**
  * The model to use for price estimation.
  */
 export declare const GEMINI_MODEL_FOR_ESTIMATION = "gemini-1.5-flash";
-/**
- * Gemini pricing entry per 1 million tokens.
- */
-export type GeminiPricing = {
-    input: number;
-    output: number;
-};
 /**
  * Resolves Gemini pricing for the requested model.
- *
- * It first tries exact match, then prefix match, then falls back to a stable
- * default pricing model.
- */
-export declare function resolveGeminiPricing(modelName?: string): GeminiPricing;
-/**
- * A an estimation of how many characters are in one token.
  */
-export declare const CHARS_PER_TOKEN = 4;
+export declare function resolveGeminiPricing(modelName?: string): ModelPricing;

package/esm/scripts/run-codex-prompts/runners/openai-codex/OpenAiCodexRunner.d.ts

@@ -1,6 +1,7 @@
 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 { OpenAiCodexRunnerOptions } from './OpenAiCodexRunnerOptions';
 /**
  * Runs prompts via the OpenAI Codex CLI.
@@ -13,6 +14,13 @@ export declare class OpenAiCodexRunner implements PromptRunner {
      * Creates a new Codex runner.
      */
     constructor(options: OpenAiCodexRunnerOptions);
+    /**
+     * Reads the current ChatGPT subscription quota snapshot through Codex's local app server.
+     *
+     * API-key sessions and unsupported Codex versions simply return no snapshot, which keeps this optional dashboard
+     * information from affecting the actual prompt execution.
+     */
+    getSubscriptionUsage(): Promise<HarnessSubscriptionUsage | undefined>;
     /**
      * Runs the Codex prompt in a temporary script and waits for completion output.
      */

package/esm/scripts/run-codex-prompts/runners/openai-codex/buildCodexUsageFromOutput.d.ts

@@ -6,5 +6,8 @@ import type { Usage } from '../../../../src/execution/Usage';
 export declare const DEFAULT_CODEX_COMPLETION_SHARE = 0.1;
 /**
  * Builds usage stats from Codex CLI output.
+ *
+ * The `modelName` is omitted when Codex ran without a model override, in which case only Codex knows which
+ * model it picked and the price can be estimated from the fallback pricing alone.
  */
-export declare function buildCodexUsageFromOutput(output: string, modelName: string): Usage;
+export declare function buildCodexUsageFromOutput(output: string, modelName: string | undefined): Usage;

package/esm/scripts/run-codex-prompts/runners/openai-codex/getCodexSubscriptionUsage.d.ts

@@ -0,0 +1,19 @@
+import type { HarnessSubscriptionUsage } from '../types/HarnessSubscriptionUsage';
+/**
+ * Reads the current Codex subscription limit windows through its local app-server protocol.
+ *
+ * Codex versions without this optional protocol, API-key sessions, and transient account failures simply provide no
+ * snapshot. Subscription usage is contextual UI information, so it must never make a coding prompt fail.
+ *
+ * @private internal utility of the OpenAI Codex runner
+ */
+export declare function getCodexSubscriptionUsage(codexCommand: string): Promise<HarnessSubscriptionUsage | undefined>;
+/**
+ * Converts the raw Codex app-server rate-limit response into Promptbook's harness-neutral subscription snapshot.
+ *
+ * Modern Codex versions can report several metered buckets, while older versions expose a single compatibility
+ * bucket. In both cases every primary and secondary rolling window is preserved for the terminal dashboard.
+ *
+ * @private internal utility of the OpenAI Codex runner
+ */
+export declare function buildCodexSubscriptionUsage(response: unknown): HarnessSubscriptionUsage | undefined;

package/esm/scripts/run-codex-prompts/runners/qwen-code/QwenCodeRunner.d.ts

@@ -0,0 +1,23 @@
+import type { PromptRunner } from '../types/PromptRunner';
+import type { PromptRunOptions } from '../types/PromptRunOptions';
+import type { PromptRunResult } from '../types/PromptRunResult';
+import type { QwenCodeRunnerOptions } from './QwenCodeRunnerOptions';
+/**
+ * Default Qwen Code model used by the coding runner.
+ */
+export declare const DEFAULT_QWEN_CODE_MODEL = "qwen3.8-max";
+/**
+ * Runs prompts via the Qwen Code CLI.
+ */
+export declare class QwenCodeRunner implements PromptRunner {
+    private readonly options;
+    readonly name = "qwen-code";
+    /**
+     * Creates a new Qwen Code runner.
+     */
+    constructor(options: QwenCodeRunnerOptions);
+    /**
+     * Runs the prompt using Qwen Code and parses usage output.
+     */
+    runPrompt(options: PromptRunOptions): Promise<PromptRunResult>;
+}

package/esm/scripts/run-codex-prompts/runners/qwen-code/buildQwenCodeScript.d.ts

@@ -0,0 +1,8 @@
+import type { QwenCodeScriptOptions } from './QwenCodeScriptOptions';
+/**
+ * Builds the shell script that runs Qwen Code with the prompt and coding context.
+ *
+ * Note: `-y` runs the harness unattended, because `ptbk coder` approves the whole prompt
+ *       up front and there is nobody at the keyboard to confirm the single tool calls.
+ */
+export declare function buildQwenCodeScript(options: QwenCodeScriptOptions): string;

package/esm/scripts/run-codex-prompts/runners/qwen-code/parseQwenCodeUsageFromOutput.d.ts

@@ -0,0 +1,9 @@
+import type { Usage } from '../../../../src/execution/Usage';
+/**
+ * Parses Qwen Code CLI output and extracts usage information.
+ *
+ * @param output The output from the Qwen Code CLI.
+ * @param prompt The prompt that was sent to the Qwen Code CLI.
+ * @param modelName The Qwen Code model used for this run.
+ */
+export declare function parseQwenCodeUsageFromOutput(output: string, prompt: string, modelName?: string): Usage;

package/esm/scripts/run-codex-prompts/runners/qwen-code/qwen-code-pricing.d.ts

@@ -0,0 +1,30 @@
+import type { ModelPricing } from '../common/modelPricing';
+/**
+ * The pricing for Qwen Code models per 1 million tokens in USD.
+ *
+ * Note: This is an estimation.
+ *
+ * @see https://www.alibabacloud.com/help/en/model-studio/models
+ */
+export declare const QWEN_CODE_PRICING: {
+    readonly 'qwen3-coder-plus': {
+        readonly input: 1;
+        readonly output: 5;
+    };
+    readonly 'qwen3-coder-flash': {
+        readonly input: 0.3;
+        readonly output: 1.5;
+    };
+    readonly 'qwen3-max': {
+        readonly input: 1.2;
+        readonly output: 6;
+    };
+};
+/**
+ * The model to use for price estimation.
+ */
+export declare const QWEN_CODE_MODEL_FOR_ESTIMATION = "qwen3-coder-plus";
+/**
+ * Resolves Qwen Code pricing for the requested model.
+ */
+export declare function resolveQwenCodePricing(modelName?: string): ModelPricing;