@oh-my-pi/pi-coding-agent 16.3.4 → 16.3.6

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

@@ -42,9 +42,11 @@ export declare function canonicalSnapshotKey(absolutePath: string): string;
  * Producers that only displayed a slice of the file (range reads, search hits)
  * use this to mint a whole-file tag: the displayed lines stay partial, but the
  * tag fingerprints the entire file so a follow-up edit anchored at any line
- * validates whenever the live file is byte-identical to what was read.
+ * validates whenever the live file is byte-identical to what was read. Raw
+ * reads pass `seenLines` even though they do not emit a header, letting a prior
+ * or later same-content hashline tag inherit the raw range's provenance.
  */
-export declare function recordFileSnapshot(session: FileSnapshotStoreOwner, absolutePath: string): Promise<string | undefined>;
+export declare function recordFileSnapshot(session: FileSnapshotStoreOwner, absolutePath: string, seenLines?: Iterable<number>): Promise<string | undefined>;
 /**
  * The 1-indexed file lines a hashline-formatted body actually displayed.
  * Single `NN:` rows contribute that line; a collapsed summary `NN-MM:` row

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

@@ -102,7 +102,6 @@ export interface EditRenderContext {
 }
 export declare const editToolRenderer: {
     mergeCallAndResult: boolean;
-    provisionalPendingPreview: boolean;
     renderCall(args: EditRenderArgs, options: RenderResultOptions & {
         renderContext?: EditRenderContext;
     }, uiTheme: Theme): Component;

package/dist/types/extensibility/custom-tools/types.d.ts

@@ -20,6 +20,7 @@ import type * as PiCodingAgent from "../../index";
 import type { Theme } from "../../modes/theme/theme";
 import type { ReadonlySessionManager } from "../../session/session-manager";
 import type { TodoItem } from "../../tools/todo";
+import type { RecoveredRetryError } from "../shared-events";
 import type * as TypeBox from "../typebox";
 /** Alias for clarity */
 export type CustomToolUIContext = HookUIContext;
@@ -115,6 +116,7 @@ export type CustomToolSessionEvent = {
     success: boolean;
     attempt: number;
     finalError?: string;
+    recoveredErrors?: RecoveredRetryError[];
 } | {
     reason: "ttsr_triggered";
     rules: Rule[];

package/dist/types/extensibility/shared-events.d.ts

@@ -14,7 +14,7 @@
  */
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { CompactionPreparation, CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
-import type { ImageContent, TextContent, ToolResultMessage } from "@oh-my-pi/pi-ai";
+import type { AssistantRetryRecovery, ImageContent, TextContent, ToolResultMessage } from "@oh-my-pi/pi-ai";
 import type { Rule } from "../capability/rule";
 import type { Goal, GoalModeState } from "../goals/state";
 import type { BranchSummaryEntry, CompactionEntry, SessionEntry } from "../session/session-entries";
@@ -192,12 +192,19 @@ export interface AutoRetryStartEvent {
     errorMessage: string;
     errorId?: number;
 }
+export interface RecoveredRetryError {
+    entryId: string;
+    persistenceKey?: string;
+    note: string;
+    retryRecovery: AssistantRetryRecovery;
+}
 /** Fired when auto-retry ends */
 export interface AutoRetryEndEvent {
     type: "auto_retry_end";
     success: boolean;
     attempt: number;
     finalError?: string;
+    recoveredErrors?: RecoveredRetryError[];
 }
 /** Fired when TTSR rule matching interrupts generation */
 export interface TtsrTriggeredEvent {

package/dist/types/hindsight/content.d.ts

@@ -64,6 +64,10 @@ export interface RetentionTranscript {
     transcript: string | null;
     messageCount: number;
 }
+/** Remove retention framing lines from a stored coding-agent episode transcript. */
+export declare function stripRetentionProtocolMarkers(content: string): string;
 export declare function prepareRetentionTranscript(messages: HindsightMessage[], retainFullWindow?: boolean): RetentionTranscript;
+/** Format all retention messages without protocol markers for embedding, FTS, and recall display. */
+export declare function prepareEmbeddableRetentionTranscript(messages: HindsightMessage[]): RetentionTranscript;
 /** Format only user-authored messages for memory fact/entity extraction. */
 export declare function prepareUserRetentionTranscript(messages: HindsightMessage[]): RetentionTranscript;

package/dist/types/internal-urls/artifact-protocol.d.ts

@@ -1,4 +1,12 @@
 import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext, UrlCompletion } from "./types";
+/** Filesystem location for a session artifact, resolved without materializing its content. */
+export interface ResolvedArtifactFile {
+    id: string;
+    path: string;
+    size: number;
+}
+/** Resolve an `artifact://` URL to its backing file without reading artifact bytes. */
+export declare function resolveArtifactFile(url: InternalUrl, context?: ResolveContext): Promise<ResolvedArtifactFile>;
 export declare class ArtifactProtocolHandler implements ProtocolHandler {
     readonly scheme = "artifact";
     readonly immutable = true;

package/dist/types/internal-urls/types.d.ts

@@ -102,6 +102,16 @@ export interface ResolveContext {
      * reject directory resources, so they never need the listing.
      */
     skipDirectoryListing?: boolean;
+    /**
+     * When set, handlers that would otherwise materialize expensive content
+     * (e.g. reading a multi-MiB artifact into memory just to expose its
+     * `sourcePath`) may return the resource shape without content. Callers
+     * that only need `sourcePath` — search/grep, bash URL expansion — pass
+     * this so a large `artifact://` still resolves to its backing file
+     * without OOM risk. Handlers that cannot separate path from content
+     * ignore the flag.
+     */
+    pathOnly?: boolean;
 }
 /**
  * Caller context for write operations dispatched to host-owned URI handlers.

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

@@ -8,6 +8,10 @@ export interface LspConfig {
  * Check if any root marker file exists in the directory
  */
 export declare function hasRootMarkers(cwd: string, markers: string[]): boolean;
+/**
+ * Check whether any ancestor directory of a file is an LSP project root.
+ */
+export declare function hasRootMarkerAncestor(filePath: string, markers: string[]): boolean;
 /**
  * Resolve a command to an executable path.
  * Checks project-local bin directories first, then falls back to $PATH.

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

@@ -11,6 +11,8 @@ export declare function rangesOverlap(a: Range, b: Range): boolean;
  * Equal start positions tiebreak by original array index descending so that,
  * applied bottom-up, inserts at the same position land in array order
  * (LSP spec: the order of edits in the array defines the order in the result).
+ * Byte-identical non-empty range edits are idempotent, so duplicate server
+ * output is collapsed before overlap validation.
  */
 export declare function sortAndValidateTextEdits(edits: TextEdit[]): TextEdit[];
 /**

package/dist/types/mcp/oauth-discovery.d.ts

@@ -12,9 +12,26 @@ export interface AuthDetectionResult {
     oauth?: OAuthEndpoints;
     authServerUrl?: string;
     resourceMetadataUrl?: string;
+    /**
+     * OAuth scopes advertised by the challenge (RFC 6750 `scope=` on
+     * `WWW-Authenticate`) or by protected-resource metadata. Passed through
+     * `discoverOAuthEndpoints` as `protectedScopes` so the eventual
+     * authorization request carries them even when the auth-server metadata
+     * document itself omits `scopes_supported`.
+     */
+    scopes?: string;
     message?: string;
 }
 export declare function extractMcpAuthServerUrl(error: Error, serverUrl?: string): string | undefined;
+/**
+ * Pull the `scope`/`scopes` parameter out of a `WWW-Authenticate` challenge
+ * embedded in the error message. RFC 6750 lets servers advertise the missing
+ * scopes when they reject a bearer token with `insufficient_scope`, and RFC
+ * 8414-adjacent MCP gateways sometimes list the required scopes there rather
+ * than in `scopes_supported`. Returns the raw space-separated value, or
+ * `undefined` when the challenge does not carry one.
+ */
+export declare function extractOAuthChallengeScopes(error: Error): string | undefined;
 /**
  * Extract OAuth endpoints from error response.
  * Looks for WWW-Authenticate header format or JSON error bodies.
@@ -25,6 +42,18 @@ export declare function extractOAuthEndpoints(error: Error): OAuthEndpoints | nu
  * Returns structured info about what auth is needed.
  */
 export declare function analyzeAuthError(error: Error, serverUrl?: string): AuthDetectionResult;
+/**
+ * Fetch the RFC 9728 protected-resource metadata document at
+ * {@link resourceMetadataUrl} and return any scopes it advertises. Used by
+ * `/mcp add` / `/mcp reauth` on the JSON-error-body path, where the caller
+ * already holds usable OAuth endpoints but the required scopes live only in
+ * the advertised protected-resource metadata — a case `discoverOAuthEndpoints`
+ * normally handles but that path is skipped when the body carried endpoints.
+ * Returns `undefined` on any error or when no scopes are advertised.
+ */
+export declare function fetchResourceMetadataScopes(resourceMetadataUrl: string, opts?: {
+    fetch?: FetchImpl;
+}): Promise<string | undefined>;
 /**
  * Try to discover OAuth endpoints by querying the server's well-known endpoints.
  * This is a fallback when error responses don't include OAuth metadata.
@@ -32,4 +61,5 @@ export declare function analyzeAuthError(error: Error, serverUrl?: string): Auth
 export declare function discoverOAuthEndpoints(serverUrl: string, authServerUrl?: string, resourceMetadataUrl?: string, opts?: {
     fetch?: FetchImpl;
     protectedResource?: string;
+    protectedScopes?: string;
 }): Promise<OAuthEndpoints | null>;

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

@@ -23,6 +23,7 @@ export declare class AssistantMessageComponent extends Container {
      */
     setCacheInvalidation(info: CacheInvalidation | undefined): void;
     invalidate(): void;
+    render(width: number): readonly string[];
     setHideThinkingBlock(hide: boolean): void;
     setProseOnlyThinking(proseOnly: boolean): void;
     dispose(): void;
@@ -33,19 +34,23 @@ export declare class AssistantMessageComponent extends Container {
     setErrorPinned(pinned: boolean): void;
     isTranscriptBlockFinalized(): boolean;
     /**
-     * Whether this still-live block's scrolled-off rows may be committed to
-     * immutable native scrollback (the {@link TranscriptContainer} durable-
-     * snapshot path). Reflowing Markdown — a streaming mermaid diagram or a GFM
-     * table — re-lays-out its body as source arrives (the diagram reshapes, the
-     * table re-aligns its columns), so committing an intermediate layout strands
-     * a stale fragment in native scrollback that only a full repaint (Ctrl+L) can
-     * clear. While such content is still streaming the block therefore stays
-     * wholly in the repaintable live region and commits once, at its final
-     * layout, when the turn finalizes.
+     * Settled leading rows for mid-stream native-scrollback commits (see
+     * `FinalizableBlock.getTranscriptBlockSettledRows`). Completed content
+     * blocks render in final form (non-transient) and settle in full; the
+     * actively streaming markdown contributes its rendered frozen-token
+     * prefix. The walk stops at the first child that is not declared
+     * byte-stable (the animated thinking pulse, extension components, images,
+     * error rows), and a cache-invalidation marker above the content defers
+     * settling entirely. Mermaid anywhere defers wholesale — its ASCII
+     * rendering resolves asynchronously and can re-layout settled-looking
+     * rows. Reads only L1-cached child renders at the width recorded by this
+     * frame's render().
      */
-    isTranscriptBlockCommitStable(): boolean;
+    getTranscriptBlockSettledRows(): number;
     getTranscriptBlockVersion(): number;
     markTranscriptBlockFinalized(): void;
+    applyRetryRecovery(retryRecovery: AssistantMessage["retryRecovery"]): void;
+    messagePersistenceKey(): string | undefined;
     setToolResultImages(toolCallId: string, images: ImageContent[]): void;
     updateContent(message: AssistantMessage, opts?: {
         transient?: boolean;

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

@@ -7,6 +7,12 @@ export declare class BashExecutionComponent extends Container {
     #private;
     private readonly command;
     constructor(command: string, ui: TUI, excludeFromContext?: boolean);
+    /**
+     * Transcript finalization contract (see `FinalizableBlock`): the collapsed
+     * streaming preview rewrites its tail window every chunk, so the block must
+     * stay out of native scrollback until the command completes.
+     */
+    isTranscriptBlockFinalized(): boolean;
     /**
      * Set whether the output is expanded (shows full output) or collapsed (preview only).
      */

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

@@ -11,6 +11,12 @@ export declare class EvalExecutionComponent extends Container {
     private readonly excludeFromContext;
     private readonly language;
     constructor(code: string, ui: TUI, excludeFromContext?: boolean, language?: EvalExecutionLanguage);
+    /**
+     * Transcript finalization contract (see `FinalizableBlock`): the collapsed
+     * streaming preview rewrites its tail window every chunk, so the block must
+     * stay out of native scrollback until the cell completes.
+     */
+    isTranscriptBlockFinalized(): boolean;
     setExpanded(expanded: boolean): void;
     invalidate(): void;
     appendOutput(chunk: string): void;

package/dist/types/modes/components/login-dialog.d.ts

@@ -8,9 +8,17 @@ export declare class LoginDialogComponent extends Container {
     constructor(tui: TUI, providerId: string, onComplete: (success: boolean, message?: string) => void);
     get signal(): AbortSignal;
     /**
-     * Called by onAuth callback - show URL and optional instructions
+     * Called by the OAuth `onAuth` callback. Renders the full authorization URL
+     * as the primary copy target — that works from any machine, including
+     * SSH/WSL/headless sessions where the OMP-hosted `launchUrl` would resolve
+     * against the user's local browser and fail. When `launchUrl` is present it
+     * is offered as an additional local shortcut so narrow local terminals still
+     * have a truncation-safe copy target (viewport clipping on a long authorize
+     * URL silently drops trailing OAuth query parameters — e.g.
+     * `code_challenge_method=S256`). The OSC 8 hyperlink carries the full URL
+     * for terminals that support click-through.
      */
-    showAuth(url: string, instructions?: string): void;
+    showAuth(url: string, instructions?: string, launchUrl?: string): void;
     /**
      * Show input for manual code/URL entry (for callback server providers)
      */

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

@@ -78,9 +78,9 @@ export declare class ToolExecutionComponent extends Container implements NativeS
     /**
      * Standalone harnesses may mount a tool component directly under `TUI`
      * instead of inside `TranscriptContainer`. In that shape the component must
-     * report its own live-region seam for provisional previews, or the core
-     * renderer treats it like shell output and commits tail-window edit/eval/bash
-     * previews to immutable native scrollback before the result replaces them.
+     * report its own live-region seam while unfinalized, or the core renderer
+     * treats it like shell output and commits still-mutating preview rows to
+     * immutable native scrollback before the result replaces them.
      */
     getNativeScrollbackLiveRegionStart(): number | undefined;
     /**
@@ -92,16 +92,6 @@ export declare class ToolExecutionComponent extends Container implements NativeS
      * past, or an explicit {@link seal} flips it to `true`.
      */
     isTranscriptBlockFinalized(): boolean;
-    /**
-     * Whether this still-live block's settled rows may enter native scrollback
-     * (see `FinalizableBlock.isTranscriptBlockCommitStable`). Renderers classify
-     * pending views by durability instead of by tool name: a provisional view is
-     * allowed to be useful on screen, but finalization may replace or re-anchor
-     * it wholesale, so committing any of its rows would strand stale preview
-     * bytes in immutable scrollback. Non-provisional views stream rows whose
-     * committed prefix survives the remaining transitions.
-     */
-    isTranscriptBlockCommitStable(): 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/components/transcript-container.d.ts

@@ -1,18 +1,20 @@
 import { type Component, Container, type NativeScrollbackCommittedRows, type NativeScrollbackLiveRegion, type RenderStablePrefix, type ViewportTailProvider } from "@oh-my-pi/pi-tui";
 /**
  * Transcript container that renders every block's current content each frame
- * and reports the live-region seam (`NativeScrollbackLiveRegion`) that gates
- * the engine's append-only scrollback commits.
+ * and reports the native-scrollback exactness boundary
+ * (`NativeScrollbackLiveRegion`): the frame row below which every rendered
+ * row is final. The boundary covers the leading run of finalized blocks plus
+ * the first still-live block's declared settled rows
+ * ({@link FinalizableBlock.getTranscriptBlockSettledRows}). Rows below it
+ * commit to native scrollback as exact, audited content; rows above it that
+ * scroll off the window commit as frozen visual snapshots the engine never
+ * re-anchors or recommits (the tape records what was on screen).
  *
- * The engine never rewrites committed history: rows above the seam that have
- * entered the tape keep whatever bytes they were committed with ("let the
- * history be"), while the visible window always repaints from each block's
- * latest render — a late tool result, a post-finalize error pin, or an expand
- * toggle is always reflected on screen. Blocks that are still mutating (an
- * unfinalized tool, a streaming assistant message) stay below the seam so
- * their rows do not enter history while they can still change; a streaming
- * block whose render grows append-only deepens the seam through its settled
- * head so a long reply's scrolled-off rows still reach scrollback mid-stream.
+ * The engine never rewrites committed history: rows that have entered the
+ * tape keep whatever bytes they were committed with ("let the history be"),
+ * while the visible window always repaints from each block's latest render —
+ * a late tool result, a post-finalize error pin, or an expand toggle is
+ * always reflected on screen while it remains in the window.
  *
  * Assembly is incremental: the returned array is persistent and mutated in
  * place. Each block's render is still called every frame, but a block whose
@@ -29,29 +31,24 @@ export declare class TranscriptContainer extends Container implements NativeScro
     setNativeScrollbackCommittedRows(rows: number): void;
     getRenderStablePrefixRows(): number;
     getNativeScrollbackLiveRegionStart(): number | undefined;
-    getNativeScrollbackCommitSafeEnd(): number | undefined;
-    getNativeScrollbackSnapshotSafeEnd(): number | undefined;
-    getNativeScrollbackOfferSafeEnd(): number | undefined;
     /**
-     * Whether `component` sits below a still-mutating block — i.e. inside the
-     * live region, where its rows cannot have been committed to native
-     * scrollback yet (commits are prefix-only and stop at the first
-     * still-live block). Callers that retract ephemeral blocks (IRC cards)
-     * must check this: removing a block whose rows may already be in history
-     * is an interior deletion of the committed prefix, which the engine can
-     * only repair by recommitting everything below it — duplication.
+     * Whether none of `component`'s rows (per the most recent render) have
+     * entered native scrollback. Callers that retract ephemeral blocks (IRC
+     * cards, displaceable todo/job snapshots) must check this: removing a
+     * block whose rows are already on the tape is an interior deletion of
+     * committed history the engine cannot express — the block must be sealed
+     * in place as history instead. A component that has never rendered has no
+     * committed rows and is safely removable.
      */
-    isWithinLiveRegion(component: Component): boolean;
+    isBlockUncommitted(component: Component): boolean;
     /**
      * Whether `component` is inside the live (repaintable) region exactly as
      * {@link render} computes it: at/after the first still-mutating block, or
-     * the transcript tail when every block has finalized. Unlike
-     * {@link isWithinLiveRegion} (strictly below a still-mutating block, i.e.
-     * guaranteed-uncommitted), this also counts the trailing block that anchors
-     * the live region. Self-animating finalized blocks (a detached task's
-     * shimmering progress rows) poll this to stop animating — and settle on
-     * static bytes — the moment they sit above the seam, where their rows
-     * become commit-eligible native-scrollback history.
+     * the transcript tail when every block has finalized. Self-animating
+     * finalized blocks (a detached task's shimmering progress rows) poll this
+     * to stop animating — and settle on static bytes — the moment they sit
+     * above the seam, where their rows become commit-eligible native-scrollback
+     * history.
      */
     isBlockInLiveRegion(component: Component): boolean;
     /**

package/dist/types/modes/controllers/mcp-command-controller.d.ts

@@ -1,11 +1,28 @@
 import { type Component } from "@oh-my-pi/pi-tui";
 import type { InteractiveModeContext } from "../types";
-/** Renders the MCP OAuth fallback URL without hard-wrapping the copy target. */
+/**
+ * Renders the MCP OAuth fallback URL. Always shows the full authorization URL
+ * as the primary `Copy URL:` target — that works from any machine, including
+ * SSH/WSL/headless sessions where the OMP-hosted `/launch` loopback URL would
+ * resolve against the user's local browser and fail.
+ *
+ * The render is `width`-aware: on any viewport narrower than the composed row
+ * ({@link TUI#prepareLine} truncates anything wider with `Ellipsis.Omit`, no
+ * marker), the URL is hard-wrapped into width-fitted rows so the primary copy
+ * target can never silently lose trailing OAuth parameters — the failure mode
+ * that motivated #4418 in the first place. Browsers strip whitespace when a
+ * multi-row selection is pasted into the address bar, so the reassembled URL
+ * is byte-identical to what we rendered.
+ *
+ * When the flow's callback server hosts a short `launchUrl`, it is offered
+ * as an additional local shortcut for wide-terminal local users. The OSC 8
+ * hyperlink continues to carry the full URL for terminals that support it.
+ */
 export declare class MCPAuthorizationLinkPrompt implements Component {
     #private;
-    constructor(url: string);
+    constructor(url: string, launchUrl?: string);
     invalidate(): void;
-    render(_width: number): readonly string[];
+    render(width: number): readonly string[];
 }
 /**
  * Thrown by {@link MCPCommandController}'s OAuth handler when the user (or a

package/dist/types/modes/rpc/rpc-client.d.ts

@@ -271,11 +271,15 @@ export declare class RpcClient {
      * The server will emit an `open_url` extension_ui_request for the auth URL.
      * Resolves when login completes or rejects on failure.
      *
-     * @param onOpenUrl Called when the server emits the auth URL. The host must open
-     *   it in a browser for the callback-server OAuth flow to complete.
+     * @param onOpenUrl Called when the server emits the auth URL. The host must
+     *   open `url` in a browser for the callback-server OAuth flow to complete.
+     *   When the flow's callback server hosts a `/launch` redirect, `launchUrl`
+     *   is a short loopback URL that 302s to `url` — hosts SHOULD surface it as
+     *   the truncation-safe copy target so terminal viewport clipping cannot
+     *   corrupt trailing OAuth query parameters (e.g. `code_challenge_method=S256`).
      */
     login(providerId: string, options?: {
-        onOpenUrl?: (url: string, instructions?: string) => void;
+        onOpenUrl?: (url: string, instructions?: string, launchUrl?: string) => void;
     }): Promise<{
         providerId: string;
     }>;

package/dist/types/modes/rpc/rpc-types.d.ts

@@ -599,6 +599,12 @@ export type RpcExtensionUIRequest = {
     id: string;
     method: "open_url";
     url: string;
+    /**
+     * Short loopback URL that 302-redirects to {@link url}. When present,
+     * hosts SHOULD surface it as the copy target so terminal viewport
+     * truncation cannot corrupt OAuth query parameters on the full URL.
+     */
+    launchUrl?: string;
     instructions?: string;
 };
 export interface RpcHostToolDefinition {

package/dist/types/modes/utils/transcript-render-helpers.d.ts

@@ -43,12 +43,21 @@ export declare function assistantHasVisibleContent(message: AssistantAgentMessag
  * array values to an empty object.
  */
 export declare function normalizeToolArgs(args: unknown): Record<string, unknown>;
+export type AssistantErrorPresentation = {
+    kind: "none";
+} | {
+    kind: "full";
+    text: string;
+    isError: true;
+} | {
+    kind: "compact-recovered";
+    text: string;
+    isError: false;
+};
 /**
- * Resolve the inline error label, if any, for a turn-ending assistant message.
- * Silent aborts yield no label. `retryAttempt` tunes the abort label wording.
+ * Resolve the turn-ending assistant error presentation, if any.
+ * Silent and user-interrupt aborts yield no label. Recovered auto-retry errors
+ * collapse to a single non-error note; terminal errors keep the full red presentation.
  */
-export declare function resolveAssistantErrorMessage(message: AssistantAgentMessage, retryAttempt?: number): {
-    hasErrorStop: boolean;
-    errorMessage: string | null;
-};
+export declare function resolveAssistantErrorPresentation(message: AssistantAgentMessage, retryAttempt?: number): AssistantErrorPresentation;
 export {};

package/dist/types/session/agent-session.d.ts

@@ -33,6 +33,7 @@ import type { LoadedCustomCommand } from "../extensibility/custom-commands";
 import type { CustomTool } from "../extensibility/custom-tools/types";
 import type { ExtensionRunner } from "../extensibility/extensions";
 import type { CompactOptions, ContextUsage } from "../extensibility/extensions/types";
+import type { RecoveredRetryError } from "../extensibility/shared-events";
 import type { Skill, SkillWarning } from "../extensibility/skills";
 import { type FileSlashCommand } from "../extensibility/slash-commands";
 import { GoalRuntime } from "../goals/runtime";
@@ -80,6 +81,7 @@ export type AgentSessionEvent = AgentEvent | {
     success: boolean;
     attempt: number;
     finalError?: string;
+    recoveredErrors?: RecoveredRetryError[];
 } | {
     type: "retry_fallback_applied";
     from: string;

package/dist/types/subprocess/worker-runtime.d.ts

@@ -69,6 +69,11 @@ export declare function replayCachedReady<K, M>(cache: Map<K, Promise<M>>, model
  * runtime's `node_modules` directory.
  */
 export declare function installSharpStubResolver(runtimeDir: string): Promise<string>;
+/**
+ * Repairs the compiled Transformers side runtime when CUDA was requested and
+ * Bun skipped `onnxruntime-node`'s NuGet sidecar install.
+ */
+export declare function ensureOnnxRuntimeCudaProviders(runtimeDir: string, device?: string | undefined): Promise<void>;
 /**
  * Lazily resolve (and memoize) the transformers version spec. In the `catalog:`
  * case {@link resolveTransformersVersionSpec} `require`s the installed
@@ -88,6 +93,12 @@ interface ConfigurableTransformers {
         ERROR: unknown;
     };
 }
+export interface TransformersRuntimeMetadata {
+    __ompRuntimeNodeModules?: string;
+    __ompTransformersEntry?: string;
+    __ompCudaRepairError?: string;
+}
+export declare function formatOnnxRuntimeCudaDiagnostics(metadata: TransformersRuntimeMetadata, requestedDevice: string, error: unknown): Promise<string | null>;
 /**
  * Memoize an async runtime load so it runs at most once per process, clearing
  * the cache on failure so a later call can retry. Each worker holds one

package/dist/types/tools/bash-skill-urls.d.ts

@@ -1,9 +1,9 @@
 import type { Skill } from "../extensibility/skills";
 import { type LocalProtocolOptions } from "../internal-urls";
-import type { InternalResource } from "../internal-urls/types";
+import type { InternalResource, ResolveContext } from "../internal-urls/types";
 interface InternalUrlResolver {
     canHandle(input: string): boolean;
-    resolve(input: string): Promise<InternalResource>;
+    resolve(input: string, context?: ResolveContext): Promise<InternalResource>;
 }
 export interface InternalUrlExpansionOptions {
     skills: readonly Skill[];

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

@@ -154,7 +154,6 @@ export declare function createShellRenderer<TArgs>(config: ShellRendererConfig<T
     }, uiTheme: Theme, args?: TArgs): Component;
     mergeCallAndResult: boolean;
     inline: boolean;
-    provisionalPendingPreview: string;
 };
 export declare const bashToolRenderer: {
     renderCall(args: BashRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
@@ -170,6 +169,5 @@ export declare const bashToolRenderer: {
     }, uiTheme: Theme, args?: BashRenderArgs | undefined): Component;
     mergeCallAndResult: boolean;
     inline: boolean;
-    provisionalPendingPreview: string;
 };
 export {};

package/dist/types/tools/browser/tab-supervisor.d.ts

@@ -16,6 +16,16 @@ export interface PendingRun {
     session: ToolSession;
     signal?: AbortSignal;
     toolCalls: Map<string, AbortController>;
+    /**
+     * Fires when `releaseTab` closes the tab out from under an in-flight run
+     * (sibling `browser close --all`, session-scoped reap, etc.). Composed
+     * into the cmux run's signal so `wait(...)`, cmux socket calls, and the
+     * facade proxies unwind promptly instead of blocking to the run's
+     * timeout. `pending.reject` still fires first so the awaiting caller
+     * sees the tab-close error immediately; `closeAc` propagates the
+     * cancellation into the still-running `runCmuxCode` body (issue #4499).
+     */
+    closeAc?: AbortController;
 }
 interface TabSessionBase<TBrowser extends BrowserHandle = BrowserHandle> {
     name: string;

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

@@ -54,7 +54,5 @@ export declare const evalToolRenderer: {
     }, uiTheme: Theme, _args?: EvalRenderArgs): Component;
     mergeCallAndResult: boolean;
     inline: boolean;
-    provisionalPendingPreview: string;
-    provisionalPartialResult: boolean;
 };
 export {};

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

@@ -21,26 +21,6 @@ export type ToolRenderer = {
     mergeCallAndResult?: boolean;
     /** Render without background box, inline in the response flow */
     inline?: boolean;
-    /**
-     * Whether pending-call rows are provisional: useful on screen while a tool is
-     * streaming, but not durable transcript history. `true` means every pending
-     * shape is provisional. `"collapsed"` means only the collapsed pending shape
-     * is provisional; expanded rendering is top-anchored/append-shaped enough to
-     * let the transcript commit its settled prefix. Absent = the pending preview
-     * streams rows the result render preserves.
-     */
-    provisionalPendingPreview?: boolean | "collapsed";
-    /**
-     * Whether the partial-result render is provisional: chrome rows (header
-     * glyph, frame state) that change between `options.isPartial === true` and
-     * the final result render. When `true`, the block is treated as
-     * commit-unstable while a partial result is in flight, so the
-     * stable-prefix ratchet in `deriveLiveCommitState` cannot promote the
-     * partial chrome to native scrollback only to have the final render strand
-     * it above the settled frame. Absent = the partial render is byte-stable
-     * with the final render and may commit like any settled stream.
-     */
-    provisionalPartialResult?: boolean;
     /**
      * Whether the renderer's pending-call path visibly consumes
      * `options.spinnerFrame`. Used to avoid scheduling repaint ticks for live

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

@@ -68,8 +68,6 @@ export declare const sshToolRenderer: {
         renderContext?: SshRenderContext;
     }, uiTheme: Theme, args?: SshRenderArgs): Component;
     mergeCallAndResult: boolean;
-    provisionalPendingPreview: boolean;
-    provisionalPartialResult: boolean;
     forceFirstResultViewportRepaint: boolean;
     forceResultViewportRepaintOnSettle: boolean;
 };

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

@@ -49,7 +49,7 @@ export declare class WriteTool implements AgentTool<typeof writeSchema, WriteToo
 interface WriteRenderArgs {
     path?: string;
     file_path?: string;
-    content?: string;
+    content?: unknown;
 }
 export declare const writeToolRenderer: {
     renderCall(args: WriteRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;