@oh-my-pi/pi-coding-agent 16.4.4 → 16.4.6

package/dist/types/async/job-manager.d.ts

@@ -15,6 +15,12 @@ export interface AsyncJob {
      * supply an id (e.g. legacy tests, SDK consumers without an agent context).
      */
     ownerId?: string;
+    /**
+     * Registry id of the subagent this job runs (task/tan/vibe jobs). Lets
+     * job-view code link a job row to its AgentRegistry ref even when the job
+     * id differs from the agent id (vibe turn jobs, tan clones).
+     */
+    agentId?: string;
     /**
      * Job is registered but parked behind a caller-managed gate (e.g. a task
      * batch semaphore). Queued jobs do not count toward the running-job limit
@@ -37,6 +43,8 @@ export interface AsyncJobRegisterOptions {
     id?: string;
     /** Registry id of the agent that owns this job; used to scope cancelAll. */
     ownerId?: string;
+    /** Registry id of the subagent this job runs; see {@link AsyncJob.agentId}. */
+    agentId?: string;
     onProgress?: (text: string, details?: Record<string, unknown>) => void | Promise<void>;
     /** Register the job in queued state; see {@link AsyncJob.queued}. */
     queued?: boolean;

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

@@ -30,7 +30,7 @@ export interface BenchRunSuccess {
     ttftMs: number;
     durationMs: number;
     outputTokens: number;
-    /** Generation throughput measured over the post-first-token window. */
+    /** Output tokens/sec over the total request duration. */
     tokensPerSecond: number;
 }
 export interface BenchRunFailure {
@@ -74,12 +74,6 @@ export interface BenchDependencies {
     now?: () => number;
     stdoutIsTTY?: boolean;
 }
-/**
- * Tokens/s over the generation window (duration minus TTFT) so queue/prefill
- * latency does not dilute throughput. Falls back to total duration when the
- * response arrived as a single chunk (TTFT ~ duration).
- */
-export declare function computeTokensPerSecond(outputTokens: number, durationMs: number, ttftMs: number, deltaChunkCount: number): number;
 export declare function formatBenchTable(summary: BenchSummary): string;
 export declare function runBenchCommand(command: BenchCommandArgs, deps?: BenchDependencies): Promise<BenchSummary>;
 export {};

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

@@ -9,6 +9,7 @@
  */
 import { type UsageHistoryEntry, type UsageReport } from "@oh-my-pi/pi-ai";
 export interface UsageCommandArgs {
+    action?: string;
     json?: boolean;
     provider?: string;
     redact?: boolean;

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

@@ -4,6 +4,13 @@
 import { Command } from "@oh-my-pi/pi-utils/cli";
 export default class Usage extends Command {
     static description: string;
+    static args: {
+        action: import("@oh-my-pi/pi-utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+            options: string[];
+        };
+    };
     static flags: {
         json: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
             char: string;

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

@@ -1384,7 +1384,7 @@ export declare const SETTINGS_SCHEMA: {
             readonly tab: "model";
             readonly group: "Retry & Fallback";
             readonly label: "Retry Fallback Chains";
-            readonly description: 'JSON object mapping model roles to ordered fallback model selectors, e.g. {"default":["openai/gpt-4o-mini"]}.';
+            readonly description: 'JSON object mapping model roles, model selectors ("provider/model-id"), or provider wildcards ("provider/*") to ordered fallback selectors, e.g. {"default":["openai/gpt-4o-mini"],"google-antigravity/*":["google/*","google-vertex/*"]}. Model-oriented keys apply whenever that model/provider is active, regardless of role; a "provider/*" entry keeps the failing model\'s id and swaps the provider.';
         };
     };
     readonly "retry.fallbackRevertPolicy": {
@@ -3749,6 +3749,16 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Enable the web_search tool for live web results";
         };
     };
+    readonly "ask.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly group: "Available Tools";
+            readonly label: "Ask";
+            readonly description: "Enable the ask tool for interactive user questions";
+        };
+    };
     readonly "browser.enabled": {
         readonly type: "boolean";
         readonly default: true;
@@ -4291,36 +4301,36 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly "task.softRequestBudget": {
         readonly type: "number";
-        readonly default: 90;
+        readonly default: 200;
         readonly ui: {
             readonly tab: "tasks";
             readonly group: "Subagents";
             readonly label: "Soft Subagent Request Budget";
-            readonly description: "Soft per-subagent request budget (assistant requests per run). Crossing it can inject a steering notice when task.softRequestBudgetNotice is enabled; at 1.5x the budget the run is aborted gracefully, salvaging partial output. 0 disables the guard. Bundled scout/sonic agents use a lower built-in budget.";
+            readonly description: "Soft per-subagent request budget (assistant requests per run). Crossing it injects a wrap-up steering notice (see task.softRequestBudgetNotice); at 1.5x the budget the run is force-stopped and the agent must yield its partial findings. 0 disables the guard. Bundled scout/sonic agents use a lower built-in budget.";
             readonly options: readonly [{
                 readonly value: "0";
                 readonly label: "Disabled";
-            }, {
-                readonly value: "40";
-                readonly label: "40 requests";
             }, {
                 readonly value: "90";
                 readonly label: "90 requests";
-                readonly description: "Default";
             }, {
                 readonly value: "150";
                 readonly label: "150 requests";
+            }, {
+                readonly value: "200";
+                readonly label: "200 requests";
+                readonly description: "Default";
             }];
         };
     };
     readonly "task.softRequestBudgetNotice": {
         readonly type: "boolean";
-        readonly default: false;
+        readonly default: true;
         readonly ui: {
             readonly tab: "tasks";
             readonly group: "Subagents";
             readonly label: "Soft Request Budget Notice";
-            readonly description: "Inject one steering notice when a subagent crosses its soft request budget. Off by default; enabling it asks the child to wrap up before the 1.5x graceful abort guard.";
+            readonly description: "Inject one steering notice when a subagent crosses its soft request budget, asking it to wrap up before the 1.5x forced-yield stop.";
         };
     };
     readonly "task.disabledAgents": {

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

@@ -129,9 +129,10 @@ export declare class Settings {
      */
     getBashInterceptorRules(): BashInterceptorRule[];
     /**
-     * Set a model role (helper for modelRoles record).
+     * Set a model role (helper for modelRoles record). Passing `undefined`
+     * clears the role from the persisted record and any runtime override.
      */
-    setModelRole(role: ModelRole | string, modelId: string): void;
+    setModelRole(role: ModelRole | string, modelId: string | undefined): void;
     /**
      * Get a model role (helper for modelRoles record).
      */

package/dist/types/discovery/helpers.d.ts

@@ -1,8 +1,8 @@
-import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { ExtensionModule } from "../capability/extension-module.js";
 import { type Rule } from "../capability/rule.js";
 import type { Skill } from "../capability/skill.js";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types.js";
+import { type ConfiguredThinkingLevel } from "../thinking.js";
 /**
  * Standard paths for each config source.
  */
@@ -107,7 +107,7 @@ export interface ParsedAgentFields {
     spawns?: string[] | "*";
     model?: string[];
     output?: unknown;
-    thinkingLevel?: ThinkingLevel;
+    thinkingLevel?: ConfiguredThinkingLevel;
     autoloadSkills?: string[];
     readSummarize?: boolean;
     blocking?: boolean;

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

@@ -42,6 +42,40 @@ export interface ExtensionUISelectOption {
     description?: string;
 }
 export type ExtensionUISelectItem = string | ExtensionUISelectOption;
+export interface ExtensionAskDialogOption {
+    label: string;
+    description?: string;
+    preview?: string;
+}
+export interface ExtensionAskDialogQuestion {
+    id: string;
+    question: string;
+    header?: string;
+    options: ExtensionAskDialogOption[];
+    multi?: boolean;
+    recommended?: number;
+}
+export interface ExtensionAskDialogResultItem {
+    id: string;
+    question: string;
+    options: string[];
+    multi: boolean;
+    selectedOptions: string[];
+    customInput?: string;
+    note?: string;
+    timedOut?: boolean;
+}
+export interface ExtensionAskDialogSubmitResult {
+    kind: "submit";
+    results: ExtensionAskDialogResultItem[];
+}
+/** Chat-redirect result: the user chose "Chat about this" instead of
+ *  answering. Distinct from `undefined` (cancel) so AskTool can hand off to
+ *  the chat loop rather than aborting. */
+export interface ExtensionAskDialogChatResult {
+    kind: "chat";
+}
+export type ExtensionAskDialogResult = ExtensionAskDialogSubmitResult | ExtensionAskDialogChatResult;
 export declare function getExtensionUISelectOptionLabel(option: ExtensionUISelectItem): string;
 /**
  * UI dialog options for extensions.
@@ -108,6 +142,8 @@ export interface ExtensionUIContext {
     confirm(title: string, message: string, dialogOptions?: ExtensionUIDialogOptions): Promise<boolean>;
     /** Show a text input dialog. */
     input(title: string, placeholder?: string, dialogOptions?: ExtensionUIDialogOptions): Promise<string | undefined>;
+    /** Show the rich ask dialog when the interactive TUI surface is available. */
+    askDialog?(questions: ExtensionAskDialogQuestion[], dialogOptions?: ExtensionUIDialogOptions): Promise<ExtensionAskDialogResult | undefined>;
     /** Show a notification to the user. */
     notify(message: string, type?: "info" | "warning" | "error"): void;
     /** Listen to raw terminal input (interactive mode only). Returns an unsubscribe function. */

package/dist/types/irc/bus.d.ts

@@ -77,6 +77,10 @@ export declare class IrcBus {
         from?: string;
     }, timeoutMs: number, signal?: AbortSignal, options?: {
         drainPending?: boolean;
+        liveness?: {
+            registry: AgentRegistry;
+            senderId: string;
+        };
     }): Promise<IrcMessage | null>;
     /** Drain (or peek) pending messages for `agentId`. */
     inbox(agentId: string, opts?: {

package/dist/types/modes/components/__tests__/pause-screen.test.d.ts

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

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

@@ -0,0 +1,27 @@
+import { type Component, type TUI } from "@oh-my-pi/pi-tui";
+import type { ExtensionAskDialogQuestion, ExtensionAskDialogSubmitResult } from "../../extensibility/extensions/index.js";
+/** Bound a prompt editor title to a fixed row/width budget so long or
+ *  multi-line questions stay usable inside the small prompt overlay. */
+export declare function boundPromptTitle(prefix: string, question: string): string;
+interface AskDialogCallbacks {
+    onSubmit(result: ExtensionAskDialogSubmitResult): void;
+    onCancel(): void;
+    onPrompt(title: string, prefill?: string): Promise<string | undefined>;
+}
+interface AskDialogOptions {
+    timeout?: number;
+    onTimeout?: () => void;
+    tui?: TUI;
+}
+export declare class AskDialogComponent implements Component {
+    #private;
+    private readonly questions;
+    private readonly callbacks;
+    private readonly options;
+    constructor(questions: ExtensionAskDialogQuestion[], callbacks: AskDialogCallbacks, options?: AskDialogOptions);
+    invalidate(): void;
+    dispose(): void;
+    handleInput(keyData: string): void;
+    render(width: number): readonly string[];
+}
+export {};

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

@@ -86,14 +86,9 @@ export declare class CustomEditor extends Editor {
     static readonly SHIMMER_FRAME_MS = 70;
     /** Time for the gradient to sweep one full cycle across each keyword. */
     static readonly SHIMMER_PERIOD_MS = 1800;
-    /** Gradient-highlight the "ultrathink" / "orchestrate" / "workflowz" keywords as the user types
-     *  them, skipping any occurrence inside code spans, fenced blocks, or XML sections. Also make
-     *  pasted image placeholders visually distinct and hyperlink them once their blob file exists.
-     *  When the editor is focused, the buffer contains a magic keyword, and `magicKeywords.enabled`
-     *  is on, the gradient shifts every frame to produce a Claude-Code-style shimmer; each render
-     *  schedules the next frame, so losing focus, deleting the keyword, or flipping the setting
-     *  stops the animation on its own. The static glow itself runs even when shimmering is gated
-     *  off, matching existing behavior for the editor and sent bubbles. */
+    /** Decorate magic keywords, attachments, and the queue-composer header/list markers.
+     *  Queue shorthand reserves its first logical line as a dim `Queueing` label; sequential
+     *  item markers use the accent color so separate follow-ups remain visible while composing. */
     decorateText: (text: string) => string;
     /** Optional test/host override for the magic-keyword shimmer gate. When
      *  defined, takes precedence over the global `magicKeywords.enabled` setting,

package/dist/types/modes/components/index.d.ts

@@ -16,7 +16,8 @@ export * from "./hook-selector.js";
 export * from "./keybinding-hints.js";
 export * from "./login-dialog.js";
 export * from "./logout-account-selector.js";
-export * from "./model-selector.js";
+export * from "./model-browser.js";
+export * from "./model-hub.js";
 export * from "./oauth-selector.js";
 export * from "./queue-mode-selector.js";
 export * from "./read-tool-group.js";

package/dist/types/modes/components/model-browser.d.ts

@@ -0,0 +1,100 @@
+import type { Model } from "@oh-my-pi/pi-ai";
+import { type Component, type SgrMouseEvent } from "@oh-my-pi/pi-tui";
+import type { Settings } from "../../config/settings.js";
+import type { ModelPerfStats } from "../../session/agent-storage.js";
+import { type ConfiguredThinkingLevel } from "../../thinking.js";
+/** One selectable model row. `selector` is the canonical `provider/id` key. */
+export interface ModelBrowserItem {
+    provider: string;
+    id: string;
+    model: Model;
+    selector: string;
+}
+/** Resolved role assignment as displayed by the browser and the hub. */
+export interface RoleAssignment {
+    model: Model;
+    thinkingLevel: ConfiguredThinkingLevel;
+    /** True when the role has no configured value and fell back to auto-selection. */
+    autoSelected: boolean;
+}
+/** Map of role id to its resolved assignment (absent roles are unresolved). */
+export type RoleAssignments = Record<string, RoleAssignment | undefined>;
+/** Wrap raw models into browser items. */
+export declare function buildBrowserItems(models: ReadonlyArray<Model>): ModelBrowserItem[];
+/** Options for {@link sortModelItems}. */
+export interface SortModelItemsOptions {
+    roles?: RoleAssignments;
+    mruOrder?: ReadonlyArray<string>;
+    /**
+     * When a search query is narrowing the list, role assignments should NOT
+     * promote a weakly-matching default model above a perfect text match —
+     * defer to MRU/version instead so user affinity drives the order.
+     */
+    skipRoleRank?: boolean;
+}
+/**
+ * Order models for display: role-assigned first, then most-recently-used,
+ * then per provider by priority, version, and recency.
+ */
+export declare function sortModelItems(items: ModelBrowserItem[], options?: SortModelItemsOptions): void;
+/** Compact glyph for a configured thinking level; empty for `inherit` (nothing to show). */
+export declare function thinkingLevelGlyph(level: ConfiguredThinkingLevel): string;
+/**
+ * A slim role chip: `●default ◉` — solid dot for configured assignments,
+ * hollow for auto-selected fallbacks, thinking glyph attached when set.
+ */
+export declare function formatRoleChip(role: string, assignment: RoleAssignment, settings: Settings): string;
+/** Behavior switches for {@link ModelBrowser}. */
+export interface ModelBrowserOptions {
+    /** Render the dim `provider/` prefix before model ids. Default true. */
+    showProvider?: boolean;
+    /** Session token count used to disable models whose context window is exceeded. */
+    currentContextTokens?: number;
+    /** When true, rows over the current context are unselectable (session-switch mode). */
+    disableOverContext?: boolean;
+    /** Host-provided empty-state text (e.g. provider discovery status). */
+    emptyText?: () => string | undefined;
+    initialQuery?: string;
+}
+/**
+ * The reusable browser component. Renders a fixed-height block
+ * (`maxVisible + LIST_ROW_START + DETAIL_ROWS` rows) so host mouse geometry
+ * stays stable across renders.
+ */
+export declare class ModelBrowser implements Component {
+    #private;
+    /** Enter or click-on-selected. */
+    onActivate?: (item: ModelBrowserItem) => void;
+    onSelectionChange?: (item: ModelBrowserItem | undefined) => void;
+    onQueryChange?: (query: string) => void;
+    /** Cancel key with an empty query (a non-empty query is cleared first). */
+    onCancel?: () => void;
+    constructor(settings: Settings, options?: ModelBrowserOptions);
+    /** Replace the scope's base items; the live query re-applies and selection is pinned by selector. */
+    setItems(items: ModelBrowserItem[]): void;
+    setRoles(roles: RoleAssignments): void;
+    setMruOrder(order: ReadonlyArray<string>): void;
+    /** Measured TPS/TTFT averages keyed by `provider/id` selector (see AgentStorage.getModelPerf). */
+    setPerfStats(perf: ReadonlyMap<string, ModelPerfStats>): void;
+    setMaxVisible(rows: number): void;
+    setShowProvider(show: boolean): void;
+    /** Total rendered height for the current `maxVisible` (host layout budgeting). */
+    get renderedRows(): number;
+    get query(): string;
+    setQuery(query: string): void;
+    getSelected(): ModelBrowserItem | undefined;
+    get visibleCount(): number;
+    /** Move selection to `selector`; false when it is not in the current view. */
+    selectSelector(selector: string): boolean;
+    moveSelection(delta: number): void;
+    handleInput(data: string): void;
+    /** Cancel-key ladder: clear a non-empty query first, then bubble to the host. */
+    handleCancel(): void;
+    /**
+     * Route a mouse event. `line` is relative to the browser's first rendered
+     * row (the search row).
+     */
+    routeMouse(event: SgrMouseEvent, line: number): void;
+    render(width: number): string[];
+    invalidate(): void;
+}

package/dist/types/modes/components/model-hub.d.ts

@@ -0,0 +1,52 @@
+import type { Model } from "@oh-my-pi/pi-ai";
+import { type Component, type TUI } from "@oh-my-pi/pi-tui";
+import type { ModelRegistry } from "../../config/model-registry.js";
+import type { Settings } from "../../config/settings.js";
+import { type ConfiguredThinkingLevel } from "../../thinking.js";
+/** `roles` is the full /models hub; `pick` is a one-shot session/embedded picker. */
+export type ModelHubMode = "roles" | "pick";
+/** A `--models` scope entry (mirrors the session's scoped model list). */
+export interface ScopedModelItem {
+    model: Model;
+    thinkingLevel?: string;
+}
+export interface ModelHubCallbacks {
+    /** Persist a role assignment. */
+    onAssign: (model: Model, role: string, thinkingLevel: ConfiguredThinkingLevel | undefined, selector: string) => void;
+    /** Clear a configured role back to auto-selection. */
+    onUnassign: (role: string) => void;
+    /** Persist a `retry.fallbackChains` entry — keyed by a role, `provider/model-id`, or `provider/*`; an empty chain clears the key. */
+    onFallbackChainChange?: (role: string, chain: string[]) => void;
+    /** Pick-mode activation: session-only switch or embedded pick. */
+    onPick?: (model: Model, selector: string) => void;
+    /** Locked provider activation: forward to the /login flow. */
+    onLoginRequest?: (providerId: string) => void;
+    /** Persist a new quick-switch cycle order (the ctrl+p role cycle). */
+    onCycleOrderChange?: (order: string[]) => void;
+    onCancel: () => void;
+}
+export interface ModelHubOptions {
+    mode?: ModelHubMode;
+    /** Session token count; in pick mode, models with smaller context windows are disabled. */
+    currentContextTokens?: number;
+    /** Preselect this provider's sidebar entry (e.g. when reopening after /login). */
+    initialProviderId?: string;
+    /** Status-row hint shown in pick mode. */
+    pickerHint?: string;
+    initialQuery?: string;
+}
+/** Test hook: forget which providers were auto-refreshed this process. */
+export declare function resetProviderAutoRefreshGuard(): void;
+/**
+ * The fullscreen model hub component. Hosted via `ui.showOverlay(..., { fullscreen: true })`;
+ * the host must call {@link ModelHubComponent.dispose} when the overlay closes.
+ */
+export declare class ModelHubComponent implements Component {
+    #private;
+    constructor(tui: TUI, settings: Settings, registry: ModelRegistry, scopedModels: ReadonlyArray<ScopedModelItem>, callbacks: ModelHubCallbacks, options?: ModelHubOptions);
+    /** Cancel pending provider refresh timers and the spinner. Host calls this on overlay close. */
+    dispose(): void;
+    invalidate(): void;
+    handleInput(data: string): void;
+    render(width: number): string[];
+}

package/dist/types/modes/components/pause-screen.d.ts

@@ -0,0 +1,43 @@
+import { type Component, type OverlayFocusOwner, type OverlayHandle, type OverlayOptions } from "@oh-my-pi/pi-tui";
+/**
+ * Slice of `InteractiveModeContext` the pause screen drives. Narrow so tests
+ * can exercise the full engage → hold → release lifecycle without a real TUI.
+ */
+export interface PauseScreenHost {
+    ui: {
+        showOverlay(component: Component, options?: OverlayOptions): OverlayHandle;
+        setFocus(component: Component): void;
+        requestRender(): void;
+        readonly terminal: {
+            readonly rows: number;
+        };
+    };
+    showStatus(message: string, options?: {
+        dim?: boolean;
+    }): void;
+    readonly sessionName?: string;
+}
+/**
+ * Paint the pause scene as exactly `height` rows, vertically centered.
+ * Exported for tests.
+ */
+export declare function renderPauseScreen(width: number, height: number, elapsedMs: number, sessionName?: string): string[];
+/** Fullscreen overlay component; resolves {@link run} when a resume key lands. */
+export declare class PauseScreenComponent implements Component, OverlayFocusOwner {
+    #private;
+    readonly host: PauseScreenHost;
+    constructor(host: PauseScreenHost);
+    /** Start the clock; resolves once the user asks to resume. */
+    run(): Promise<void>;
+    dispose(): void;
+    ownsOverlayFocusTarget(component: Component): boolean;
+    handleInput(data: string): void;
+    render(width: number): readonly string[];
+}
+/**
+ * Engage the global pause gate and hold the fullscreen pause screen until the
+ * user resumes. No-op when the gate is already engaged. Always releases the
+ * gate on the way out (including teardown throws) — a leaked pause would
+ * freeze every agent in the process with no UI left to release it.
+ */
+export declare function runPauseScreen(host: PauseScreenHost): Promise<void>;

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

@@ -9,6 +9,9 @@ export type SessionHistoryMatcher = (query: string) => string[];
  * 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, but weak pure fuzzy tokens are dropped as noise.
+ *
+ * This is the synchronous reference implementation; {@link SessionList} runs
+ * the same primitives incrementally so huge listings never block a keystroke.
  */
 export declare function rankSessionSearchMatches(allSessions: SessionInfo[], query: string): SessionInfo[];
 /**
@@ -35,9 +38,13 @@ declare class SessionList implements Component {
     onExit: () => void;
     onToggleScope?: () => void;
     onDeleteRequest?: (session: SessionInfo) => void;
+    /** Re-render hook for async list updates (fuzzy scan chunks, history merge). */
+    onRequestRender?: () => void;
     constructor(sessions: SessionInfo[], showCwd?: boolean, historyMatcher?: SessionHistoryMatcher, getTerminalRows?: () => number);
     /** Replace the visible dataset, e.g. when toggling folder/all-projects scope. */
     setSessions(sessions: SessionInfo[], showCwd: boolean): void;
+    /** Cancel pending async search work; idempotent, called on every picker exit path. */
+    dispose(): void;
     removeSession(sessionPath: string): void;
     /** Resolve a list-local rendered-line index to a filtered-session index. */
     hitTestSession(line: number): number | undefined;
@@ -76,6 +83,12 @@ export declare class SessionSelectorComponent extends Container {
     #private;
     constructor(sessions: SessionInfo[], onSelect: (session: SessionInfo) => void, onCancel: () => void, onExit: () => void, options?: SessionSelectorOptions);
     setOnRequestRender(callback: () => void): void;
+    /**
+     * Dispose the session list explicitly: while the delete-confirmation dialog
+     * is mounted the list is detached from the child tree, so Container's
+     * child-walking dispose would miss its pending history-merge timer.
+     */
+    dispose(): void;
     /**
      * Concatenate the children's renders (like {@link Container}) while recording
      * the line where the session list begins, so the fullscreen picker can hit-

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

@@ -32,6 +32,8 @@ export interface ToolExecutionHandle extends Component {
     }, isPartial?: boolean, toolCallId?: string): void;
     setArgsComplete(toolCallId?: string): void;
     setExpanded(expanded: boolean): void;
+    /** Freeze the block as final history: stop spinners and let it commit to scrollback. */
+    seal(): void;
 }
 /** Redraw live tool blocks at the spinner's glyph-advance rate. Rendering more
  * often produced identical frames — the previous 30fps cadence emitted ~2.4

package/dist/types/modes/controllers/extension-ui-controller.d.ts

@@ -1,6 +1,6 @@
 import type { Component, TUI } from "@oh-my-pi/pi-tui";
 import { KeybindingsManager } from "../../config/keybindings.js";
-import type { ExtensionUIContext, ExtensionUIDialogOptions, ExtensionUISelectItem, ExtensionWidgetContent, ExtensionWidgetOptions, TerminalInputHandler } from "../../extensibility/extensions/index.js";
+import type { ExtensionAskDialogQuestion, ExtensionAskDialogResult, ExtensionUIContext, ExtensionUIDialogOptions, ExtensionUISelectItem, ExtensionWidgetContent, ExtensionWidgetOptions, TerminalInputHandler } from "../../extensibility/extensions/index.js";
 import { type HookSelectorSlider } from "../../modes/components/hook-selector.js";
 import { type Theme } from "../../modes/theme/theme.js";
 import type { InteractiveModeContext, InteractiveSelectorDialogOptions } from "../../modes/types.js";
@@ -32,6 +32,7 @@ export declare class ExtensionUiController {
     showCollabAwareEditor(title: string, prefill?: string, dialogOptions?: ExtensionUIDialogOptions, editorOptions?: {
         promptStyle?: boolean;
     }): Promise<string | undefined>;
+    showAskDialog(questions: ExtensionAskDialogQuestion[], dialogOptions?: ExtensionUIDialogOptions): Promise<ExtensionAskDialogResult | undefined>;
     /**
      * Show a selector for hooks.
      */

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

@@ -33,6 +33,8 @@ export declare class InputController {
     handleCtrlZ(): void;
     handleDequeue(): void;
     handleRetry(): Promise<void>;
+    /** Queue `/queue` input behind an active turn, or start it immediately when idle. */
+    handleQueueCommand(text: string): Promise<void>;
     /** Send editor text as a follow-up message (queued behind current stream). */
     handleFollowUp(): Promise<void>;
     restoreQueuedMessagesToEditor(options?: {

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

@@ -166,6 +166,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     get eventBus(): EventBus | undefined;
     get viewSession(): AgentSession;
     get focusedAgentId(): string | undefined;
+    get sessionName(): string | undefined;
     focusAgentSession(id: string): Promise<void>;
     focusParentSession(): Promise<void>;
     unfocusSession(): Promise<void>;
@@ -364,6 +365,8 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleCtrlZ(): void;
     handleDequeue(): void;
     handleImagePaste(): Promise<boolean>;
+    /** Queue slash-command input behind the active turn. */
+    handleQueueCommand(message: string): Promise<void>;
     handleBtwCommand(question: string): Promise<void>;
     handleTanCommand(work: string): Promise<void>;
     hasActiveBtw(): boolean;

package/dist/types/modes/queue-input.d.ts

@@ -0,0 +1,8 @@
+/** Prefix matcher shared by queue-list parsing and editor highlighting. */
+export declare const QUEUE_LIST_MARKER_RE: RegExp;
+/** Extract the message body from the `->` / `=>` yield-queue shorthand. */
+export declare function parseQueueShorthand(text: string): string | undefined;
+/** Whether text currently forms a sequential queue list, including an unfinished trailing item. */
+export declare function isQueuedMessageList(text: string): boolean;
+/** Split a sequential numeric, Roman-numeral, or alphabetic list into queue entries. */
+export declare function splitQueuedMessages(text: string): string[];

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

@@ -1,7 +1,7 @@
 import type { TabBarTheme } from "@oh-my-pi/pi-tui";
 /** Sanitize text for display in a single-line status. Strips ANSI/VT escape sequences, maps remaining C0/C1 control characters to spaces, collapses whitespace, trims. */
 export declare function sanitizeStatusText(text: string): string;
-/** Shared tab bar theme used by model-selector and settings-selector. */
+/** Shared tab bar theme used by fullscreen overlays (settings, agent hub). */
 export declare function getTabBarTheme(): TabBarTheme;
 /**
  * Suffix appended to the loader's working message to remind users they can

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

@@ -95,6 +95,8 @@ export interface InteractiveModeContext {
     statusLine: StatusLineComponent;
     session: AgentSession;
     sessionManager: SessionManager;
+    /** The current session display name / title. */
+    readonly sessionName: string | undefined;
     /** Session the transcript/editor/status are attached to: the focused agent's, else `session`. */
     readonly viewSession: AgentSession;
     /** Id of the focused agent, undefined when the main session is attached. */
@@ -350,6 +352,8 @@ export interface InteractiveModeContext {
     handleCtrlZ(): void;
     handleDequeue(): void;
     handleImagePaste(): Promise<boolean>;
+    /** Queue a message for delivery only after the active agent turn would stop. */
+    handleQueueCommand(message: string): Promise<void>;
     handleBtwCommand(question: string): Promise<void>;
     handleTanCommand(work: string): Promise<void>;
     hasActiveBtw(): boolean;

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

@@ -711,7 +711,7 @@ export declare class AgentSession {
      * surface bounded. Display-only — NEVER feed the result to
      * `agent.replaceMessages` or a provider.
      */
-    buildTranscriptSessionContext(options?: Pick<BuildSessionContextOptions, "collapseCompactedHistory">): SessionContext;
+    buildTranscriptSessionContext(options?: Pick<BuildSessionContextOptions, "collapseCompactedHistory" | "keepDanglingToolCalls">): SessionContext;
     /** Convert session messages using the same pre-LLM pipeline as the active session. */
     convertMessagesToLlm(messages: AgentMessage[], signal?: AbortSignal): Promise<Message[]>;
     /** Apply session-level stream hooks to a direct side request. */