@oh-my-pi/pi-coding-agent 15.11.4 → 15.11.6

package/dist/types/cli/usage-cli.d.ts

@@ -7,11 +7,15 @@
  * credentials produced no usage report are listed too, so the output
  * always covers the full credential pool.
  */
-import type { UsageReport } from "@oh-my-pi/pi-ai";
+import { type UsageHistoryEntry, type UsageReport } from "@oh-my-pi/pi-ai";
 export interface UsageCommandArgs {
     json?: boolean;
     provider?: string;
     redact?: boolean;
+    /** Show recorded usage-limit history instead of a live snapshot. */
+    history?: boolean;
+    /** History window in days (with `history`). */
+    days?: number;
 }
 /** Identity slice of a stored credential, for "every account" coverage. */
 export interface UsageAccountIdentity {
@@ -69,4 +73,9 @@ export declare function computeProviderWindowStats(reports: UsageReport[]): Prov
  * each provider section as "no usage data" rows.
  */
 export declare function formatUsageBreakdown(reports: UsageReport[], accounts: UsageAccountIdentity[], nowMs: number, redaction?: Map<string, string>): string;
+/**
+ * Render recorded usage-limit history: per provider, per account, one
+ * peak-per-bucket sparkline per limit window plus latest/peak percentages.
+ */
+export declare function formatUsageHistory(entries: UsageHistoryEntry[], sinceMs: number, nowMs: number, redaction?: Map<string, string>): string;
 export declare function runUsageCommand(cmd: UsageCommandArgs): Promise<void>;

package/dist/types/commands/usage.d.ts

@@ -19,6 +19,15 @@ export default class Usage extends Command {
             description: string;
             default: boolean;
         };
+        history: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+            default: boolean;
+        };
+        days: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"integer"> & {
+            char: string;
+            description: string;
+            default: number;
+        };
     };
     static examples: string[];
     run(): Promise<void>;

package/dist/types/config/settings-schema.d.ts

@@ -1738,13 +1738,27 @@ export declare const SETTINGS_SCHEMA: {
         };
     };
     readonly "snapcompact.systemPrompt": {
-        readonly type: "boolean";
-        readonly default: false;
+        readonly type: "enum";
+        readonly values: readonly ["none", "agents-md", "all"];
+        readonly default: "none";
         readonly ui: {
             readonly tab: "context";
             readonly group: "Experimental";
             readonly label: "Snapcompact System Prompt";
-            readonly description: "Experimental: render the system prompt as dense PNG image(s) and attach to the first user message (vision models only). Saves tokens; loses system-prompt prompt caching.";
+            readonly description: "Experimental: render selected system prompt text as dense PNG image(s) and attach to the first user message (vision models only). Saves tokens; loses prompt caching for imaged text.";
+            readonly options: readonly [{
+                readonly value: "none";
+                readonly label: "None";
+                readonly description: "Keep the system prompt as text.";
+            }, {
+                readonly value: "agents-md";
+                readonly label: "AGENTS.md";
+                readonly description: "Only move loaded context-file instructions to images, when that saves tokens.";
+            }, {
+                readonly value: "all";
+                readonly label: "All";
+                readonly description: "Move the full system prompt to images, when that saves tokens.";
+            }];
         };
     };
     readonly "snapcompact.toolResults": {
@@ -4102,6 +4116,36 @@ export declare const SETTINGS_SCHEMA: {
             }];
         };
     };
+    readonly "codexResets.autoRedeem": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "providers";
+            readonly group: "Services";
+            readonly label: "Codex Auto-Redeem Saved Resets";
+            readonly description: "When a turn is blocked by the Codex weekly limit on the active account and no other account is available, automatically spend one saved rate-limit reset (ChatGPT 'save rate limit resets'). Conservative: never fires for 5-hour-only or Spark limits, near a natural reset, or twice for the same block. Requires retries enabled.";
+        };
+    };
+    readonly "codexResets.minBlockedMinutes": {
+        readonly type: "number";
+        readonly default: 60;
+        readonly ui: {
+            readonly tab: "providers";
+            readonly group: "Services";
+            readonly label: "Codex Auto-Redeem Min Block";
+            readonly description: "Only auto-redeem when the natural weekly reset is at least this many minutes away (don't spend a ~30-day credit to save a short wait).";
+        };
+    };
+    readonly "codexResets.keepCredits": {
+        readonly type: "number";
+        readonly default: 0;
+        readonly ui: {
+            readonly tab: "providers";
+            readonly group: "Services";
+            readonly label: "Codex Auto-Redeem Reserve";
+            readonly description: "Never auto-spend below this many saved resets (0 = the last credit may be spent automatically).";
+        };
+    };
     readonly "provider.appendOnlyContext": {
         readonly type: "enum";
         readonly values: readonly ["auto", "on", "off"];
@@ -4451,6 +4495,11 @@ export interface ShellMinimizerSettings {
     sourceOutlineLevel: "default" | "aggressive";
     legacyFilters: boolean | undefined;
 }
+export interface CodexResetsSettings {
+    autoRedeem: boolean;
+    minBlockedMinutes: number;
+    keepCredits: number;
+}
 /** Map group prefix -> typed settings interface */
 export interface GroupTypeMap {
     compaction: CompactionSettings;
@@ -4469,6 +4518,7 @@ export interface GroupTypeMap {
     modelTags: ModelTagsSettings;
     cycleOrder: string[];
     shellMinimizer: ShellMinimizerSettings;
+    codexResets: CodexResetsSettings;
 }
 export type GroupPrefix = keyof GroupTypeMap;
 export {};

package/dist/types/modes/components/reset-usage-selector.d.ts

@@ -0,0 +1,12 @@
+import { Container } from "@oh-my-pi/pi-tui";
+import type { ResetUsageAccount } from "../../slash-commands/helpers/reset-usage";
+/**
+ * Account picker for `/usage reset`. Lists Codex accounts with their saved
+ * rate-limit reset counts; selecting one redeems a reset. Because a reset is a
+ * scarce, irreversible credit, Enter requires a second press to confirm.
+ */
+export declare class ResetUsageSelectorComponent extends Container {
+    #private;
+    constructor(accounts: ResetUsageAccount[], onSelect: (account: ResetUsageAccount) => void, onCancel: () => void);
+    handleInput(keyData: string): void;
+}

package/dist/types/modes/components/session-selector.d.ts

@@ -8,7 +8,7 @@ export type SessionHistoryMatcher = (query: string) => string[];
  * Resume search narrows a recency-sorted list: once every query token appears
  * as a literal substring, newer sessions should beat a slightly better fuzzy
  * position match. Pure fuzzy/acronym matches still sort by fuzzy score after
- * literal matches.
+ * literal matches, but weak pure fuzzy tokens are dropped as noise.
  */
 export declare function rankSessionSearchMatches(allSessions: SessionInfo[], query: string): SessionInfo[];
 /**

package/dist/types/modes/components/tool-execution.d.ts

@@ -72,6 +72,20 @@ export declare class ToolExecutionComponent extends Container {
      * past, or an explicit {@link seal} flips it to `true`.
      */
     isTranscriptBlockFinalized(): boolean;
+    /**
+     * Whether this still-live block's settled rows may enter native scrollback
+     * (see `FinalizableBlock.isTranscriptBlockCommitStable`). A pending
+     * collapsed preview is provisional: the tail-window streaming views
+     * (edit/bash/eval caps) are re-anchored top-first by the result render, so
+     * promoting their visually static head — e.g. an edit preview idling on
+     * its last frame while the apply + LSP pass runs — would strand a stale
+     * copy of the call box above the final block the moment the result lands.
+     * Expanded pending blocks stream top-anchored append-shaped content whose
+     * rows the result render preserves byte-stable (the over-tall write/eval
+     * scrollback contract), so they stay commit-eligible. Displaceable waiting
+     * polls are removed wholesale by the next poll and must never commit.
+     */
+    isTranscriptBlockCommitStable(): boolean;
     /**
      * Mark the tool terminal even though no result arrived (the turn aborted or
      * abandoned it) and stop animating, so it can freeze and stops pinning the

package/dist/types/modes/controllers/selector-controller.d.ts

@@ -41,6 +41,7 @@ export declare class SelectorController {
     handleResumeSession(sessionPath: string): Promise<void>;
     handleSessionDeleteCommand(): Promise<void>;
     showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
+    showResetUsageSelector(): Promise<void>;
     showDebugSelector(): Promise<void>;
     showAgentHub(observers: SessionObserverRegistry): void;
 }

package/dist/types/modes/interactive-mode.d.ts

@@ -27,6 +27,7 @@ import type { ToolExecutionHandle } from "./components/tool-execution";
 import { TranscriptContainer } from "./components/transcript-container";
 import { type LoopLimitRuntime } from "./loop-limit";
 import { OAuthManualInputManager } from "./oauth-manual-input";
+import type { ObservableSession } from "./session-observer-registry";
 import type { Theme } from "./theme/theme";
 import type { CompactionQueuedMessage, InteractiveModeContext, InteractiveModeInitOptions, InteractiveSelectorDialogOptions, SubmittedUserInput, TodoItem, TodoPhase } from "./types";
 /** Options for creating an InteractiveMode instance (for future API use) */
@@ -42,6 +43,13 @@ export interface InteractiveModeOptions {
     /** Additional initial messages to queue */
     initialMessages?: string[];
 }
+/**
+ * Build the anchored subagent HUD block: a bold accent "Subagents" header plus
+ * one hooked row per running agent in the same `Id: description` shape the
+ * inline task rows use (muted task preview when no description was given).
+ * Returns an empty array when nothing is running so the container can clear.
+ */
+export declare function renderSubagentHudLines(sessions: ObservableSession[], columns: number): string[];
 export declare class InteractiveMode implements InteractiveModeContext {
     #private;
     session: AgentSession;
@@ -56,6 +64,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     pendingMessagesContainer: Container;
     statusContainer: Container;
     todoContainer: Container;
+    subagentContainer: Container;
     btwContainer: Container;
     omfgContainer: Container;
     errorBannerContainer: Container;
@@ -265,6 +274,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleResumeSession(sessionPath: string): Promise<void>;
     handleSessionDeleteCommand(): Promise<void>;
     showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
+    showResetUsageSelector(): Promise<void>;
     showProviderSetup(): Promise<void>;
     showHookConfirm(title: string, message: string): Promise<boolean>;
     handleCtrlC(): void;

package/dist/types/modes/session-observer-registry.d.ts

@@ -8,6 +8,8 @@ export interface ObservableSession {
     description?: string;
     status: "active" | "completed" | "failed" | "aborted";
     sessionFile?: string;
+    parentToolCallId?: string;
+    index?: number;
     lastUpdate: number;
     /** Latest progress snapshot from the subagent executor */
     progress?: AgentProgress;

package/dist/types/modes/types.d.ts

@@ -66,6 +66,7 @@ export interface InteractiveModeContext {
     pendingMessagesContainer: Container;
     statusContainer: Container;
     todoContainer: Container;
+    subagentContainer: Container;
     btwContainer: Container;
     omfgContainer: Container;
     errorBannerContainer: Container;
@@ -264,6 +265,7 @@ export interface InteractiveModeContext {
     handleResumeSession(sessionPath: string): Promise<void>;
     handleSessionDeleteCommand(): Promise<void>;
     showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
+    showResetUsageSelector(): Promise<void>;
     showProviderSetup(): Promise<void>;
     showHookConfirm(title: string, message: string): Promise<boolean>;
     showDebugSelector(): Promise<void>;

package/dist/types/modes/utils/context-usage.d.ts

@@ -1,6 +1,7 @@
 import type { Model } from "@oh-my-pi/pi-ai";
 import type { Skill } from "../../extensibility/skills";
 import type { AgentSession } from "../../session/agent-session";
+import { type SnapcompactSavingsEstimate } from "../../session/snapcompact-inline";
 import type { Tool } from "../../tools";
 import type { theme as Theme } from "../theme/theme";
 type CategoryId = "systemPrompt" | "systemContext" | "systemTools" | "skills" | "messages";
@@ -18,6 +19,8 @@ export interface ContextBreakdown {
     usedTokens: number;
     autoCompactBufferTokens: number;
     freeTokens: number;
+    /** Estimated snapcompact wire savings; set when requested and a snapcompact.* setting is enabled. */
+    snapcompact?: SnapcompactSavingsEstimate;
 }
 export declare function estimateSkillsTokens(skills: readonly Skill[]): number;
 export declare function estimateToolSchemaTokens(tools: ReadonlyArray<Pick<Tool, "name" | "description" | "parameters">>): number;
@@ -38,7 +41,9 @@ export declare function computeNonMessageTokens(session: AgentSession): number;
  * Compute a breakdown of estimated context usage by category for the active
  * session and model.
  */
-export declare function computeContextBreakdown(session: AgentSession): ContextBreakdown;
+export declare function computeContextBreakdown(session: AgentSession, options?: {
+    snapcompactSavings?: boolean;
+}): ContextBreakdown;
 /**
  * Render a colorful context-usage panel as ANSI text. Output is a series of
  * lines pairing the grid (left) with the legend (right).

package/dist/types/session/agent-session.d.ts

@@ -15,7 +15,7 @@
 import type { InMemorySnapshotStore } from "@oh-my-pi/hashline";
 import { type Agent, type AgentEvent, type AgentMessage, type AgentState, type AgentTool, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { type CompactionResult, type ShakeConfig } from "@oh-my-pi/pi-agent-core/compaction";
-import type { AssistantMessage, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ServiceTier, SimpleStreamOptions, TextContent, ToolChoice, UsageReport } from "@oh-my-pi/pi-ai";
+import type { AssistantMessage, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ResetCreditAccountStatus, ResetCreditRedeemOutcome, ResetCreditTarget, ServiceTier, SimpleStreamOptions, TextContent, ToolChoice, UsageReport } from "@oh-my-pi/pi-ai";
 import { Effort } from "@oh-my-pi/pi-ai";
 import { type AsyncJob, type AsyncJobDeliveryState, AsyncJobManager } from "../async";
 import type { Rule } from "../capability/rule";
@@ -1052,6 +1052,19 @@ export declare class AgentSession {
         contextWindow?: number;
     }): ContextUsage | undefined;
     fetchUsageReports(signal?: AbortSignal): Promise<UsageReport[] | null>;
+    /**
+     * Redeem one saved Codex rate-limit reset for a specific account, injecting
+     * the provider base URL like {@link AgentSession.fetchUsageReports}. Powers
+     * the `/usage reset` command and auto-redeem. Never throws for business
+     * outcomes — inspect the returned `code`.
+     */
+    redeemResetCredit(target: ResetCreditTarget, signal?: AbortSignal): Promise<ResetCreditRedeemOutcome>;
+    /**
+     * List saved Codex rate-limit resets per stored account, fetched live from
+     * the dedicated credits endpoint (bypasses the usage cache). Powers the
+     * `/usage reset` account selector.
+     */
+    listResetCredits(signal?: AbortSignal): Promise<ResetCreditAccountStatus[]>;
     /**
      * Export session to HTML.
      * @param outputPath Optional output path (defaults to session directory)

package/dist/types/session/auth-storage.d.ts

@@ -2,5 +2,5 @@
  * Re-exports from @oh-my-pi/pi-ai.
  * All credential storage types and the AuthStorage class now live in the ai package.
  */
-export type { ApiKeyCredential, AuthCredential, AuthCredentialEntry, AuthCredentialStore, AuthStorageData, AuthStorageOptions, CredentialOrigin, CredentialOriginKind, OAuthAccountIdentity, OAuthCredential, SerializedAuthStorage, SnapshotResponse, StoredAuthCredential, } from "@oh-my-pi/pi-ai";
+export type { ApiKeyCredential, AuthCredential, AuthCredentialEntry, AuthCredentialStore, AuthStorageData, AuthStorageOptions, CredentialOrigin, CredentialOriginKind, OAuthAccountIdentity, OAuthCredential, ResetCreditAccountStatus, ResetCreditRedeemOutcome, ResetCreditTarget, SerializedAuthStorage, SnapshotResponse, StoredAuthCredential, } from "@oh-my-pi/pi-ai";
 export { AuthBrokerClient, AuthStorage, DEFAULT_SNAPSHOT_CACHE_TTL_MS, REMOTE_REFRESH_SENTINEL, RemoteAuthCredentialStore, readAuthBrokerSnapshotCache, SqliteAuthCredentialStore, writeAuthBrokerSnapshotCache, } from "@oh-my-pi/pi-ai";

package/dist/types/session/codex-auto-reset.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Pure decision predicate for auto-redeeming a saved OpenAI Codex rate-limit
+ * reset, plus the process-wide coordinator that serializes attempts.
+ *
+ * WHY THIS IS REACTIVE-ONLY (never proactive):
+ * The only trustworthy "blocked right now" signal is a live 429 /
+ * `usage_limit_reached` from a request authenticated as the session's active
+ * Codex credential. The session hook calls this predicate from the usage-limit
+ * branch of the retry pipeline, *after* free remedies (sibling-account switch)
+ * fail and *before* model fallback. A proactive surface (the status-line usage
+ * poll) cannot be used: at `used_percent < 100` the account is not actually
+ * limited, so redeeming would be a credit-wasting no-op; at exactly 100 the
+ * user may be idle, so the freshly-reset weekly window would tick away with
+ * nobody working. Saved resets are a scarce, ~monthly, effectively
+ * irreversible resource — every gate here is biased to precision over recall:
+ * we would rather miss a redeem than waste a credit.
+ *
+ * THE DECISION-2 TRAP (status MUST NOT be used to find the blocker):
+ * `openai-codex.ts` applies the top-level `rate_limit.limit_reached` flag to
+ * BOTH the primary (5h) and secondary (weekly) `buildUsageLimit` calls, so when
+ * an account is blocked, *both* limit entries carry `status: "exhausted"`
+ * regardless of which window is actually at 100%. Only `amount.usedFraction`
+ * disambiguates which window is the real blocker. This module therefore keys
+ * eligibility off exact limit ids (`openai-codex:primary` /
+ * `openai-codex:secondary`) and `usedFraction`, never off `status`.
+ *
+ * ANTI-WASTE GATES (in evaluation order): the policy must be OFF unless opted
+ * in; the active model must be Codex (not Spark — a Spark block lives on a
+ * separate meter and it is unknown whether a credit even resets it); a fresh
+ * usage report for the active account must confirm `limitReached`; the WEEKLY
+ * (secondary) window must be genuinely exhausted — a 5h-only block self-heals
+ * within the hour, so a credit spent there buys nothing; the natural reset must be far
+ * enough away to justify spending a ~30-day credit yet within one plausible
+ * window length; a credit must be verifiably available above the reserve; and
+ * the same block episode must not have been attempted already (debounce +
+ * per-account cooldown). All of this is pure — no fetches, no IO. The only
+ * stateful piece is the {@link CodexAutoRedeemCoordinator} container, whose
+ * read-only views are passed in so the predicate itself stays deterministic.
+ */
+import type { OAuthAccountIdentity, ResetCreditTarget, UsageReport } from "@oh-my-pi/pi-ai";
+/** Weekly window counts as exhausted at `usedFraction >= 0.999` (used_percent >= 99.9). */
+export declare const WEEKLY_EXHAUSTED_MIN_FRACTION = 0.999;
+/** A weekly reset can never be more than one window length (7d) away; +1h slack for skew. */
+export declare const MAX_PLAUSIBLE_REMAINING_MS: number;
+/** Report must be no older than the 5-min usage cache TTL plus slack. */
+export declare const REPORT_FRESHNESS_MS: number;
+/** Per-account cooldown that catches blockKey drift across a minute boundary. */
+export declare const ATTEMPT_COOLDOWN_MS = 60000;
+/** Minute bucket for blockKey, absorbing `reset_after_seconds`-derived jitter. */
+export declare const DEBOUNCE_BUCKET_MS = 60000;
+export type CodexAutoRedeemSkipReason = "disabled" | "wrong-provider" | "spark-model" | "no-identity" | "no-report" | "stale-report" | "not-limit-reached" | "weekly-not-exhausted" | "no-reset-time" | "reset-too-soon" | "reset-implausible" | "credits-unknown" | "reserve" | "already-attempted" | "cooldown";
+export interface CodexAutoRedeemInput {
+    nowMs: number;
+    /** `this.model.provider`. */
+    provider: string;
+    /** `this.model.id`. */
+    modelId: string;
+    settings: {
+        autoRedeem: boolean;
+        minBlockedMinutes: number;
+        keepCredits: number;
+    };
+    /** `getOAuthAccountIdentity("openai-codex", sessionId)`, captured at hook entry before any await. */
+    identity: OAuthAccountIdentity | undefined;
+    /** `session.fetchUsageReports()` (≤5-min cache). */
+    reports: UsageReport[] | null;
+    attemptedBlockKeys: ReadonlySet<string>;
+    lastAttemptAtByAccount: ReadonlyMap<string, number>;
+}
+export type CodexAutoRedeemDecision = {
+    redeem: true;
+    target: ResetCreditTarget;
+    accountKey: string;
+    blockKey: string;
+    weeklyResetAtMs: number;
+    remainingMs: number;
+    availableCount: number;
+} | {
+    redeem: false;
+    reason: CodexAutoRedeemSkipReason;
+};
+/**
+ * Decide whether to auto-redeem a saved Codex reset for the active account.
+ *
+ * Pure: every gate below is a function of the snapshot inputs only. Order
+ * matters — cheapest / most-decisive gates first so the common "not eligible"
+ * paths short-circuit before any account/report matching.
+ */
+export declare function evaluateCodexAutoRedeem(input: CodexAutoRedeemInput): CodexAutoRedeemDecision;
+/**
+ * Process-wide (NOT per-session) coordinator state. Parallel subagent sessions
+ * share the same Codex accounts and must not race a double-spend, so this is a
+ * single shared container, not a per-session field.
+ *
+ * - `attemptedBlockKeys`: one attempt EVER per block episode, regardless of
+ *   outcome — recorded before calling the consume so exceptions can't re-enter.
+ * - `lastAttemptAtByAccount`: per-account cooldown timestamps (epoch ms),
+ *   catching blockKey drift across a minute boundary.
+ * - `inFlightByAccount`: serializes per account — a second session for the same
+ *   account adopts the in-flight promise instead of starting a second consume.
+ */
+export interface CodexAutoRedeemCoordinator {
+    attemptedBlockKeys: Set<string>;
+    lastAttemptAtByAccount: Map<string, number>;
+    inFlightByAccount: Map<string, Promise<boolean>>;
+}
+export declare const defaultCodexAutoRedeemCoordinator: CodexAutoRedeemCoordinator;

package/dist/types/session/snapcompact-inline.d.ts

@@ -1,20 +1,121 @@
 /**
  * Snapcompact inline imaging: per-request transform that swaps the system
- * prompt and/or large historical tool results for dense PNG frames on
- * vision-capable models.
- *
+ * prompt, loaded context-file instructions, and/or large historical tool
+ * results for dense PNG frames on vision-capable models.
  * Runs inside the agent loop's `transformProviderContext` hook — after the
  * persisted history is converted to the outgoing `Context`, before the
  * provider stream call. It only ever builds NEW message objects/arrays; the
  * input context shares `content` array references with the persisted
  * `SessionMessageEntry` messages, so mutation would leak rendered images
  * into session.jsonl.
+ *
+ * The swap policy (budget, savings gate, skip rules) lives in
+ * `planInlineSwaps`, shared by the transform and the `/context` savings
+ * estimate (`estimateInlineSavings`) so the two can never disagree.
  */
 import type { Context, Model } from "@oh-my-pi/pi-ai";
+import * as snapcompact from "@oh-my-pi/snapcompact";
+export type SnapcompactSystemPromptMode = "none" | "agents-md" | "all";
 export interface SnapcompactInlineOptions {
-    renderSystemPrompt: boolean;
+    renderSystemPrompt: SnapcompactSystemPromptMode;
     renderToolResults: boolean;
 }
+/** Tool-result swap candidate, in context order. */
+export interface InlineToolResultCandidate {
+    /** toolCallId — stable identity for render caching and application. */
+    id: string;
+    /** Token count of the joined text blocks (0 when empty or image-carrying). */
+    textTokens: number;
+    /** Frames needed to render the text (0 = empty or below the token floor). */
+    frames: number;
+    /** Already carries an image (screenshot etc.) — never re-imaged. */
+    hasImage: boolean;
+}
+export interface InlineSystemPromptCandidate {
+    textTokens: number;
+    frames: number;
+}
+export interface InlinePlanInput {
+    options: SnapcompactInlineOptions;
+    shape: snapcompact.Shape;
+    /** Provider image-count budget minus images already present in the context. */
+    budget: number;
+    /** All tool results in context order, INCLUDING the most recent one. */
+    toolResults: readonly InlineToolResultCandidate[];
+    /** Selected prompt text; undefined when system-prompt imaging is off or empty. */
+    systemPrompt: InlineSystemPromptCandidate | undefined;
+    /** Whether a user message exists to carry the prompt frames. */
+    hasUserMessage: boolean;
+}
+export interface InlineSwapPlan {
+    /** Tool results to swap, oldest first. */
+    toolResults: Array<{
+        id: string;
+        textTokens: number;
+        frames: number;
+    }>;
+    /** Set when the system prompt should swap to frames (uses leftover budget). */
+    systemPrompt: InlineSystemPromptCandidate | undefined;
+}
+/**
+ * Decide which content gets swapped for frames. Pure — the same rules drive
+ * the provider-request transform and the /context savings estimate.
+ */
+export declare function planInlineSwaps(input: InlinePlanInput): InlineSwapPlan;
+/**
+ * Minimal structural view of a history message — both pi-ai `Message`s (the
+ * outgoing context) and agent-core `AgentMessage`s (the live session) satisfy
+ * it, so the estimator can read session state without conversion.
+ */
+export interface InlineMessageView {
+    role: string;
+    toolCallId?: string;
+    content?: unknown;
+}
+export interface SnapcompactSavingsEstimate {
+    /** Frames only ship on models that accept image input. */
+    visionCapable: boolean;
+    /** Present iff system-prompt imaging is enabled. */
+    systemPrompt?: {
+        applied: boolean;
+        /** Why the prompt stays text when `applied` is false. */
+        reason?: "empty" | "margin" | "budget";
+        textTokens: number;
+        frames: number;
+        /** Estimated billed tokens for the frames (0 when there are none). */
+        imageTokens: number;
+        savedTokens: number;
+        scope: Exclude<SnapcompactSystemPromptMode, "none">;
+    };
+    /** Present iff tool-result imaging is enabled. */
+    toolResults?: {
+        /** Tool results currently in history. */
+        total: number;
+        swapped: number;
+        /** Text tokens of the swapped results only. */
+        textTokens: number;
+        frames: number;
+        imageTokens: number;
+        savedTokens: number;
+    };
+    /** Net estimated wire savings for the next request. */
+    savedTokens: number;
+}
+/**
+ * Estimate what `SnapcompactInlineTransformer.transform` would save on the
+ * NEXT request, given the session's live system prompt and message history.
+ *
+ * Mirrors the transform exactly via `planInlineSwaps`, with one deliberate
+ * difference: `hasUserMessage` is assumed true, because the request being
+ * estimated is always triggered by a user prompt — even when the current
+ * history is still empty.
+ */
+export declare function estimateInlineSavings(input: {
+    options: SnapcompactInlineOptions;
+    model: Model | undefined;
+    systemPrompt: readonly string[];
+    messages: readonly InlineMessageView[];
+}): SnapcompactSavingsEstimate;
 /**
  * Stateless with respect to the model (passed per call, so mid-session model
  * switches re-resolve shape and budget); stateful only for the render caches,

package/dist/types/slash-commands/helpers/reset-usage.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared helpers for the `/usage reset` command (TUI selector + ACP): turn the
+ * live per-account reset-credit status into selector rows, and map a redeem
+ * outcome code to a human message.
+ */
+import type { ResetCreditAccountStatus, ResetCreditRedeemOutcome, ResetCreditTarget } from "../../session/auth-storage";
+export declare const CODEX_PROVIDER_ID = "openai-codex";
+/** One Codex account row for the reset-usage selector. */
+export interface ResetUsageAccount {
+    /** Display label (email, else account id). */
+    label: string;
+    /** Saved resets redeemable for this account right now. */
+    availableCount: number;
+    /** Identifies the account when redeeming. */
+    target: ResetCreditTarget;
+    /** Whether this is the session's active Codex account. */
+    active: boolean;
+    /** Set when this account could not be reached (token/list failure). */
+    error?: string;
+}
+/**
+ * Map live per-account reset status to selector rows. Sorted with the active
+ * account first, then most-credits, then label.
+ */
+export declare function toResetUsageAccounts(statuses: ResetCreditAccountStatus[]): ResetUsageAccount[];
+/** Human-facing summary of a redeem outcome for status lines and ACP output. */
+export declare function describeRedeemOutcome(outcome: ResetCreditRedeemOutcome, label: string): string;

package/dist/types/task/render.d.ts

@@ -15,6 +15,7 @@ interface TaskRenderContext {
 type TaskRenderOptions = RenderResultOptions & {
     renderContext?: TaskRenderContext;
 };
+export declare function formatTaskId(id: string): string;
 /**
  * Render the tool call arguments.
  */

package/dist/types/tools/todo.d.ts

@@ -9,13 +9,6 @@ export type TodoStatus = "pending" | "in_progress" | "completed" | "abandoned";
 export interface TodoItem {
     content: string;
     status: TodoStatus;
-    /**
-     * Append-only list of freeform notes attached by `op: "note"`.
-     * Each element is one note and may itself be multi-line.
-     * Rendered as text only when the task is in_progress; otherwise shown as a
-     * dim marker indicating the task has notes.
-     */
-    notes?: string[];
 }
 export interface TodoPhase {
     name: string;
@@ -37,7 +30,6 @@ declare const todoSchema: z.ZodObject<{
             done: "done";
             drop: "drop";
             init: "init";
-            note: "note";
             rm: "rm";
             start: "start";
             view: "view";
@@ -49,7 +41,6 @@ declare const todoSchema: z.ZodObject<{
         task: z.ZodOptional<z.ZodString>;
         phase: z.ZodOptional<z.ZodString>;
         items: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        text: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 type TodoParams = z.infer<typeof todoSchema>;
@@ -111,7 +102,6 @@ export declare class TodoTool implements AgentTool<typeof todoSchema, TodoToolDe
                 done: "done";
                 drop: "drop";
                 init: "init";
-                note: "note";
                 rm: "rm";
                 start: "start";
                 view: "view";
@@ -123,7 +113,6 @@ export declare class TodoTool implements AgentTool<typeof todoSchema, TodoToolDe
             task: z.ZodOptional<z.ZodString>;
             phase: z.ZodOptional<z.ZodString>;
             items: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            text: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
     readonly concurrency = "exclusive";