@oh-my-pi/pi-coding-agent 15.10.0 → 15.10.1

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

@@ -15,10 +15,14 @@ declare const findSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type FindToolInput = z.infer<typeof findSchema>;
 /**
- * Group find matches by their directory so the model doesn't pay repeated
- * tokens for shared path prefixes. Preserves the input order: groups appear in
- * the order their first member was emitted (mtime-desc for native glob), and
- * within a group entries keep their relative order.
+ * Group find matches into a multi-level directory tree so the model doesn't pay
+ * repeated tokens for shared path prefixes. Single-child directory chains fold
+ * into one header (`# a/b/c/`), so a common prefix — including an absolute root
+ * for out-of-cwd results — collapses to a single line. Each level adds one `#`;
+ * files are listed bare under the deepest directory header that owns them.
+ *
+ * Order follows the input (mtime-desc for native glob): a directory appears when
+ * its first member is emitted, and a node's own files precede its subdirectories.
  */
 export declare function formatFindGroupedOutput(paths: readonly string[]): string;
 export interface FindToolDetails {

package/dist/types/tools/grouped-file-output.d.ts

@@ -1,7 +1,55 @@
+interface PathTreeNode {
+    /** Direct file leaves, in first-seen order. */
+    files: Array<{
+        name: string;
+        key: string;
+    }>;
+    /** Dedup set for `files` (a glob can surface the same path twice on retry). */
+    fileNames: Set<string>;
+    /** Child directories, in first-seen order. */
+    subdirs: Array<{
+        name: string;
+        node: PathTreeNode;
+    }>;
+    /** Dedup index for `subdirs`. */
+    dirIndex: Map<string, PathTreeNode>;
+}
+export interface PathTreeInput {
+    /** Path string; absolute, cwd-relative, or url-like. Backslashes are normalized. */
+    path: string;
+    /** Whether the leaf itself is a directory (trailing-slash match from find). */
+    isDir: boolean;
+    /** Opaque key carried onto file events for section lookup. Defaults to `path`. */
+    key?: string;
+}
+/** One node emitted while walking the tree: a folded directory or a file leaf. */
+export interface GroupedTreeEvent {
+    kind: "dir" | "file";
+    /** 0-based nesting depth (root children are depth 0). */
+    depth: number;
+    /** Folded chain for dirs (e.g. `a/b/c`, no trailing slash); basename for files. */
+    name: string;
+    /** File key for `kind === "file"`; empty string for directories. */
+    key: string;
+}
+/**
+ * Build a directory tree from a flat list of paths. URL-like entries are kept
+ * whole as root-level file leaves (they have no meaningful directory structure).
+ * Absolute paths carry a leading empty segment so they share a common `/` root
+ * and fold like any other prefix.
+ */
+export declare function buildPathTree(entries: Iterable<PathTreeInput>): PathTreeNode;
+/**
+ * Depth-first walk yielding directory and file events. Directories collapse their
+ * single-child chains (`a` → `a/b` → `a/b/c`) so a shared prefix becomes one
+ * header. Each node's direct files are emitted before its subdirectories, keeping
+ * a file unambiguously attached to the header above it.
+ */
+export declare function walkPathTree(node: PathTreeNode, depth?: number): Generator<GroupedTreeEvent>;
 /**
  * One file's contribution to a grouped file output. The header itself is generated
- * by `formatGroupedFiles` (single `#` for root files, `##` for files inside a dir);
- * use `headerSuffix` to tack on extras like ` (1 replacement)`.
+ * by `formatGroupedFiles` (one `#` per nesting level); use `headerSuffix` to tack
+ * on extras like ` (1 replacement)`.
  */
 export interface GroupedFileSection {
     /** Optional suffix appended to the file header. */
@@ -18,19 +66,54 @@ export interface GroupedFilesOutput {
     display: string[];
 }
 /**
- * Render a list of files as directory-grouped sections shared by grep, ast-grep,
- * ast-edit, and the LSP diagnostic formatter.
+ * Render a list of files as a multi-level, prefix-folded directory tree shared by
+ * grep, ast-grep, ast-edit, and the LSP diagnostic formatter.
  *
- * Layout:
- *   # dir/
- *   ## file.ts
+ * Layout (one `#` per level; the shared prefix folds into the top header):
+ *   # packages/pkg/src/
+ *   ## root.ts
  *   …body…
- *
- *   # otherdir/
- *   ## other.ts
+ *   ## nested/
+ *   ### child.ts
  *   …body…
  *
- * Files in the project root (directory `.`) become single-`#` headers without a
- * `## file` line, matching the existing convention.
+ * Files in the (folded) project root become single-`#` headers with no parent
+ * directory line. A blank line precedes every directory header and every
+ * root-level file so the renderers can split the output into collapsible groups.
  */
 export declare function formatGroupedFiles(files: string[], renderFile: (filePath: string) => GroupedFileSection): GroupedFilesOutput;
+/** Per-line classification of grouped output, used by renderers for hyperlinks. */
+export interface GroupedLineContext {
+    /** Directory header, file header, or any non-header body/content line. */
+    kind: "dir" | "file" | "content";
+    /** Number of leading `#` for headers; 0 for content lines. */
+    depth: number;
+    /** Resolved absolute path of the dir/file a header points at (when resolvable). */
+    headerPath?: string;
+    /** For content lines, the absolute path of the owning file (line hyperlinks). */
+    filePath?: string;
+    /** Header is an internal/url-like target the caller resolves itself. */
+    isUrl?: boolean;
+}
+/**
+ * Walk grouped output lines, tracking a directory stack keyed by header depth, so
+ * each header and body line can be linked back to its absolute filesystem path.
+ * Reconstruction is stack-based (not per-blank-group) so nested directory headers
+ * resolve correctly across the whole output.
+ *
+ * `headerBase` is the directory the displayed (folded) header paths are relative
+ * to — for grep/ast tools that is the session cwd, since display paths are
+ * formatted relative to cwd regardless of the (sub)directory the search was
+ * scoped to. `fileScope` is the initial owning file for body lines that appear
+ * before any header (single-file scopes have no `#` headers); it defaults to
+ * `headerBase` and should be passed the scoped file's absolute path.
+ */
+export declare function classifyGroupedLines(lines: readonly string[], headerBase: string | undefined, fileScope?: string | undefined): GroupedLineContext[];
+/**
+ * Split line indices into blank-line-separated groups, mirroring
+ * `splitGroupsByBlankLine`: when any blank line is present, break on runs of
+ * blanks; otherwise return a single group of the non-empty lines. Returning
+ * indices lets callers slice parallel arrays (raw lines, styled lines, contexts).
+ */
+export declare function groupLineIndicesByBlank(rawLines: readonly string[]): number[][];
+export {};

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

@@ -4,7 +4,10 @@
  *
  * These keep the transcript terse — one status line plus, for `retain`, one
  * `Remember: …` line per stored item — instead of the generic JSON arg tree,
- * which exploded multi-line memory blobs into an unreadable wall.
+ * which exploded multi-line memory blobs into an unreadable wall. The tool
+ * container is a transparent passthrough, so these renderers stay frameless:
+ * a status line with a couple of dim bullets reads far cleaner than boxing a
+ * one-line memory note.
  */
 import type { Component } from "@oh-my-pi/pi-tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";

package/dist/types/tools/plan-mode-guard.d.ts

@@ -1,16 +1,15 @@
 import type { ToolSession } from ".";
 /**
- * Resolve a write/edit target to its absolute filesystem path.
- *
- * In plan mode, transparently redirects `PLAN.md` aliases and targets whose
- * basename matches the plan file's basename to the canonical plan file
- * location at `state.planFilePath`. This lets `write` and `edit` accept the
- * habitual plan filename after approval even when the active artifact has a
- * titled path such as `local://APPROVED.md`.
- *
- * Outside plan mode (or when the basename does not match) this is a no-op.
+ * Resolve a write/edit target to its absolute filesystem path, honoring the
+ * `local://` and `vault://` schemes. Plain paths resolve against the session cwd.
  */
 export declare function resolvePlanPath(session: ToolSession, targetPath: string): string;
+/**
+ * Plan mode keeps the working tree read-only while letting the agent draft its
+ * plan. Writes and edits to the `local://` artifact sandbox are allowed (that is
+ * where the plan and any scratch notes live); anything that would touch the
+ * working tree — or rename/delete a file — is rejected.
+ */
 export declare function enforcePlanModeWrite(session: ToolSession, targetPath: string, options?: {
     move?: string;
     op?: "create" | "update" | "delete";

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

@@ -46,8 +46,8 @@ export declare const TRUNCATE_LENGTHS: {
     /** Very short (task previews, badges) */
     readonly SHORT: 40;
 };
-/** Standard expand hint text */
-export declare const EXPAND_HINT = "(Ctrl+O for more)";
+/** Human-readable key currently bound to tool-output expansion, e.g. `Ctrl+O`. */
+export declare function expandKeyHint(): string;
 /**
  * Get first N lines of text as preview, with each line truncated.
  */
@@ -163,18 +163,14 @@ export declare function capParseErrors(errors: string[] | undefined, limit?: num
     errors: string[];
     total: number;
 };
-/**
- * Group `rawLines` by blank-line separators, mirroring the historical search /
- * ast-grep / ast-edit renderer behavior: if any blank line is present, splits on
- * runs of blank lines; otherwise collapses non-empty lines into a single group.
- */
-export declare function splitGroupsByBlankLine(rawLines: string[]): string[][];
 /**
  * Standard width+expand keyed render cache used by every search-style tool
  * renderer. `compute` re-runs only when the cache key changes; the returned
  * Component is the canonical `{ render, invalidate }` pair.
  */
-export declare function createCachedComponent(getExpanded: () => boolean, compute: (width: number, expanded: boolean) => string[]): Component;
+export declare function createCachedComponent(getExpanded: () => boolean, compute: (width: number, expanded: boolean) => string[], options?: {
+    paddingX?: number;
+}): Component;
 /**
  * Append the indented bullet list of parse errors (capped at
  * {@link PARSE_ERRORS_LIMIT}) to `lines`, with an overflow summary line if the

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

@@ -47,6 +47,10 @@ export interface SearchToolDetails {
     /** Absolute base directory used during search. Used by the renderer to resolve
      * display-relative paths to absolute paths for OSC 8 hyperlinks. */
     searchPath?: string;
+    /** Session cwd at search time. The renderer resolves the display-relative
+     * (cwd-relative) header/match paths against this for OSC 8 hyperlinks;
+     * `searchPath` is the scope label target, not the display-path base. */
+    cwd?: string;
     /** User-supplied paths whose base directory was missing on disk. The tool
      * skipped these and continued with the surviving entries; surfaced as a
      * non-fatal warning in the renderer and in the model-facing text. */

package/dist/types/tools/sqlite-reader.d.ts

@@ -1,4 +1,5 @@
 import type { Database } from "bun:sqlite";
+export declare function looksLikeSqlite(bytes: Uint8Array): boolean;
 export interface SqlitePathCandidate {
     sqlitePath: string;
     subPath: string;

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

@@ -146,14 +146,15 @@ export declare const TODO_STRIKE_HOLD_FRAMES = 2;
 export declare const TODO_STRIKE_REVEAL_FRAMES = 12;
 export declare const TODO_STRIKE_TOTAL_FRAMES: number;
 export declare const todoToolRenderer: {
-    renderCall(args: TodoRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderCall(args: TodoRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
     renderResult(result: {
         content: Array<{
             type: string;
             text?: string;
         }>;
         details?: TodoToolDetails;
-    }, options: RenderResultOptions, uiTheme: Theme, _args?: TodoRenderArgs): Component;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: TodoRenderArgs): Component;
     mergeCallAndResult: boolean;
 };
 export {};

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

@@ -17,6 +17,9 @@ export interface WriteToolDetails {
     meta?: OutputMeta;
     /** Set when the file was auto-chmod'd because content begins with a `#!` shebang. */
     madeExecutable?: boolean;
+    /** Absolute filesystem path the write resolved to. Used by the renderer to wrap
+     * the (possibly cwd-relative) header path in an OSC 8 `file://` hyperlink. */
+    resolvedPath?: string;
 }
 type WriteParams = WriteToolInput;
 /**

package/dist/types/tui/output-block.d.ts

@@ -2,7 +2,7 @@
  * Bordered output container with optional header and sections.
  */
 import type { Component } from "@oh-my-pi/pi-tui";
-import type { Theme } from "../modes/theme/theme";
+import type { Theme, ThemeColor } from "../modes/theme/theme";
 import type { State } from "./types";
 export interface OutputBlockOptions {
     header?: string;
@@ -11,11 +11,16 @@ export interface OutputBlockOptions {
     sections?: Array<{
         label?: string;
         lines: string[];
+        separator?: boolean;
     }>;
     width: number;
     applyBg?: boolean;
+    contentPaddingLeft?: number;
     /** Animate the border with a sweeping dark segment (pending/running state). */
     animate?: boolean;
+    /** Override the state-derived border color. Used for muted "legacy" tool
+     * frames that should not visually compete with framed-output tools. */
+    borderColor?: ThemeColor;
 }
 declare const FRAMED_BLOCK_COMPONENT: unique symbol;
 export type FramedBlockComponent = Component & {
@@ -24,9 +29,9 @@ export type FramedBlockComponent = Component & {
 export declare function markFramedBlockComponent<T extends Component>(component: T): T & FramedBlockComponent;
 export declare function isFramedBlockComponent(component: Component): boolean;
 /**
- * Monotonic frame counter for animated borders, quantized to the TUI's ~16ms
- * render cap so the cache key advances once per ~60fps frame — fine enough for a
- * smooth segment sweep, coarse enough to coalesce multiple render passes that
+ * Monotonic frame counter for animated borders, quantized to the TUI's ~30fps
+ * render cap so the cache key advances once per animation frame — fine enough
+ * for a smooth segment sweep, coarse enough to coalesce multiple render passes
  * land inside the same frame.
  */
 export declare function borderShimmerTick(): number;
@@ -54,4 +59,11 @@ export declare class CachedOutputBlock {
     /** Invalidate the cache, forcing a rebuild on next render. */
     invalidate(): void;
 }
+/**
+ * Build a self-framing tool component backed by a cached output block. The
+ * `build` callback returns the block options for a given width; the cache
+ * dedupes re-renders. Pass `borderColor: "borderMuted"` for the dim "legacy"
+ * look that does not compete with the state-colored framed tools.
+ */
+export declare function framedBlock(theme: Theme, build: (width: number) => OutputBlockOptions): Component;
 export {};

package/dist/types/tui/status-line.d.ts

@@ -5,6 +5,9 @@ import type { Theme, ThemeColor } from "../modes/theme/theme";
 import type { ToolUIStatus } from "../tools/render-utils";
 export interface StatusLineOptions {
     icon?: ToolUIStatus;
+    /** Pre-rendered glyph that replaces the status icon (e.g. a magnifier for
+     * search-family tools). Takes precedence over `icon`. */
+    iconOverride?: string;
     spinnerFrame?: number;
     title: string;
     titleColor?: ThemeColor;

package/dist/types/utils/enhanced-paste.d.ts

@@ -0,0 +1,20 @@
+import type { ImageContent } from "@oh-my-pi/pi-ai";
+export interface Osc5522Packet {
+    metadata: Map<string, string>;
+    payload: string;
+}
+export interface EnhancedPasteHandlers {
+    write(data: string): void;
+    pasteText(text: string): void;
+    pasteImage(image: ImageContent): void | Promise<void>;
+    showStatus(message: string): void;
+}
+export declare function isOsc5522Packet(data: string): boolean;
+export declare function parseOsc5522Packet(data: string): Osc5522Packet | undefined;
+export declare class EnhancedPasteController {
+    #private;
+    constructor(handlers: EnhancedPasteHandlers);
+    enable(): void;
+    disable(): void;
+    handleInput(data: string): boolean;
+}

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

@@ -4,7 +4,7 @@
  * Uses Moonshot Kimi Code search API to retrieve web results.
  * Endpoint: POST https://api.kimi.com/coding/v1/search
  */
-import type { AuthStorage } from "@oh-my-pi/pi-ai";
+import { type AuthStorage } from "@oh-my-pi/pi-ai";
 import type { SearchResponse } from "../../../web/search/types";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "15.10.0",
+	"version": "15.10.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -47,14 +47,14 @@
 		"@agentclientprotocol/sdk": "0.22.1",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "15.10.0",
-		"@oh-my-pi/omp-stats": "15.10.0",
-		"@oh-my-pi/pi-agent-core": "15.10.0",
-		"@oh-my-pi/pi-ai": "15.10.0",
-		"@oh-my-pi/pi-mnemopi": "15.10.0",
-		"@oh-my-pi/pi-natives": "15.10.0",
-		"@oh-my-pi/pi-tui": "15.10.0",
-		"@oh-my-pi/pi-utils": "15.10.0",
+		"@oh-my-pi/hashline": "15.10.1",
+		"@oh-my-pi/omp-stats": "15.10.1",
+		"@oh-my-pi/pi-agent-core": "15.10.1",
+		"@oh-my-pi/pi-ai": "15.10.1",
+		"@oh-my-pi/pi-mnemopi": "15.10.1",
+		"@oh-my-pi/pi-natives": "15.10.1",
+		"@oh-my-pi/pi-tui": "15.10.1",
+		"@oh-my-pi/pi-utils": "15.10.1",
 		"@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

@@ -15,6 +15,7 @@
  */
 import { type AssistantMessage, completeSimple, Effort, type Model } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
+
 import type { ModelRegistry } from "../config/model-registry";
 import { resolveRoleSelection } from "../config/model-resolver";
 import type { Settings } from "../config/settings";
@@ -82,7 +83,10 @@ async function classifyOnline(input: string, deps: ClassifyDifficultyDeps): Prom
 			messages: [{ role: "user", content: input, timestamp: Date.now() }],
 		},
 		{
-			apiKey,
+			apiKey: deps.registry.resolver(model.provider, {
+				sessionId: deps.sessionId,
+				baseUrl: model.baseUrl,
+			}),
 			maxTokens,
 			disableReasoning: true,
 			metadata,

package/src/cli/dry-balance-cli.ts

@@ -1,8 +1,10 @@
 import type {
 	Api,
+	ApiKeyResolver,
 	AssistantMessage,
 	AssistantMessageEvent,
 	AssistantMessageEventStream,
+	AuthCredentialSnapshotEntry,
 	Context,
 	Model,
 	OAuthAccess,
@@ -59,6 +61,12 @@ export interface DryBalanceAuthStorage {
 		options?: DryBalanceAuthOptions,
 	): Promise<OAuthAccess | undefined>;
 	getOAuthAccesses?(provider: string, options?: DryBalanceAuthOptions): Promise<OAuthAccessResolution[]>;
+	/**
+	 * Force-refresh a single credential by id (step (b) of the auth-retry
+	 * policy). The bench re-mints the failing account's token in place on a
+	 * 401 rather than rotating accounts — it is measuring each account.
+	 */
+	forceRefreshCredentialById?(id: number, signal?: AbortSignal): Promise<AuthCredentialSnapshotEntry>;
 }
 
 export interface DryBalanceModelRegistry {
@@ -152,6 +160,8 @@ export interface DryBalanceDependencies {
 	now?: () => number;
 	stdoutIsTTY?: boolean;
 	stderrIsTTY?: boolean;
+	stdoutColumns?: number;
+	stderrColumns?: number;
 }
 
 type DryBalanceAttemptResult =
@@ -181,6 +191,7 @@ type DryBalanceBenchTarget =
 			ok: true;
 			account: string;
 			accessToken: string;
+			credentialId?: number;
 	  }
 	| {
 			ok: false;
@@ -310,10 +321,11 @@ function renderBenchStatusLine(
 	}
 }
 
-function createBenchProgressSink(
+export function createBenchProgressSink(
 	total: number,
 	write: (text: string) => void,
 	interactive: boolean,
+	columns: number,
 ): DryBalanceBenchProgressSink {
 	const statuses: DryBalanceBenchProgressStatus[] = Array.from({ length: total }, () => ({ state: "waiting" }));
 	if (!interactive) {
@@ -333,13 +345,21 @@ function createBenchProgressSink(
 	let frame = 0;
 	let lineCount = 0;
 	let timer: NodeJS.Timeout | undefined;
+	const width = Number.isFinite(columns) && columns > 0 ? Math.trunc(columns) : 80;
 	const render = (): void => {
 		const lines = [
 			chalk.bold("bench requests"),
 			...statuses.map((status, index) => renderBenchStatusLine(status, index, total, frame)),
 		];
-		if (lineCount > 0) write(`\x1b[${lineCount}A`);
-		write(`${lines.map(line => `\x1b[2K${line}`).join("\n")}\n`);
+		// Anchor every redraw at column 0 and terminate each row with CRLF: a
+		// bare `\n` only returns to column 0 when the tty performs ONLCR
+		// translation, which is off whenever the terminal is in raw mode — there
+		// the old column-preserving cursor-up staircased each frame into
+		// scrollback. Cap each line to the terminal width so a wrapped row never
+		// desyncs the `\x1b[<n>A` cursor-up from the logical line count.
+		const move = lineCount > 0 ? `\x1b[${lineCount}A` : "";
+		const body = lines.map(line => `\x1b[2K${truncateToWidth(line, width)}`).join("\r\n");
+		write(`${move}\r${body}\r\n`);
 		lineCount = lines.length;
 	};
 	render();
@@ -370,13 +390,23 @@ function createBenchProgressSink(
 async function runBenchRequest(
 	model: Model<Api>,
 	sessionId: string,
-	account: string,
-	accessToken: string,
+	target: Extract<DryBalanceBenchTarget, { ok: true }>,
+	authStorage: DryBalanceAuthStorage,
 	streamFn: DryBalanceStreamSimple,
 	now: () => number,
 ): Promise<DryBalanceBenchResult> {
+	const { account, accessToken, credentialId } = target;
 	const startedAt = now();
 	let firstTokenAt: number | undefined;
+	// Re-mint the cached token on a 401: a peer/broker may have rotated it out
+	// from under our snapshot (Anthropic rotates refresh tokens on every use).
+	// The bench measures one account, so the switch step intentionally declines.
+	const apiKey: ApiKeyResolver = async ({ lastChance, error }) => {
+		if (error === undefined) return accessToken;
+		if (lastChance || credentialId === undefined || !authStorage.forceRefreshCredentialById) return undefined;
+		const refreshed = await authStorage.forceRefreshCredentialById(credentialId);
+		return refreshed.credential.type === "oauth" ? refreshed.credential.access : undefined;
+	};
 	try {
 		const context: Context = {
 			messages: [
@@ -389,7 +419,7 @@ async function runBenchRequest(
 			],
 		};
 		const stream = streamFn(model, context, {
-			apiKey: accessToken,
+			apiKey,
 			sessionId,
 			maxTokens: resolveBenchMaxTokens(model),
 			temperature: 0.2,
@@ -454,7 +484,7 @@ async function resolveBenchTargets(
 		seen.add(key);
 		const account = extractAccount(entry);
 		if (entry.ok) {
-			targets.push({ ok: true, account, accessToken: entry.accessToken });
+			targets.push({ ok: true, account, accessToken: entry.accessToken, credentialId: entry.credentialId });
 		} else {
 			targets.push({ ok: false, account, error: entry.error });
 		}
@@ -465,6 +495,7 @@ async function resolveBenchTargets(
 async function runBenchTargets(
 	model: Model<Api>,
 	targets: DryBalanceBenchTarget[],
+	authStorage: DryBalanceAuthStorage,
 	randomSessionId: () => string,
 	progress: DryBalanceBenchProgressSink | undefined,
 	streamFn: DryBalanceStreamSimple,
@@ -482,14 +513,7 @@ async function runBenchTargets(
 				return result;
 			}
 			progress?.markRunning(index, target.account);
-			const result = await runBenchRequest(
-				model,
-				randomSessionId(),
-				target.account,
-				target.accessToken,
-				streamFn,
-				now,
-			);
+			const result = await runBenchRequest(model, randomSessionId(), target, authStorage, streamFn, now);
 			progress?.complete(index, result);
 			return result;
 		}),
@@ -792,8 +816,19 @@ export async function runDryBalanceCommand(
 			const progressInteractive = command.flags.json
 				? (deps.stderrIsTTY ?? process.stderr.isTTY === true)
 				: (deps.stdoutIsTTY ?? process.stdout.isTTY === true);
-			progress = createBenchProgressSink(targets.length, progressWrite, progressInteractive);
-			benchResults = await runBenchTargets(model, targets, randomSessionId, progress, streamFn, now);
+			const progressColumns = command.flags.json
+				? (deps.stderrColumns ?? process.stderr.columns ?? 80)
+				: (deps.stdoutColumns ?? process.stdout.columns ?? 80);
+			progress = createBenchProgressSink(targets.length, progressWrite, progressInteractive, progressColumns);
+			benchResults = await runBenchTargets(
+				model,
+				targets,
+				runtime.modelRegistry.authStorage,
+				randomSessionId,
+				progress,
+				streamFn,
+				now,
+			);
 			results = targets.map(target =>
 				target.ok ? { ok: true, account: target.account } : { ok: false, reason: target.error },
 			);

package/src/cli/gallery-cli.ts

@@ -196,7 +196,10 @@ export async function runGalleryCommand(args: GalleryCommandArgs): Promise<void>
 	const expanded = args.expanded ?? false;
 	const states = args.states && args.states.length > 0 ? args.states : [...GALLERY_STATES];
 
-	const allNames = Object.keys(toolRenderers).sort();
+	// Renderer-registry tools plus fixture-only tools (no dedicated renderer,
+	// e.g. `report_tool_issue` / custom extension tools) so the gallery covers
+	// the generic fallback + custom-tool branches too.
+	const allNames = Array.from(new Set([...Object.keys(toolRenderers), ...Object.keys(galleryFixtures)])).sort();
 	const names = args.tool ? allNames.filter(name => name === args.tool) : allNames;
 	if (args.tool && names.length === 0) {
 		process.stdout.write(`Unknown tool '${args.tool}'. Known tools: ${allNames.join(", ")}\n`);

package/src/cli/gallery-fixtures/misc.ts

@@ -218,4 +218,33 @@ export const miscFixtures: Record<string, GalleryFixture> = {
 			},
 		},
 	},
+
+	// Built-in tool with no dedicated renderer — exercises the generic fallback
+	// (`#formatToolExecution`) path so its padded, state-tinted block is QA'd.
+	report_tool_issue: {
+		label: "Report Tool Issue",
+		streamingArgs: { tool: "lsp" },
+		args: {
+			tool: "lsp",
+			report: "Rename returned no edit for an exported symbol that has 12 references",
+		},
+		result: { content: [{ type: "text", text: "Noted, thanks!" }] },
+		errorResult: {
+			content: [{ type: "text", text: "Could not record the report: issue tracker unreachable" }],
+			isError: true,
+		},
+	},
+
+	// Stand-in for a custom/extension tool that ships no renderer — same generic
+	// fallback path most MCP/extension tools take.
+	custom: {
+		label: "Custom Tool",
+		streamingArgs: { query: "weather" },
+		args: { query: "weather in Tokyo", units: "metric" },
+		result: { content: [{ type: "text", text: "Tokyo: 22°C, partly cloudy, humidity 64%." }] },
+		errorResult: {
+			content: [{ type: "text", text: "Upstream provider returned 503 Service Unavailable" }],
+			isError: true,
+		},
+	},
 };

package/src/commit/analysis/conventional.ts

@@ -1,5 +1,5 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Api, Model } from "@oh-my-pi/pi-ai";
+import type { Api, ApiKey, Model } from "@oh-my-pi/pi-ai";
 import { completeSimple } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
 import analysisSystemPrompt from "../../commit/prompts/analysis-system.md" with { type: "text" };
@@ -14,7 +14,7 @@ const ConventionalAnalysisTool = createConventionalAnalysisTool(
 
 export interface ConventionalAnalysisInput {
 	model: Model<Api>;
-	apiKey: string;
+	apiKey: ApiKey;
 	thinkingLevel?: ThinkingLevel;
 	contextFiles?: Array<{ path: string; content: string }>;
 	userContext?: string;

package/src/commit/analysis/summary.ts

@@ -1,5 +1,5 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Api, AssistantMessage, Model } from "@oh-my-pi/pi-ai";
+import type { Api, ApiKey, AssistantMessage, Model } from "@oh-my-pi/pi-ai";
 import { completeSimple, validateToolCall } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
@@ -19,7 +19,7 @@ const SummaryTool = {
 
 export interface SummaryInput {
 	model: Model<Api>;
-	apiKey: string;
+	apiKey: ApiKey;
 	thinkingLevel?: ThinkingLevel;
 	commitType: string;
 	scope: string | null;