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

package/CHANGELOG.md

@@ -2,6 +2,80 @@
 
 ## [Unreleased]
 
+## [15.10.1] - 2026-06-07
+
+### Added
+
+- Added `display.smoothStreaming` setting (default `true`) to let users enable or disable smooth assistant-stream text reveal
+- Added `/tan <work>` slash command to fork the current conversation into a background agent so tangential work can continue asynchronously while your main session stays active
+- Added a background `/tan` dispatch message that records the handoff in the transcript and marks the delegated work as non-blocking
+- Added `providerPromptCacheKey` support to `CreateAgentSessionOptions` so `/tan` background sessions can reuse the parent session’s prompt-cache lineage
+- Added session cloning for `/tan` runs with copied artifacts and shared MCP proxy tools
+- Added `SessionManager.forkFrom`’s optional `suppressBreadcrumb` mode to avoid breadcrumb updates when forking background `/tan` sessions
+- Added OSC 5522 enhanced paste handling in `InputController`, so terminal clipboard events are decoded as image or text payloads and inserted without passing raw paste sequences to the editor
+- Added bracketed image-path paste support in `CustomEditor` so a single pasted image file path (PNG/JPEG/GIF/WEBP) is loaded from disk and inserted as an image candidate
+- Added direct support for `Image #N` insertion from pasted local image paths by routing successful image-path pastes through the same image normalization and resize flow as clipboard image pastes
+- Added `/fresh` to rotate the provider-facing session id and clear in-memory provider stream/cache state without changing the local session file.
+- Added a `ChatBlock` transcript primitive (`modes/components/chat-block.ts`) and a single `ctx.present(...)` sink (with `ctx.resetTranscript()`) so chat output is mounted in one place instead of the repeated `chatContainer.addChild(...)` + `ui.requestRender()` pattern scattered across controllers. `ChatBlock` carries a React/Svelte-style lifecycle — `onMount` starts effects, `onCleanup` registers teardown, `finish()` self-completes (stops timers and freezes the block at its final content), and `dispose()`/`resetTranscript()` tears everything down — so animated blocks own their own resources instead of leaking `setInterval`/`requestRender` bookkeeping into callers. The MCP "Connecting…" spinner is now such a block.
+- Added a `framedBlock` output-block helper (`tui/output-block.ts`) plus a `borderColor` override and `applyBg: false` (no background fill) on output blocks, a `renderStatusLine` `iconOverride`, and an `icon.search` (magnifier) theme symbol — so tool renderers can draw self-contained muted-outline frames and search-family tools can show a magnifier instead of a checkmark.
+
+### Changed
+
+- Changed the bash tool frame to use a plain top rule instead of repeating "Bash" in the title bar, and folded minimizer raw-output artifact links into the status footer as `Artifact: <id>`.
+
+- Changed grouped `read` output to use a white filled-circle mark for the group/single-read success state and omit duplicate per-file success marks inside multi-read groups.
+
+- Changed assistant streaming output to reveal text incrementally at 30 FPS with grapheme-safe adaptive catch-up, instead of replacing the whole message chunk-by-chunk
+- Changed shimmer-driven TUI animations (working text, pending bash/eval borders, and theme activity-spinner documentation) to render at 30fps instead of 60fps.
+- Changed running `task` tool agent rows to use a static `•` marker and shimmer only the subagent name, leaving descriptions, stats, and nested tool detail text solid while removing the rotating status glyph from those rows.
+- Changed settings singleton method access to reuse bound methods for the active instance instead of allocating a new bound function on every `settings.get` lookup.
+- Changed plan-mode approval to keep the drafted `local://<slug>-plan.md` file at its original name as the canonical plan path, so approved plans are no longer renamed when leaving plan mode
+- Changed plan-mode write enforcement so only `local://` artifact files are writable during planning, blocking working-tree edits and allowing scratch or draft plan files in the local artifact area
+- Changed the `todo` tool result renderer to stop redrawing every phase's full task list on each update: when a multi-phase list is rendered collapsed (the default, not manually expanded), only phases the latest update touched — the phase holding the in_progress task, any phase with a just-completed task, and phases named by the ops that ran (`init` counts as touching all) — render their tasks; untouched phases collapse to a one-line `N. Name  done/total` summary. When call args are unavailable (e.g. transcript rebuilds) it falls back to the in_progress/completed-transition signals, and the manual expand toggle still shows every task. Also dropped the blank separator line previously inserted between phases.
+- Changed non-agent API operations (title and commit-message generation, image generation, web search, eval `llm()`, auto-thinking classifier, memory consolidation) to use session-aware API key resolution with auth retries via `registry.resolver()` / `authStorage.resolver()`, refreshing the active credential before rotating to another account
+- Changed image generation to wrap every provider fetch branch in `withAuth`, so 401 / usage-limit errors trigger credential force-refresh and rotation for authStorage-backed providers (OpenAI-hosted, antigravity, xai-oauth) while env-only providers (openrouter, gemini) stay single-attempt
+- Changed web-search providers using `authStorage.getApiKey` (anthropic, exa, tavily, parallel, synthetic, zai, kimi) to wrap HTTP calls in `withAuth` for automatic credential rotation on 401 / usage-limit errors
+- Changed the directory grouping for `find`, `search`, `ast_grep`, `ast_edit`, and `lsp` diagnostics from a single flat `# dir/` heading per immediate directory to a multi-level tree that folds the common path prefix into one heading. Previously every group repeated the full directory path — so results rooted outside cwd printed the absolute prefix (e.g. `/Users/me/proj/`) on every heading and nested directories were never collapsed. Now a single-child directory chain folds into one heading (`# packages/pkg/src/`, including an absolute root for out-of-cwd results), subdirectories nest one `#` deeper (`## nested/` → `### child.ts`), and each directory's own files are listed before its subdirectories. TUI hyperlink reconstruction tracks the nested directory stack across the whole output so file and code-frame links keep resolving to the correct absolute paths.
+- Changed the plan-mode approval surface from an inline transcript block plus a separate bottom selector into a single fullscreen overlay (like `/copy`) and overhauled its navigation. The overlay now renders the plan per-section through `ScrollView` (line-level ↑/↓ scroll, Shift+↑/↓ to scroll faster, PgUp/PgDn, g/G) with no stray per-line `…`, and — when the terminal is wide enough and the plan has ≥2 headings — shows a compact VS Code-style section sidebar (the redundant plan-title heading and any "Contents" label are omitted). Focus moves between regions with Tab/Shift+Tab (and flows at the edges: Down past the last section or the bottom of the body drops into the approval options; Up steps back), while the sidebar glows to track the scrolled section. The sidebar can fast-jump between sections, delete a section (with `u` undo), and annotate sections with feedback (`a`); deletions and annotations are collected into refinement feedback that is submitted back to the model when the operator picks "Refine plan". Mouse works too: clicking an approval option activates it, clicking a sidebar section jumps to it, and the wheel scrolls the plan. ←/→ always drive the model-tier slider, Enter confirms, the external-editor key opens the plan, and Esc cancels. The overlay borrows the terminal's alternate screen buffer for its lifetime (`fullscreen` overlay), so the transcript stays put on the normal screen instead of bleeding through scrollback behind the modal.
+- Changed the interactive controllers (command, MCP, selector, extension-UI, event), debug panels, and the status/error/warning helpers to render chat output through `ctx.present(...)` instead of appending to `chatContainer` and calling `ui.requestRender()` directly; transcript rebuilds dispose live blocks via `ctx.resetTranscript()` so animated blocks' timers stop on reset.
+- Changed tool-execution block rendering so the container (`ToolExecutionComponent`) is a transparent passthrough — it no longer inserts a top/bottom blank line, adds left/right padding, or paints a state-colored background behind tool output. Tools with substantial body now self-frame with a muted outline and the tool title in the frame's top bar (`edit`/`apply_patch`, `write`, `ask`, `todo`, `github`, `goal`, `inspect_image`, `search_tool_bm25`, `task`), matching the already-framed `bash`/`read`/`eval`/`debug`/`web_search`/`lsp` blocks, while streaming/in-progress and trivial results collapse to a clean status line. The search-family list tools (`find`, `search`, `ast_grep`) and `job` render frameless/minimal; `find`/`search`/`ast_grep` show a magnifier on success instead of a checkmark, and `job` drops its `Job:` label prefix (the per-job rows are self-describing). The `search_tool_bm25`, `github`, and `inspect_image` frames draw with no background fill, and `inspect_image`'s label was shortened to `Inspect`.
+- Changed the plan-mode active prompt (`prompts/system/plan-mode-active.md`) to make plans decision-complete and cut filler. Added an Objective framing ("another engineer can execute end-to-end without making a single design decision"), a shared "Resolving Unknowns" section (explore discoverable facts before asking; reserve `ask` for non-derivable preferences/tradeoffs with 2–4 options + a recommended default), and a single shared "The Plan" structure (Context / Approach grouped by behavior not file-by-file / ≤5 Critical files / Verification / Assumptions) that replaces the per-branch structure guidance previously duplicated across the iterative and parallel workflows. Added explicit prohibitions on sections that decide nothing (Non-Goals, Out of Scope, Alternatives Considered, Risks/Mitigations boilerplate, Future Work), on enumerating every file/line, and on inventing schema/validation/precedence policy the request never established.
+- Changed completion notifications (`completion.notify`) to fire whenever the agent yields its turn, including in the foreground. The `agent_end` notification was previously gated behind background mode (`isBackgrounded`), so an ordinary foreground turn never emitted one; the gate is gone and the desktop toast now fires on every normal turn completion (still skipped for aborted/error turns and when `completion.notify` is `off`).
+- Changed the in-progress `task` tool block to keep the shared `context` brief (`# Goal` / `# Constraints` background) visible after the first progress snapshot arrives, instead of dropping it the moment the streaming call view was replaced by the result frame, and to stop animating a spinner/clock next to the `Task` frame header while running — the per-agent body lines already carry their own running spinner, so the header now shows a static state icon (matching the completed/failed header icons). The context is rendered through a shared `buildContextSection` helper that also undoes per-field double-encoding, so the brief reads cleanly in the result frame even though `renderResult` receives the raw (un-repaired) tool args.
+- Changed the messaging shown when you press Esc to interrupt a streaming turn from the ambiguous `Operation aborted` / `Tool execution was aborted: Request was aborted` to `Interrupted by user`, so a deliberate user interrupt no longer reads like an internal failure. Every Esc/flush interrupt path (`onEscape` while streaming, the queued-message restore-and-abort path, and the empty-submit queue flush) threads the reason through `AgentSession.abort({ reason })` → `Agent.abort(reason)` so it rides the `AbortController` onto the aborted assistant message's `errorMessage`; the turn label renders it verbatim on both the live and replay paths, and the synthetic placeholder results paired with in-flight tool calls now read `Tool execution was aborted: Interrupted by user`. Aborts that carry no reason still fall back to the retry-aware `Operation aborted` generic. Transcript label resolution is centralized in `resolveAbortLabel` (`session/messages.ts`).
+
+### Removed
+
+- Removed the `/background` (and `/bg`) slash command and the background-mode subsystem it was the sole entry point for — `InteractiveMode.isBackgrounded`, `createBackgroundUiContext`, `handleBackgroundEvent`, and every `isBackgrounded` guard across the input/event/extension-UI controllers and UI helpers. The command suspended the whole process group via `SIGTSTP` (a leftover testing shortcut) instead of detaching the running agent, which is not the expected workflow — use terminal panes or a multiplexer instead.
+
+### Fixed
+
+- Fixed inline `find` and `search` result blocks to align with grouped `read` output and render their success headers with the normal tool-title color instead of accent blue.
+
+- Fixed the working-status shimmer to opt into the loader's 30fps animated-message repaint path while keeping both the status spinner and pending bash/eval tool spinners on their normal 80 ms glyph cadence.
+- Fixed consecutive `read` tool calls failing to collapse into a single grouped block when a reasoning model emits one read per completion (`[thinking, read]`). The read group was reset on every assistant `message_start`, so each read rendered as its own one-entry `Read …` line; now a read run accretes across completions and is broken only by a rendered non-empty text/thinking block, a non-read tool, or a user/IRC message — matching the transcript-rebuild path. `ReadToolGroupComponent` now reports its live/finalized state so the growing `Read (N)` header repaints correctly on native-scrollback (risk) terminals.
+- Fixed the `task` tool shared-context brief rendering raw Markdown headings (`# Goal`, `# Constraints`) inside framed call/result blocks instead of using the normal Markdown renderer.
+- Fixed the animated pending border on `bash`/`eval` blocks leaving a frozen dark "bar" segment behind after a backgrounded command finalized through the async update path. Once a command is auto-backgrounded (`details.async.state === "running"`) the block stays "partial" in the TUI until the async job-manager delivers the final result, but it also gets committed to native scrollback — so a mid-sweep shimmer frame baked a stray darkened border segment into the committed copy. The border now stops animating (and the 60fps redraw loop stops) the moment a block enters the backgrounded state, so the committed frame is a clean static border.
+- Fixed cold `omp` launch to clear native terminal history on the first paint, avoiding a once-per-launch duplicate welcome/transcript copy before the normal session replay.
+- Fixed plan approval resolution so `resolve` with `action: "apply"` can still find the plan file when `extra.title` is missing or stale by falling back to the current plan path and most-recent local plan artifacts
+- Fixed the search-family tool magnifier glyph (`find`, `search`, `ast_grep`, `search_tool_bm25`) to use the `accent` title color instead of `success` green, so the icon matches the tool title in the status header instead of standing out
+- Fixed TTSR stream interrupts to pass the matched rule name through the abort reason, so aborted in-flight tool placeholders say why they were stopped instead of `Request was aborted`.
+- Fixed URL reads for binary/special payloads to reuse local readers: remote archives list their root entries, SQLite databases show their table overview, notebooks render as editable cells, and unrenderable binary returns a metadata notice instead of decoded byte garbage.
+- Fixed pasted image-file paths that cannot be loaded to fall back to normal text paste with status feedback instead of disappearing.
+- Fixed tool-output file paths not being clickable OSC 8 `file://` hyperlinks in several renderers. `read` titles for plain text and image files (the common case) emitted no link at all because the renderer only linked when a `resolvedPath` was recorded — which the ordinary file/image read paths never set, keeping the absolute path only in `meta.source`; the renderer now falls back to that source path. `write` headers were never wrapped in a hyperlink and now link to the absolute path written (file, archive entry, SQLite, and conflict resolutions). `edit`/`apply_patch` headers wrapped the model-supplied (often cwd-relative) argument path, producing a root-anchored `file:///rel/path` URI; they now link the absolute `details.path` instead. Finally, `search`, `ast_grep`, and `ast_edit` produced doubled link targets (`/proj/src/src/file.ts`) for searches scoped to a subdirectory, because the renderer resolved the cwd-relative display paths against the scope directory rather than cwd — the scoped-search base is now the session cwd (with the scoped file's absolute path still seeding single-file body lines).
+- Fixed `omp dry-balance --bench` to recover from 401 token failures by re-minting the failing OAuth credential in place before switching accounts
+- Fixed the bash tool corrupting commands that embed multi-byte UTF-8 (e.g. `✓`/`×` inside a `grep -E` pattern) ahead of a trailing `| head`/`| tail`. The `bash.stripTrailingHeadTail` rewrite cut at char-offset positions reported by `brush-parser` while slicing the command by byte offset, so the trailing-pipe strip landed mid-pattern and dropped the closing quote — turning `… |✓|×|XCTAssert" | tail -80` into `… |✓|×-80` and making execution fail with `pi-natives:command: unterminated double quote`. Fixed in `pi_shell::fixup` (`@oh-my-pi/pi-natives`).
+- Fixed `omp dry-balance --bench` to recover from 401 token failures by re-minting the failing OAuth credential in place before switching accounts
+- Fixed duplicate file entries in grouped outputs for `find`, `search`, `ast_grep`, `ast_edit`, and `lsp` diagnostics when the same path appeared multiple times
+- Fixed search, grep, and edit output rendering so repeated directory group blank-line boundaries no longer break nested path/link reconstruction
+- Fixed `omp dry-balance --bench` flooding the terminal with staircased, duplicated spinner/status lines (and an indented summary) when the tty has ONLCR/OPOST disabled (raw mode). The interactive progress region separated rows with a bare LF and repositioned with a column-preserving `\x1b[<n>A` cursor-up, both of which only land at column 0 when the terminal translates LF→CRLF; with that translation off, every 80 ms redraw cascaded down and to the right into scrollback. The live region now carriage-returns before every cleared row, terminates each row with CRLF, and caps each row to the terminal width so a wrapped line cannot desync the cursor-up from the logical line count.
+- Fixed inconsistent vertical spacing between transcript blocks: some blocks (tool results from `search`/`find` and other renderer-backed tools) rendered with a doubled gap (a leading `Spacer` plus the content box's own `paddingY`), while others (the grouped `read` card, file-mention lists, IRC cards) rendered with no gap at all. Vertical spacing is now owned entirely by the chat renderer: `TranscriptContainer` strips each block's plain-blank top/bottom edges and inserts exactly one blank line between consecutive blocks, so every block is separated by a single consistent gap regardless of which component produced it. Individual components (assistant/user/tool/read-group/bash/eval/skill/custom/hook/compaction/branch/todo-reminder/plan-review messages) no longer emit their own leading `Spacer`/`paddingY` for separation, and multi-row groups (IRC cards, file-mention lists, completed-job batches, and the bordered command/`/changelog`/`/context`/version/OAuth/debug panels) are wrapped as single `TranscriptBlock` children so the renderer spaces them as one unit. Background-colored box padding is preserved as block-internal design.
+- Fixed `resolve` with `action: "discard"` surfacing a hard `isError` "No pending action to resolve" failure to the model when the agent asked to cancel a staged action (e.g. an `ast_edit` preview) but nothing was pending. A discard is a request to reach the "no staged change" end-state, which already holds in that case, so it is now honored as a successful cancellation (`"Nothing to discard; no pending action remains."` with `details.action: "discard"`) instead of an error. `action: "apply"` with no pending action still errors.
+- Fixed the collapsed tool-output expand hint rendering double brackets (e.g. `((Ctrl+O for more))`) — the `EXPAND_HINT` text already carried its own parentheses and then `formatExpandHint` wrapped it again with the theme's bracket glyphs. The hint now resolves the key actually bound to `app.tools.expand` at render time and reads `⟨<key>: Expand⟩` (e.g. `⟨Ctrl+O: Expand⟩`), so a single bracket pair surrounds it and a user remap of the expand keybinding is reflected instead of a hard-coded `Ctrl+O`.
+- Fixed the `edit`/`apply_patch` tool dropping its outlined frame while streaming/in-progress (only the final result was framed); the in-progress diff preview now renders inside the same muted frame as the completed result.
+- Fixed the `todo` and `job` tools rendering a success icon and success styling on a failed/error result; error results now show the error icon and a red frame border.
+- Fixed `debug` tool refusing every `dlv` launch on Go modules. The launch handler ran `validateLaunchProgram` before adapter selection and rejected any directory program with `launch program resolves to a directory`, while dlv's default `mode=debug` requires a Go package path (a directory or `.go` source file). Adapter resolution now precedes validation, directory programs prefer adapters that advertise `acceptsDirectoryProgram` before falling back to native extensionless debuggers, the rejection only fires when the resolved adapter does not advertise that flag (set on `dlv` in `dap/defaults.json`), and dlv's `mode` is derived from the program shape — directories and `.go` files launch as `mode=debug`, other files as `mode=exec` — so `omp` can debug both Go packages and pre-built binaries ([#2020](https://github.com/can1357/oh-my-pi/issues/2020)).
+
 ## [15.10.0] - 2026-06-06
 
 ### Breaking Changes
@@ -9496,4 +9570,4 @@ Initial public release.
 - Git branch display in footer
 - Message queueing during streaming responses
 - OAuth integration for Gmail and Google Calendar access
-- HTML export with syntax highlighting and collapsible sections
+- HTML export with syntax highlighting and collapsible sections

package/dist/types/cli/dry-balance-cli.d.ts

@@ -1,4 +1,4 @@
-import type { Api, AssistantMessageEventStream, Context, Model, OAuthAccess, OAuthAccessResolution, SimpleStreamOptions } from "@oh-my-pi/pi-ai";
+import type { Api, AssistantMessageEventStream, AuthCredentialSnapshotEntry, Context, Model, OAuthAccess, OAuthAccessResolution, SimpleStreamOptions } from "@oh-my-pi/pi-ai";
 import type { CanonicalModelVariant } from "../config/model-equivalence";
 import { type CanonicalModelQueryOptions } from "../config/model-registry";
 import { Settings } from "../config/settings";
@@ -20,6 +20,12 @@ export interface DryBalanceAuthOptions {
 export interface DryBalanceAuthStorage {
     getOAuthAccess(provider: string, sessionId?: string, 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 {
     authStorage: DryBalanceAuthStorage;
@@ -98,7 +104,15 @@ export interface DryBalanceDependencies {
     now?: () => number;
     stdoutIsTTY?: boolean;
     stderrIsTTY?: boolean;
+    stdoutColumns?: number;
+    stderrColumns?: number;
 }
+interface DryBalanceBenchProgressSink {
+    markRunning(index: number, account: string): void;
+    complete(index: number, result: DryBalanceBenchResult): void;
+    close(): void;
+}
+export declare function createBenchProgressSink(total: number, write: (text: string) => void, interactive: boolean, columns: number): DryBalanceBenchProgressSink;
 export declare function formatDryBalanceText(summary: DryBalanceSummary): string;
 export declare function runDryBalanceCommand(command: DryBalanceCommandArgs, deps?: DryBalanceDependencies): Promise<DryBalanceSummary>;
 export {};

package/dist/types/commit/analysis/conventional.d.ts

@@ -1,9 +1,9 @@
 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 type { ConventionalAnalysis } from "../../commit/types";
 export interface ConventionalAnalysisInput {
     model: Model<Api>;
-    apiKey: string;
+    apiKey: ApiKey;
     thinkingLevel?: ThinkingLevel;
     contextFiles?: Array<{
         path: string;

package/dist/types/commit/analysis/summary.d.ts

@@ -1,9 +1,9 @@
 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 type { CommitSummary } from "../../commit/types";
 export interface SummaryInput {
     model: Model<Api>;
-    apiKey: string;
+    apiKey: ApiKey;
     thinkingLevel?: ThinkingLevel;
     commitType: string;
     scope: string | null;

package/dist/types/commit/changelog/generate.d.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 * as z from "zod/v4";
 import { type ChangelogGenerationResult } from "../../commit/types";
 export declare const changelogTool: {
@@ -19,7 +19,7 @@ export declare const changelogTool: {
 };
 export interface ChangelogPromptInput {
     model: Model<Api>;
-    apiKey: string;
+    apiKey: ApiKey;
     thinkingLevel?: ThinkingLevel;
     changelogPath: string;
     isPackageChangelog: boolean;

package/dist/types/commit/changelog/index.d.ts

@@ -1,9 +1,9 @@
 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";
 export interface ChangelogFlowInput {
     cwd: string;
     model: Model<Api>;
-    apiKey: string;
+    apiKey: ApiKey;
     thinkingLevel?: ThinkingLevel;
     stagedFiles: string[];
     dryRun: boolean;

package/dist/types/commit/map-reduce/index.d.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 type { ConventionalAnalysis } from "../../commit/types";
 export interface MapReduceSettings {
     enabled?: boolean;
@@ -10,10 +10,10 @@ export interface MapReduceSettings {
 }
 export interface MapReduceInput {
     model: Model<Api>;
-    apiKey: string;
+    apiKey: ApiKey;
     thinkingLevel?: ThinkingLevel;
     smolModel: Model<Api>;
-    smolApiKey: string;
+    smolApiKey: ApiKey;
     smolThinkingLevel?: ThinkingLevel;
     diff: string;
     stat: string;

package/dist/types/commit/map-reduce/map-phase.d.ts

@@ -1,9 +1,9 @@
 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 type { FileDiff, FileObservation } from "../../commit/types";
 export interface MapPhaseInput {
     model: Model<Api>;
-    apiKey: string;
+    apiKey: ApiKey;
     thinkingLevel?: ThinkingLevel;
     files: FileDiff[];
     config?: {

package/dist/types/commit/map-reduce/reduce-phase.d.ts

@@ -1,9 +1,9 @@
 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 type { ConventionalAnalysis, FileObservation } from "../../commit/types";
 export interface ReducePhaseInput {
     model: Model<Api>;
-    apiKey: string;
+    apiKey: ApiKey;
     thinkingLevel?: ThinkingLevel;
     observations: FileObservation[];
     stat: string;

package/dist/types/commit/model-selection.d.ts

@@ -1,15 +1,21 @@
 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 type { ApiKeyResolverRegistry } from "../config/api-key-resolver";
 import { type ModelLookupRegistry } from "../config/model-resolver";
 import type { Settings } from "../config/settings";
 export interface ResolvedCommitModel {
     model: Model<Api>;
-    apiKey: string;
+    /**
+     * Resolver for the model's bearer: re-resolves on 401 / usage-limit so the
+     * whole commit pipeline (analysis, map/reduce, changelog) inherits the
+     * central force-refresh + account-rotation policy.
+     */
+    apiKey: ApiKey;
     thinkingLevel?: ThinkingLevel;
 }
-type CommitModelRegistry = ModelLookupRegistry & {
+type CommitModelRegistry = ModelLookupRegistry & ApiKeyResolverRegistry & {
     getApiKey: (model: Model<Api>) => Promise<string | undefined>;
 };
 export declare function resolvePrimaryModel(override: string | undefined, settings: Settings, modelRegistry: CommitModelRegistry): Promise<ResolvedCommitModel>;
-export declare function resolveSmolModel(settings: Settings, modelRegistry: CommitModelRegistry, fallbackModel: Model<Api>, fallbackApiKey: string): Promise<ResolvedCommitModel>;
+export declare function resolveSmolModel(settings: Settings, modelRegistry: CommitModelRegistry, fallbackModel: Model<Api>, fallbackApiKey: ApiKey): Promise<ResolvedCommitModel>;
 export {};

package/dist/types/config/api-key-resolver.d.ts

@@ -0,0 +1,34 @@
+import type { ApiKeyResolver, AuthStorage } from "@oh-my-pi/pi-ai";
+export interface ApiKeyResolverOptions {
+    /** Session id for credential stickiness; read at resolve time by the caller. */
+    sessionId?: string;
+    /** Provider base URL hint forwarded to the auth-storage cascade. */
+    baseUrl?: string;
+}
+/**
+ * Minimal slice of `ModelRegistry` the resolver needs. Typed structurally so
+ * narrower registry shells (e.g. the commit pipeline's `CommitModelRegistry`)
+ * can build resolvers without depending on the full class.
+ */
+export interface ApiKeyResolverRegistry {
+    getApiKeyForProvider(provider: string, sessionId?: string, options?: {
+        baseUrl?: string;
+        forceRefresh?: boolean;
+        signal?: AbortSignal;
+    }): Promise<string | undefined>;
+    authStorage: Pick<AuthStorage, "rotateSessionCredential">;
+    /**
+     * Build an {@link ApiKeyResolver} implementing the central a/b/c auth-retry
+     * policy: initial → resolve; step (b) → force-refresh same account; step (c)
+     * → rotate to a sibling credential, then re-resolve.
+     *
+     * The resolver is stateless (safe to reuse across requests). Callers that
+     * need the initial key for a guard can call `resolveApiKeyOnce(resolver)`.
+     */
+    resolver(provider: string, options?: ApiKeyResolverOptions): ApiKeyResolver;
+}
+/**
+ * Default implementation of {@link ApiKeyResolverRegistry.resolver}.
+ * Also usable standalone for structural registries that don't carry the method.
+ */
+export declare function createApiKeyResolver(registry: Pick<ApiKeyResolverRegistry, "getApiKeyForProvider" | "authStorage">, provider: string, options?: ApiKeyResolverOptions): ApiKeyResolver;

package/dist/types/config/model-registry.d.ts

@@ -1,9 +1,11 @@
 import { type ModelRefreshStrategy } from "@oh-my-pi/pi-ai/model-manager";
 import type { Api, Context, Model, SimpleStreamOptions, ThinkingConfig } from "@oh-my-pi/pi-ai/types";
 import type { AssistantMessageEventStream } from "@oh-my-pi/pi-ai/utils/event-stream";
+import type { ApiKeyResolver } from "@oh-my-pi/pi-ai";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/utils/oauth/types";
 import { type ThemeColor } from "../modes/theme/theme";
 import type { AuthStorage } from "../session/auth-storage";
+import { type ApiKeyResolverOptions } from "./api-key-resolver";
 import { type ConfigError, ConfigFile } from "./config-file";
 import { type CanonicalModelIndex, type CanonicalModelRecord, type CanonicalModelVariant, type ModelEquivalenceConfig } from "./model-equivalence";
 import { type Settings } from "./settings";
@@ -326,8 +328,22 @@ export declare class ModelRegistry {
     getApiKey(model: Model<Api>, sessionId?: string): Promise<string | undefined>;
     /**
      * Get API key for a provider (e.g., "openai").
+     *
+     * `options.forceRefresh` powers step (b) of the auth-retry policy — it
+     * re-mints the session-sticky OAuth token even when the cached copy still
+     * looks valid. `options.signal` is threaded into any broker-bound refresh.
+     */
+    getApiKeyForProvider(provider: string, sessionId?: string, options?: {
+        baseUrl?: string;
+        forceRefresh?: boolean;
+        signal?: AbortSignal;
+    }): Promise<string | undefined>;
+    /**
+     * Build an {@link ApiKeyResolver} for this provider, implementing the
+     * central a/b/c auth-retry policy. Callers that need the initial key for
+     * a guard can call `resolveApiKeyOnce(resolver)`.
      */
-    getApiKeyForProvider(provider: string, sessionId?: string, baseUrl?: string): Promise<string | undefined>;
+    resolver(provider: string, options?: ApiKeyResolverOptions): ApiKeyResolver;
     /**
      * Check if a model is using OAuth credentials (subscription).
      */

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

@@ -689,6 +689,15 @@ export declare const SETTINGS_SCHEMA: {
             }];
         };
     };
+    readonly "display.smoothStreaming": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly label: "Smooth Streaming";
+            readonly description: "Reveal assistant text smoothly while streamed chunks arrive";
+        };
+    };
     readonly "display.showTokenUsage": {
         readonly type: "boolean";
         readonly default: false;

package/dist/types/dap/config.d.ts

@@ -2,5 +2,18 @@ import type { DapAdapterConfig, DapResolvedAdapter } from "./types";
 export declare function getAdapterConfigs(): Record<string, DapAdapterConfig>;
 export declare function resolveAdapter(adapterName: string, cwd: string): DapResolvedAdapter | null;
 export declare function getAvailableAdapters(cwd: string): DapResolvedAdapter[];
-export declare function selectLaunchAdapter(program: string, cwd: string, adapterName?: string): DapResolvedAdapter | null;
+export declare function selectLaunchAdapter(program: string, cwd: string, adapterName?: string, programKind?: LaunchProgramKind): DapResolvedAdapter | null;
 export declare function selectAttachAdapter(cwd: string, adapterName?: string, port?: number): DapResolvedAdapter | null;
+/** How the launch `program` resolves on disk. `"missing"` is reserved for
+ *  programs the adapter creates on demand (rare); we treat them like files. */
+export type LaunchProgramKind = "file" | "directory" | "missing";
+/** Compute adapter-specific launch arguments that depend on the resolved
+ *  program. Returned values are spread over `adapter.launchDefaults` so they
+ *  take precedence over the static defaults but can still be overridden by
+ *  the fields `DapSessionManager.launch` sets explicitly (program, cwd, args).
+ *
+ *  Currently scoped to dlv, where `mode` selects how the program path is
+ *  interpreted: directories and `.go` source files debug as a Go package
+ *  (`mode=debug`), anything else is treated as a compiled binary (`mode=exec`).
+ */
+export declare function resolveLaunchOverrides(adapter: DapResolvedAdapter, program: string, programKind: LaunchProgramKind): Record<string, unknown>;

package/dist/types/dap/types.d.ts

@@ -422,6 +422,10 @@ export interface DapAdapterConfig {
      *  On Linux, connects via a unix domain socket.
      *  On macOS, the adapter dials into a local TCP listener (--client-addr). */
     connectMode?: "stdio" | "socket";
+    /** When true, the adapter accepts a directory as the launch `program`
+     *  (e.g. dlv treats it as a Go package path). When false/undefined, the
+     *  debug tool rejects directory programs upfront. */
+    acceptsDirectoryProgram?: boolean;
 }
 export interface DapResolvedAdapter {
     name: string;
@@ -434,6 +438,7 @@ export interface DapResolvedAdapter {
     launchDefaults: Record<string, unknown>;
     attachDefaults: Record<string, unknown>;
     connectMode: "stdio" | "socket";
+    acceptsDirectoryProgram: boolean;
 }
 export interface DapBreakpointRecord {
     id?: number;
@@ -514,6 +519,11 @@ export interface DapLaunchSessionOptions {
     program: string;
     args?: string[];
     cwd: string;
+    /** Per-launch overrides merged over `adapter.launchDefaults`. Used to
+     *  inject adapter-specific values that depend on the resolved program
+     *  (e.g. dlv's `mode` switches between `debug` and `exec` based on
+     *  whether `program` is a Go package path or a compiled binary). */
+    extraLaunchArguments?: Record<string, unknown>;
 }
 export interface DapAttachSessionOptions {
     adapter: DapResolvedAdapter;

package/dist/types/lsp/utils.d.ts

@@ -28,9 +28,10 @@ export declare function severityToIcon(severity?: DiagnosticSeverity): string;
  */
 export declare function formatDiagnostic(diagnostic: Diagnostic, filePath: string): string;
 /**
- * Reformat pre-formatted diagnostic messages into grep-style directory/file groups.
+ * Reformat pre-formatted diagnostic messages into a multi-level, prefix-folded
+ * directory/file grouping (see `formatGroupedFiles`).
  * Input:  ["path:line:col [sev] msg", ...]
- * Output: "# dir/\n## file.ts\n  line:col [sev] msg"
+ * Output: "# pkg/src/\n## file.ts\n  line:col [sev] msg"
  *
  * Messages that don't match the expected format are appended ungrouped at the end.
  */

package/dist/types/modes/components/chat-block.d.ts

@@ -0,0 +1,64 @@
+import { Container } from "@oh-my-pi/pi-tui";
+/**
+ * Capabilities a mounted {@link ChatBlock} may use against its host transcript.
+ * Kept minimal so blocks never reach into the full TUI/InteractiveMode surface.
+ */
+export interface ChatBlockHost {
+    /** Schedule a repaint of the transcript. */
+    requestRender(): void;
+}
+/**
+ * Lifecycle-aware transcript block — the "return a block, let the host mount it"
+ * primitive, modelled on React/Svelte component lifecycles.
+ *
+ * Producers build and return a `ChatBlock` instead of poking `chatContainer` and
+ * `ui.requestRender()` directly. The host (`ctx.present`) appends it and calls
+ * {@link mount}, which runs {@link onMount}; effects started there register
+ * teardown via {@link onCleanup}. The block repaints through {@link requestRender}
+ * — never touching the TUI — and tears down exactly once on {@link finish}
+ * (self-complete: stop the animation, keep the final frame in the transcript) or
+ * {@link dispose} (host discards it, e.g. a transcript reset).
+ *
+ * While mounted and unfinished a block reports `isTranscriptBlockFinalized() ===
+ * false` so {@link "../components/transcript-container".TranscriptContainer}
+ * keeps it in the live, repaintable region on ED3-risk terminals; after
+ * `finish()`/`dispose()` it reports `true` and freezes at its final content.
+ */
+export declare abstract class ChatBlock extends Container {
+    #private;
+    /**
+     * Run setup after the block is in the transcript: start timers/subscriptions
+     * and register their teardown with {@link onCleanup}. Default: no-op (a block
+     * whose content is fixed at construction needs no mount work).
+     */
+    protected onMount(): void;
+    /**
+     * Register a teardown to run on {@link finish}/{@link dispose}, à la a
+     * `useEffect` cleanup. If the block is already disposed the cleanup runs
+     * immediately so callers never leak.
+     */
+    protected onCleanup(cleanup: () => void): void;
+    /** Ask the host to repaint. No-op before mount or after dispose. */
+    protected requestRender(): void;
+    /** True between {@link mount} and {@link finish}/{@link dispose}. */
+    protected get active(): boolean;
+    /**
+     * Host-only: attach the host and run {@link onMount}. Idempotent — a second
+     * call (e.g. a transcript rebuild that re-presents the same instance) is a
+     * no-op.
+     */
+    mount(host: ChatBlockHost): void;
+    /**
+     * Self-complete: stop ongoing effects and freeze the block at its current
+     * content, leaving it rendered in the transcript. Use when the operation the
+     * block represents finishes (connection resolved, download done).
+     */
+    finish(): void;
+    /**
+     * Host-only teardown: release everything and propagate to children. Called
+     * when the host permanently discards the block (transcript reset). Idempotent.
+     */
+    dispose(): void;
+    /** Live blocks stay repaintable; finished/disposed ones may freeze. */
+    isTranscriptBlockFinalized(): boolean;
+}

package/dist/types/modes/components/custom-editor.d.ts

@@ -1,6 +1,7 @@
 import { Editor, type KeyId } from "@oh-my-pi/pi-tui";
 import type { AppKeybinding } from "../../config/keybindings";
 type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.display.reset" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.clipboard.pasteImage" | "app.clipboard.pasteTextRaw" | "app.clipboard.copyPrompt">;
+export declare function extractBracketedImagePastePath(data: string): string | undefined;
 /**
  * Custom editor that handles configurable app-level shortcuts for coding-agent.
  */
@@ -29,6 +30,8 @@ export declare class CustomEditor extends Editor {
     onCopyPrompt?: () => void;
     /** Called when the configured image-paste shortcut is pressed. */
     onPasteImage?: () => Promise<boolean>;
+    /** Called when a bracketed paste contains exactly one image-file path. */
+    onPasteImagePath?: (path: string) => void;
     /** Called when the configured raw text-paste shortcut is pressed. */
     onPasteTextRaw?: () => void;
     /** Called when the configured dequeue shortcut is pressed. */

package/dist/types/modes/components/overlay-box.d.ts

@@ -0,0 +1,17 @@
+/** Pad or truncate a (possibly ANSI-styled) string to exactly `width` columns. */
+export declare function fit(text: string, width: number): string;
+/** Top border with an optional accent-colored title inset into the rule. */
+export declare function topBorder(width: number, title: string): string;
+/** A horizontal rule with left/right tees, splitting overlay sections. */
+export declare function divider(width: number): string;
+export declare function bottomBorder(width: number): string;
+/** Wrap pre-styled content in vertical borders with single-column insets. */
+export declare function row(content: string, width: number): string;
+/** Body content width for a two-column overlay of total `width`. */
+export declare function splitBodyWidth(width: number, sidebarWidth: number): number;
+/** Top border carrying the title, split by a `┬` over the column divider. */
+export declare function topBorderSplit(width: number, title: string, sidebarWidth: number): string;
+/** Section rule that closes the sidebar column with a `┴` over the divider. */
+export declare function dividerSplit(width: number, sidebarWidth: number): string;
+/** A two-column content row: `│ sidebar │ body │`, each inset by one column. */
+export declare function splitRow(sidebar: string, body: string, width: number, sidebarWidth: number): string;

package/dist/types/modes/components/plan-review-overlay.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Fullscreen plan-review overlay. The overlay owns its entire content: the plan
+ * is split into sections (preamble + one per heading), each rendered through its
+ * own {@link Markdown} and windowed by a {@link ScrollView}, while the approval
+ * options (plus the optional model-tier slider) sit beneath inside the same
+ * outlined box — one self-contained surface in the spirit of the `/copy` picker.
+ *
+ * When the terminal is wide enough and the plan has ≥2 headings, a Contents
+ * sidebar appears: it tracks the scrolled section with an accent "glow", and —
+ * when focused — lets the operator jump between sections, delete a section
+ * (with undo), and annotate sections with feedback that feeds the Refine loop.
+ *
+ * Focus regions (`toc`/`body`/`actions`) cycle with Tab/Shift+Tab; arrows move
+ * within the focused region and step left into the sidebar. The default focus is
+ * `actions`, so the muscle memory of the old single-target overlay carries over:
+ * ↑/↓ select options, Enter confirms, ←/→ drives the slider when there is no
+ * sidebar, g/G + PgUp/PgDn scroll, and the external-editor key opens the plan.
+ */
+import { type Component } from "@oh-my-pi/pi-tui";
+import type { HookSelectorSlider } from "./hook-selector";
+export interface PlanReviewOverlayCallbacks {
+    /** Invoked with the chosen option label (never a disabled one). */
+    onPick: (label: string) => void;
+    /** Invoked on Esc / cancel. */
+    onCancel: () => void;
+    /** Invoked when the external-editor key is pressed (overlay stays open). */
+    onExternalEditor?: () => void;
+    /** Invoked with the new full plan text after an in-overlay delete/undo. */
+    onPlanEdited?: (content: string) => void;
+    /** Invoked with the Refine feedback markdown whenever annotations change. */
+    onFeedbackChange?: (feedback: string) => void;
+}
+export interface PlanReviewOverlayOptions {
+    /** Prompt rendered above the options (e.g. "Plan mode - next step"). */
+    promptTitle?: string;
+    options: string[];
+    /** Indices into `options` that render dimmed and cannot be selected. */
+    disabledIndices?: number[];
+    /** Trailing footer hint (cancel hint); the overlay prepends dynamic help. */
+    helpText?: string;
+    /** Initially highlighted option index. */
+    initialIndex?: number;
+    /** Optional model-tier slider rendered between the plan body and options. */
+    slider?: HookSelectorSlider;
+    /** Display label for the external-editor key, surfaced in the footer help. */
+    externalEditorLabel?: string;
+}
+export declare class PlanReviewOverlay implements Component {
+    #private;
+    private readonly callbacks;
+    constructor(planContent: string, options: PlanReviewOverlayOptions, callbacks: PlanReviewOverlayCallbacks);
+    invalidate(): void;
+    /** Swap the displayed plan (e.g. after an external-editor round-trip) and
+     *  reset scroll/focus so the operator starts at the top. Does not emit
+     *  `onPlanEdited` (the editor round-trip already persisted the file). */
+    setPlanContent(planContent: string): void;
+    handleInput(keyData: string): void;
+    render(width: number): string[];
+}