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

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/config/settings-schema.d.ts

@@ -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/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,97 @@
+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 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;
+    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,51 @@
+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";
+export type ModelHubAction = "modelRole" | "retryFallback";
+/** 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 (or a retry-fallback registration). */
+    onAssign: (model: Model, role: string, thinkingLevel: ConfiguredThinkingLevel | undefined, selector: string, action: ModelHubAction) => void;
+    /** Clear a configured role back to auto-selection. */
+    onUnassign: (role: 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/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>;

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. */

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. */

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

@@ -40,5 +40,14 @@ export interface BuildSessionContextOptions {
     transcript?: boolean;
     /** In transcript mode, elide entries replaced by the latest compaction. */
     collapseCompactedHistory?: boolean;
+    /**
+     * Transcript mode only: keep `toolCall` blocks that have no matching
+     * `toolResult` on the path instead of stripping them. Pass this when the
+     * session is mid-turn (a tool is still executing, its result not yet
+     * persisted) so the rebuilt transcript renders the in-flight call as
+     * pending; without it a focus/unfocus or overlay-close rebuild silently
+     * hides the call the agent is still waiting on.
+     */
+    keepDanglingToolCalls?: boolean;
 }
 export declare function buildSessionContext(entries: SessionEntry[], leafId?: string | null, byId?: Map<string, SessionEntry>, options?: BuildSessionContextOptions): SessionContext;

package/dist/types/task/executor.d.ts

@@ -3,7 +3,7 @@
  *
  * Runs each subagent on the main thread and forwards AgentEvents for progress tracking.
  */
-import type { AgentTelemetryConfig, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { AgentTelemetryConfig } from "@oh-my-pi/pi-agent-core";
 import type { ServiceTierByFamily } from "@oh-my-pi/pi-ai";
 import type { Rule } from "../capability/rule.js";
 import { ModelRegistry } from "../config/model-registry.js";
@@ -20,23 +20,27 @@ import type { MnemopiSessionState } from "../mnemopi/state.js";
 import type { AgentSession } from "../session/agent-session.js";
 import type { ArtifactManager } from "../session/artifacts.js";
 import type { AuthStorage } from "../session/auth-storage.js";
+import type { ConfiguredThinkingLevel } from "../thinking.js";
 import type { ContextFileEntry } from "../tools/index.js";
 import type { EventBus } from "../utils/event-bus.js";
 import type { WorkspaceTree } from "../workspace-tree.js";
 import { type AgentDefinition, type AgentProgress, type ReviewFinding, type SingleResult, type YieldItem } from "./types.js";
 export type { YieldItem } from "./types.js";
 /**
- * Soft per-agent request budgets (assistant requests per run). When a subagent
- * crosses its budget it can receive an optional steering notice asking it to
- * wrap up; at 1.5x the budget the run is aborted gracefully so partial output is
- * salvaged. The `default` key applies to agents without an explicit entry and
- * can be overridden via the `task.softRequestBudget` setting (0 disables the
- * guard). The notice is off by default and controlled separately by
- * `task.softRequestBudgetNotice`.
+ * Soft per-agent request budgets (assistant requests per run). Crossing the
+ * budget injects a wrap-up steering notice (`task.softRequestBudgetNotice`,
+ * on by default). At 1.5x the budget the free-running turn is stopped and the
+ * agent is driven to one forced final `yield` so partial findings come back
+ * as a real report; only if it still refuses to yield within
+ * {@link BUDGET_STOP_GRACE_REQUESTS} more requests is the run hard-aborted.
+ * The `default` key applies to agents without an explicit entry and can be
+ * overridden via the `task.softRequestBudget` setting (0 disables the guard).
  */
 export declare const SOFT_REQUEST_BUDGET: Record<string, number>;
-/** Optional steering notice injected when a subagent crosses its soft request budget. */
-export declare function buildBudgetNotice(requests: number): string;
+/** Extra requests allowed after a budget stop for the forced yield to land before the run is hard-aborted. */
+export declare const BUDGET_STOP_GRACE_REQUESTS = 5;
+/** Steering notice injected when a subagent crosses its soft request budget. */
+export declare function buildBudgetNotice(requests: number, budget: number): string;
 /** Options for subagent execution */
 export interface ExecutorOptions {
     cwd: string;
@@ -55,9 +59,8 @@ export interface ExecutorOptions {
         path: string;
         content: string;
     };
+    /** Pre-set UI label (e.g. eval bridge label). When absent, a tiny-model label is generated from the assignment. */
     description?: string;
-    /** Specialist role/expertise for this spawn; drives the system-prompt preamble, display name, and telemetry identity. */
-    role?: string;
     index: number;
     id: string;
     parentToolCallId?: string;
@@ -74,7 +77,7 @@ export interface ExecutorOptions {
      * if the resolved subagent model has no working credentials. See #985.
      */
     parentActiveModelPattern?: string;
-    thinkingLevel?: ThinkingLevel;
+    thinkingLevel?: ConfiguredThinkingLevel;
     outputSchema?: unknown;
     /**
      * Caller supplied a schema that supersedes the agent's native output prompt.
@@ -199,10 +202,20 @@ export declare function finalizeSubprocessOutput(args: FinalizeSubprocessOutputA
  */
 export declare function createMCPProxyTools(mcpManager: MCPManager): CustomTool[];
 export declare function createSubagentSettings(baseSettings: Settings, overrides?: Partial<Record<SettingPath, unknown>>, inheritedServiceTier?: ServiceTierByFamily | null): Settings;
+export type AbortReason = "signal" | "terminate" | "timeout" | "budget";
+/**
+ * Settle a subagent's registry lifecycle after a run: terminal teardown for
+ * hard aborts, unregister for one-shot helpers, park for isolated runs, and
+ * idle + lifecycle adoption for kept-alive agents. A soft-budget abort on a
+ * kept-alive, revivable agent is treated as a self-inflicted stop rather than
+ * a kill — the agent stays interrogable and resumable (irc wake / revival).
+ */
 export declare function finalizeSubagentLifecycle(args: {
     id: string;
     session: AgentSession;
     aborted: boolean;
+    /** Which watchdog (if any) requested the abort; decides revivability. */
+    abortKind?: AbortReason;
     keepAlive: boolean;
     isolated: boolean;
     agentIdleTtlMs: number;