@oh-my-pi/pi-coding-agent 15.10.2 → 15.10.4

package/CHANGELOG.md

@@ -2,7 +2,72 @@
 
 ## [Unreleased]
 
+## [15.10.4] - 2026-06-08
+
+### Added
+
+- macOS release binaries are now signed with a Developer ID Application identity (hardened runtime + secure timestamp + JIT/library-validation entitlements) and notarized in CI when the `APPLE_*` signing secrets are configured; releases auto-fall back to ad-hoc signing until then. This makes the shipped binaries Gatekeeper-acceptable, unblocking an official Homebrew submission ([#776](https://github.com/can1357/oh-my-pi/issues/776)). See `docs/macos-signing-notarization.md`.
+- Added a Homebrew install path: `brew install can1357/tap/omp`. The [can1357/homebrew-tap](https://github.com/can1357/homebrew-tap) formula installs the prebuilt release binary, and a `release_brew` CI job regenerates it (version + per-asset sha256) from each published release via `scripts/ci-update-brew-formula.ts` ([#776](https://github.com/can1357/oh-my-pi/issues/776)).
+
+### Changed
+
+- Adjusted `completion()` model resolution so the `default` tier now prefers the session’s active model and falls back to the configured default role when needed
+- Rewrote the session auto-title prompt (`prompts/system/title-system.md`) and the `set_title` tool description to ask for a concise, sentence-case title (3-7 words) that captures the session's topic/goal, with good/bad examples and explicit guidance to treat the first message as data (no following embedded links/instructions, no refusals, describe URL/reference asks). The local on-device title prompt (`tiny-title-system.md`) was aligned to the same 3-7 word, sentence-case convention. The deterministic greeting/low-signal filter and the `none` deferral sentinel are unchanged.
+- Renamed the eval oneshot helper from `llm()` to `completion()` in both JavaScript and Python preludes, including status events, prompt docs, and runtime tests.
+
+### Fixed
+
+- Fixed `completion()` to always send a non-empty default system prompt when `system` is omitted so providers that require instructions no longer reject requests
+- Fixed structured `completion()` mode to return parsed JSON from plain text output when the model skips the forced `respond` tool call
+- Fixed slow-tier `completion()` reasoning requests to avoid unsupported effort settings by only enabling reasoning on reasoning-capable models and capping effort to supported levels
+- Fixed JS eval worker reset/dispose to close workers gracefully before forced termination, avoiding Bun 1.3.14 N-API teardown crashes with native modules such as `canvas`.
+
+## [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
@@ -9637,4 +9702,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/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/__tests__/js-context-manager.test.d.ts

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

package/dist/types/eval/bridge-timeout.d.ts

@@ -2,7 +2,7 @@
  * Timeout suspension for in-flight host-side eval bridge calls.
  *
  * The eval watchdog caps a cell's `timeout` as a budget on the cell runtime's
- * own work. Host-side `agent()` / `parallel()` / `llm()` bridge calls hand
+ * own work. Host-side `agent()` / `parallel()` / `completion()` bridge calls hand
  * control to the outer TypeScript process, where the Python kernel or JS VM is
  * only waiting for a result. While that delegated work is in flight, the cell
  * timeout must be ignored completely; once the bridge returns and the runtime is

package/dist/types/eval/{llm-bridge.d.ts → completion-bridge.d.ts}

@@ -1,25 +1,25 @@
 import type { ToolSession } from "../tools";
 import type { JsStatusEvent } from "./js/shared/types";
-/** Synthetic bridge name reserved for the `llm()` helper across both runtimes. */
-export declare const EVAL_LLM_BRIDGE_NAME = "__llm__";
-type LlmTier = "smol" | "default" | "slow";
-export interface EvalLlmBridgeOptions {
+/** Synthetic bridge name reserved for the `completion()` helper across both runtimes. */
+export declare const EVAL_COMPLETION_BRIDGE_NAME = "__completion__";
+type CompletionTier = "smol" | "default" | "slow";
+export interface EvalCompletionBridgeOptions {
     session: ToolSession;
     signal?: AbortSignal;
     emitStatus?: (event: JsStatusEvent) => void;
 }
-export interface EvalLlmResult {
+export interface EvalCompletionResult {
     text: string;
     details: {
         model: string;
-        tier: LlmTier;
+        tier: CompletionTier;
         structured: boolean;
     };
 }
 /**
- * Run a single stateless completion on behalf of an eval cell's `llm()` call.
+ * Run a single stateless completion on behalf of an eval cell's `completion()` call.
  * Returns a `{ text, details }` value shaped like a {@link callSessionTool}
  * result so the existing bridge transport carries it to either runtime.
  */
-export declare function runEvalLlm(args: unknown, options: EvalLlmBridgeOptions): Promise<EvalLlmResult>;
+export declare function runEvalCompletion(args: unknown, options: EvalCompletionBridgeOptions): Promise<EvalCompletionResult>;
 export {};

package/dist/types/eval/idle-timeout.d.ts

@@ -3,7 +3,7 @@
  *
  * A cell's `timeout` bounds time while the Python kernel or JS VM is in control.
  * Host-side bridge calls can {@link pause} the watchdog so delegated
- * `agent()`/`parallel()`/`llm()` work is ignored completely, then {@link resume}
+ * `agent()`/`parallel()`/`completion()` work is ignored completely, then {@link resume}
  * starts a fresh timeout window once the runtime gets control back.
  *
  * The active timer self-reschedules instead of being torn down on every

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

@@ -37,6 +37,17 @@ export interface AcpSessionFactoryOptions {
 export declare function createAcpSessionFactory(args: AcpSessionFactoryOptions): AcpSessionFactory;
 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?: SessionPrompt, askToMoveSession?: SessionPrompt): Promise<SessionManager | undefined>;
 interface RunRootCommandDependencies {

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

@@ -34,6 +34,10 @@ export type SubmittedUserInput = {
     images?: ImageContent[];
     imageLinks?: (string | undefined)[];
     customType?: string;
+    /** Route through `session.prompt(text, { synthetic: true })` so the text lands
+     *  as a hidden agent-authored `developer` message rather than a visible user
+     *  turn. Used by the `c`/`.` continue shortcut. */
+    synthetic?: boolean;
     display?: boolean;
     cancelled: boolean;
     started: boolean;

package/dist/types/session/messages.d.ts

@@ -10,6 +10,7 @@ import type { AssistantMessage, ImageContent, Message, MessageAttribution, TextC
 export { type BranchSummaryMessage, type CompactionSummaryMessage, createBranchSummaryMessage, createCompactionSummaryMessage, } from "@oh-my-pi/pi-agent-core/compaction/messages";
 import type { OutputMeta } from "../tools/output-meta";
 export declare const SKILL_PROMPT_MESSAGE_TYPE = "skill-prompt";
+export declare const LSP_LATE_DIAGNOSTIC_MESSAGE_TYPE = "lsp-late-diagnostic";
 export interface SkillPromptDetails {
     name: string;
     path: string;
@@ -41,16 +42,18 @@ export declare const SILENT_ABORT_MARKER = "__omp.silent_abort__";
  *  namespacing changes) propagate through every consumer in lockstep. */
 export declare function isSilentAbort(errorMessage: string | undefined): boolean;
 /** Reason threaded through `AbortController.abort(reason)` when the user aborts
- *  the turn with Esc (see `AgentSession.abort`). The agent surfaces it verbatim
- *  on the aborted assistant message's `errorMessage`, so the transcript reads as
- *  a deliberate user interrupt instead of an opaque failure. */
+ *  the turn with Esc (see `AgentSession.abort`). The agent keeps it on the
+ *  aborted assistant message's `errorMessage` so queued follow-ups/tool-result
+ *  placeholders can distinguish a deliberate interrupt from a bare lifecycle
+ *  abort, but interactive renderers suppress this redundant transcript line. */
 export declare const USER_INTERRUPT_LABEL = "Interrupted by user";
+export declare function isUserInterruptAbort(errorMessage: string | undefined): boolean;
+export declare function shouldRenderAbortReason(errorMessage: string | undefined): boolean;
 /** Resolve the operator-facing label for an aborted assistant turn. A custom
- *  abort reason (e.g. `USER_INTERRUPT_LABEL`) threaded onto `errorMessage` is
- *  shown verbatim; aborts with no threaded reason fall back to the retry-aware
- *  generic label. Centralizes the live-stream (`EventController`), replay
- *  (`ui-helpers`), and component (`AssistantMessageComponent`) render paths so
- *  they stay in lockstep. */
+ *  abort reason threaded onto `errorMessage` is returned verbatim; aborts with
+ *  no threaded reason fall back to the retry-aware generic label. Call
+ *  `shouldRenderAbortReason` before rendering when user interrupts should stay
+ *  visually quiet. */
 export declare function resolveAbortLabel(errorMessage: string | undefined, retryAttempt?: number): string;
 /** Extract the optional `__pendingDisplayTag` field from a CustomMessage's
  *  `details` blob. Safe over `unknown`; returns undefined when the field is

package/dist/types/session/yield-queue.d.ts

@@ -7,7 +7,7 @@ export interface YieldDispatcher<P> {
 }
 export interface YieldQueueOptions {
     isStreaming: () => boolean;
-    injectStreaming(msg: AgentMessage): void;
+    injectStreaming?(msg: AgentMessage): void;
     injectIdle(messages: AgentMessage[]): Promise<void>;
     scheduleIdleFlush(run: () => Promise<void>): void;
 }
@@ -19,6 +19,15 @@ export declare class YieldQueue {
     enqueue<P>(kind: string, entry: P): void;
     has(kind?: string): boolean;
     flush(mode: YieldFlushMode): Promise<void>;
+    /**
+     * Snapshot and remove all queued entries, returning one lazy thunk per kind.
+     * Each thunk applies the dispatcher's staleness filter and builds the batched
+     * message only when called — so the consumer (the agent loop) decides, at the
+     * moment it injects, whether the message is still worth delivering (a thunk may
+     * return null to skip). Background-job completions and late diagnostics reach
+     * the model between requests without the agent having to stop.
+     */
+    drainLazy(): Array<() => AgentMessage | null>;
     clear(): void;
 }
 export {};

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

@@ -46,7 +46,6 @@ export declare const evalToolRenderer: {
     }, options: RenderResultOptions & {
         renderContext?: EvalRenderContext;
     }, uiTheme: Theme, _args?: EvalRenderArgs): Component;
-    isStreamingPreviewAppendOnly(_args: EvalRenderArgs, _options: RenderResultOptions, result?: unknown): boolean;
     mergeCallAndResult: boolean;
     inline: boolean;
 };

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

@@ -69,6 +69,28 @@ export type ContextFileEntry = {
     depth?: number;
 };
 export type { DiscoverableTool, DiscoverableToolSearchIndex, DiscoverableToolSearchResult, DiscoverableToolSource, } from "../tool-discovery/tool-index";
+/**
+ * A late LSP diagnostics result that arrived after the edit/write tool already
+ * returned. Surfaced to the model and the transcript via
+ * {@link ToolSession.queueDeferredDiagnostics}, batched through the session
+ * yield queue like background-job results.
+ */
+export interface DeferredDiagnosticsEntry {
+    /** Absolute path the diagnostics belong to (the renderer shortens it). */
+    path: string;
+    /** One-line severity summary, e.g. "2 errors". */
+    summary: string;
+    /** Formatted, ready-to-display diagnostic lines. */
+    messages: string[];
+    /** True when any message is error severity. */
+    errored: boolean;
+    /**
+     * Evaluated at injection time (in the dispatcher's stale check): drop the entry
+     * when a newer mutation to the same file has superseded it, so the model never
+     * sees diagnostics for stale content.
+     */
+    isStale(): boolean;
+}
 /** Session context for tool factories */
 export interface ToolSession {
     /** Current working directory */
@@ -242,6 +264,15 @@ export interface ToolSession {
     diagnosticsLedger?: import("../lsp/diagnostics-ledger").DiagnosticsLedger;
     /** Queue a hidden message to be injected at the next agent turn. */
     queueDeferredMessage?(message: CustomMessage): void;
+    /** Queue late LSP diagnostics (arrived after an edit/write returned) to be shown
+     *  in the transcript and delivered to the model at the next yield, like background
+     *  job results. */
+    queueDeferredDiagnostics?(entry: DeferredDiagnosticsEntry): void;
+    /** Bump and return the session-global mutation counter for `path`. Edit/write
+     *  tools call this on every file mutation so stale late-diagnostics can be dropped. */
+    bumpFileMutationVersion?(path: string): number;
+    /** Read the current session-global mutation counter for `path` (0 if never mutated). */
+    getFileMutationVersion?(path: string): number;
     /** Get the active OpenTelemetry config so subagent dispatch can forward
      *  the parent's tracer/hooks with the subagent's own identity stamped. */
     getTelemetry?: () => AgentTelemetryConfig | undefined;

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

@@ -115,9 +115,13 @@ export interface ResolvedMultiSearchPath {
     exactFilePaths?: string[];
     targets?: ResolvedSearchTarget[];
 }
-export interface ResolvedMultiFindPattern {
+export interface ResolvedFindTarget {
     basePath: string;
     globPattern: string;
+    hasGlob: boolean;
+}
+export interface ResolvedMultiFindPattern {
+    targets: ResolvedFindTarget[];
     scopePath: string;
 }
 /**

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

@@ -39,6 +39,8 @@ export interface ReadToolDetails {
     };
     /** Number of unresolved git conflicts surfaced by this read (TUI uses for inline `⚠ N` badge). */
     conflictCount?: number;
+    /** Paths recovered from a delimited read argument; used only by the TUI to render one call as multiple read rows. */
+    displayReadTargets?: string[];
 }
 type ReadParams = ReadToolInput;
 /**
@@ -58,7 +60,6 @@ export declare class ReadTool implements AgentTool<typeof readSchema, ReadToolDe
     readonly parameters: z.ZodObject<{
         path: z.ZodString;
     }, z.core.$strict>;
-    readonly nonAbortable = true;
     readonly strict = true;
     constructor(session: ToolSession);
     execute(_toolCallId: string, params: ReadParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<ReadToolDetails>, _toolContext?: AgentToolContext): Promise<AgentToolResult<ReadToolDetails>>;

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

@@ -124,7 +124,9 @@ export declare function formatDiagnostics(diag: {
     errored: boolean;
     summary: string;
     messages: string[];
-}, expanded: boolean, theme: Theme, getLangIcon: (filePath: string) => string): string;
+}, expanded: boolean, theme: Theme, getLangIcon: (filePath: string) => string, options?: {
+    title?: string;
+}): string;
 export interface DiffStats {
     added: number;
     removed: number;

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

@@ -19,21 +19,6 @@ export type ToolRenderer = {
         renderContext?: Record<string, unknown>;
     }, theme: Theme, args?: unknown) => Component;
     mergeCallAndResult?: boolean;
-    /**
-     * While a tool's preview is still streaming, report whether the
-     * currently-rendered preview is append-only: its rows only grow at the bottom
-     * and never re-layout above the bottom live region (a full, top-anchored
-     * content/code preview). The transcript reports this up to the TUI so a
-     * streaming preview taller than the viewport commits its scrolled-off head to
-     * native scrollback instead of dropping it (see
-     * `ToolExecutionComponent.isTranscriptBlockAppendOnly`). `result` is the
-     * latest (possibly partial) tool result, or `undefined` before one exists —
-     * `eval`/`bash` use its presence to defer committing until the streamed input
-     * (code) has finalized. Omit (or return `false`) for previews that slide a
-     * tail window or later collapse to a compact result — committing their head
-     * would strand stale rows.
-     */
-    isStreamingPreviewAppendOnly?: (args: unknown, options: RenderResultOptions, result?: unknown) => boolean;
     /** Render without background box, inline in the response flow */
     inline?: boolean;
 };

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

@@ -39,7 +39,6 @@ export declare class WriteTool implements AgentTool<typeof writeSchema, WriteToo
         path: z.ZodString;
         content: z.ZodString;
     }, z.core.$strip>;
-    readonly nonAbortable = true;
     readonly strict = true;
     readonly concurrency = "exclusive";
     readonly loadMode = "discoverable";
@@ -56,7 +55,6 @@ interface WriteRenderArgs {
 }
 export declare const writeToolRenderer: {
     renderCall(args: WriteRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
-    isStreamingPreviewAppendOnly(args: WriteRenderArgs, options: RenderResultOptions, _result?: unknown): boolean;
     renderResult(result: {
         content: Array<{
             type: string;

package/dist/types/tui/code-cell.d.ts

@@ -18,8 +18,6 @@ export interface CodeCellOptions {
      */
     codeTail?: boolean;
     expanded?: boolean;
-    /** Animate the cell border with a sweeping segment while pending/running. */
-    animate?: boolean;
     width: number;
 }
 export declare function renderCodeCell(options: CodeCellOptions, theme: Theme): string[];

package/dist/types/tui/hyperlink.d.ts

@@ -20,20 +20,18 @@ export declare function uriHyperlink(uri: string, displayText: string): string;
  */
 export declare function urlHyperlink(url: string, displayText: string): string;
 /**
- * Wrap `displayText` in an OSC 8 hyperlink pointing at the given absolute file path.
+ * Wrap `displayText` in an OSC 8 hyperlink pointing at a filesystem path.
  *
  * Returns `displayText` unchanged when hyperlinks are disabled or when
  * the text already contains an OSC 8 sequence (prevents double-wrapping).
+ * Relative paths resolve against the current working directory before URI
+ * encoding so the OSC 8 target is always a valid `file://` URL.
  *
- * The caller is responsible for passing an absolute path. Relative paths
- * produce invalid `file://` URIs and are accepted silently to avoid runtime
- * errors in renderer hot paths.
- *
- * @param absPath - Absolute filesystem path
+ * @param filePath - Filesystem path
  * @param displayText - Text to render as the hyperlink anchor (may contain ANSI codes)
  * @param opts - Optional line/col position appended as `?line=N&col=M` query params
  */
-export declare function fileHyperlink(absPath: string, displayText: string, opts?: {
+export declare function fileHyperlink(filePath: string, displayText: string, opts?: {
     line?: number;
     col?: number;
 }): string;

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

@@ -16,8 +16,6 @@ export interface OutputBlockOptions {
     width: number;
     applyBg?: boolean;
     contentPaddingLeft?: number;
-    /** Animate the border with a sweeping dark segment (pending/running state). */
-    animate?: boolean;
     /** Override the state-derived border color. Used for muted "legacy" tool
      * frames that should not visually compete with framed-output tools. */
     borderColor?: ThemeColor;
@@ -28,22 +26,6 @@ export type FramedBlockComponent = Component & {
 };
 export declare function markFramedBlockComponent<T extends Component>(component: T): T & FramedBlockComponent;
 export declare function isFramedBlockComponent(component: Component): boolean;
-/**
- * Monotonic frame counter for animated borders, quantized to the TUI's ~30fps
- * render cap so the cache key advances once per animation frame — fine enough
- * for a smooth segment sweep, coarse enough to coalesce multiple render passes
- * land inside the same frame.
- */
-export declare function borderShimmerTick(): number;
-/**
- * Column of the travelling segment's center on the bottom edge for a box of
- * inner width `W` at time `now`. The segment bounces left → right → left across
- * the bottom border: a triangle wave over one full there-and-back cycle, eased
- * per leg so it slows as it nears each wall before reversing. Position is
- * derived from the wall clock against a fixed cycle, so a resize shifts the
- * center proportionally — no reset.
- */
-export declare function borderSegmentHeadCol(W: number, now: number): number;
 export declare function renderOutputBlock(options: OutputBlockOptions, theme: Theme): string[];
 /**
  * Cached wrapper around `renderOutputBlock`.