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

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,123 @@
 /**
  * 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;
+    /** Frame variant override; `"auto"`/omitted picks the provider's eval winner. */
+    shape?: snapcompact.ShapeVariantName | "auto";
+}
+/** 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/bash.d.ts

@@ -124,6 +124,7 @@ export declare function createShellRenderer<TArgs>(config: ShellRendererConfig<T
     }, uiTheme: Theme, args?: TArgs): Component;
     mergeCallAndResult: boolean;
     inline: boolean;
+    provisionalPendingPreview: boolean;
 };
 export declare const bashToolRenderer: {
     renderCall(args: BashRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
@@ -139,5 +140,6 @@ export declare const bashToolRenderer: {
     }, uiTheme: Theme, args?: BashRenderArgs | undefined): Component;
     mergeCallAndResult: boolean;
     inline: boolean;
+    provisionalPendingPreview: boolean;
 };
 export {};

package/dist/types/tools/eval-render.d.ts

@@ -48,5 +48,6 @@ export declare const evalToolRenderer: {
     }, uiTheme: Theme, _args?: EvalRenderArgs): Component;
     mergeCallAndResult: boolean;
     inline: boolean;
+    provisionalPendingPreview: boolean;
 };
 export {};

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

@@ -21,5 +21,18 @@ export type ToolRenderer = {
     mergeCallAndResult?: boolean;
     /** Render without background box, inline in the response flow */
     inline?: boolean;
+    /**
+     * Collapsed pending preview is provisional — a tail-window or otherwise
+     * re-anchored view the result render replaces wholesale (an edit's
+     * streamed-diff tail, bash/ssh command caps, eval cells whose outputs
+     * interleave under each cell). Its rows must never commit to native
+     * scrollback mid-run; see
+     * `ToolExecutionComponent.isTranscriptBlockCommitStable`. Absent = the
+     * pending preview streams top-anchored append-shaped rows the result
+     * render preserves (task context/assignment, write content), which stay
+     * commit-eligible so a call taller than the viewport scrolls into history
+     * instead of reading as cut off.
+     */
+    provisionalPendingPreview?: boolean;
 };
 export declare const toolRenderers: Record<string, ToolRenderer>;

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

@@ -65,5 +65,6 @@ export declare const sshToolRenderer: {
         renderContext?: SshRenderContext;
     }, uiTheme: Theme, args?: SshRenderArgs): Component;
     mergeCallAndResult: boolean;
+    provisionalPendingPreview: boolean;
 };
 export {};

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";

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "15.11.4",
+	"version": "15.11.7",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -47,16 +47,16 @@
 		"@agentclientprotocol/sdk": "0.22.1",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "15.11.4",
-		"@oh-my-pi/omp-stats": "15.11.4",
-		"@oh-my-pi/pi-agent-core": "15.11.4",
-		"@oh-my-pi/pi-ai": "15.11.4",
-		"@oh-my-pi/pi-catalog": "15.11.4",
-		"@oh-my-pi/pi-mnemopi": "15.11.4",
-		"@oh-my-pi/pi-natives": "15.11.4",
-		"@oh-my-pi/pi-tui": "15.11.4",
-		"@oh-my-pi/pi-utils": "15.11.4",
-		"@oh-my-pi/snapcompact": "15.11.4",
+		"@oh-my-pi/hashline": "15.11.7",
+		"@oh-my-pi/omp-stats": "15.11.7",
+		"@oh-my-pi/pi-agent-core": "15.11.7",
+		"@oh-my-pi/pi-ai": "15.11.7",
+		"@oh-my-pi/pi-catalog": "15.11.7",
+		"@oh-my-pi/pi-mnemopi": "15.11.7",
+		"@oh-my-pi/pi-natives": "15.11.7",
+		"@oh-my-pi/pi-tui": "15.11.7",
+		"@oh-my-pi/pi-utils": "15.11.7",
+		"@oh-my-pi/snapcompact": "15.11.7",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",