@oh-my-pi/pi-coding-agent 16.0.1 → 16.0.3

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

@@ -23,7 +23,12 @@ export interface AdvisorNote {
 export interface AdvisorMessageDetails {
     notes: AdvisorNote[];
 }
-/** Render one advisor card body from a batch of notes (prefix + one bullet per note). */
+/**
+ * Render a batch of advisor notes as the agent-facing message body: one
+ * `<advisory>` element per note, severity as an attribute. Shared by the
+ * non-interrupting YieldQueue dispatcher and the interrupting steer path so both
+ * build byte-identical content.
+ */
 export declare function formatAdvisorBatchContent(notes: readonly AdvisorNote[]): string;
 /**
  * Whether advice at this severity should interrupt the running agent (delivered
@@ -32,6 +37,30 @@ export declare function formatAdvisorBatchContent(notes: readonly AdvisorNote[])
  * and `blocker` interrupt; a plain `nit` queues.
  */
 export declare function isInterruptingSeverity(severity: AdvisorSeverity | undefined): boolean;
+/** How an advisor note is routed to the primary. */
+export type AdvisorDeliveryChannel = "aside" | "steer" | "preserve";
+/**
+ * Decide how one advisor note reaches the primary agent.
+ *
+ * - A non-interrupting `nit` always rides the non-interrupting aside queue.
+ * - 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.
+ * - 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
+ *   card instead of restarting the run. But once a turn is actively streaming
+ *   again (a resume the user already drove), steering the note in does NOT
+ *   auto-resume anything, so it is delivered live. Parking it during an active
+ *   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.
+ */
+export declare function resolveAdvisorDeliveryChannel(opts: {
+    severity: AdvisorSeverity | undefined;
+    autoResumeSuppressed: boolean;
+    streaming: boolean;
+    aborting: boolean;
+}): AdvisorDeliveryChannel;
 /**
  * Side-effect-free investigation tools handed to the advisor agent so it can
  * inspect the workspace before weighing in. Names match the primary session's

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

@@ -22,7 +22,7 @@ import { Command } from "@oh-my-pi/pi-utils/cli";
  * Heuristic used to decide whether `omp install <target>` should `link` a
  * local directory or `install` a remote spec. Exported for tests.
  */
-export declare function looksLikeLocalPath(target: string): boolean;
+export declare function looksLikeLocalPath(target: string, cwd?: string): boolean;
 export default class Install extends Command {
     static description: string;
     static args: {

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

@@ -19,6 +19,14 @@ import type { Api, Effort, Model } from "@oh-my-pi/pi-ai";
 import { type ModelRegistry } from "./model-registry";
 import { type ModelRole } from "./model-roles";
 import type { Settings } from "./settings";
+/**
+ * Pick the first provider-default model in availability order.
+ *
+ * If multiple providers expose that same default id, rank only that shared-id
+ * group by canonical provider priority so native/OAuth transports beat mirrors
+ * without changing unrelated provider fallback precedence.
+ */
+export declare function pickDefaultAvailableModel(availableModels: Model<Api>[]): Model<Api> | undefined;
 export interface ScopedModel {
     model: Model<Api>;
     thinkingLevel?: ThinkingLevel;
@@ -37,7 +45,21 @@ export declare function parseModelString(modelStr: string): {
  * Format a model as "provider/modelId" string.
  */
 export declare function formatModelString(model: Model<Api>): string;
+export declare function formatModelStringWithRouting(model: Model<Api>): string;
 export declare function formatModelSelectorValue(selector: string, thinkingLevel: ThinkingLevel | undefined): string;
+/**
+ * Split a trailing `@<upstream>` provider-routing selector off a model pattern.
+ *
+ * `openrouter/z-ai/glm-4.7@cerebras` -> base `openrouter/z-ai/glm-4.7`, upstream
+ * `cerebras`. A `:thinking` suffix after the slug is kept on the base
+ * (`...@cerebras:high` -> base `...:high`). Returns undefined when there is no
+ * `@` or the suffix is not a bare provider slug, so model ids that legitimately
+ * contain `@` (`claude-opus-4-8@default`, `workers-ai/@cf/...`) are never split.
+ */
+export declare function splitUpstreamRouting(pattern: string): {
+    base: string;
+    upstream: string;
+} | undefined;
 export declare function resolveProviderModelReference(provider: string, modelId: string, availableModels: readonly Model<Api>[]): Model<Api> | undefined;
 export interface ModelMatchPreferences {
     /** Most-recently-used model keys (provider/modelId) to prefer when ambiguous. */

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

@@ -3241,16 +3241,6 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Enable the ast_edit tool for structural AST rewrites";
         };
     };
-    readonly "renderMermaid.enabled": {
-        readonly type: "boolean";
-        readonly default: false;
-        readonly ui: {
-            readonly tab: "tools";
-            readonly group: "Available Tools";
-            readonly label: "Render Mermaid";
-            readonly description: "Enable the render_mermaid tool for Mermaid-to-ASCII rendering";
-        };
-    };
     readonly "debug.enabled": {
         readonly type: "boolean";
         readonly default: true;

package/dist/types/eval/js/shared/runtime.d.ts

@@ -55,4 +55,5 @@ export declare class JsRuntime {
         cwd?: string;
     }): Promise<unknown>;
     displayValue(value: unknown, hooks?: RuntimeHooks | undefined): void;
+    dispose(): void;
 }

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

@@ -2,4 +2,5 @@ import type { Transport } from "./worker-protocol";
 export declare class WorkerCore {
     #private;
     constructor(transport: Transport);
+    dispose(): void;
 }

package/dist/types/exec/non-interactive-env.d.ts

@@ -1 +1,3 @@
 export declare const NON_INTERACTIVE_ENV: Readonly<Record<string, string>>;
+/** Builds the per-command environment for non-interactive child processes. */
+export declare function buildNonInteractiveEnv(overrides?: Record<string, string>, baseEnv?: Record<string, string | undefined>, platform?: NodeJS.Platform): Record<string, string>;

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

@@ -40,8 +40,8 @@ export declare function loadExtensions(paths: string[], cwd: string, eventBus?:
 /**
  * Discover absolute paths of extensions to load, without importing or
  * binding factories. Hot path on session startup — the scan walks native
- * `.omp`/`.pi` extension capabilities, the installed-plugin tree, and any
- * configured paths.
+ * `.omp`/`.pi` extension capabilities, JS/TS hook factories, the
+ * installed-plugin tree, and any configured paths.
  *
  * Subagents reuse the parent's collected paths via the SDK's
  * `preloadedExtensionPaths` option, then call {@link loadExtensions} themselves

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

@@ -28,7 +28,6 @@ export interface GoalRuntimeSnapshot {
 }
 export type GoalPromptKind = "active" | "continuation" | "budget-limit";
 export declare function remainingTokens(goal: Goal | null | undefined): number | null;
-export declare function escapeXmlText(input: string): string;
 export declare function renderTrustedObjective(objective: string): string;
 export declare function goalTokenDelta(current: GoalTokenUsage, baseline: GoalTokenUsage): number;
 export declare function renderGoalPrompt(kind: GoalPromptKind, goal: Goal): string;

package/dist/types/mcp/tool-bridge.d.ts

@@ -8,6 +8,7 @@ import type { TSchema } from "@oh-my-pi/pi-ai";
 import type { SourceMeta } from "../capability/types";
 import type { CustomTool, CustomToolContext, CustomToolResult, RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
+import type { OutputMeta } from "../tools/output-meta";
 import type { MCPContent, MCPServerConnection, MCPToolDefinition } from "./types";
 /** Reconnect callback: tears down stale connection, returns new one or null. */
 export type MCPReconnect = () => Promise<MCPServerConnection | null>;
@@ -26,6 +27,8 @@ export interface MCPToolDetails {
     provider?: string;
     /** Provider display name (e.g., "Claude Code", "MCP Config") */
     providerName?: string;
+    /** Structured output metadata (set by the spill wrapper when output is truncated to an artifact). */
+    meta?: OutputMeta;
 }
 export declare function createMCPToolName(serverName: string, toolName: string): string;
 /**

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

@@ -1,10 +1,20 @@
 import { Editor, type KeyId } from "@oh-my-pi/pi-tui";
 import type { AppKeybinding } from "../../config/keybindings";
 type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.display.reset" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.clipboard.pasteImage" | "app.clipboard.pasteTextRaw" | "app.clipboard.copyPrompt">;
-/** Plain spaces from one auto-repeat run that trigger the space-hold push-to-talk STT gesture.
- *  Holding the space bar makes the terminal emit a burst of spaces; once more than this many land
- *  in the editor we treat it as "space held", track them back out, and start recording. */
-export declare const SPACE_HOLD_THRESHOLD = 5;
+/** Max gap (ms) between two spaces for the later one to count as OS key auto-repeat rather than a
+ *  deliberate press. OS auto-repeat is fast; a deliberate tap (even a fast one) is slower. */
+export declare const SPACE_REPEAT_MAX_GAP_MS = 120;
+/** Two consecutive inter-space gaps are "mechanical" (machine-driven auto-repeat) when both are
+ *  within {@link SPACE_REPEAT_MAX_GAP_MS} and differ by no more than this — an absolute jitter floor
+ *  or, for slower repeat rates, {@link SPACE_REPEAT_JITTER_RATIO} of the smaller gap. OS key-repeat
+ *  is metronomic; a human smashing the bar is fast but irregular, so its deltas never stay this
+ *  steady. */
+export declare const SPACE_REPEAT_JITTER_MS = 18;
+export declare const SPACE_REPEAT_JITTER_RATIO = 0.35;
+/** Consecutive mechanical (fast + steady) deltas that confirm the space bar is held and start
+ *  recording. Needs a sustained metronomic cadence, so jittery smashing and deliberate taps never
+ *  reach it. */
+export declare const SPACE_HOLD_MECHANICAL_RUN = 2;
 /** Idle gap (ms) after the last repeated space that counts as the space bar being released, ending
  *  the push-to-talk recording. Must comfortably exceed the OS key-repeat interval. */
 export declare const SPACE_HOLD_RELEASE_MS = 250;

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

@@ -10,7 +10,7 @@ export declare class CommandController {
     constructor(ctx: InteractiveModeContext);
     openInBrowser(urlOrPath: string): void;
     handleExportCommand(text: string): Promise<void>;
-    handleDumpCommand(isRaw?: boolean): void;
+    handleDumpCommand(): void;
     handleAdvisorDumpCommand(isRaw?: boolean): void;
     handleDebugTranscriptCommand(): Promise<void>;
     handleShareCommand(): Promise<void>;

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

@@ -268,7 +268,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     findLastAssistantMessage(): AssistantMessage | undefined;
     extractAssistantText(message: AssistantMessage): string;
     handleExportCommand(text: string): Promise<void>;
-    handleDumpCommand(isRaw?: boolean): void;
+    handleDumpCommand(): void;
     handleAdvisorDumpCommand(isRaw?: boolean): void;
     handleDebugTranscriptCommand(): Promise<void>;
     handleShareCommand(): Promise<void>;

package/dist/types/modes/setup-wizard/wizard-overlay.d.ts

@@ -1,7 +1,7 @@
-import { type Component } from "@oh-my-pi/pi-tui";
+import { type Component, type OverlayFocusOwner } from "@oh-my-pi/pi-tui";
 import type { InteractiveModeContext } from "../types";
 import type { SetupScene } from "./scenes/types";
-export declare class SetupWizardComponent implements Component {
+export declare class SetupWizardComponent implements Component, OverlayFocusOwner {
     #private;
     readonly ctx: InteractiveModeContext;
     readonly scenes: readonly SetupScene[];
@@ -9,6 +9,7 @@ export declare class SetupWizardComponent implements Component {
     run(): Promise<void>;
     dispose(): void;
     invalidate(): void;
+    ownsOverlayFocusTarget(component: Component): boolean;
     handleInput(data: string): void;
     render(width: number): readonly string[];
 }

package/dist/types/modes/theme/mermaid-cache.d.ts

@@ -1,8 +1,25 @@
+import { type MermaidAsciiRenderOptions } from "@oh-my-pi/pi-utils";
+/**
+ * Options controlling how fenced Mermaid source is resolved to terminal ASCII.
+ * Extends the raw render options (theme, color mode, spacing, `useAscii`) with a
+ * viewport-fitting hint.
+ */
+export interface MermaidResolveOptions extends MermaidAsciiRenderOptions {
+    /**
+     * Maximum display width (terminal columns) the diagram should occupy. A
+     * layout that overflows this width is re-rendered in the perpendicular
+     * orientation — a wide horizontal chain collapses to a tall vertical column
+     * (which the terminal can scroll), and a wide vertical fan-out collapses to a
+     * tall horizontal column. Omit to keep the source's own layout regardless of
+     * width.
+     */
+    maxWidth?: number;
+}
 /**
  * Resolve mermaid ASCII from fenced block source text.
  * Returns null when rendering fails, while memoizing failures to avoid repeated work.
  */
-export declare function resolveMermaidAscii(source: string): string | null;
+export declare function resolveMermaidAscii(source: string, options?: MermaidResolveOptions): string | null;
 /**
  * Clear the mermaid cache.
  */

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

@@ -262,7 +262,7 @@ export interface InteractiveModeContext {
     handleHotkeysCommand(): void;
     handleToolsCommand(): void;
     handleContextCommand(): void;
-    handleDumpCommand(isRaw?: boolean): void;
+    handleDumpCommand(): void;
     handleAdvisorDumpCommand(isRaw?: boolean): void;
     handleDebugTranscriptCommand(): Promise<void>;
     handleClearCommand(): Promise<void>;

package/dist/types/registry/agent-lifecycle.d.ts

@@ -10,8 +10,16 @@
  * `parked` ↔ `idle`.
  */
 import type { AgentSession } from "../session/agent-session";
-import { AgentRegistry } from "./agent-registry";
+import { type AgentRef, AgentRegistry } from "./agent-registry";
 export type AgentReviver = () => Promise<AgentSession>;
+/**
+ * Builds a reviver for a `parked` ref restored from disk (Agent Hub scan,
+ * collab mirror, resumed process) that carries a sessionFile but no in-memory
+ * adoption. Returns undefined when the ref cannot be faithfully rebuilt (no
+ * persisted session contract, or its workspace is gone). Injected from the
+ * top-level session so this manager stays free of sdk/SessionManager imports.
+ */
+export type PersistedSubagentReviverFactory = (ref: AgentRef) => Promise<AgentReviver | undefined>;
 export interface AdoptOptions {
     /** TTL before an idle agent is parked. <= 0 disables parking. */
     idleTtlMs: number;
@@ -24,6 +32,13 @@ export declare class AgentLifecycleManager {
     /** Reset the global manager. Test-only. */
     static resetGlobalForTests(): void;
     constructor(registry?: AgentRegistry);
+    /**
+     * Install the factory used to cold-revive `parked` refs restored from disk
+     * (Agent Hub scan, collab mirror, resumed process) — they carry a sessionFile
+     * but no adoption. Set by the top-level session, which owns the ambient deps
+     * (auth, models, MCP, artifacts) the factory needs at revive time.
+     */
+    setPersistedSubagentReviverFactory(factory: PersistedSubagentReviverFactory, idleTtlMs: number): void;
     /**
      * Take ownership of a finished subagent. Caller has already set registry
      * status to "idle". Arms the TTL timer (idleTtlMs <= 0 adopts without one).

package/dist/types/sdk.d.ts

@@ -144,6 +144,14 @@ export interface CreateAgentSessionOptions {
     agentRegistry?: AgentRegistry;
     /** Parent task ID prefix for nested artifact naming (e.g., "Extensions") */
     parentTaskPrefix?: string;
+    /**
+     * Registry id of the spawning agent, recorded as this subagent's parent in
+     * the agent registry. Distinct from `parentTaskPrefix`, which is this agent's
+     * own artifact/output-id prefix (the executor passes the child's own id
+     * there, so it must never double as the parent link). Undefined for the
+     * top-level "Main" session, which has no parent.
+     */
+    parentAgentId?: string;
     /** Inherited eval executor session id for subagents sharing parent eval state. */
     parentEvalSessionId?: string;
     /** Session manager. Default: session stored under the configured agentDir sessions root */

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

@@ -669,12 +669,23 @@ export declare class AgentSession {
     sendUserMessage(content: string | (TextContent | ImageContent)[], options?: {
         deliverAs?: "steer" | "followUp";
     }): Promise<void>;
-    /** Clear queued messages and return them (text plus any attached images). */
-    clearQueue(): {
+    /** Clear queued messages and return the user-restorable ones (text plus any attached images).
+     *  Only user-authored messages (plain user turns, `attribution:"user"` custom like `/skill`) are
+     *  returned for editor restore. Other queued messages stay in the agent-core queues so a continuing
+     *  stream still delivers them — EXCEPT on `forInterrupt` (Esc+abort), where only advisor cards are
+     *  kept (abort()'s #extractQueuedAdvisorCards preserves them as visible advice) and every other
+     *  non-user steer (hidden goal/plan/budget, IRC/extension asides) is dropped, so abort()'s
+     *  #drainStrandedQueuedMessages can't auto-resume the run the user just interrupted (the drain only
+     *  fires while agent.hasQueuedMessages()). Plain Alt+Up dequeue preserves those non-user steers. */
+    clearQueue(options?: {
+        forInterrupt?: boolean;
+    }): {
         steering: RestoredQueuedMessage[];
         followUp: RestoredQueuedMessage[];
     };
-    /** Number of pending displayable messages (includes steering, follow-up, and next-turn messages) */
+    /** Number of pending displayable messages (includes steering, follow-up, and next-turn messages).
+     *  Reflects actual queued work (advisor cards included) — feeds hasPendingMessages()/RPC and the
+     *  empty-submit abort gate. The user-restorable subset is surfaced by getQueuedMessages()/clearQueue(). */
     get queuedMessageCount(): number;
     getQueuedMessages(): {
         steering: readonly string[];
@@ -683,6 +694,7 @@ export declare class AgentSession {
     /**
      * Pop the last queued message (steering first, then follow-up).
      * Used by dequeue keybinding to restore messages to editor one at a time.
+     * Steps over agent-authored queued messages (advisor cards, hidden/internal steers).
      */
     popLastQueuedMessage(): RestoredQueuedMessage | undefined;
     get skillsSettings(): SkillsSettings | undefined;
@@ -1128,12 +1140,12 @@ export declare class AgentSession {
      */
     getLastVisibleHandoffText(): string | undefined;
     /**
-     * Format the entire session as plain text for clipboard export.
-     * Includes user messages, assistant text, thinking blocks, tool calls, and tool results.
+     * Format the entire session as plain text for clipboard export: system
+     * prompt, model/thinking config, tool inventory, and the full transcript
+     * rendered with markdown role headings (`## User`, `## Assistant`,
+     * `### Tool Call`/`### Tool Result`).
      */
-    formatSessionAsText(options?: {
-        compact?: boolean;
-    }): string;
+    formatSessionAsText(): string;
     /**
      * Enable or disable the advisor for this session. The setting is overridden for the session,
      * and the runtime is started or stopped to match.

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

@@ -55,6 +55,9 @@ export declare function isSilentAbort(errorMessage: string | undefined): boolean
 export declare const USER_INTERRUPT_LABEL = "Interrupted by user";
 export declare function isUserInterruptAbort(errorMessage: string | undefined): boolean;
 export declare function shouldRenderAbortReason(errorMessage: string | undefined): boolean;
+/** Sentinel `errorMessage` the agent stamps on any abort that carried no custom
+ *  reason (bare `abort()`). Renderers treat it as "no specific reason given". */
+export declare const GENERIC_ABORT_SENTINEL = "Request was aborted";
 /** Resolve the operator-facing label for an aborted assistant turn. A custom
  *  abort reason threaded onto `errorMessage` is returned verbatim; aborts with
  *  no threaded reason fall back to the retry-aware generic label. Call

package/dist/types/session/session-dump-format.d.ts

@@ -1,5 +1,10 @@
 /**
- * Plain-text / markdown session formatting (same shape as /dump clipboard export).
+ * Plain-text / markdown session formatting for `/dump` and `/advisor dump raw`.
+ *
+ * Renders a prelude (system prompt, model/thinking config, tool inventory)
+ * followed by the message history as per-message markdown headings: `## User`,
+ * `## Assistant` (with `<thinking>` blocks and `### Tool Call: <name>` + YAML
+ * args), `### Tool Result: <name>`, and the execution/summary sections.
  */
 import type { AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Model, ToolExample } from "@oh-my-pi/pi-ai";
@@ -18,6 +23,7 @@ export interface FormatSessionDumpTextOptions {
     tools?: readonly SessionDumpToolInfo[];
 }
 /**
- * Format messages and session metadata as markdown/plain text (same as AgentSession.formatSessionAsText / /dump).
+ * Format messages and session metadata as markdown/plain text (same as
+ * AgentSession.formatSessionAsText / /dump).
  */
 export declare function formatSessionDumpText(options: FormatSessionDumpTextOptions): string;

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

@@ -108,6 +108,10 @@ export interface SessionInitEntry extends SessionEntryBase {
     tools: string[];
     /** Output schema if structured output was requested */
     outputSchema?: unknown;
+    /** Spawn allowlist the subagent ran with ("" = none, "*" = any, else CSV); absent on pre-spawns files. */
+    spawns?: string;
+    /** The agent's `readSummarize` setting (`false` = read summarization disabled); absent uses the session default. */
+    readSummarize?: boolean;
 }
 /** Mode change entry - tracks agent mode transitions (e.g. plan mode). */
 export interface ModeChangeEntry extends SessionEntryBase {

package/dist/types/session/session-history-format.d.ts

@@ -5,6 +5,8 @@ export interface HistoryFormatOptions {
     includeThinking?: boolean;
     /** Render tool intent comment before tool call lines. */
     includeToolIntent?: boolean;
+    /** Render watched-session roles as inline `**agent**:` / `**user**:` labels (collapsing consecutive same-role messages) instead of `## ` headings, so a primary transcript embedded inside an advisor turn stays visually distinct. */
+    watchedRoles?: boolean;
 }
 /**
  * Format a session's message array as a concise markdown transcript.

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

@@ -152,6 +152,8 @@ export declare class SessionManager {
         task: string;
         tools: string[];
         outputSchema?: unknown;
+        spawns?: string;
+        readSummarize?: boolean;
     }): string;
     appendCompaction<T = unknown>(summary: string, shortSummary: string | undefined, firstKeptEntryId: string, tokensBefore: number, details?: T, fromExtension?: boolean, preserveData?: Record<string, unknown>): string;
     appendCustomEntry(customType: string, data?: unknown): string;
@@ -254,7 +256,27 @@ export declare class SessionManager {
      */
     static open(filePath: string, sessionDir?: string, storage?: SessionStorage, options?: {
         initialCwd?: string;
+        suppressBreadcrumb?: boolean;
     }): Promise<SessionManager>;
+    /**
+     * Lock-free peek for cold subagent revival: returns the recorded working
+     * directory (session header) and the latest `session_init` contract (system
+     * prompt / tools / output schema) WITHOUT taking the single-writer lock that
+     * {@link open} acquires — the caller re-opens for the actual revive. Returns
+     * null when the file can't be read; `init` is null for files written before
+     * `session_init` was recorded (no faithful contract to rebuild from).
+     */
+    static peekSessionInit(filePath: string, storage?: SessionStorage): Promise<{
+        cwd: string;
+        init: {
+            systemPrompt: string;
+            task: string;
+            tools: string[];
+            outputSchema?: unknown;
+            spawns?: string;
+            readSummarize?: boolean;
+        } | null;
+    } | null>;
     /** Continue the most recent session, or create a new one if none exists. */
     static continueRecent(cwd: string, sessionDir?: string, storage?: SessionStorage): Promise<SessionManager>;
     /** Create an in-memory session (no file persistence). */

package/dist/types/stt/downloader.d.ts

@@ -27,12 +27,12 @@ export interface SttDownloadProgress {
     label: string;
 }
 /**
- * Whether the selected model is already present in the local cache. For
+ * Whether the selected model is fully present in the local cache. For
  * transformers.js Whisper tiers a complete download leaves `config.json` plus
- * the `onnx/` weight files (a bare `config.json` from an interrupted fetch reads
- * as not-cached); for sherpa-onnx tiers every model file (encoder/decoder/joiner
- * + tokens) must be present (`.part` sidecars from an interrupted fetch are
- * ignored).
+ * matching `encoder*.onnx` and `decoder*.onnx` shards under `onnx/` (a partial
+ * fetch with only one shard, or a bare `config.json`, reads as not-cached); for
+ * sherpa-onnx tiers every model file (encoder/decoder/joiner + tokens) must be
+ * present (`.part` sidecars from an interrupted fetch are ignored).
  */
 export declare function isSttModelCached(key: string): Promise<boolean>;
 /**

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

@@ -132,6 +132,12 @@ export interface ExecutorOptions {
     parentTelemetry?: AgentTelemetryConfig;
     /** Skills to autoload via sendCustomMessage before the first prompt */
     autoloadSkills?: Skill[];
+    /**
+     * Registry id of the spawning agent, recorded as this subagent's parent.
+     * Forwarded verbatim to the SDK; the executor never derives it (the spawner
+     * passes its own `getAgentId()`).
+     */
+    parentAgentId?: string;
 }
 export interface YieldItem {
     data?: unknown;

package/dist/types/task/persisted-revive.d.ts

@@ -0,0 +1,36 @@
+import type { ModelRegistry } from "../config/model-registry";
+import type { Settings } from "../config/settings";
+import type { PersistedSubagentReviverFactory } from "../registry/agent-lifecycle";
+import type { AgentSession } from "../session/agent-session";
+import type { AuthStorage } from "../session/auth-storage";
+/**
+ * Ambient context the reviver needs at revive time. The top-level session is
+ * kept LIVE (cwd / artifact manager read on demand) so a later `/new` or cwd
+ * move is followed rather than snapshotted; auth/models/settings are
+ * process-stable and captured by reference.
+ */
+export interface PersistedSubagentReviveContext {
+    session: AgentSession;
+    authStorage: AuthStorage;
+    modelRegistry: ModelRegistry;
+    settings: Settings;
+    /** LSP policy of the top-level session; revived subagents inherit it rather than defaulting on. */
+    enableLsp: boolean;
+}
+/**
+ * Build the factory the {@link AgentLifecycleManager} uses to cold-revive a
+ * `parked` subagent ref restored from disk (Agent Hub scan, collab mirror, or a
+ * resumed process). Such a ref carries a sessionFile but no in-memory adoption —
+ * the executor's live reviver closure died with the process/turn that spawned
+ * it — so `ensureLive` (IRC sends, hub focus) would otherwise refuse it.
+ *
+ * This rebuilds the subagent the same way `--resume` rebuilds a session: reopen
+ * the JSONL and replay it through {@link createAgentSession}. The catch is that
+ * resume restores only conversation/model from the file — the runtime contract
+ * (tools / system prompt / output schema / kind) is built from options, so a
+ * bare reopen would resurrect a wrong (top-level) session. We source that
+ * contract from the persisted `session_init` entry instead, and mirror the
+ * executor's subagent wiring (MCP proxy tools, depth-derived gating,
+ * yield-required, active-tool clamp, registry status sync).
+ */
+export declare function createPersistedSubagentReviverFactory(ctx: PersistedSubagentReviveContext): PersistedSubagentReviverFactory;

package/dist/types/tiny/models.d.ts

@@ -9,6 +9,8 @@ export interface TinyTitleLocalModelSpec {
     label: string;
     description: string;
     contextNote: string;
+    /** Model family emits hidden reasoning unless the chat template disables it. */
+    reasoning?: boolean;
 }
 export declare const TINY_TITLE_LOCAL_MODELS: readonly [{
     readonly key: "lfm2-350m";
@@ -24,6 +26,7 @@ export declare const TINY_TITLE_LOCAL_MODELS: readonly [{
     readonly label: "Qwen3 0.6B";
     readonly description: "Most robust local option; slower first load, about 500 MB cached.";
     readonly contextNote: "Use when title quality matters more than local startup cost.";
+    readonly reasoning: true;
 }, {
     readonly key: "gemma-270m";
     readonly repo: "onnx-community/gemma-3-270m-it-ONNX";
@@ -77,6 +80,7 @@ export declare const TINY_MEMORY_LOCAL_MODELS: readonly [{
     readonly label: "Qwen3 1.7B";
     readonly description: "Recommended; most disciplined extraction (ignores chit-chat), good consolidation, about 1.1 GB cached.";
     readonly contextNote: "Best single-model pick for memory from the local experiment.";
+    readonly reasoning: true;
 }, {
     readonly key: "gemma-3-1b";
     readonly repo: "onnx-community/gemma-3-1b-it-ONNX";
@@ -113,6 +117,8 @@ export declare const TINY_MEMORY_MODEL_OPTIONS: ({
 })[];
 export declare function isTinyMemoryLocalModelKey(value: string): value is TinyMemoryLocalModelKey;
 export declare function getTinyMemoryModelSpec(key: TinyMemoryLocalModelKey): (typeof TINY_MEMORY_LOCAL_MODELS)[number];
+/** Return whether a memory local model may emit reasoning tokens before answers. */
+export declare function isTinyMemoryReasoningModelKey(key: TinyMemoryLocalModelKey): boolean;
 /** Any local model key (title or memory), used by the shared inference worker. */
 export type TinyLocalModelKey = TinyTitleLocalModelKey | TinyMemoryLocalModelKey;
 /** Resolve a local model spec by key across both the title and memory registries. */
@@ -133,6 +139,7 @@ export declare const TINY_LOCAL_MODELS: readonly [{
     readonly label: "Qwen3 0.6B";
     readonly description: "Most robust local option; slower first load, about 500 MB cached.";
     readonly contextNote: "Use when title quality matters more than local startup cost.";
+    readonly reasoning: true;
 }, {
     readonly key: "gemma-270m";
     readonly repo: "onnx-community/gemma-3-270m-it-ONNX";
@@ -161,6 +168,7 @@ export declare const TINY_LOCAL_MODELS: readonly [{
     readonly label: "Qwen3 1.7B";
     readonly description: "Recommended; most disciplined extraction (ignores chit-chat), good consolidation, about 1.1 GB cached.";
     readonly contextNote: "Best single-model pick for memory from the local experiment.";
+    readonly reasoning: true;
 }, {
     readonly key: "gemma-3-1b";
     readonly repo: "onnx-community/gemma-3-1b-it-ONNX";

package/dist/types/tools/builtin-names.d.ts

@@ -1,2 +1,2 @@
-export declare const BUILTIN_TOOL_NAMES: readonly ["read", "bash", "edit", "ast_grep", "ast_edit", "render_mermaid", "ask", "debug", "eval", "ssh", "github", "find", "search", "lsp", "inspect_image", "browser", "checkpoint", "rewind", "task", "job", "irc", "todo", "web_search", "search_tool_bm25", "write", "memory_edit", "retain", "recall", "reflect", "learn", "manage_skill"];
+export declare const BUILTIN_TOOL_NAMES: readonly ["read", "bash", "edit", "ast_grep", "ast_edit", "ask", "debug", "eval", "ssh", "github", "find", "search", "lsp", "inspect_image", "browser", "checkpoint", "rewind", "task", "job", "irc", "todo", "web_search", "search_tool_bm25", "write", "memory_edit", "retain", "recall", "reflect", "learn", "manage_skill"];
 export type BuiltinToolName = (typeof BUILTIN_TOOL_NAMES)[number];

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

@@ -54,7 +54,6 @@ export * from "./memory-recall";
 export * from "./memory-reflect";
 export * from "./memory-retain";
 export * from "./read";
-export * from "./render-mermaid";
 export * from "./report-tool-issue";
 export * from "./resolve";
 export * from "./review";

package/dist/types/utils/markit.d.ts

@@ -3,5 +3,13 @@ export interface MarkitConversionResult {
     ok: boolean;
     error?: string;
 }
+interface MuPdfWasmModuleConfig {
+    print?: (...values: unknown[]) => void;
+    printErr?: (...values: unknown[]) => void;
+}
+declare global {
+    var $libmupdf_wasm_Module: MuPdfWasmModuleConfig | undefined;
+}
 export declare function convertFileWithMarkit(filePath: string, signal?: AbortSignal): Promise<MarkitConversionResult>;
 export declare function convertBufferWithMarkit(buffer: Uint8Array, extension: string, signal?: AbortSignal): Promise<MarkitConversionResult>;
+export {};