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

package/CHANGELOG.md

@@ -2,6 +2,118 @@
 
 ## [Unreleased]
 
+## [15.10.3] - 2026-06-08
+
+### Added
+
+- Added clickable file path hyperlinks to read tool outputs (read-call rows, grouped summaries, and inline previews) using resolved or absolute file targets with selector-based line anchors for quick navigation
+- Added a resolved-span echo to `replace block`/`delete block` edits: a successful block op now prints `replace block N → resolved lines A-B (K lines)` between the section header and the diff preview, so the model can confirm tree-sitter matched the construct it intended (e.g. catch a decorator left outside the block) instead of inferring the span from the diff after the fact.
+
+### Changed
+
+- Changed the `find` tool to process each explicit multi-path target separately before merging results so searches stay scoped to the requested paths
+- Changed multi-path `find` handling so invalid extra targets no longer fail the whole query and now return matches from valid targets only
+- Changed background-job completion and late LSP diagnostic delivery to inject at the next agent step boundary (mid-run), via the new non-interrupting "aside" channel, instead of only when the agent reaches a yield/follow-up point. The model now sees these notifications between its own requests without the turn having to end first, and in-flight tools are never interrupted; `job`-poll acknowledgement still suppresses results the agent already saw.
+- Changed late LSP diagnostics after edit or write to surface in the chat transcript as `Late diagnostics` entries rendered through the same grouped tree renderer the `edit`/`write` tools use (per-file nodes, severity icons, `:line:col` locations), and to honor the global tool-output expand toggle (collapsed entries cap at 5 diagnostics with a `… N more` hint)
+- Changed delayed diagnostics delivery to batch late results in one message per flush instead of a raw hidden custom payload
+- Changed hidden custom messages and file-mention context to reach providers as `developer` messages instead of user-authored turns, so system reminders no longer pollute compacted user history.
+- Rewrote the plan-mode active prompt (`prompts/system/plan-mode-active.md`) from scratch to stop producing shallow plans. Reframed the artifact as an **execution spec** a fresh agent runs after the planning conversation is cleared/compacted (zero design decisions for the implementer) rather than a brevity-capped summary. Folded high-consensus requirements into the existing sections as inline, conditional rules — no new boilerplate sections: ordered Approach steps that keep the build/tests green after each step (sequencing); exact signatures/literals for new or load-bearing symbols (contracts); full callsite list + clean cutover for renames/signature-changes/removals; Verification that must exercise the new behavior (input → observable output) with run preconditions, not just build/typecheck; Assumptions restricted to user-overridable choices plus pre-decided fallbacks for load-bearing assumptions; a provenance rule (plan facts must come from a read this session; unverified claims flagged inline); and bans on conversation back-references and decision-free sections (Non-Goals/Alternatives/Risks/Future Work). Kept the decision-complete self-check and the brevity-vs-completeness tiebreak (completeness wins). Render contract (Handlebars vars/conditionals) unchanged; verified across all `planExists`/`reentry`/`iterative` branch combinations.
+
+### Fixed
+
+- Fixed duplicate `find` matches in multi-target queries by deduplicating overlapping paths in merged results
+- Fixed `find` partial updates to avoid repeated streamed rows while scans are still running
+- Fixed stale late diagnostics from older edits being shown after a file was edited again
+- Fixed read output paths so selector suffixes are preserved when corrected paths were returned without selectors
+- Fixed `read` surfacing a misleading red "Operation aborted" on a plain-file or directory read when a turn was interrupted mid-read. Those reads are deterministic and fast, so `execute` now runs them to completion instead of cancelling them; slower/non-deterministic reads (archive, sqlite, document, image, summary, conflict scan, URL) stay cancellable.
+- Fixed edit tool headers to hide first-change line suffixes, middle-elide long paths only when the header width needs it, show compact change stats, and target encoded `file://` hyperlinks.
+- Fixed Esc interrupts rendering a redundant `Interrupted by user` assistant transcript line while preserving the interrupt reason for tool-result placeholders and continuation logic.
+- LSP writethrough no longer burns the full diagnostics poll on every edit/write. `typescript-language-server` never echoes the document version in `publishDiagnostics` ([upstream #983](https://github.com/typescript-language-server/typescript-language-server/issues/983)), so the exact-version gate never passed; `waitForDiagnostics` now accepts an exact version match instantly and otherwise settles on the latest publish after a short quiescence window, dropping superseded in-flight diagnostics.
+- LSP writethrough no longer blocks the whole edit/write on slow diagnostics: it now waits only a short inline window (~500ms) for a settled result, then hands the in-flight fetch to the deferred channel so a slow or cold language server (e.g. a large-project `tsserver`) delivers its diagnostics as a follow-up message instead of stalling the tool 3–5s on every edit. The background fetch also gets a longer budget so slow servers still surface late rather than being dropped.
+- Fixed the `c`/`.` continue shortcut making the agent second-guess itself after an Esc interrupt. Continuing used to submit an *empty* user turn, which left the model with only the aborted-turn context — so it tended to restate the halted state and ask whether to proceed rather than just continuing. The shortcut now resumes with a hidden agent-authored `developer` directive ("keep going — don't stop to summarize or re-confirm the plan") instead of an empty turn. It still produces no visible transcript entry, same as before.
+- Fixed native scrollback commit boundaries to be computed generically from finalized transcript blocks and observed append-only live growth, so tall final tool results and streaming previews keep their scrolled-off heads on ED3-risk terminals without per-tool append-only predicates; live blocks that re-layout remain deferred until finalization or the next checkpoint.
+- Fixed read-group summaries for multi-path `read` results to use result-provided display targets so each resolved path is shown as its own row
+- Fixed read-group range summaries to abbreviate long merged selectors with ellipsis to keep repeated-file range rows readable
+- Fixed read-group TUI summaries so a single delimited `read` call renders as separate read rows, and repeated reads of the same file collapse under one file with full-file/range children.
+- Fixed grouped `read` rows freezing on their pending "⏳ Read <path>" preview on ED3-risk terminals (ghostty/kitty/iTerm2/…) when a parallel sibling tool closed the read run and appended a block below the group before the read's result arrived. The read-group block now stays in the repaintable live region until its entries settle, so the late success result repaints instead of being stranded; a `seal()` escape hatch (turn end / transcript rebuild) still lets a never-delivered read freeze rather than pinning the live region.
+- Fixed session search to return all sessions unchanged when the query is blank
+- Fixed duplicate session suggestions by deduplicating history matches by session path when merging metadata and prompt-history results
+- Fixed `/resume` search ranking so sessions whose prompts or metadata match the query now prefer prompt recency and recent literal matches instead of letting older earlier-title fuzzy matches outrank a just-used session.
+- Fixed `omp --resume <id>` / `--fork <id>` crashing with `[Uncaught Exception]` when the id did not match a known session. `createSessionManager` now throws a dedicated `SessionResolutionError`, which `runRootCommand` catches to print `Error: Session "..." not found.` plus a hint to stderr and exit with code 1. The same path covers `--fork` combined with `--no-session` and the non-interactive cross-project / moved-cwd prompts that previously surfaced raw stack traces ([#2084](https://github.com/can1357/oh-my-pi/issues/2084)).
+
+### Removed
+
+- Removed the animated pending border ("shimmer") on running `bash`, `eval`, and `ssh` execution blocks. While pending, a block now shows a static accent border instead of sweeping a dark segment around its bottom edge; `display.shimmer` still governs the working-status line and `task` row animations.
+- Removed the tool-level `nonAbortable` bypass so `write` and `edit` honor the active turn `AbortSignal`. `read` is abortable for everything that is slow or non-deterministic (URL/internal-URL reads, archive, sqlite, document conversion, image decode, structural summary, conflict scan, suffix glob); only the deterministic plain-file line/range reads and directory listings run to completion.
+
+## [15.10.2] - 2026-06-08
+
+### Added
+
+- Added `raw-sse.txt` to debug report bundles, exporting recent raw provider SSE diagnostics when captured
+- Added `/model` visibility for auto-selected role defaults: inferred `pi/smol`/`pi/slow`/designer choices now show as compact `[ROLE auto]` badges, while explicitly configured roles keep the existing solid badges and thinking labels.
+- Added credential provenance to the `/login` and `/logout` provider picker: each authenticated provider now shows where its credential comes from — `(login)`, `(api key)`, `(env: VAR_NAME)`, `(config)`, `(--api-key)`, or `(custom provider)` — so a real OAuth login is distinguishable from an env var that merely aliases the provider (e.g. `COPILOT_GITHUB_TOKEN`). The origin is also matched by the picker's type-to-search filter.
+
+### Changed
+
+- Changed raw SSE debug export output to prepend dropped-record metadata so truncated sessions in debug bundles now report dropped record and character counts
+- Changed settings reads to cache pre-split schema paths and resolved values, with coarse invalidation on source/cwd changes.
+- Changed status-line rendering to cache merged effective settings until `updateSettings()` changes the configuration.
+- Changed `CustomEditor` app shortcut dispatch to parse each input packet once and match against precomputed canonical key sets, preserving the existing shortcut precedence while avoiding repeated key reparses.
+- Changed `lsp references` to retry only when no references or only the queried declaration are returned, using two fixed 250ms retries for project-aware servers
+- Changed `read` handling of `https://github.com/<owner>/<repo>:raw` to use raw page rendering only, removing the GitHub API README fallback
+- Changed model resolution to apply provider-priority ordering when selecting models for roles and ambiguous patterns, using `modelProviderOrder` settings and built-in provider priority so first-party providers are preferred over relays in tie cases
+- Changed model canonical variant selection to use the same provider-priority ordering instead of candidate order when deduplicating equivalent upstream models
+- Changed the working-message shimmer to sweep at a fixed velocity (cells/second) instead of a fixed sweep duration divided by the message length. The band now advances ≤1 cell per 30fps redraw frame and stays equally smooth on short and long messages — previously a longer message swept proportionally faster and stepped visibly because it outran the redraw cadence. Sweep/round-trip duration now scales with length. Additionally, when `display.shimmer = disabled` the working line is static, so the loader no longer schedules 30fps redraws for it and falls back to the spinner-only ~12.5fps cadence.
+- Changed the eval fan-out trigger keyword from `workflow`/`workflows` to `workflowz`.
+
+### Fixed
+
+- Fixed working-message loader session accents so spinner/message color math is cached per session name, session-accent setting, and theme luminance while still updating immediately on renames, setting toggles, and theme changes.
+- Fixed startup model fallback selection so sessions now prefer each provider’s configured default model before choosing the first available authenticated model
+- Fixed implicit model selection path for tools and sessions by honoring persisted model-provider order when no explicit pattern is provided
+- Fixed the working spinner appearing to ignore Esc for 2-3 seconds when an interrupt lands mid-tool. Esc fires the abort synchronously, but the agent loop only stops the loader at `agent_end`, which it cannot reach until every in-flight tool settles in `executeToolCalls`' `await Promise.allSettled(...)` — and process/subagent/kernel-owning tools tear down gracefully (SIGTERM, 2-3s grace, SIGKILL), so the loader kept showing the unchanged "Working…/<intent>" line and read as a dropped keypress. The loader now switches to "Interrupting…" the instant Esc requests the abort and freezes intent-driven label updates until the turn unwinds (`EventController.notifyInterrupting`), so the interrupt is acknowledged immediately even while teardown completes.
+- Fixed a flaky JS eval worker startup that intermittently failed unrelated CI runs. The worker-ready wait reused Bun's 5s default per-test timeout as its floor, so a slow cold-start under `--isolate` + high concurrency was aborted mid-init; terminating a still-initializing Bun worker is the documented SIGILL/SIGTRAP crash trigger, which took down the whole test file. Worker init now floors at a fixed 15s infrastructure budget (independent of, and still dominated by, a larger per-cell `timeout`), and the JS eval test suites set a 20s file-local timeout so cold starts complete instead of being torn down.
+- Fixed reviewer-style subagent yields crashing the calling eval cell when a caller-supplied output schema declares `additionalProperties: false` without a `findings` property. `normalizeCompleteData` now consults the active validator before splicing collected `report_finding` entries onto the yielded payload, so injection is suppressed when the schema would reject it — keeping the executor's post-mortem validation in lockstep with the in-tool `yield` validation that already accepted the same raw payload ([#2070](https://github.com/can1357/oh-my-pi/issues/2070))
+- Fixed Anthropic empty `toolUse` stops without tool calls corrupting session history by retrying them and removing orphaned turns even at the retry cap.
+- Fixed MCP tools hanging in non-yolo modes by declaring `approval = "write"` on `MCPTool` and `DeferredMCPTool`, and propagating the `approval` property through `customToolToDefinition()` in `sdk.ts`
+- Fixed session resumption after a working directory is moved/renamed (e.g. `git worktree move`): `--continue` now re-roots the terminal's last session into the new directory when its original directory no longer exists, explicit `--resume <id> --session-dir <dir>` local matches re-root instead of reopening with the stale cwd, and cross-project `--resume <id>` offers to move (re-root) the session rather than only forking a duplicate copy when the source directory is gone
+- Fixed Kitty OSC 5522 paste rejecting plain text as "no supported text or image data": the listing parser now decodes the `mime="."` DATA payload (whitespace-separated MIME list) Kitty actually sends, in addition to the per-type DATA packets described by the ancillary 5522-mode spec, and per-type spec listings now request the selected payload with `type=read:mime=...` instead of Kitty's dot-payload request shape ([#2051](https://github.com/can1357/oh-my-pi/issues/2051))
+- Fixed follow-up shortcut submission of builtin slash commands so `/goal set ...` applies goal mode instead of queueing as plain text.
+- Fixed Ctrl+Z crashing the agent on Windows with `TypeError: Unknown signal: SIGTSTP`. `InputController.handleCtrlZ` called `process.kill(0, "SIGTSTP")` unconditionally, but `SIGTSTP` is POSIX job-control and Bun/Node on Windows rejects the signal name from the JS side; the throw propagated out of the TUI input dispatcher as an uncaught exception. The handler now no-ops with a "Suspend (Ctrl+Z) is not supported on this platform" status on Windows, and on POSIX wraps `process.kill` in a try/catch that detaches the registered SIGCONT resume hook and re-`start()`s the TUI on failure so a rejected signal can never leave the UI stranded with a leaked listener ([#2036](https://github.com/can1357/oh-my-pi/issues/2036)).
+- Fixed a relative `--cwd` target (e.g. `omp --cwd repo` launched from `/tmp`) leaking the raw relative string into the session config. `applyStartupCwd` chdired into the resolved directory via `setProjectDir` but left `parsed.cwd` as `"repo"`, so `buildSessionOptions` (which prefers `parsed.cwd` over `getProjectDir()`) handed downstream settings/discovery/session creation a value that re-resolved against the new process cwd (`/tmp/repo/repo`) or persisted a relative session cwd. `parsed.cwd` is now re-synced to the resolved absolute project dir after the chdir.
+- Fixed the `--cwd` launch flag so it is parsed and can override the startup directory instead of always falling back to the current process directory or home auto-switch target.
+- Fixed session auto-retry for generic `upstream_error: Upstream request failed` gateway failures.
+- Stripped read-output line-number prefixes (`N:`) from auto-piped bare body rows in the hashline edit parser, so pasting `3:text` without a `+` prefix no longer injects `3:` as literal content. Uses single-pass stripping to avoid corrupting content whose own text starts with `digits:` ([#1492](https://github.com/can1357/oh-my-pi/issues/1492)).
+- Fixed `eval` `llm()` returning HTTP 400 "Instructions are required" when called without a `system` prompt against providers (notably `openai-codex`) whose Responses transformer drops the `instructions` field on an empty system prompt. `runEvalLlm` now sends a minimal default system prompt ("You are a helpful assistant.") when no `system` is supplied, so `llm("question")` works against every provider; an explicit `system=` still wins.
+- Fixed the Python `read(path, offset, limit)` prelude helper rejecting documented positional arguments with `TypeError: read() takes 1 positional argument but 3 were given`. The signature was keyword-only (`def read(path, *, offset=1, limit=None)`) while the eval helper table advertises positional optional args; agents that called `read("file.py", 10, 20)` literally crashed. The `*` is removed so both `read("f", 10, 20)` and `read("f", offset=10, limit=20)` work.
+- Fixed `eval` reset cells failing with `"Python kernel reset already in progress"` / `"JS context reset already in progress"` when two cells happened to overlap on the same session (e.g. a rapid resubmit, or a parallel-cell race). The executor now coalesces concurrent resets — additional callers wait for the in-flight reset to finish and then run on the freshly restarted kernel — instead of throwing a user-visible error for what is purely an internal coordination state.
+- Fixed the `eval` tool description advertising the `agent()` helper unconditionally even in subagent sessions whose parent forbids spawning. When `getSessionSpawns()` returns `""`, the prelude doc now omits `agent()` so the model is not promised a helper that can only ever throw "Cannot spawn 'task'. Allowed: none (spawns disabled for this agent)".
+- Fixed plan mode rejecting `local://` plan-artifact edits when addressed via the absolute path the `read` tool echoes back in the `[path#tag]` header. `enforcePlanModeWrite` previously only matched the literal `local://` scheme; it now also accepts any absolute path whose realpath resolves inside the session's local sandbox root, so the absolute spelling and the `local://` spelling are interchangeable in plan mode.
+- Fixed snapshot tags freshly minted by `read` being rejected as stale by a subsequent `edit` against the same file when the two sides reached the file via symlink-equivalent spellings (e.g. macOS `/tmp/…` vs `/private/tmp/…`, or `read local://foo.md` recording under the file's `fs.realpath` while `edit local://foo.md` looked up under the raw `path.resolve(localRoot, …)` form). The file snapshot store now keys every record/lookup through a `realpath`-canonicalized key (`canonicalSnapshotKey`), fusing all spellings of the same on-disk file onto one snapshot entry.
+- Fixed `read` of a `github.com/<owner>/<repo>` URL with `:raw` returning the full JS-rendered HTML shell. Repo roots now resolve to the decoded README via the GitHub API (`/repos/<owner>/<repo>/readme`), falling back to the raw HTML only when the API returns no usable payload.
+- Fixed `issue://` and `pr://` reads returning stale OPEN/CLOSED state after a successful `gh issue close` / `gh pr merge` (or any other state-changing `gh` invocation) in the same session. The `bash` tool now invalidates the matching `github-cache` rows before executing any `gh (issue|pr) <close|reopen|merge|delete|edit|comment|lock|unlock|pin|unpin|transfer|develop|ready|review>` command.
+- Fixed line-range selectors on PDF/DOCX/PPTX/XLSX/RTF/EPUB reads being ignored. The markit-converted markdown body now flows through the same in-memory range slicer used for plain text, so `file.pdf:50-100` and `file.pdf:5-16,40-80` slice the converted body instead of returning the whole document.
+- Fixed the `read` selector cheatsheet incorrectly promising "exactly one line" for `:N+1` while the implementation pads single-line reads with ≤1 leading and ≤3 trailing context; documented that multi-range selectors do not pad, giving callers a way to request exact bounds.
+- Documented the `bash.autoBackground.enabled` behavior in the `bash` tool prompt so the `Background job <id> started: …` notice for foreground commands that exceed `autoBackgroundThresholdSeconds` no longer reads as a tool malfunction.
+- Fixed `task` subagents whose in-tool `yield` validator had already accepted a payload after exhausting `MAX_SCHEMA_RETRIES` being rejected a second time by the post-mortem executor validator. The override now propagates through the yield tool's `details.schemaOverridden` flag, and the executor surfaces a `SUBAGENT_WARNING_SCHEMA_OVERRIDDEN` stderr line instead of re-emitting `schema_violation` for data the subagent already had to ship. Finalize also degrades to no validation (matching the yield tool's `looseRecordSchema` fallback) when the caller-supplied output schema fails to normalize.
+- Fixed the `web_search` `codex` provider returning `(see attached image)` / `[Attached image]` / `See image above` and similar non-informational image-placeholder strings as the answer. Detection broadened to a small regex set, and when annotations did produce sources we now drop the placeholder prose from `answer` (returning sources only); when neither annotations nor a real answer materialize, we throw 502 to advance the provider chain.
+- Fixed `search`, `find`, `ast_grep`, and `ast_edit` rejecting bracket-containing file paths (Next.js routes like `apps/[id]/page.tsx`) as glob patterns when the literal path exists on disk. `parseSearchPathPreferringLiteral` now prefers the literal interpretation for paths that resolve on disk and only falls back to glob expansion when the literal does not exist.
+- Fixed `search` with an external `http(s)/ftp/ws/file://` URL in `paths` surfacing a misleading "Path not found" error. The tool now rejects external URLs with a clear "use `read` for URLs" message.
+- Fixed `search` rejecting `skip: null` at the schema layer; `null` now normalizes to `0` alongside the omitted case, matching how callers serialize default pagination state.
+- Fixed `search` returning zero matches with no explanation when explicit file targets exceed the native grep cap (4 MB). The tool now surfaces a `Skipped oversized files (>4MB grep limit; …)` notice listing the truncated paths.
+- Fixed the archive-extraction error message in `search` recommending `grep` — which the system prompt forbids — instead of pointing to `read <archive>:<member>`.
+- Fixed `browser` `tab.open(name, { viewport })` on an existing tab not applying the new viewport: `acquireTab`'s reuse path now resizes the page in addition to navigating.
+- Fixed `browser` tab metadata leaking `user:pass@` basic-auth credentials in the URL surfaced to transcripts and observe snapshots; URLs are now redacted via `redactUrlCredentials()`.
+- Fixed `browser` `tab.extract(format)` returning a `ReadableResult | null` shape that the tool prompt advertised as plain content. The helper now returns the markdown/text string directly (or throws a clear `ToolError` when extraction is empty), and the prompt matches.
+- Fixed `lsp` requests timing out at a hard-coded 30 s ceiling when the caller supplied an explicit abort signal (e.g. the tool wall-clock). The signal is now the deadline; the 30 s default still applies when neither a signal nor an explicit `timeoutMs` is provided.
+- Fixed `lsp status` reporting servers as `Active language servers: …` when the binary resolves on PATH but never spawns (rustup wrapper, missing toolchain component, etc.). Status now labels each entry as `(ready)` or `(configured, not started)`.
+- Fixed `lsp rename_file` fanning `willRenameFiles` requests across every configured server (including ones with no jurisdiction over the file type) and burning the wall-clock timeout. The action now pre-filters configured LSPs to those whose `fileTypes` cover the source or destination path, falling back to a plain filesystem rename when no server claims the type.
+- Fixed `lsp references` returning only the queried declaration (or only in-file results) on project-aware servers that had not finished indexing. The retry budget is raised from 2 → 3 with 250 / 500 / 1000 ms backoff, and the retry trigger now also fires when all results live in the queried file.
+- Fixed `lsp config` accepting `fileTypes` entries with or without a leading dot inconsistently across actions; both `.ts` and `ts` are now normalized so a missing-dot entry no longer silently excludes a server from extension-based routing.
+- Fixed `lsp request` error path swallowing the params that were sent, making shape/coercion bugs on raw LSP calls impossible to diagnose in one round-trip; the error now echoes a truncated copy of the request params.
+- Fixed `find` with a single-star segment like `dir/*` recursing into subdirectories and returning nested matches. `parseFindPattern` already prepends `**/` for top-level globs (`*.ts` → `**/*.ts`), so anything reaching native without `**/` was deliberately scoped by the user; `recursive: false` is now passed to `natives.glob` to honor that scope.
+
 ## [15.10.1] - 2026-06-07
 
 ### Added
@@ -9570,4 +9682,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/gallery-fixtures/types.d.ts

@@ -14,14 +14,20 @@ export interface GalleryResult {
     details?: unknown;
     isError?: boolean;
 }
+export type GalleryFixtureState = "streaming" | "progress" | "success" | "error";
 export interface GalleryFixture {
     /** Display label for the tool header (defaults to the tool name). */
     label?: string;
     /** Edit mode for edit-like tools so the streaming preview dispatches correctly. */
     editMode?: EditMode;
+    /**
+     * Custom gallery-only renderer for fixtures that are not one ToolExecutionComponent
+     * (for example the read-group transcript component).
+     */
+    renderState?: (state: GalleryFixtureState, width: number, expanded: boolean) => string[] | Promise<string[]>;
     /**
      * Set for tools whose real `AgentTool` attaches `renderCall`/`renderResult`
-     * directly on the instance (e.g. `lsp`, `task`). The harness then attaches
+     * directly on the instance (e.g. `task`). The harness then attaches
      * the registry renderer onto the fake tool so the component routes through
      * the custom-tool branch — the same path production takes — instead of the
      * built-in registry branch. The two branches can diverge, so exercising the

package/dist/types/cli/startup-cwd.d.ts

@@ -0,0 +1,2 @@
+import type { Args } from "./args";
+export declare function applyStartupCwd(parsed: Args): Promise<void>;

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

@@ -40,6 +40,9 @@ export default class Index extends Command {
         "allow-home": import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
             description: string;
         };
+        cwd: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
         mode: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
             description: string;
             options: string[];

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

@@ -109,11 +109,11 @@ export declare const KEYBINDINGS: {
         readonly description: "Delete character forward";
     };
     readonly "tui.editor.deleteWordBackward": {
-        readonly defaultKeys: ["ctrl+w", "alt+backspace", "ctrl+backspace"];
+        readonly defaultKeys: ["ctrl+w", "alt+backspace", "ctrl+backspace", "super+alt+backspace"];
         readonly description: "Delete word backward";
     };
     readonly "tui.editor.deleteWordForward": {
-        readonly defaultKeys: ["alt+delete", "alt+d"];
+        readonly defaultKeys: ["alt+delete", "alt+d", "super+alt+delete", "super+alt+d"];
         readonly description: "Delete word forward";
     };
     readonly "tui.editor.deleteToLineStart": {

package/dist/types/config/model-provider-priority.d.ts

@@ -0,0 +1 @@
+export declare function buildModelProviderPriorityRank(configuredProviderOrder?: readonly string[]): Map<string, number>;

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

@@ -30,7 +30,9 @@ export declare function resolveProviderModelReference(provider: string, modelId:
 export interface ModelMatchPreferences {
     /** Most-recently-used model keys (provider/modelId) to prefer when ambiguous. */
     usageOrder?: string[];
-    /** Providers to deprioritize when no recent usage is available. */
+    /** Provider precedence used for ambiguous unqualified model patterns. */
+    providerOrder?: readonly string[];
+    /** Providers to deprioritize when no recent usage or provider priority is available. */
     deprioritizeProviders?: string[];
 }
 export type CanonicalModelRegistry = Partial<Pick<ModelRegistry, "resolveCanonicalModel" | "getCanonicalVariants" | "getCanonicalId">>;
@@ -38,6 +40,7 @@ export type ModelLookupRegistry = Pick<ModelRegistry, "getAvailable"> & Partial<
 type CliModelRegistry = Pick<ModelRegistry, "getAll"> & Partial<CanonicalModelRegistry>;
 type InitialModelRegistry = Pick<ModelRegistry, "getAvailable" | "find">;
 type RestorableModelRegistry = Pick<ModelRegistry, "getAvailable" | "find" | "getApiKey">;
+export declare function getModelMatchPreferences(settings?: Partial<Pick<Settings, "get" | "getStorage">>): ModelMatchPreferences;
 /**
  * Find an exact explicit provider/model match.
  * Bare model ids are handled separately so canonical ids can coalesce variants.

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

@@ -131,7 +131,12 @@ export declare class Settings {
  * Returns an unsubscribe function. Multiple sessions (main + subagents)
  * can register independently without overwriting each other.
  */
-export declare function onAppendOnlyModeChanged(cb: (value: string) => void): () => void;
+export declare const onAppendOnlyModeChanged: (cb: (value: string) => void) => () => void;
+/**
+ * Subscribe to session-accent setting changes.
+ * Returns an unsubscribe function. Callers should re-read settings in the callback.
+ */
+export declare const onStatusLineSessionAccentChanged: (cb: () => void) => () => void;
 /**
  * Subscribe to changes in the Hindsight bank-scoping settings. Lets the
  * Hindsight backend rebuild the active `HindsightSessionState` when the
@@ -142,7 +147,7 @@ export declare function onAppendOnlyModeChanged(cb: (value: string) => void): ()
  * Returns an unsubscribe function. The callback receives no arguments — the
  * caller is expected to re-read the relevant settings via `Settings.get`.
  */
-export declare function onHindsightScopeChanged(cb: () => void): () => void;
+export declare const onHindsightScopeChanged: (cb: () => void) => () => void;
 export declare function isSettingsInitialized(): boolean;
 /**
  * Reset the global singleton for testing.

package/dist/types/debug/report-bundle.d.ts

@@ -11,6 +11,8 @@ export interface ReportBundleOptions {
     heapSnapshot?: HeapSnapshot;
     /** Work profile (for work scheduling reports) */
     workProfile?: WorkProfile;
+    /** Raw provider SSE diagnostics captured by the session buffer */
+    rawSseText?: string;
 }
 export interface ReportBundleResult {
     path: string;
@@ -33,6 +35,7 @@ export interface DebugLogSource {
  * - env.json: Sanitized environment variables
  * - config.json: Resolved settings
  * - profile.cpuprofile: CPU profile (performance report only)
+ * - raw-sse.txt: Recent raw provider SSE diagnostics (when captured)
  * - profile.md: Markdown CPU profile (performance report only)
  * - heap.heapsnapshot: Heap snapshot (memory report only)
  * - work.folded: Work profile folded stacks (work report only)

package/dist/types/edit/file-snapshot-store.d.ts

@@ -1,13 +1,3 @@
-/**
- * Session-bound file snapshot store.
- *
- * Used by `read` and `search` to record exactly what the model saw, and by
- * the hashline patcher to verify or recover from stale section tags (file
- * changed externally between read and edit, or a prior in-session edit
- * advanced the tag). The store is the {@link InMemorySnapshotStore}
- * from `@oh-my-pi/hashline`; the only coding-agent-specific concern here
- * is wiring it onto the per-session owner object.
- */
 import { InMemorySnapshotStore } from "@oh-my-pi/hashline";
 /**
  * Upper bound on the file size we snapshot. A section tag is a content hash of
@@ -25,6 +15,24 @@ interface FileSnapshotStoreOwner {
  * the session itself.
  */
 export declare function getFileSnapshotStore(session: FileSnapshotStoreOwner): InMemorySnapshotStore;
+/**
+ * Canonicalize an absolute path into the stable key the snapshot store uses.
+ *
+ * Different code paths reach the snapshot store via different path forms:
+ * `read local://foo.md` records under the file's `fs.realpath` (the local
+ * protocol handler resolves symlinks); a subsequent `edit` may address the
+ * same artifact via `local://foo.md`, whose resolver does NOT realpath, or
+ * via the absolute path returned in the `[path#tag]` header. macOS adds the
+ * same hazard at the working-tree level (`/tmp/...` vs `/private/tmp/...`).
+ * Collapsing every key through `realpath` makes those forms fuse onto one
+ * snapshot entry, so a freshly-minted tag is never rejected as stale just
+ * because the lookup spelled the same file differently.
+ *
+ * Non-existent paths (new-file writes) fall back to a realpath of the parent
+ * directory + basename, then to the input. This keeps creates and updates on
+ * the same canonical key.
+ */
+export declare function canonicalSnapshotKey(absolutePath: string): string;
 /**
  * Read the full text of `absolutePath` (within {@link SNAPSHOT_MAX_BYTES}),
  * record it as a version snapshot, and return its content-hash tag. Returns

package/dist/types/edit/index.d.ts

@@ -28,7 +28,6 @@ export declare class EditTool implements AgentTool<TInput> {
     readonly name = "edit";
     readonly label = "Edit";
     readonly loadMode = "essential";
-    readonly nonAbortable = true;
     readonly concurrency = "exclusive";
     readonly strict = true;
     constructor(session: ToolSession);

package/dist/types/eval/py/__tests__/prelude.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/extensibility/extensions/types.d.ts

@@ -7,7 +7,7 @@
  * - Register commands, keyboard shortcuts, and CLI flags
  * - Interact with the user via UI primitives
  */
-import type { AgentMessage, AgentToolResult, AgentToolUpdateCallback, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { AgentMessage, AgentToolResult, AgentToolUpdateCallback, ThinkingLevel, ToolApproval } from "@oh-my-pi/pi-agent-core";
 import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type { Api, AssistantMessageEvent, AssistantMessageEventStream, Context, ImageContent, Model, ProviderResponseMetadata, SimpleStreamOptions, Static, TextContent, TSchema } from "@oh-my-pi/pi-ai";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/utils/oauth/types";
@@ -270,6 +270,9 @@ export interface ToolDefinition<TParams extends TSchema = TSchema, TDetails = un
     defaultInactive?: boolean;
     /** If true, tool may stage deferred changes that require explicit resolve/discard. */
     deferrable?: boolean;
+    /** Tool approval tier. Defaults to `"exec"` when omitted.
+     *  `"read"`: read-only operations. `"write"`: mutations. `"exec"`: code execution. */
+    approval?: ToolApproval;
     /** MCP server name for discovery/search metadata when this tool fronts an MCP server. */
     mcpServerName?: string;
     /** Original MCP tool name for discovery/search metadata. */

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

@@ -45,6 +45,16 @@ export declare function refreshFile(client: LspClient, filePath: string, signal?
 export declare function shutdownClient(key: string): Promise<void>;
 /**
  * Send an LSP request and wait for response.
+ *
+ * Timeout policy:
+ * - If `timeoutMs` is explicitly provided, that value is used.
+ * - Else, if `signal` is provided, no internal timer is installed (the caller
+ *   owns the deadline via the signal — typically a wall-clock `AbortSignal.timeout`
+ *   from the LSP tool). Installing a second hard-coded 30s timer here used to
+ *   cause "timed out after 30000ms" errors even when the caller had requested
+ *   `timeout: 60`.
+ * - Else (no signal, no explicit timeout), fall back to `DEFAULT_REQUEST_TIMEOUT_MS`
+ *   to avoid leaking pending requests forever.
  */
 export declare function sendRequest(client: LspClient, method: string, params: unknown, signal?: AbortSignal, timeoutMs?: number): Promise<unknown>;
 /**

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

@@ -3,7 +3,6 @@ import type { BunFile } from "bun";
 import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from "../tools";
 import { type LspServerStatus } from "./client";
-import { renderCall, renderResult } from "./render";
 import { type LspParams, type LspToolDetails, lspSchema } from "./types";
 export type { LspServerStatus } from "./client";
 export type { LspToolDetails } from "./types";
@@ -129,10 +128,6 @@ export declare class LspTool implements AgentTool<typeof lspSchema, LspToolDetai
         timeout: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
         payload: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
     }, import("zod/v4/core").$strip>;
-    readonly renderCall: typeof renderCall;
-    readonly renderResult: typeof renderResult;
-    readonly mergeCallAndResult = true;
-    readonly inline = true;
     readonly strict = true;
     constructor(session: ToolSession);
     static createIf(session: ToolSession): LspTool | null;

package/dist/types/main.d.ts

@@ -1,9 +1,3 @@
-/**
- * Main entry point for the coding agent CLI.
- *
- * This file handles CLI argument parsing and translates them into
- * createAgentSession() options. The SDK does the heavy lifting.
- */
 import type { Args } from "./cli/args";
 import { ModelRegistry } from "./config/model-registry";
 import { Settings } from "./config/settings";
@@ -41,10 +35,21 @@ export interface AcpSessionFactoryOptions {
  * tool registry and shadow the client-supplied servers (issue #1234).
  */
 export declare function createAcpSessionFactory(args: AcpSessionFactoryOptions): AcpSessionFactory;
-type ForkSessionPromptResult = "accepted" | "declined" | "unavailable";
-type ForkSessionPrompt = (session: SessionInfo) => Promise<ForkSessionPromptResult>;
+type SessionPromptResult = "accepted" | "declined" | "unavailable";
+type SessionPrompt = (session: SessionInfo) => Promise<SessionPromptResult>;
+/**
+ * Friendly CLI failure raised by {@link createSessionManager} when the user's
+ * session-resolution flags (`--resume`/`--fork`/cross-project prompts) cannot
+ * be satisfied. {@link runRootCommand} catches it and prints a clean stderr
+ * message instead of letting it surface as `[Uncaught Exception]`
+ * (see issue #2084).
+ */
+export declare class SessionResolutionError extends Error {
+    readonly hint?: string;
+    constructor(message: string, hint?: string);
+}
 /** Resolves CLI session flags into an existing, forked, in-memory, or cancelled session manager. */
-export declare function createSessionManager(parsed: Args, cwd: string, activeSettings?: Settings, askToForkSession?: ForkSessionPrompt): Promise<SessionManager | undefined>;
+export declare function createSessionManager(parsed: Args, cwd: string, activeSettings?: Settings, askToForkSession?: SessionPrompt, askToMoveSession?: SessionPrompt): Promise<SessionManager | undefined>;
 interface RunRootCommandDependencies {
     createAgentSession?: typeof createAgentSession;
     discoverAuthStorage?: typeof discoverAuthStorage;

package/dist/types/mcp/tool-bridge.d.ts

@@ -53,6 +53,7 @@ export declare class MCPTool implements CustomTool<TSchema, MCPToolDetails> {
     readonly mcpToolName: string;
     /** Server name */
     readonly mcpServerName: string;
+    readonly approval: "write";
     /** Render completed MCP calls with the result header replacing the pending call header. */
     readonly mergeCallAndResult = true;
     /** Create MCPTool instances for all tools from an MCP server connection */
@@ -79,6 +80,7 @@ export declare class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetai
     readonly mcpToolName: string;
     /** Server name */
     readonly mcpServerName: string;
+    readonly approval: "write";
     /** Render completed MCP calls with the result header replacing the pending call header. */
     readonly mergeCallAndResult = true;
     /** Create DeferredMCPTool instances for all tools from an MCP server */

package/dist/types/modes/components/assistant-message.d.ts

@@ -19,15 +19,6 @@ export declare class AssistantMessageComponent extends Container {
      */
     setErrorPinned(pinned: boolean): void;
     isTranscriptBlockFinalized(): boolean;
-    /**
-     * Assistant text/thinking streams in append-only: earlier rendered rows never
-     * re-layout, new content only grows the block at the bottom. The transcript
-     * reports this so the renderer may commit scrolled-off head rows of a long
-     * streamed reply to native scrollback instead of dropping them (see
-     * `NativeScrollbackLiveRegion#getNativeScrollbackCommitSafeEnd`). Volatile
-     * blocks (tool previews that collapse) intentionally do not implement this.
-     */
-    isTranscriptBlockAppendOnly(): boolean;
     markTranscriptBlockFinalized(): void;
     setToolResultImages(toolCallId: string, images: ImageContent[]): void;
     setUsageInfo(usage: Usage): void;

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

@@ -8,7 +8,7 @@ export declare function extractBracketedImagePastePath(data: string): string | u
 export declare class CustomEditor extends Editor {
     #private;
     imageLinks?: readonly (string | undefined)[];
-    /** Gradient-highlight the "ultrathink" / "orchestrate" / "workflow" keywords as the user types
+    /** Gradient-highlight the "ultrathink" / "orchestrate" / "workflowz" keywords as the user types
      *  them, skipping any occurrence inside code spans, fenced blocks, or XML sections. Also make
      *  pasted image placeholders visually distinct and hyperlink them once their blob file exists. */
     decorateText: (text: string) => string;

package/dist/types/modes/components/late-diagnostics-message.d.ts

@@ -0,0 +1,20 @@
+import { Container } from "@oh-my-pi/pi-tui";
+/** One file's worth of late LSP diagnostics, as carried on the transcript message. */
+export interface LateDiagnosticsFile {
+    path?: string;
+    summary?: string;
+    errored?: boolean;
+    messages?: string[];
+}
+/**
+ * Renders late LSP diagnostics (arrived after edit/write returned) in the
+ * transcript, reusing the same tree renderer the edit/write tools use so the
+ * styling stays consistent. Supports the global tool-output expand toggle.
+ */
+export declare class LateDiagnosticsMessageComponent extends Container {
+    #private;
+    private readonly files;
+    constructor(files: LateDiagnosticsFile[]);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+}

package/dist/types/modes/components/read-tool-group.d.ts

@@ -16,6 +16,12 @@ export declare class ReadToolGroupComponent extends Container implements ToolExe
     constructor(options?: ReadToolGroupOptions);
     isTranscriptBlockFinalized(): boolean;
     finalize(): void;
+    /**
+     * Force the group terminal even if an entry never received its result (the
+     * turn aborted or ended). Lets it freeze and stop pinning the transcript live
+     * region instead of lingering on a pending preview until the next thaw.
+     */
+    seal(): void;
     updateArgs(args: ReadRenderArgs, toolCallId?: string): void;
     updateResult(result: {
         content: Array<{

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

@@ -3,17 +3,26 @@ import type { SessionInfo } from "../../session/session-manager";
 /** Returns the IDs of sessions whose recorded prompts match a query, best first. */
 export type SessionHistoryMatcher = (query: string) => string[];
 /**
- * Combine fuzzy session matches with prompt-history matches for ranking, using
- * both signals rather than replacing one with the other.
+ * Filter and rank session picker search results.
  *
- * - `fuzzy` is the ordered fuzzy-filter result over session metadata (best first).
+ * Resume search narrows a recency-sorted list: once every query token appears
+ * as a literal substring, newer sessions should beat a slightly better fuzzy
+ * position match. Pure fuzzy/acronym matches still sort by fuzzy score after
+ * literal matches.
+ */
+export declare function rankSessionSearchMatches(allSessions: SessionInfo[], query: string): SessionInfo[];
+/**
+ * Combine metadata matches with prompt-history matches for ranking, using both
+ * signals rather than replacing one with the other.
+ *
+ * - `fuzzy` is the ordered metadata/session-text result.
  * - `historyIds` are session IDs whose recorded prompts matched the query,
  *   ordered by prompt-history rank (typically newest matching prompt first); duplicates are tolerated.
  *
- * Ranking: sessions matched by **both** signals lead (keeping fuzzy order), then
- * fuzzy-only matches, then history-only matches (by prompt-history order). A fuzzy match
- * is never dropped, and history matches not present in `allSessions` (e.g. deleted
- * or out-of-scope sessions) are ignored since they cannot be resumed from here.
+ * Ranking: prompt-history matches lead in history order, then remaining
+ * metadata matches keep their existing order. A metadata match is never dropped,
+ * and history matches not present in `allSessions` (e.g. deleted or out-of-scope
+ * sessions) are ignored since they cannot be resumed from here.
  */
 export declare function mergeSessionRanking(allSessions: SessionInfo[], fuzzy: SessionInfo[], historyIds: string[]): SessionInfo[];
 /**

package/dist/types/modes/components/status-line.d.ts

@@ -30,11 +30,13 @@ export interface StatusLineSettings {
     showHookStatus?: boolean;
     sessionAccent?: boolean;
 }
+export type EffectiveStatusLineSettings = Required<Pick<StatusLineSettings, "leftSegments" | "rightSegments" | "separator" | "segmentOptions">> & StatusLineSettings;
 export declare class StatusLineComponent implements Component {
     #private;
     private readonly session;
     constructor(session: AgentSession);
     updateSettings(settings: StatusLineSettings): void;
+    getEffectiveSettingsForTest(): EffectiveStatusLineSettings;
     setAutoCompactEnabled(enabled: boolean): void;
     setSubagentCount(count: number): void;
     setSessionStartTime(time: number): void;

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

@@ -61,24 +61,6 @@ export declare class ToolExecutionComponent extends Container {
      * past, or an explicit {@link seal} flips it to `true`.
      */
     isTranscriptBlockFinalized(): boolean;
-    /**
-     * While a tool's preview is still streaming, a block whose preview is
-     * append-only (rows only grow at the bottom, never re-layout) lets the
-     * renderer commit the scrolled-off head of an over-tall preview to native
-     * scrollback instead of dropping it — the same anti-yank path a streaming
-     * assistant reply uses (see {@link TranscriptContainer} +
-     * `NativeScrollbackLiveRegion`). Covers both phases: a pre-result call preview
-     * (a `write` whose content streams in) and a partial-result preview that
-     * streams output below fixed input (an `eval`/`bash` whose stdout grows under
-     * its code cell). Gated on {@link isTranscriptBlockFinalized} so the boundary
-     * closes the instant the block reaches a terminal state — a final result that
-     * may collapse to a compact view, a backgrounded async tool, or a seal — and
-     * the renderer decides whether its current preview shape qualifies via
-     * `isStreamingPreviewAppendOnly` (typically: only the expanded full view,
-     * which is top-anchored; the collapsed tail window re-layouts but is bounded
-     * so it never overflows anyway).
-     */
-    isTranscriptBlockAppendOnly(): boolean;
     /**
      * Mark the tool terminal even though no result arrived (the turn aborted or
      * abandoned it) and stop animating, so it can freeze and stops pinning the

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

@@ -1,10 +1,27 @@
 import type { InteractiveModeContext } from "../../modes/types";
 import type { AgentSessionEvent } from "../../session/agent-session";
+/**
+ * Loader label shown the instant a user interrupt (Esc) is requested, kept until
+ * the agent turn fully unwinds. Esc fires the abort synchronously, but the loop
+ * only stops the spinner at `agent_end`, which it cannot reach until every
+ * in-flight tool settles its abort in `executeToolCalls` (`Promise.allSettled`).
+ * Swapping the steady "Working…" for this acknowledges the keypress instead of
+ * reading as an ignored Esc for the seconds a slow tool takes to tear down.
+ */
+export declare const INTERRUPTING_WORKING_MESSAGE = "Interrupting\u2026";
 export declare class EventController {
     #private;
     private ctx;
     constructor(ctx: InteractiveModeContext);
     dispose(): void;
+    /**
+     * Acknowledge a user interrupt (Esc) immediately: switch the loader to
+     * `INTERRUPTING_WORKING_MESSAGE` and freeze intent-driven working-message
+     * updates for the rest of the turn so a late `tool_execution_start` intent
+     * cannot repaint a "Working…/<intent>" line over the acknowledgment. Reset at
+     * the next `agent_start`. No-op outside an active turn or if already set.
+     */
+    notifyInterrupting(): void;
     subscribeToAgent(): void;
     handleEvent(event: AgentSessionEvent): Promise<void>;
     sendCompletionNotification(): void;

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

@@ -180,6 +180,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     ensureLoadingAnimation(): void;
     setWorkingMessage(message?: string): void;
     applyPendingWorkingMessage(): void;
+    notifyInterrupting(): void;
     showNewVersionNotification(newVersion: string): void;
     clearEditor(): void;
     updatePendingMessagesDisplay(): void;