@oh-my-pi/pi-coding-agent 16.5.0 → 16.5.1

package/dist/types/advisor/advise-tool.d.ts

@@ -36,6 +36,13 @@ export declare function formatAdvisorBatchContent(notes: readonly AdvisorNote[])
  * and `blocker` interrupt; a plain `nit` queues.
  */
 export declare function isInterruptingSeverity(severity: AdvisorSeverity | undefined): boolean;
+/**
+ * Append a staleness caveat to an advisor note when newer primary turns arrived
+ * after the reviewed transcript window (i.e. `hasFreshBacklog` is true on the
+ * advisor runtime at delivery time). Pure function — no session coupling — so it
+ * can be unit-tested in isolation and called from `AgentSession#routeAdvice`.
+ */
+export declare function annotateForStaleness(note: string, hasFreshBacklog: boolean): string;
 /** How an advisor note is routed to the primary. */
 export type AdvisorDeliveryChannel = "aside" | "steer" | "preserve";
 /** Half-open turn-count fence for the post-interrupt cooldown. */
@@ -51,6 +58,9 @@ export declare function isAdvisorInterruptImmuneTurnActive(opts: {
  * - An interrupting `concern`/`blocker` is normally steered into the agent: into
  *   the live turn while one is streaming, or (when idle) a triggered turn so the
  *   advice is acted on immediately.
+ * - If the primary tail is already a terminal text answer and there is no queued
+ *   work, late interrupting advice is preserved as a visible card instead of
+ *   waking the primary to restate completion.
  * - After a deliberate user interrupt (`autoResumeSuppressed`) the advisor must
  *   not auto-resume the stopped run. While the agent is idle — or still tearing
  *   the interrupted turn down (`aborting`) — the note is preserved as a visible
@@ -60,13 +70,14 @@ export declare function isAdvisorInterruptImmuneTurnActive(opts: {
  *   run instead strands it (it never reaches the running agent) and the withheld
  *   notes dump as one burst at the next user prompt — the bug this guards.
  * - During the post-interrupt immune-turn window, further `concern`/`blocker`
- *   notes are downgraded to asides; suppression preservation still wins.
+ *   notes are downgraded to asides; preservation still wins.
  */
 export declare function resolveAdvisorDeliveryChannel(opts: {
     severity: AdvisorSeverity | undefined;
     autoResumeSuppressed: boolean;
     streaming: boolean;
     aborting: boolean;
+    terminalAnswerNoQueuedWork?: boolean;
     interruptImmuneTurnActive?: boolean;
 }): AdvisorDeliveryChannel;
 /**

package/dist/types/advisor/runtime.d.ts

@@ -1,4 +1,5 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import { type SecretObfuscator } from "../secrets/obfuscator.js";
 /**
  * Minimal slice of `Agent` the runtime drives — satisfied by pi-agent-core
@@ -59,6 +60,24 @@ export interface AdvisorRuntimeHost {
     /** Surface a non-recovering advisor failure to the host UI without adding model-visible context. */
     notifyFailure?(error: unknown): void;
 }
+/** Signals that an advisor response was discarded before it could become model-visible context. */
+export declare class AdvisorOutputQuarantinedError extends Error {
+    constructor(message: string);
+}
+/**
+ * Replaces an advisor assistant turn that requested unavailable tools or generated
+ * output-only destructive directives with a sanitized error before dispatch.
+ *
+ * The agent loop records assistant turns before dispatching tools. Without this
+ * pre-dispatch rewrite, an advisor hallucination can leave unrelated text in the
+ * advisor transcript even though the action itself never executes.
+ */
+export declare function quarantineAdvisorUnsafeOutput(message: AssistantMessage, availableToolNames: ReadonlySet<string>, sourceText?: string): string | undefined;
+/**
+ * Builds the provenance text used to decide whether hazardous advisor output was
+ * generated by the advisor or came from model-visible primary/tool context.
+ */
+export declare function buildAdvisorQuarantineSourceText(currentInput: string, messages: readonly AgentMessage[]): string;
 export declare class AdvisorRuntime {
     #private;
     private readonly agent;
@@ -67,7 +86,28 @@ export declare class AdvisorRuntime {
     disposed: boolean;
     constructor(agent: AdvisorAgent, host: AdvisorRuntimeHost, retryDelayMs?: number);
     get backlog(): number;
-    onTurnEnd(messages?: AgentMessage[]): void;
+    /**
+     * True when `#pending` is non-empty while the drain loop is busy — i.e., newer
+     * primary turns arrived after the current batch's transcript window was fixed
+     * but before the advisor model finished processing it. The delivery path uses
+     * this to annotate advice that was generated without seeing those newer turns.
+     * Can be true during `agent.prompt()`, a `maintainContext` await, or a retry
+     * sleep — any time `#drain` is busy and a concurrent `onTurnEnd` pushed.
+     */
+    get hasFreshBacklog(): boolean;
+    /**
+     * Called after each primary turn ends. Renders the incremental delta and
+     * queues it for the advisor model.
+     *
+     * @param messages - Live primary transcript snapshot (defaults to `snapshotMessages()`).
+     * @param opts.willContinue - When `true` the primary is mid-turn (more tool-call
+     *   steps will follow). The rendered heading is tagged `[in progress]` so the
+     *   advisor knows to withhold critique on partial work. The flag is carried on
+     *   the delta and forwarded to the reprime path so it is never silently dropped.
+     */
+    onTurnEnd(messages?: AgentMessage[], opts?: {
+        willContinue?: boolean;
+    }): void;
     waitForCatchup(maxMs: number, threshold: number, signal?: AbortSignal): Promise<void>;
     dispose(): void;
     /**

package/dist/types/cli/args.d.ts

@@ -79,5 +79,7 @@ export declare function parseArgs(inputArgs: string[], extensionFlags?: Map<stri
  * process (issue #2459).
  */
 export declare function reportUnrecognizedFlags(args: Pick<Args, "unrecognizedFlags">, write?: (text: string) => void): boolean;
+/** Emit a clean CLI usage error without an internal stack trace. */
+export declare function reportCliUsageError(error: unknown, write?: (text: string) => void): boolean;
 export declare function getExtraHelpText(): string;
 export declare function printHelp(): void;

package/dist/types/cli/update-cli.d.ts

@@ -21,11 +21,12 @@ export declare function parseUpdateArgs(args: string[]): {
     check: boolean;
     plugins: boolean;
 } | undefined;
-type UpdateMethod = "brew" | "mise" | "bun" | "binary";
+type UpdateMethod = "brew" | "mise" | "bun" | "npm" | "binary";
 interface UpdateMethodResolutionOptions {
     homebrewPrefix?: string;
     miseBinDirs?: readonly string[];
     miseDataDir?: string;
+    npmBinDir?: string;
 }
 export declare function resolveUpdateMethodForTest(ompPath: string, bunBinDir: string | undefined, options?: UpdateMethodResolutionOptions): UpdateMethod;
 interface BunInstallCachePruneResult {
@@ -89,6 +90,8 @@ export declare function replaceBinaryForUpdate(options: BinaryReplacementOptions
  * See #1824.
  */
 export declare function buildBunInstallArgs(expectedVersion: string, nativeTag?: string): string[];
+/** Build the npm argv used to update npm-managed global installs. */
+export declare function buildNpmInstallArgs(expectedVersion: string, nativeTag?: string): string[];
 export declare function buildHomebrewUpdateArgs(force: boolean): string[];
 export declare function buildMiseUpgradeArgs(): string[];
 export declare function buildMiseForceInstallArgs(expectedVersion: string): string[];

package/dist/types/cli/usage-cli.d.ts

@@ -26,6 +26,9 @@ export interface UsageAccountIdentity {
     accountId?: string;
     projectId?: string;
     enterpriseUrl?: string;
+    /** Organization/workspace the credential is scoped to (Anthropic multi-subscription). */
+    orgId?: string;
+    orgName?: string;
 }
 /**
  * Minimal-reveal masks for identity strings (`--redact`).

package/dist/types/cli/usage-error.d.ts

@@ -0,0 +1,4 @@
+/** Command-line input error that should be rendered without a stack trace. */
+export declare class CliUsageError extends Error {
+    constructor(message: string);
+}

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

@@ -1,4 +1,4 @@
-import type { Api, ApiKeyResolver, AuthStorage, Model } from "@oh-my-pi/pi-ai";
+import { type Api, type ApiKeyResolver, type AuthStorage, type Model } from "@oh-my-pi/pi-ai";
 /** Model slice accepted by the model-form `resolver(model, sessionId)` overload. */
 export type ApiKeyResolverModel = Pick<Model<Api>, "provider" | "baseUrl" | "id">;
 export interface ApiKeyResolverOptions {
@@ -25,7 +25,7 @@ export interface ApiKeyResolverRegistry {
     /**
      * Build an {@link ApiKeyResolver} implementing the central a/b/c auth-retry
      * policy: initial → resolve; step (b) → force-refresh same account; step (c)
-     * → rotate to a sibling credential, then re-resolve.
+     * → rotate to a sibling and re-resolve, unless quota exhaustion has no sibling.
      *
      * Two call forms: `resolver(provider, options?)` for provider-scoped keys,
      * and `resolver(model, sessionId?)` which derives `baseUrl`/`modelId` from

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

@@ -74,7 +74,7 @@ export declare class ModelRegistry {
         fetch?: FetchImpl;
     });
     /**
-     * Reload models from disk (built-in + custom from models.json).
+     * Reload models from disk (built-in + custom config).
      */
     refresh(strategy?: ModelRefreshStrategy): Promise<void>;
     refreshInBackground(strategy?: ModelRefreshStrategy): void;
@@ -94,12 +94,12 @@ export declare class ModelRegistry {
      */
     refreshRuntimeProviders(strategy?: ModelRefreshStrategy): Promise<void>;
     /**
-     * Get any error from loading models.json (undefined if no error).
+     * Get any error from loading custom models config (undefined if no error).
      */
     getError(): ConfigError | undefined;
     /**
      * Get all models (built-in + custom).
-     * If models.json had errors, returns only built-in models.
+     * If custom config had errors, returns only built-in models.
      */
     getAll(): Model<Api>[];
     /**

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

@@ -144,6 +144,7 @@ export declare function resolveModelOverride(modelPatterns: string[], modelRegis
     model?: Model<Api>;
     thinkingLevel?: ConfiguredThinkingLevel;
     explicitThinkingLevel: boolean;
+    warning?: string;
 };
 /**
  * Resolve a list of override patterns to the first matching model, with an
@@ -156,6 +157,11 @@ export declare function resolveModelOverride(modelPatterns: string[], modelRegis
  * `modelRoles.task` pointing at an unqualified id whose only available
  * provider variant has no configured credentials — see #985).
  *
+ * `sessionId` is forwarded to `getApiKey` so that session-sticky OAuth
+ * credentials resolve correctly during the pre-flight auth check. Without it,
+ * providers with multiple OAuth accounts may return `undefined` even though
+ * the credential is usable once the subagent session starts — see #5325.
+ *
  * Keyless-by-design providers (llama.cpp, ollama, lm-studio) advertise the
  * `kNoAuth` sentinel from `getApiKey` to signal that they do not require
  * credentials. Those are treated as authenticated here so an explicitly
@@ -166,11 +172,12 @@ export declare function resolveModelOverride(modelPatterns: string[], modelRegis
  * primary resolution unchanged so the existing error path still surfaces
  * a meaningful failure downstream.
  */
-export declare function resolveModelOverrideWithAuthFallback(modelPatterns: string[], parentActiveModelPattern: string | undefined, modelRegistry: ModelLookupRegistry & Pick<ModelRegistry, "getApiKey">, settings?: Settings): Promise<{
+export declare function resolveModelOverrideWithAuthFallback(modelPatterns: string[], parentActiveModelPattern: string | undefined, modelRegistry: ModelLookupRegistry & Pick<ModelRegistry, "getApiKey">, settings?: Settings, sessionId?: string): Promise<{
     model?: Model<Api>;
     thinkingLevel?: ConfiguredThinkingLevel;
     explicitThinkingLevel: boolean;
     authFallbackUsed: boolean;
+    warning?: string;
 }>;
 /**
  * Resolve a list of role patterns to the first matching model.

package/dist/types/config/models-config.d.ts

@@ -1,5 +1,5 @@
 /**
- * models.json config file handle and provider configuration validation.
+ * Custom model/provider config file handle and validation.
  */
 import type { Api, ModelSpec } from "@oh-my-pi/pi-ai/types";
 import { ConfigFile } from "./config-file.js";

package/dist/types/eval/__tests__/process-entry-import.test.d.ts

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

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

@@ -20,8 +20,16 @@ export declare const EVAL_TIMEOUT_PAUSE_OP = "timeout-pause";
 export declare const EVAL_TIMEOUT_RESUME_OP = "timeout-resume";
 /** Whether a status event is pure eval-timeout control and should not render. */
 export declare function isEvalTimeoutControlEvent(event: JsStatusEvent): boolean;
+/** Optional behavior for a timeout pause around a host bridge call. */
+export interface BridgeTimeoutPauseOptions {
+    /**
+     * Marks the pause as an `agent()` call whose already-started work must finish
+     * before an external eval abort reaches the kernel.
+     */
+    deferExternalAbort?: boolean;
+}
 /**
  * Run {@link operation} while suspending the eval watchdog through
  * {@link emitStatus}. A no-op wrapper when no status sink is wired.
  */
-export declare function withBridgeTimeoutPause<T>(emitStatus: ((event: JsStatusEvent) => void) | undefined, operation: () => Promise<T>): Promise<T>;
+export declare function withBridgeTimeoutPause<T>(emitStatus: ((event: JsStatusEvent) => void) | undefined, operation: () => Promise<T>, options?: BridgeTimeoutPauseOptions): Promise<T>;

package/dist/types/eval/js/context-manager.d.ts

@@ -13,6 +13,8 @@ export interface VmRunState {
  * {@link WORKER_CLOSE_TIMEOUT_MS}; never call this outside tests.
  */
 export declare function setWorkerCloseTimeoutMsForTests(ms: number): number;
+/** Test-only seam for the legacy Worker lifecycle mocks. */
+export declare function setJsEvalWorkerThreadForTests(enabled: boolean): boolean;
 export declare function executeInVmContext(options: {
     sessionKey: string;
     sessionId: string;
@@ -30,9 +32,9 @@ export declare function executeInVmContext(options: {
 export declare function resetVmContext(sessionKey: string): Promise<void>;
 export declare function disposeAllVmContexts(): Promise<void>;
 /**
- * Smoke probe: spawn the JS eval worker through the worker-host entry and prove
- * it answers the `init` handshake on a real worker thread (not the inline
- * fallback). Catches the silent worker-load and init-message-drop regressions
+ * Smoke probe: spawn the JS evaluator through the worker-host entry and prove
+ * it answers the `init` handshake in a real isolated subprocess (not the inline
+ * fallback). Catches silent process-load and init-message regressions
  * that otherwise strand every cell on the init timeout in a distribution build —
  * the failure mode that motivated `installWorkerInbox`. Wired into
  * `omp --smoke-test` so binary / source / tarball installs all exercise it.

package/dist/types/eval/js/process-entry.d.ts

@@ -0,0 +1,6 @@
+import type { WorkerInbound, WorkerOutbound } from "./worker-protocol.js";
+/** Start the JavaScript evaluator inside a subprocess IPC transport. */
+export declare function startJsEvalProcess(transport: {
+    send(message: WorkerOutbound): void;
+    onMessage(handler: (message: WorkerInbound) => void): () => void;
+}): void;

package/dist/types/eval/js/worker-core.d.ts

@@ -1,6 +1,20 @@
 import type { Transport } from "./worker-protocol.js";
+export type WorkerCoreOptions = {
+    mode: "isolated";
+    /**
+     * Mirror the session cwd onto the real process cwd so cell code using
+     * `process.cwd()`, relative paths, or child processes without an explicit
+     * `cwd` resolves against the project. Only the dedicated subprocess may
+     * pass this: `process.chdir` is unavailable in Worker threads and would
+     * mutate the host's own cwd on the inline fallback.
+     */
+    chdir?: (cwd: string) => void;
+} | {
+    mode: "inline";
+    interceptUnhandledRejections(handler: (reason: unknown) => boolean): () => void;
+};
 export declare class WorkerCore {
     #private;
-    constructor(transport: Transport);
+    constructor(transport: Transport, options: WorkerCoreOptions);
     dispose(): void;
 }

package/dist/types/eval/py/spawn-options.d.ts

@@ -26,6 +26,16 @@ export declare function shouldHideKernelWindow(opts: {
     platform: NodeJS.Platform;
     hostHasInheritableConsole: boolean;
 }): boolean;
+/**
+ * Keep eval kernels outside the host's POSIX terminal session.
+ *
+ * User code can start an interactive shell which calls `tcsetpgrp(3)`. If the
+ * kernel shares OMP's session, that shell can replace OMP as the controlling
+ * terminal's foreground process group and the host is then stopped by SIGTTIN
+ * on its next stdin read. Bun implements `detached: true` with `setsid(2)` on
+ * POSIX, making the kernel a session leader with no controlling terminal.
+ */
+export declare function shouldDetachKernel(platform: NodeJS.Platform): boolean;
 /**
  * TTY-based fallback used when the Win32 console probe is unavailable.
  *

package/dist/types/eval/py/tool-bridge.d.ts

@@ -4,6 +4,7 @@ export interface PyToolBridgeEntry {
     toolSession: ToolSession;
     signal?: AbortSignal;
     emitStatus?: (event: JsStatusEvent) => void;
+    abortRequested?: () => boolean;
 }
 export interface PyToolBridgeInfo {
     url: string;

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

@@ -17,6 +17,7 @@ import type { Settings } from "../../config/settings.js";
 import type { ExecOptions, ExecResult } from "../../exec/exec.js";
 import type { HookUIContext } from "../../extensibility/hooks/types.js";
 import type * as PiCodingAgent from "../../index.js";
+import type { LocalProtocolOptions } from "../../internal-urls/local-protocol.js";
 import type { Theme } from "../../modes/theme/theme.js";
 import type { ReadonlySessionManager } from "../../session/session-manager.js";
 import type { TodoItem } from "../../tools/todo.js";
@@ -84,6 +85,8 @@ export interface CustomToolContext {
     settings?: Settings;
     /** Fetch implementation for outbound HTTP; defaults to global fetch when omitted. */
     fetch?: FetchImpl;
+    /** Calling session's `local://` root mapping for tools that bridge out of the OMP process. */
+    localProtocolOptions?: LocalProtocolOptions;
     /** Whether to auto-approve all destructive tool operations (--auto-approve CLI flag) */
     autoApprove?: boolean;
 }

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

@@ -6,6 +6,7 @@ import type { CredentialDisabledEvent, ImageContent, Model, ProviderResponseMeta
 import type { KeyId } from "@oh-my-pi/pi-tui";
 import type { ModelRegistry } from "../../config/model-registry.js";
 import type { Settings } from "../../config/settings.js";
+import type { LocalProtocolOptions } from "../../internal-urls/local-protocol.js";
 import type { MemoryRuntimeContext } from "../../memory-backend/index.js";
 import type { SessionManager } from "../../session/session-manager.js";
 import type { BranchHandler, NavigateTreeHandler, NewSessionHandler } from "../session-handler-types.js";
@@ -65,7 +66,8 @@ export declare class ExtensionRunner {
     private readonly sessionManager;
     private readonly modelRegistry;
     private readonly settings?;
-    constructor(extensions: Extension[], runtime: ExtensionRuntime, cwd: string, sessionManager: SessionManager, modelRegistry: ModelRegistry, getMemory?: () => MemoryRuntimeContext | undefined, settings?: Settings | undefined);
+    private readonly localProtocolOptions?;
+    constructor(extensions: Extension[], runtime: ExtensionRuntime, cwd: string, sessionManager: SessionManager, modelRegistry: ModelRegistry, getMemory?: () => MemoryRuntimeContext | undefined, settings?: Settings | undefined, localProtocolOptions?: LocalProtocolOptions | undefined);
     initialize(actions: ExtensionActions, contextActions: ExtensionContextActions, commandContextActions?: ExtensionCommandContextActions, uiContext?: ExtensionUIContext): void;
     /**
      * Forward a `credential_disabled` event from `AuthStorage` to extension handlers.

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

@@ -22,6 +22,7 @@ import type { PythonResult } from "../../eval/py/executor.js";
 import type { BashResult } from "../../exec/bash-executor.js";
 import type { ExecOptions, ExecResult } from "../../exec/exec.js";
 import type * as PiCodingAgent from "../../index.js";
+import type { LocalProtocolOptions } from "../../internal-urls/local-protocol.js";
 import type { MemoryRuntimeContext } from "../../memory-backend/index.js";
 import type { CustomEditor } from "../../modes/components/custom-editor.js";
 import type { Theme } from "../../modes/theme/theme.js";
@@ -285,6 +286,8 @@ export interface ExtensionContext {
     sessionManager: ReadonlySessionManager;
     /** Model registry for API key resolution */
     modelRegistry: ModelRegistry;
+    /** Calling session's `local://` root mapping for external tool bridges. */
+    localProtocolOptions?: LocalProtocolOptions;
     /** Current model (may be undefined) */
     model: Model | undefined;
     /** Read-only model query facade: list / current / resolve / family. */

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

@@ -1,4 +1,4 @@
-import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types.js";
+import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext, UrlCompletion } from "./types.js";
 /**
  * Snapshot of memory roots for every registered session, deduped.
  * Each session has its own cwd (possibly a worktree), so subagents and main
@@ -11,14 +11,13 @@ export declare function memoryRootsFromRegistry(): string[];
 export declare function resolveMemoryUrlToPath(url: InternalUrl, memoryRoot: string): string;
 /**
  * Protocol handler for memory:// URLs.
- *
- * Walks every active session's memory root. Worktree-based subagents have
- * their own root; first one containing the file wins. Parent and subagent
- * sharing a cwd see the same file regardless of order.
+ * Resolves file-backed roots against the calling session cwd when provided.
+ * Contextless callers fall back to the live-session registry for legacy
+ * cross-session lookups.
  */
 export declare class MemoryProtocolHandler implements ProtocolHandler {
     readonly scheme = "memory";
     readonly immutable = true;
-    resolve(url: InternalUrl): Promise<InternalResource>;
-    complete(): Promise<UrlCompletion[]>;
+    resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource>;
+    complete(_query?: string, context?: ResolveContext): Promise<UrlCompletion[]>;
 }

package/dist/types/main.d.ts

@@ -53,6 +53,7 @@ export declare class SessionResolutionError extends Error {
     readonly hint?: string;
     constructor(message: string, hint?: string);
 }
+export declare function normalizeContinueSessionArgs(parsed: Args, rawArgs?: readonly string[]): void;
 /** 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>;
 /** Apply resolved CLI/discovered prompt files without bypassing system prompt templates. */

package/dist/types/modes/components/transcript-container.d.ts

@@ -1,4 +1,4 @@
-import { type Component, Container, type NativeScrollbackCommittedRows, type NativeScrollbackLiveRegion, type RenderStablePrefix, type ViewportTailProvider } from "@oh-my-pi/pi-tui";
+import { type Component, Container, type NativeScrollbackCommittedRows, type NativeScrollbackLiveRegion, type NativeScrollbackReplay, type RenderStablePrefix, type ViewportTailProvider } from "@oh-my-pi/pi-tui";
 /**
  * Transcript container that renders every block's current content each frame
  * and reports the native-scrollback exactness boundary
@@ -24,11 +24,12 @@ import { type Component, Container, type NativeScrollbackCommittedRows, type Nat
  * through {@link RenderStablePrefix} so the engine can skip marker scanning,
  * line preparation, and the committed-prefix audit for those rows.
  */
-export declare class TranscriptContainer extends Container implements NativeScrollbackLiveRegion, NativeScrollbackCommittedRows, RenderStablePrefix, ViewportTailProvider {
+export declare class TranscriptContainer extends Container implements NativeScrollbackLiveRegion, NativeScrollbackCommittedRows, NativeScrollbackReplay, RenderStablePrefix, ViewportTailProvider {
     #private;
     invalidate(): void;
     clear(): void;
     setNativeScrollbackCommittedRows(rows: number): void;
+    prepareNativeScrollbackReplay(): void;
     getRenderStablePrefixRows(): number;
     getNativeScrollbackLiveRegionStart(): number | undefined;
     /**

package/dist/types/modes/magic-keyword-boundary.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Build a case-sensitive magic-keyword matcher for prose punctuation boundaries.
+ *
+ * Sentence punctuation and quotes may touch the keyword, but letters, digits,
+ * underscores, slashes, backslashes, hyphens, file-extension dots, symbol
+ * references (`foo::keyword`), and immediate call parentheses (`keyword()`)
+ * keep the occurrence embedded in code rather than prose.
+ */
+export declare function magicKeywordRegex(keyword: string, flags?: string): RegExp;

package/dist/types/modes/orchestrate.d.ts

@@ -3,7 +3,7 @@ import { type KeywordHighlighter } from "./gradient-highlight.js";
 export declare const ORCHESTRATE_NOTICE: string;
 /**
  * Whether `text` contains the standalone keyword "orchestrate" (lowercase,
- * whitespace-delimited) in prose — never inside a code block, inline code span,
+ * prose-delimited) in prose — never inside a code block, inline code span,
  * or XML/HTML section.
  */
 export declare function containsOrchestrate(text: string): boolean;

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

@@ -12,5 +12,7 @@ export declare class RpcHostToolBridge {
     handleUpdate(frame: RpcHostToolUpdate): boolean;
     requestExecution(definition: RpcHostToolDefinition, toolCallId: string, args: Record<string, unknown>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<unknown>): Promise<AgentToolResult<unknown>>;
     rejectAllPending(message: string): void;
+    /** Reject active and future host tool requests after the RPC client disconnects. */
+    close(message: string): void;
 }
 export {};

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

@@ -8,6 +8,13 @@ export type PendingExtensionRequest = {
     resolve: (response: RpcExtensionUIResponse) => void;
     reject: (error: Error) => void;
 };
+/** Pending extension UI request map that can fail closed when the RPC client disconnects. */
+export declare class RpcPendingExtensionRequests extends Map<string, PendingExtensionRequest> {
+    #private;
+    set(id: string, request: PendingExtensionRequest): this;
+    /** Reject every active and future extension UI request. */
+    rejectAll(message: string): void;
+}
 type RpcOutput = (obj: RpcResponse | RpcExtensionUIRequest | RpcHostToolCallRequest | RpcHostToolCancelRequest | RpcHostUriRequest | RpcHostUriCancelRequest | object) => void;
 export type RpcSessionChangeCommand = Extract<RpcCommand, {
     type: "new_session";
@@ -84,15 +91,16 @@ export interface RpcInputFrameDeps {
     onHostToolUpdate: (frame: RpcHostToolUpdate) => void;
     onHostUriResult: (frame: RpcHostUriResult) => void;
 }
+/** Dispatch side-channel frames that must overtake the serialized command queue. */
+export declare function dispatchRpcControlFrame(parsed: unknown, deps: RpcInputFrameDeps): boolean;
 /**
  * Dispatch a single parsed frame from the RPC input stream.
  *
- * Bash commands are dispatched in the background so the caller (the stdin loop
- * in {@link runRpcMode}) can keep reading subsequent frames while a shell
- * command is still running. This lets a client send `abort_bash` (or any other
- * command) while a long-running `bash` is in flight. Response correlation is
- * preserved via each command's `id`; ordering across concurrent commands is
- * not guaranteed and clients MUST match on `id`.
+ * Bash commands are dispatched in the background so the caller can keep reading
+ * subsequent frames while a shell command is still running. This lets a client
+ * send `abort_bash` while a long-running `bash` is in flight. Response
+ * correlation is preserved via each command's `id`; ordering across concurrent
+ * commands is not guaranteed and clients MUST match on `id`.
  *
  * @returns `undefined` when the frame was routed to a side-channel handler
  *   (extension UI response, host tool/URI frames) or dispatched in the
@@ -101,6 +109,18 @@ export interface RpcInputFrameDeps {
  *   on non-`bash` commands propagate; the caller is expected to wrap them.
  */
 export declare function dispatchRpcInputFrame(parsed: unknown, deps: RpcInputFrameDeps): Promise<void> | undefined;
+/** Serializes ordinary RPC commands while allowing control frames to dispatch immediately. */
+export declare class RpcInputDispatcher {
+    #private;
+    constructor(options: {
+        deps: RpcInputFrameDeps;
+        afterSerialCommand?: () => Promise<void>;
+    });
+    /** Accept a parsed input frame without blocking the stdin reader. */
+    dispatch(parsed: unknown): void;
+    /** Await every accepted serial command, including commands queued before EOF. */
+    drain(): Promise<void>;
+}
 /**
  * Coordinates deferred shutdown with in-flight background input tasks.
  *

package/dist/types/modes/ultrathink.d.ts

@@ -3,7 +3,7 @@ import { type KeywordHighlighter } from "./gradient-highlight.js";
 export declare const ULTRATHINK_NOTICE: string;
 /**
  * Whether `text` contains the standalone keyword "ultrathink" (lowercase,
- * whitespace-delimited) in prose — never inside a code block, inline code span,
+ * prose-delimited) in prose — never inside a code block, inline code span,
  * or XML/HTML section.
  */
 export declare function containsUltrathink(text: string): boolean;

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

@@ -38,6 +38,18 @@ export declare function buildFileMentionBlock(files: FileMentionMessage["files"]
  * canonicalization) — i.e. content that closes the current read-tool run.
  */
 export declare function assistantHasVisibleContent(message: AssistantAgentMessage): boolean;
+/**
+ * Split mixed assistant turns into visible text before tool execution and
+ * visible text segments that must render immediately after the preceding tool.
+ * Cursor can return intro text, tool calls, progress text, and the final answer
+ * in one assistant message; keeping every text block in the leading assistant
+ * block buries post-tool text above tool results in the transcript.
+ */
+export declare function splitAssistantMessageToolTimeline(message: AssistantAgentMessage): {
+    beforeTools: AssistantAgentMessage;
+    afterToolCalls: ReadonlyMap<string, AssistantAgentMessage>;
+    hasToolCalls: boolean;
+};
 /**
  * Normalize raw tool-call arguments to a plain record, collapsing non-object or
  * array values to an empty object.

package/dist/types/modes/workflow.d.ts

@@ -7,7 +7,7 @@ export declare function renderWorkflowNotice({ taskBatch }: {
 }): string;
 /**
  * Whether `text` contains the standalone keyword "workflowz"
- * (lowercase, whitespace-delimited) in prose — never inside a code block, inline
+ * (lowercase, prose-delimited) in prose — never inside a code block, inline
  * code span, or XML/HTML section.
  */
 export declare function containsWorkflow(text: string): boolean;

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

@@ -811,6 +811,11 @@ export declare class AgentSession {
      * from role configuration (e.g., "anthropic/claude-sonnet-4-5:xhigh").
      */
     resolveRoleModelWithThinking(role: string): ResolvedModelRoleValue;
+    /**
+     * Resolve the explicit thinking suffix that should apply when a temporary
+     * picker selects a model already assigned to a configured role.
+     */
+    resolveTemporaryModelThinkingLevel(model: Model): ConfiguredThinkingLevel | undefined;
     get promptTemplates(): ReadonlyArray<PromptTemplate>;
     /** Replace file-based slash commands used for prompt expansion. */
     setSlashCommands(slashCommands: FileSlashCommand[]): void;
@@ -872,6 +877,7 @@ export declare class AgentSession {
         triggerTurn?: boolean;
         deliverAs?: "steer" | "followUp" | "nextTurn";
         queueChipText?: string;
+        acceptTerminalEmptyStop?: boolean;
     }): Promise<boolean>;
     /**
      * Send a user message through the prompt flow.

package/dist/types/session/exit-diagnostics.d.ts

@@ -1,3 +1,4 @@
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import type { SessionEntry } from "./session-entries.js";
 export declare const TOOL_EXECUTION_START_CUSTOM_TYPE = "tool_execution_start";
 export declare const SESSION_EXIT_CUSTOM_TYPE = "session_exit";
@@ -35,6 +36,16 @@ export interface SessionExitData {
     recordedAt: string;
     pendingToolCalls?: PendingToolCallDiagnostic[];
 }
+export interface AssistantModelMetadata {
+    api: AssistantMessage["api"];
+    provider: string;
+    model: string;
+}
+/**
+ * createInterruptedTurnAbortMessage returns a terminal assistant record when
+ * the latest persisted process exit follows a non-terminal conversation tail.
+ */
+export declare function createInterruptedTurnAbortMessage(entries: readonly SessionEntry[], fallbackModel?: AssistantModelMetadata): AssistantMessage | undefined;
 /**
  * Project full tool-call arguments down to the fields the pending-tool-call
  * resume warning actually renders (`command`/`path`), truncated. Returns