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

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

@@ -0,0 +1,129 @@
+/**
+ * Snapcompact inline imaging: per-request transform that swaps the system
+ * 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: 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,
+ * which live as long as the session's Agent.
+ */
+export declare class SnapcompactInlineTransformer {
+    #private;
+    private readonly options;
+    constructor(options: SnapcompactInlineOptions);
+    transform(context: Context, model: Model): Context;
+}

package/dist/types/slash-commands/helpers/active-oauth-account.d.ts

@@ -0,0 +1,14 @@
+import type { UsageLimit, UsageReport } from "@oh-my-pi/pi-ai";
+import type { OAuthAccountIdentity } from "../../session/auth-storage";
+/**
+ * True when a single usage-limit column belongs to the given OAuth identity.
+ *
+ * Single definition of the matching rules for both `/usage` renderers:
+ * - `accountId` ↔ report metadata `accountId`/`account_id` or `limit.scope.accountId`
+ * - `email`     ↔ report metadata `email`
+ * - `projectId` ↔ report metadata `projectId` or `limit.scope.projectId`
+ *   (Google-style providers key usage on the GCP project, not an account id)
+ */
+export declare function limitMatchesActiveAccount(report: UsageReport, limit: UsageLimit, identity: OAuthAccountIdentity | undefined): boolean;
+/** True when any limit column in `report` belongs to the given OAuth identity. */
+export declare function reportMatchesActiveAccount(report: UsageReport, identity: OAuthAccountIdentity | undefined): boolean;

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/system-prompt.d.ts

@@ -2,7 +2,7 @@
  * System prompt construction and project context loading
  */
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import type { SkillsSettings } from "./config/settings";
+import type { Personality, SkillsSettings } from "./config/settings";
 import { type Skill } from "./extensibility/skills";
 import { type WorkspaceTree } from "./workspace-tree";
 interface AlwaysApplyRule {
@@ -88,6 +88,8 @@ export interface BuildSystemPromptOptions {
     memoryRootEnabled?: boolean;
     /** Active model identifier (e.g. "anthropic/claude-opus-4") surfaced to the agent. */
     model?: string;
+    /** Personality preset rendered into the default system prompt. "none" omits the block. Default: "default" */
+    personality?: Personality;
 }
 /** Result of building provider-facing system prompt messages. */
 export interface BuildSystemPromptResult {

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

@@ -2,14 +2,24 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
 import type { TaskParams, TaskToolDetails } from "./types";
+/** Render context threaded in from `ToolExecutionComponent.#buildRenderContext`. */
+interface TaskRenderContext {
+    hasResult?: boolean;
+    /**
+     * The block left the transcript live region (detached spawn the transcript
+     * has moved past, or a sealed block): progress rows render static gray, so
+     * commit-eligible rows do not repaint after entering native scrollback.
+     */
+    frozen?: boolean;
+}
+type TaskRenderOptions = RenderResultOptions & {
+    renderContext?: TaskRenderContext;
+};
+export declare function formatTaskId(id: string): string;
 /**
  * Render the tool call arguments.
  */
-export declare function renderCall(args: TaskParams, options: RenderResultOptions & {
-    renderContext?: {
-        hasResult?: boolean;
-    };
-}, theme: Theme): Component;
+export declare function renderCall(args: TaskParams, options: TaskRenderOptions, theme: Theme): Component;
 /**
  * Render the tool result.
  */
@@ -20,9 +30,10 @@ export declare function renderResult(result: {
     }>;
     details?: TaskToolDetails;
     isError?: boolean;
-}, options: RenderResultOptions, theme: Theme, args?: TaskParams): Component;
+}, options: TaskRenderOptions, theme: Theme, args?: TaskParams): Component;
 export declare const taskToolRenderer: {
     renderCall: typeof renderCall;
     renderResult: typeof renderResult;
     mergeCallAndResult: boolean;
 };
+export {};

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

@@ -1,9 +1,12 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolApprovalDecision } from "@oh-my-pi/pi-agent-core";
 import * as z from "zod/v4";
 import type { Settings } from "../config/settings";
+import * as git from "../utils/git";
 import type { ToolSession } from ".";
 import { type CacheStatus } from "./github-cache";
 import type { OutputMeta } from "./output-meta";
+/** Runs `gh --json` for issue data, retrying without optional stateReason on older gh releases. */
+export declare function githubIssueJsonWithStateReasonFallback<T>(cwd: string, args: readonly string[], signal: AbortSignal | undefined, options?: git.GhCommandOptions): Promise<T>;
 declare const githubSchema: z.ZodObject<{
     op: z.ZodEnum<{
         pr_checkout: "pr_checkout";

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

@@ -76,24 +76,16 @@ export declare function formatBadge(label: string, color: ToolUIColor, theme: Th
  * Uses consistent wording pattern.
  */
 export declare function formatMoreItems(remaining: number, itemType: string): string;
+/** Tail-window height for collapsed command/code previews. */
+export declare function previewWindowRows(): number;
 /**
- * Maximum rows a tool's streaming/pending *call* preview may render before it is
- * capped. This is intentionally conservative: the preview still sits inside a
- * transcript that already consumed some viewport rows, and tool blocks carry
- * extra chrome (status/header/border/"more lines"), so a "reasonable" raw code
- * or command preview like 10-12 lines can still overflow and strand its top
- * while the block is volatile. Keeping the live call window short avoids that
- * across terminals without turning the transcript into an interactive scroller.
- */
-export declare const CALL_PREVIEW_MAX_LINES = 6;
-/**
- * Cap a pre-rendered pending/call preview to a bounded window. When truncated,
- * show both the head and the live tail so the user can still see what the tool
- * is currently writing while the volatile block stays short enough not to strand
- * its top above the viewport. `Ctrl+O` widens the bounded window, but does not
- * fully uncap live tool previews for the same reason.
+ * Cap a pre-rendered command preview to a viewport-sized tail window: the end
+ * of the command stays visible (it is the live edge while args stream) behind
+ * an "… N earlier lines" marker on top. The same window applies while
+ * streaming and after completion so the block never jumps; only `expanded`
+ * (ctrl+o) uncaps it.
  *
- * `prefix` (raw, e.g. a dim tree gutter) is prepended to the summary line so
+ * `prefix` (raw, e.g. a dim tree gutter) is prepended to the marker line so
  * nested previews stay aligned.
  */
 export declare function capPreviewLines(lines: string[], theme: Theme, options?: {

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/dist/types/utils/session-color.d.ts

@@ -1,13 +1,25 @@
 /**
- * Derive a stable CSS hex accent color from a session name.
+ * Derive a stable CSS hex accent color from a session name and the active theme.
+ *
+ * Picks a hue from a **dark/light-specific range** so the accent feels natural
+ * for the theme type (warm on dark, cool on light). The session name hash
+ * determines the exact hue within the range. The result is checked against
+ * all theme color hues and shifted if it lands within {@link MIN_HUE_DISTANCE}
+ * of an existing theme hue, but is clamped to the hue band so it never
+ * drifts into an unrelated part of the spectrum.
  *
  * On dark themes (`surfaceLuminance` undefined) the accent is vivid (high
  * saturation, high lightness). On light themes the lightness is reduced until the
  * accent's perceived luminance clears {@link ACCENT_MIN_CONTRAST} against the
  * actual surface it renders on — so it stays legible on near-white *and* mid-light
- * backgrounds — while keeping the same per-session hue.
+ * backgrounds.
+ *
+ * @param name — session name for per-session uniqueness.
+ * @param themeColorHexes — all theme colors to check collision against.
+ * @param surfaceLuminance — undefined on dark themes; WCAG luminance of the
+ *   status-line background on light themes.
  */
-export declare function getSessionAccentHex(name: string, surfaceLuminance?: number): string;
+export declare function getSessionAccentHex(name: string, themeColorHexes: string[], surfaceLuminance?: number): string;
 /**
  * Convert a hex accent color to an ANSI-16m foreground escape sequence.
  * Returns `undefined` if `hex` is nullish or Bun.color conversion fails.

package/dist/types/web/kagi.d.ts

@@ -6,7 +6,7 @@
  * through the shared {@link AuthStorage} broker (Bearer token), and responses
  * are categorized result buckets rather than the legacy flat object array.
  */
-import type { AuthStorage, FetchImpl } from "@oh-my-pi/pi-ai";
+import { type AuthStorage, type FetchImpl } from "@oh-my-pi/pi-ai";
 /** V1 search request body. */
 export interface KagiSearchRequest {
     query: string;
@@ -96,5 +96,4 @@ export interface KagiSearchResult {
     relatedQuestions: string[];
     answer?: string;
 }
-export declare function findKagiApiKey(authStorage: AuthStorage, sessionId?: string, signal?: AbortSignal): Promise<string | null>;
 export declare function searchWithKagi(query: string, options: KagiSearchOptions | undefined, authStorage: AuthStorage): Promise<KagiSearchResult>;

package/dist/types/web/search/providers/codex.d.ts

@@ -1,4 +1,4 @@
-import type { AuthStorage, FetchImpl } from "@oh-my-pi/pi-ai";
+import { type AuthStorage, type FetchImpl } from "@oh-my-pi/pi-ai";
 import type { SearchResponse } from "../../../web/search/types";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";

package/dist/types/web/search/providers/gemini.d.ts

@@ -8,10 +8,12 @@
  * sibling SQLite store and never POSTs the broker sentinel to a Google token
  * endpoint.
  */
-import type { AuthStorage, FetchImpl } from "@oh-my-pi/pi-ai";
+import { type AuthStorage, type FetchImpl, type OAuthAccess } from "@oh-my-pi/pi-ai";
 import type { SearchResponse } from "../../../web/search/types";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
+declare const GEMINI_PROVIDERS: readonly ["google-gemini-cli", "google-antigravity"];
+type GeminiProviderId = (typeof GEMINI_PROVIDERS)[number];
 interface GeminiToolParams {
     google_search?: Record<string, unknown>;
     code_execution?: Record<string, unknown>;
@@ -31,19 +33,20 @@ export interface GeminiSearchParams extends GeminiToolParams {
     fetch?: FetchImpl;
 }
 export declare function buildGeminiRequestTools(params: GeminiToolParams): Array<Record<string, Record<string, unknown>>>;
-/** Resolved auth for a Gemini API request. */
-interface GeminiAuth {
-    accessToken: string;
+/** First configured Gemini OAuth provider plus its pre-resolved access. */
+interface GeminiAuthSeed {
+    provider: GeminiProviderId;
+    access: OAuthAccess;
     projectId: string;
-    isAntigravity: boolean;
 }
 /**
  * Walks the configured Gemini OAuth providers in deterministic order and
  * returns the first one that yields a usable access token + projectId via
  * {@link AuthStorage.getOAuthAccess}. AuthStorage handles refresh + broker
  * routing internally; this helper never touches refresh tokens directly.
+ * The resolved access seeds `withOAuthAccess` so the happy path resolves once.
  */
-export declare function findGeminiAuth(authStorage: AuthStorage, sessionId: string | undefined, signal: AbortSignal | undefined): Promise<GeminiAuth | null>;
+export declare function findGeminiAuth(authStorage: AuthStorage, sessionId: string | undefined, signal: AbortSignal | undefined): Promise<GeminiAuthSeed | null>;
 /**
  * Executes a web search using Google Gemini with Google Search grounding.
  */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "15.11.3",
+	"version": "15.11.6",
 	"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.3",
-		"@oh-my-pi/omp-stats": "15.11.3",
-		"@oh-my-pi/pi-agent-core": "15.11.3",
-		"@oh-my-pi/pi-ai": "15.11.3",
-		"@oh-my-pi/pi-catalog": "15.11.3",
-		"@oh-my-pi/pi-mnemopi": "15.11.3",
-		"@oh-my-pi/pi-natives": "15.11.3",
-		"@oh-my-pi/pi-tui": "15.11.3",
-		"@oh-my-pi/pi-utils": "15.11.3",
-		"@oh-my-pi/snapcompact": "15.11.3",
+		"@oh-my-pi/hashline": "15.11.6",
+		"@oh-my-pi/omp-stats": "15.11.6",
+		"@oh-my-pi/pi-agent-core": "15.11.6",
+		"@oh-my-pi/pi-ai": "15.11.6",
+		"@oh-my-pi/pi-catalog": "15.11.6",
+		"@oh-my-pi/pi-mnemopi": "15.11.6",
+		"@oh-my-pi/pi-natives": "15.11.6",
+		"@oh-my-pi/pi-tui": "15.11.6",
+		"@oh-my-pi/pi-utils": "15.11.6",
+		"@oh-my-pi/snapcompact": "15.11.6",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/auto-thinking/classifier.ts

@@ -83,11 +83,7 @@ async function classifyOnline(input: string, deps: ClassifyDifficultyDeps): Prom
 			messages: [{ role: "user", content: input, timestamp: Date.now() }],
 		},
 		{
-			apiKey: deps.registry.resolver(model.provider, {
-				sessionId: deps.sessionId,
-				baseUrl: model.baseUrl,
-				modelId: model.id,
-			}),
+			apiKey: deps.registry.resolver(model, deps.sessionId),
 			maxTokens,
 			disableReasoning: true,
 			metadata,