@promptbook/node 0.114.0-3 → 0.114.0-30

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

@@ -0,0 +1,26 @@
+import type { AgentPlannedMessageSnapshot } from '../../../src/book-3.0/AgentPlannedMessagesSidecar';
+/**
+ * Planned-message sidecar information made visible to one coding-harness prompt.
+ */
+export type AgentPlannedMessagesPromptSidecar = {
+    /**
+     * Portable path of the sidecar inside the agent folder.
+     */
+    readonly relativeSidecarPath: string;
+    /**
+     * Planned messages that are already waiting to wake the agent.
+     */
+    readonly currentPlannedMessages: ReadonlyArray<AgentPlannedMessageSnapshot>;
+};
+/**
+ * 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
+ * wake-up is planned, and each of them keeps repeating until its schedule is over or it is cancelled.
+ * The sidecar file is the only channel that changes them, so an answer that merely claims a follow-up
+ * was planned changes nothing — and an answer that changes nothing keeps the current plan running.
+ *
+ * @param sidecar - Sidecar prepared by the Agents Server for the answered message.
+ * @returns Prompt section, or an empty string outside Agents Server-managed runs.
+ */
+export declare function buildAgentGoalChatPromptSection(sidecar: AgentPlannedMessagesPromptSidecar | undefined): string;

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

@@ -1,8 +1,19 @@
 import { type AgentProjectsPromptSectionOptions } from './buildAgentProjectsPromptSection';
+import { type AgentPlannedMessagesPromptSidecar } from './buildAgentGoalChatPromptSection';
+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;
+    /**
+     * Planned-message sidecar prepared by the Agents Server for the agent's singleton goal chat.
+     */
+    plannedMessagesSidecar?: AgentPlannedMessagesPromptSidecar;
+};
 /**
  * Builds the prompt sent to the selected coding runner for one queued user-thread book.
  */

package/esm/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/esm/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/esm/scripts/run-codex-prompts/common/runGoScript/$spawnLoggedBashScript.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import { type ChildProcessWithoutNullStreams } from 'child_process';
+/**
+ * Input used to start one temporary logged Bash script.
+ *
+ * @private internal type of `$spawnLoggedBashScript`
+ */
+type SpawnLoggedBashScriptOptions = {
+    readonly scriptPath: string;
+    readonly logPath?: string;
+    /**
+     * Process which owns the temporary harness shell. Defaults to the current coder process.
+     */
+    readonly parentProcessId?: number;
+};
+/**
+ * Starts one temporary Bash script in a process tree owned by the current Node process.
+ *
+ * The wrapper watches the supplied owning process ID. When that process exits abruptly, the wrapper terminates every
+ * nested shell and harness process instead of leaving it orphaned.
+ *
+ * @private internal utility of the coding prompt runner
+ */
+export declare function $spawnLoggedBashScript(options: SpawnLoggedBashScriptOptions): ChildProcessWithoutNullStreams;
+export {};

package/esm/scripts/run-codex-prompts/common/runGoScript/$terminateLoggedBashProcessTree.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { type ChildProcess } from 'child_process';
+/**
+ * Stops one active temporary Bash shell together with the harness process tree it owns.
+ *
+ * Unix sends `SIGTERM` to the wrapper so its shell trap terminates the separately grouped harness job. Windows does
+ * not reliably deliver that signal to Bash, so the native `taskkill` command terminates the direct shell tree instead.
+ *
+ * @private internal utility of the coding prompt runner
+ */
+export declare function $terminateLoggedBashProcessTree(commandProcess: ChildProcess): void;

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

@@ -9,6 +9,10 @@ export declare const PTBK_CODER_LOG_FILE_ENV_NAME = "PTBK_CODER_LOG_FILE";
  * without the generated script and the prompt it embeds.
  */
 export declare const SCRIPT_EXECUTION_LOG_RAW_OUTPUT_MARKER = "--- raw output ---";
+/**
+ * Environment variable that identifies the Node process responsible for a temporary harness shell.
+ */
+export declare const PTBK_CODER_PARENT_PROCESS_ID_ENV_NAME = "PTBK_CODER_PARENT_PROCESS_ID";
 /**
  * Shapes one bash invocation that optionally mirrors live script output into a temporary log file.
  */

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

@@ -0,0 +1,92 @@
+/**
+ * Pause lifecycle of `ptbk coder run`.
+ */
+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;
+/**
+ * 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;
+/**
+ * If the execution is paused, it will wait until it is resumed.
+ *
+ * @param options.silent - When `true`, suppresses console output (used when the terminal UI handles display).
+ * @param options.onPaused - Callback invoked when entering the PAUSED state.
+ * @param options.onResumed - Callback invoked when leaving the PAUSED state.
+ */
+export declare function checkPause(options?: {
+    silent?: boolean;
+    onPaused?: () => void;
+    onResumed?: () => void;
+}): Promise<void>;
+/**
+ * Returns the current pause state for external consumers such as the terminal UI.
+ */
+export declare function getPauseState(): CoderRunPauseState;
+/**
+ * Returns the label of the next checkpoint where pausing will take effect.
+ */
+export declare function getPauseTargetLabel(): string;
+/**
+ * Updates the label of the next pause checkpoint.
+ */
+export declare function announcePauseTargetLabel(nextPauseTargetLabel: string): void;
+/**
+ * Restores the default generic pause target label.
+ */
+export declare function resetPauseTargetLabel(): void;
+/**
+ * Requests a pause from an external controller (e.g. the Ink UI).
+ */
+export declare function requestPause(): void;
+/**
+ * Resumes execution from an external controller after a pause.
+ */
+export declare function requestResume(): void;

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

@@ -0,0 +1,15 @@
+import { type WorldTimeDeadlineTick } from './waitUntilWorldTimeDeadline';
+/**
+ * Waits until one wall-clock deadline has passed, or until the user skips the wait with the `S` control.
+ *
+ * This is the single way `ptbk coder` waits for a deadline the user is allowed to cut short, so every
+ * wait which shows the `S  Skip current waiting` control really reacts to it: the pacing waits between
+ * prompts, the cool-down after an error, the harness session-limit waits and the server keep-alive poll.
+ *
+ * @private internal utility of `ptbk coder` wait handling
+ */
+export declare function waitForSkippableWorldTimeDeadline(options: {
+    readonly deadlineTimeMs: number;
+    readonly pollIntervalMs: number;
+    readonly onTick?: WorldTimeDeadlineTick;
+}): Promise<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;

package/esm/scripts/run-codex-prompts/runners/types/HarnessSubscriptionUsage.d.ts

@@ -0,0 +1,43 @@
+/**
+ * One rolling subscription limit reported by a coding harness.
+ *
+ * @private internal type of `ptbk coder`
+ */
+export type HarnessSubscriptionUsageLimit = {
+    /**
+     * Short, user-facing name of the limit window, for example `5h` or `7d`.
+     */
+    readonly label: string;
+    /**
+     * Percentage of this limit which has already been consumed, from 0 through 100.
+     */
+    readonly usedPercentage: number;
+    /**
+     * Unix timestamp in seconds at which this limit window resets, when reported by the harness.
+     */
+    readonly resetsAt?: number;
+};
+/**
+ * Subscription usage snapshot which a coding harness can optionally report.
+ *
+ * The runner contract deliberately keeps this independent from per-prompt token usage: subscription limits can be
+ * shared with other tools and can contain several rolling windows.
+ *
+ * @private internal type of `ptbk coder`
+ */
+export type HarnessSubscriptionUsage = {
+    /**
+     * Every subscription limit currently reported by the harness, in display order.
+     */
+    readonly limits: ReadonlyArray<HarnessSubscriptionUsageLimit>;
+};
+/**
+ * Merges a newly reported subset of subscription windows into the latest complete snapshot.
+ *
+ * Some harnesses emit an update only for the limit whose state changed. Keeping the previous windows means a
+ * five-hour update cannot make a still-valid weekly limit disappear from the dashboard. Existing order is preserved
+ * and newly discovered windows are appended, which keeps the terminal presentation stable between refreshes.
+ *
+ * @private internal utility of `ptbk coder`
+ */
+export declare function mergeHarnessSubscriptionUsage(previousSubscriptionUsage: HarnessSubscriptionUsage | undefined, latestSubscriptionUsage: HarnessSubscriptionUsage): HarnessSubscriptionUsage;

package/esm/src/_packages/components.index.d.ts

@@ -70,8 +70,10 @@ import type { CitationLabelResolver } from '../book-components/Chat/types/Citati
 import type { MessageButton } from '../book-components/Chat/utils/parseMessageButtons';
 import { parseMessageButtons } from '../book-components/Chat/utils/parseMessageButtons';
 import type { MarkdownInlineReference } from '../book-components/Chat/utils/renderMarkdown';
+import type { MarkdownInlineReferenceIcon } from '../book-components/Chat/utils/renderMarkdown';
 import type { MarkdownInlineReferenceMenuStatus } from '../book-components/Chat/utils/renderMarkdown';
 import type { MarkdownInlineReferenceMenuOption } from '../book-components/Chat/utils/renderMarkdown';
+import type { MarkdownInlineReferenceMenuAction } from '../book-components/Chat/utils/renderMarkdown';
 import type { MarkdownInlineReferenceMenu } from '../book-components/Chat/utils/renderMarkdown';
 import { ArrowIcon } from '../book-components/icons/ArrowIcon';
 import { MicIcon } from '../book-components/icons/MicIcon';
@@ -159,8 +161,10 @@ export type { CitationLabelResolver };
 export type { MessageButton };
 export { parseMessageButtons };
 export type { MarkdownInlineReference };
+export type { MarkdownInlineReferenceIcon };
 export type { MarkdownInlineReferenceMenuStatus };
 export type { MarkdownInlineReferenceMenuOption };
+export type { MarkdownInlineReferenceMenuAction };
 export type { MarkdownInlineReferenceMenu };
 export { ArrowIcon };
 export { MicIcon };

package/esm/src/_packages/types.index.d.ts

@@ -62,8 +62,10 @@ import type { CitationLabelResolver } from '../book-components/Chat/types/Citati
 import type { ParsedCitation } from '../book-components/Chat/utils/parseCitationsFromContent';
 import type { MessageButton } from '../book-components/Chat/utils/parseMessageButtons';
 import type { MarkdownInlineReference } from '../book-components/Chat/utils/renderMarkdown';
+import type { MarkdownInlineReferenceIcon } from '../book-components/Chat/utils/renderMarkdown';
 import type { MarkdownInlineReferenceMenuStatus } from '../book-components/Chat/utils/renderMarkdown';
 import type { MarkdownInlineReferenceMenuOption } from '../book-components/Chat/utils/renderMarkdown';
+import type { MarkdownInlineReferenceMenuAction } from '../book-components/Chat/utils/renderMarkdown';
 import type { MarkdownInlineReferenceMenu } from '../book-components/Chat/utils/renderMarkdown';
 import type { TeamToolResult } from '../book-components/Chat/utils/toolCallParsing/TeamToolResult';
 import type { QrCodeOptions } from '../book-components/Qr/useQrCode';
@@ -511,8 +513,10 @@ export type { CitationLabelResolver };
 export type { ParsedCitation };
 export type { MessageButton };
 export type { MarkdownInlineReference };
+export type { MarkdownInlineReferenceIcon };
 export type { MarkdownInlineReferenceMenuStatus };
 export type { MarkdownInlineReferenceMenuOption };
+export type { MarkdownInlineReferenceMenuAction };
 export type { MarkdownInlineReferenceMenu };
 export type { TeamToolResult };
 export type { QrCodeOptions };