@oh-my-pi/pi-coding-agent 17.0.1 → 17.0.3

package/dist/types/mcp/transports/stdio.d.ts

@@ -37,6 +37,18 @@ export interface StdioSpawnCommand {
      * grandchildren keep stdout routed through our pipe (#3544).
      */
     detached: boolean;
+    /**
+     * Pass argv to `Bun.spawn` verbatim (Windows only), suppressing the
+     * default libuv backslash-quoting.
+     *
+     * Set when `cmd` already holds a `cmd.exe /d /e:ON /v:OFF /c "<line>"`
+     * command line escaped for `cmd.exe`'s parser (see `buildCmdExeArgv`).
+     * libuv's quoting targets `CommandLineToArgvW`, not `cmd.exe`, so letting
+     * it re-quote a batch launch would corrupt arguments and re-open the
+     * `%VAR%` / quote-injection holes the escaping closes (BatBadBut,
+     * CVE-2024-24576).
+     */
+    windowsVerbatimArguments?: boolean;
 }
 /** Inputs used to resolve platform-specific stdio spawn behavior. */
 export interface ResolveStdioSpawnOptions {
@@ -55,7 +67,7 @@ export interface ResolveStdioSpawnOptions {
  * only appends `.exe` for extensionless names — `.cmd`/`.bat` are never
  * tried, so `npx` (which exists only as `npx.cmd` on Windows) crashes the
  * subprocess immediately. When the resolver can't pin the command down,
- * route through `cmd.exe /d /s /c` so Windows's own PATHEXT lookup runs.
+ * route through `cmd.exe` so Windows's own PATHEXT lookup runs.
  */
 export declare function resolveStdioSpawnCommand(config: MCPStdioServerConfig, options: ResolveStdioSpawnOptions): Promise<StdioSpawnCommand>;
 /** Minimal write surface of `Subprocess.stdin` we need for framed sends. */
@@ -85,6 +97,35 @@ interface FrameSink {
  * the dead transport is detected by the read loop / request timeout instead.
  */
 export declare function writeFrame(stdin: FrameSink, frame: string): boolean;
+/**
+ * The subset of `Subprocess` that termination needs. Decoupled from the
+ * `Subprocess<In, Out, Err>` stdio generics — `#process`'s pipes are
+ * irrelevant to signaling — so tests can exercise it against a plain
+ * `Bun.spawn(cmd, { stdio: "ignore" })` child without fighting the generics.
+ */
+interface KillableSubprocess {
+    readonly pid: number;
+    readonly exited: Promise<number>;
+    kill(signal?: number | NodeJS.Signals): void;
+}
+/**
+ * Terminate an MCP stdio subprocess: SIGTERM (process-group when `detached`
+ * on POSIX, direct child otherwise), wait up to `TERM_GRACE_MS` for a
+ * cooperative exit, then escalate to SIGKILL — waiting up to `KILL_GRACE_MS`
+ * more only when the leader itself hadn't already exited. A detached
+ * leader's cooperative exit does not prove the whole process group is gone
+ * (a grandchild can outlive it and ignore SIGTERM), so detached transports
+ * always fire the group SIGKILL sweep, even after a clean SIGTERM exit.
+ * Every step is a no-op-safe signal against an already-exited target, so
+ * repeat calls (idempotent `close()`) never throw.
+ *
+ * Exported so tests can exercise group-signal escalation with an explicit
+ * `detached`/`platform` pair: `StdioTransport.connect()` derives `detached`
+ * from `resolveStdioSpawnCommand()`, which is tied to the host's real
+ * `process.platform`, so a POSIX detached session cannot be reproduced
+ * end-to-end through `connect()` on a non-Linux dev/CI host.
+ */
+export declare function terminateStdioProcess(proc: KillableSubprocess, detached: boolean, platform?: NodeJS.Platform): Promise<void>;
 /**
  * Stdio transport for MCP servers.
  * Spawns a subprocess and communicates via stdin/stdout.

package/dist/types/modes/components/advisor-config.d.ts

@@ -16,11 +16,13 @@
  * `save` callback.
  */
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Model } from "@oh-my-pi/pi-ai";
+import type { Model, UsageReport } from "@oh-my-pi/pi-ai";
 import { type Component, type TUI } from "@oh-my-pi/pi-tui";
 import { type AdvisorConfigScope, type WatchdogConfigDoc } from "../../advisor/index.js";
 import type { ModelRegistry } from "../../config/model-registry.js";
 import type { Settings } from "../../config/settings.js";
+import type { PerAdvisorStat } from "../../session/agent-session.js";
+import type { OAuthAccountIdentity } from "../../session/auth-storage.js";
 /** Host callbacks: all disk + live-runtime effects flow through these. */
 export interface AdvisorConfigCallbacks {
     /** Load a scope's `WATCHDOG.yml` into an editable doc (empty when absent). */
@@ -32,6 +34,11 @@ export interface AdvisorConfigCallbacks {
     requestRender: () => void;
     /** Surface a transient status/warning line to the user. */
     notify: (message: string) => void;
+    /** Live advisor usage stats; lets the preview show tokens/cost per advisor. */
+    getAdvisorStats?: () => PerAdvisorStat[];
+    getUsageReports?: () => Promise<UsageReport[] | null>;
+    /** Resolve the active OAuth identity for quota filtering (per-advisor account stickiness). */
+    resolveActiveAccount?: (provider: string, sessionId?: string) => OAuthAccountIdentity | undefined;
 }
 export interface AdvisorConfigDeps {
     modelRegistry: ModelRegistry;

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

@@ -1,3 +1,18 @@
+/**
+ * Agent Hub overlay component.
+ *
+ * One overlay, two views:
+ * - Table view: every registered agent except Main (Main IS the ambient
+ *   chat), live from the global AgentRegistry — status, unread irc count,
+ *   current/last task, last activity. Select with j/k, Enter opens a chat,
+ *   `r` revives a parked agent, `x` aborts + releases one.
+ * - Chat view: per-agent transcript (incremental session-file tail, absorbed
+ *   from the old session observer overlay) plus an input line. Submitting
+ *   revives a parked agent, then prompts/steers it; the message lands in the
+ *   agent's persisted history via the normal prompt path.
+ *
+ * Replaces the old SessionObserverOverlayComponent (ctrl+s observer).
+ */
 import { type AgentTool } from "@oh-my-pi/pi-agent-core";
 import { Container, type TUI } from "@oh-my-pi/pi-tui";
 import type { KeyId } from "../../config/keybindings.js";

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

@@ -11,6 +11,13 @@ import { Container, type Focusable, type TUI } from "@oh-my-pi/pi-tui";
 export interface HookEditorOptions {
     /** When true, use prompt-style keybindings with the legacy ask prompt chrome. */
     promptStyle?: boolean;
+    /**
+     * Max rows the inner Editor may occupy. When omitted, the editor is
+     * bounded to the current terminal height minus the component's chrome
+     * (≈10 rows) so long content scrolls instead of pushing the submit
+     * hint out of view.
+     */
+    maxHeight?: number;
 }
 /** Interactive multiline dialog used by hooks and the ask tool's Other response. */
 export declare class HookEditorComponent extends Container implements Focusable {

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

@@ -8,11 +8,12 @@ export interface ScopedModelItem {
     model: Model;
     thinkingLevel?: string;
 }
+export type ModelRoleSelectionScope = "global" | "project";
 export interface ModelHubCallbacks {
     /** Persist a role assignment. */
-    onAssign: (model: Model, role: string, thinkingLevel: ConfiguredThinkingLevel | undefined, selector: string) => void;
+    onAssign: (model: Model, role: string, thinkingLevel: ConfiguredThinkingLevel | undefined, selector: string, scope?: ModelRoleSelectionScope) => void;
     /** Clear a configured role back to auto-selection. */
-    onUnassign: (role: string) => void;
+    onUnassign: (role: string, scope?: ModelRoleSelectionScope) => 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;
     /** Locked provider activation: forward to the /login flow. */
@@ -37,6 +38,8 @@ export declare class ModelHubComponent implements Component {
     /** Cancel pending provider refresh timers and the spinner. Host calls this on overlay close. */
     dispose(): void;
     invalidate(): void;
+    /** Re-sync after an asynchronous callback finishes mutating settings. */
+    refreshAfterExternalMutation(): void;
     handleInput(data: string): void;
     render(width: number): string[];
 }

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

@@ -85,6 +85,8 @@ export declare class SessionSelectorComponent extends Container {
     setOnRequestRender(callback: () => void): void;
     /** Ignore input after selection while the host resumes the session. */
     lockInput(): void;
+    /** Re-enable input after a failed resume so the user can pick again. */
+    unlockInput(): void;
     /**
      * Dispose the session list explicitly: while the delete-confirmation dialog
      * is mounted the list is detached from the child tree, so Container's

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

@@ -52,4 +52,12 @@ export declare class CommandController {
     handleHandoffCommand(customInstructions?: string): Promise<void>;
 }
 export declare function renderProviderSection(details: ProviderDetails, uiTheme: Pick<typeof theme, "fg">): string;
+/**
+ * Compact one-line quota summary for a single advisor's provider.
+ * Returns `null` when the provider has no usage data.
+ * When `activeAccount` is provided, only limits matching that credential
+ * are shown (mirrors `renderUsageReports`'s account-stickiness filtering).
+ * Example output: `Quota: 7d window · 67% used · resets in 3.2d`
+ */
+export declare function formatCompactQuota(provider: string, reports: UsageReport[], nowMs: number, activeAccount?: OAuthAccountIdentity): string | null;
 export declare function renderUsageReports(reports: UsageReport[], uiTheme: typeof theme, nowMs: number, availableWidth: number, resolveActiveAccount?: (provider: string) => OAuthAccountIdentity | undefined): string;

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

@@ -50,7 +50,9 @@ export declare class SelectorController {
     showCopySelector(): void;
     showTreeSelector(): void;
     showSessionSelector(): Promise<void>;
-    handleResumeSession(sessionPath: string): Promise<void>;
+    handleResumeSession(sessionPath: string, options?: {
+        settingsFlushed?: boolean;
+    }): Promise<boolean>;
     handleSessionDeleteCommand(): Promise<void>;
     showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
     showResetUsageSelector(): Promise<void>;

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

@@ -1,5 +1,5 @@
 import type { ImageContent } from "@oh-my-pi/pi-ai";
-import type { AgentSession, AgentSessionEvent } from "../session/agent-session.js";
+import { type AgentSession, type AgentSessionEvent } from "../session/agent-session.js";
 /**
  * Options for print mode.
  */

package/dist/types/modes/warp-events.d.ts

@@ -0,0 +1,24 @@
+import type { ExtensionFactory } from "../extensibility/extensions/types.js";
+/** True when Warp has negotiated the structured CLI-agent OSC protocol. */
+export declare function isWarpCliAgentProtocolActive(): boolean;
+export type WarpEventValue = string | number | boolean | null | readonly WarpEventValue[] | {
+    readonly [key: string]: WarpEventValue | undefined;
+};
+/** Fields added to the Warp CLI-agent event envelope by the event bridge. */
+export type WarpEvent = Readonly<Record<string, WarpEventValue | undefined>>;
+export interface WarpEventEmitterOptions {
+    sessionId: string;
+    getCwd?: () => string;
+}
+export interface WarpEventEmitter {
+    emit(event: WarpEvent): void;
+}
+/**
+ * Creates the Warp event transport for a top-level interactive TUI session.
+ * The caller MUST enforce that install-site invariant; the sole production
+ * caller is gated by `isInteractive`, so ACP, RPC, print, headless, and
+ * subagent sessions never construct an emitter.
+ */
+export declare function createWarpEventEmitter(options: WarpEventEmitterOptions): WarpEventEmitter | undefined;
+/** Internal event bridge installed only by the top-level interactive TUI runner. */
+export declare function createWarpEventBridgeExtension(): ExtensionFactory;

package/dist/types/modes/warp-events.test.d.ts

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

package/dist/types/plan-mode/model-transition.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Plan-mode model transition policy.
+ *
+ * Plan mode drives the active session model from the `plan` role: it switches
+ * to the plan model on entry and restores the pre-plan model on exit. The same
+ * policy also runs when the `plan` role is reassigned mid-planning, so a
+ * correction to the wrong plan model takes effect at the next turn boundary
+ * (issue #5657).
+ *
+ * This module holds only the pure decision — what transition a given
+ * (current model, resolved role, streaming) triple implies — so the branching
+ * is testable without a live session or TUI. The interactive mode performs the
+ * resulting side effect.
+ */
+import type { Model } from "@oh-my-pi/pi-ai";
+import type { ResolvedModelRoleValue } from "../config/model-resolver.js";
+import type { ConfiguredThinkingLevel } from "../thinking.js";
+/** The action implied by resolving the `plan` role against the active model. */
+export type PlanModelTransition = 
+/** Already on the plan model with no thinking-level change to apply. */
+{
+    kind: "none";
+}
+/** Same model; only the plan role's explicit thinking level differs. */
+ | {
+    kind: "thinking";
+    thinkingLevel: ConfiguredThinkingLevel;
+}
+/**
+ * Switch to `model`. `deferred` is set when the session is mid-stream: the
+ * switch must wait for the current turn to end (a live `setModelTemporary`
+ * resets the provider session), so the caller queues it instead.
+ */
+ | {
+    kind: "apply";
+    model: Model;
+    thinkingLevel: ConfiguredThinkingLevel | undefined;
+    deferred: boolean;
+};
+/**
+ * Decide how to reconcile the active model with the resolved `plan` role.
+ *
+ * @param currentModel - The session's active model, or `undefined` before one is set.
+ * @param resolved - The `plan` role resolved against the available models.
+ * @param isStreaming - Whether the session is mid-turn (forces a deferred switch).
+ */
+export declare function resolvePlanModelTransition(currentModel: Model | undefined, resolved: ResolvedModelRoleValue, isStreaming: boolean): PlanModelTransition;

package/dist/types/plan-mode/model-transition.test.d.ts

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

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

@@ -8,6 +8,12 @@
  * sessionFile), and revives it on demand through
  * {@link AgentLifecycleManager.ensureLive}. Only this manager flips
  * `parked` ↔ `idle`.
+ *
+ * Park/dispose is gated against concurrent ensureLive/hub-send:
+ * - A disposing session is never handed out.
+ * - ensureLive during an in-flight park either cancels the park (session still
+ *   live) or waits for detach+park and then revives.
+ * - Concurrent ensureLive/park operations coalesce per id.
  */
 import type { AgentSession } from "../session/agent-session.js";
 import { type AgentRef, AgentRegistry } from "./agent-registry.js";
@@ -46,17 +52,36 @@ export declare class AgentLifecycleManager {
     adopt(id: string, opts: AdoptOptions): void;
     /** True if the id is adopted (parked or live). */
     has(id: string): boolean;
-    /** True while {@link park} is disposing this agent's session (lets dispose hooks distinguish park from teardown). */
+    /**
+     * True when this manager owns `registry` — i.e. its adopt/park/revive state
+     * describes that registry's refs. Lets a caller holding a specific registry
+     * (e.g. a custom-registry {@link IrcBus} that fell back to the global
+     * manager) skip lifecycle gating that would consult unrelated park state.
+     */
+    manages(registry: AgentRegistry): boolean;
+    /**
+     * True while {@link park} is disposing this agent's session (lets dispose
+     * hooks distinguish park from teardown). False once the park is cancelled
+     * by ensureLive or after detach+dispose completes.
+     */
     isParking(id: string): boolean;
     /**
      * Dispose the live session, detach it from the registry, and mark the
      * agent `parked`. No-op unless the id is adopted and live.
+     *
+     * The session is detached (and status flipped to `parked`) *before*
+     * `session.dispose()` so concurrent {@link ensureLive}/hub-send never
+     * observe or inject into a disposing session. A concurrent ensureLive that
+     * arrives before detach cancels the park and keeps the live session.
      */
     park(id: string): Promise<void>;
     /**
      * Return the live session, reviving from the sessionFile if parked.
      * Throws a plain Error if the id is unknown or parked without a reviver.
      * Concurrent calls share one in-flight revive.
+     *
+     * Never returns a session that is mid-dispose: an in-flight park is either
+     * cancelled (session still live) or awaited to completion before revive.
      */
     ensureLive(id: string): Promise<AgentSession>;
     /** Hard removal: dispose if live, unregister from registry, drop timers. */

package/dist/types/registry/persisted-agents.d.ts

@@ -0,0 +1,3 @@
+import { type AgentRegistry } from "./agent-registry.js";
+/** Register persisted subagent and advisor transcripts as parked registry refs. */
+export declare function registerPersistedSubagents(registry: AgentRegistry, sessionFile: string | null | undefined): Promise<void>;

package/dist/types/sdk.d.ts

@@ -1,5 +1,5 @@
-import { type AgentTelemetryConfig, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Model } from "@oh-my-pi/pi-ai";
+import { Agent, type AgentOptions, type AgentTelemetryConfig, type AgentTool, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Model, SimpleStreamOptions } from "@oh-my-pi/pi-ai";
 import type { Dialect } from "@oh-my-pi/pi-ai/dialect";
 import { type Rule } from "./capability/rule.js";
 import { ModelRegistry } from "./config/model-registry.js";
@@ -21,6 +21,7 @@ import { AgentSession, type PlanYolo, type Prewalk } from "./session/agent-sessi
 import type { AuthStorage } from "./session/auth-storage.js";
 import { SessionManager } from "./session/session-manager.js";
 import { type BuildSystemPromptResult } from "./system-prompt.js";
+import type { StructuredSubagentSchemaMode } from "./task/types.js";
 import { type ConfiguredThinkingLevel } from "./thinking.js";
 import { BashTool, BUILTIN_TOOLS, createTools, EditTool, EvalTool, GlobTool, GrepTool, HIDDEN_TOOLS, type LspStartupServerInfo, ReadTool, type Tool, type ToolSession, WebSearchTool, WriteTool } from "./tools/index.js";
 import { EventBus } from "./utils/event-bus.js";
@@ -141,18 +142,28 @@ export interface CreateAgentSessionOptions {
     promptTemplates?: PromptTemplate[];
     /** File-based slash commands. Default: discovered from commands/ directories */
     slashCommands?: FileSlashCommand[];
-    /** Enable MCP server discovery from .mcp.json files. Default: true */
+    /**
+     * Enable MCP capabilities. `false` skips MCP discovery and ignores
+     * `mcpManager`, preventing process-global or inherited MCP access. Default:
+     * true.
+     */
     enableMCP?: boolean;
-    /** Existing MCP manager to reuse (skips discovery, propagates to toolSession). */
+    /** Existing MCP manager to reuse when MCP is enabled (skips discovery, propagates to toolSession). */
     mcpManager?: MCPManager;
     /** Enable LSP integration (tool, formatting, diagnostics, warmup). Default: true */
     enableLsp?: boolean;
+    /** Whether this invocation may expose IRC. `false` removes it even for subagents. */
+    enableIrc?: boolean;
     /** Skip subprocess-kernel availability checks and prelude warmup */
     skipPythonPreflight?: boolean;
     /** Tool names explicitly requested (enables disabled-by-default tools) */
     toolNames?: string[];
-    /** Output schema for structured completion (subagents) */
+    /** Limit the session to explicitly supplied tool names, without discovered extras. */
+    restrictToolNames?: boolean;
+    /** Output schema for structured completion (subagents). */
     outputSchema?: unknown;
+    /** Enforcement policy for {@link outputSchema}; defaults to legacy permissive behavior. */
+    outputSchemaMode?: StructuredSubagentSchemaMode;
     /** Whether to include the yield tool by default */
     requireYieldTool?: boolean;
     /** Task recursion depth (for subagent sessions). Default: 0 */
@@ -346,6 +357,17 @@ export interface BuildSystemPromptOptions {
  * as separate entries so providers can cache prompt prefixes without concatenating blocks.
  */
 export declare function buildSystemPrompt(options?: BuildSystemPromptOptions): Promise<BuildSystemPromptResult>;
+/** Dependencies used to construct an isolated auto-learn capture agent. */
+export interface AutoLearnCaptureRunnerOptions {
+    sourceAgent: Agent;
+    captureTools: AgentTool[];
+    createAgent: (options: AgentOptions) => Agent;
+    onPayload?: SimpleStreamOptions["onPayload"];
+    onResponse?: SimpleStreamOptions["onResponse"];
+    createSessionId?: () => string;
+}
+/** Build a private capture runner over a detached message snapshot and provider session. */
+export declare function createAutoLearnCaptureRunner(options: AutoLearnCaptureRunnerOptions): (content: string, signal?: AbortSignal) => Promise<void>;
 /**
  * Create an AgentSession with the specified options.
  *

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

@@ -18,7 +18,7 @@ import { type CompactionResult, type ShakeConfig } from "@oh-my-pi/pi-agent-core
 import type { AssistantMessage, Context, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ResetCreditAccountStatus, ResetCreditRedeemOutcome, ResetCreditTarget, ServiceTier, ServiceTierByFamily, ServiceTierFamily, SimpleStreamOptions, TextContent, ToolChoice, UsageReport } from "@oh-my-pi/pi-ai";
 import { Effort } from "@oh-my-pi/pi-ai";
 import { postmortem } from "@oh-my-pi/pi-utils";
-import { type AdvisorConfig } from "../advisor/index.js";
+import { type AdvisorConfig, type AdvisorRuntimeStatus } from "../advisor/index.js";
 import { type AsyncJob, type AsyncJobDeliveryState, AsyncJobManager } from "../async/index.js";
 import type { Rule } from "../capability/rule.js";
 import type { ModelRegistry } from "../config/model-registry.js";
@@ -224,6 +224,8 @@ export interface AgentSessionConfig {
     builtInToolNames?: Iterable<string>;
     /** Update tool-session predicates that render guidance from the live active tool set. */
     setActiveToolNames?: (names: Iterable<string>) => void;
+    /** Register the write transport lazily when runtime xdev mounts first need it. */
+    ensureWriteRegistered?: () => Promise<boolean>;
     /** Current session pre-LLM message transform pipeline */
     transformContext?: (messages: AgentMessage[], signal?: AbortSignal) => AgentMessage[] | Promise<AgentMessage[]>;
     /**
@@ -275,7 +277,8 @@ export interface AgentSessionConfig {
     xdevRegistry?: XdevRegistry;
     /** Discoverable tools mounted under `xd://` in the initial enabled set (startup partition in `sdk.ts`). */
     initialMountedXdevToolNames?: string[];
-    requestedToolNames?: ReadonlySet<string>;
+    /** Explicit/effective names pinned top-level during runtime repartitioning. */
+    presentationPinnedToolNames?: ReadonlySet<string>;
     /**
      * Optional accessor for live MCP server instructions. Read by the session's
      * `rebuildSystemPrompt`-skip optimization to detect server-side instruction
@@ -491,15 +494,20 @@ export interface AdvisorStats {
     /** Per-advisor breakdown; one entry per active advisor (single-advisor sessions have one). */
     advisors: PerAdvisorStat[];
 }
-/** One advisor's slice of {@link AdvisorStats}, surfaced for the multi-advisor status panel. */
+/** One advisor's slice of {@link AdvisorStats}. Active advisors carry full
+ *  token/cost data; disabled/no-model/quota-exhausted advisors appear with
+ *  just `name` + `status` so the status line can render a dot for every
+ *  configured advisor. */
 export interface PerAdvisorStat {
     name: string;
-    model: Model;
+    status: AdvisorRuntimeStatus;
+    model?: Model;
     contextWindow: number;
     contextTokens: number;
     tokens: AdvisorStats["tokens"];
     cost: number;
     messages: AdvisorStats["messages"];
+    sessionId?: string;
 }
 export interface FreshSessionResult {
     previousSessionId: string;
@@ -612,6 +620,8 @@ export declare class AgentSession {
      */
     subscribe(listener: AgentSessionEventListener): () => void;
     subscribeCommandMetadataChanged(listener: CommandMetadataChangedListener): () => void;
+    /** Run one abortable auto-learn capture outside the primary agent loop. */
+    runAutolearnCapture(capture: (signal: AbortSignal) => Promise<void>): Promise<void>;
     /** True once dispose() has begun; deferred background work (e.g. the deferred
      *  MCP discovery task in sdk.ts) must not touch the session past this point. */
     get isDisposed(): boolean;
@@ -915,6 +925,12 @@ export declare class AgentSession {
     get skillWarnings(): readonly SkillWarning[];
     getTodoPhases(): TodoPhase[];
     setTodoPhases(phases: TodoPhase[]): void;
+    /**
+     * Generate an automatic session title tied to this session's lifecycle.
+     * Input and replan callers share the signal so disposal cancels provider and
+     * local-worker requests instead of leaving background inference alive.
+     */
+    generateTitle(firstMessage: string): Promise<string | null>;
     /** Currently-applied {@link TITLE_SYSTEM.md} override, or undefined when the
      *  bundled prompt is in effect. Consumed by {@link InteractiveMode} so the
      *  first-input title path and the replan refresh share one source. */
@@ -1167,8 +1183,7 @@ export declare class AgentSession {
      */
     retry(): Promise<boolean>;
     /**
-     * Execute a bash command.
-     * Adds result to agent context and session.
+     * Execute a bash command and retain the session/branch that owned its start.
      * @param command The bash command to execute
      * @param onChunk Optional streaming callback for output
      * @param options.excludeFromContext If true, command output won't be sent to LLM (!! prefix)
@@ -1178,10 +1193,7 @@ export declare class AgentSession {
         excludeFromContext?: boolean;
         useUserShell?: boolean;
     }): Promise<BashResult>;
-    /**
-     * Record a bash execution result in session history.
-     * Used by executeBash and by extensions that handle bash execution themselves.
-     */
+    /** Record a bash result supplied outside executeBash in the current ownership scope. */
     recordBashResult(command: string, result: BashResult, options?: {
         excludeFromContext?: boolean;
     }): void;
@@ -1471,6 +1483,18 @@ export declare class AgentSession {
      * (`streamFn`, `promptCacheKey`, `providerSessionState`, ...).
      */
     getAdvisorAgent(): Agent | undefined;
+    /**
+     * Lightweight advisor status for the status line: returns just the configured
+     * flag and per-advisor name/status without computing token/cost breakdowns.
+     * Avoids re-tokenizing the advisor transcript on every render frame.
+     */
+    getAdvisorStatusOverview(): {
+        configured: boolean;
+        advisors: {
+            name: string;
+            status: AdvisorRuntimeStatus;
+        }[];
+    };
     /**
      * Return structured advisor stats for the status command and TUI panel.
      */

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

@@ -1,5 +1,6 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, MessageAttribution, ServiceTierByFamily, TextContent } from "@oh-my-pi/pi-ai";
+import type { StructuredSubagentSchemaMode } from "../task/types.js";
 export declare const CURRENT_SESSION_VERSION = 3;
 export declare const SESSION_TITLE_SLOT_BYTES = 256;
 export declare const SESSION_TITLE_SLOT_ENTRY_TYPE = "title";
@@ -142,8 +143,12 @@ export interface SessionInitEntry extends SessionEntryBase {
     task: string;
     /** Tools available to the agent */
     tools: string[];
-    /** Output schema if structured output was requested */
+    /** Output schema if structured output was requested. */
     outputSchema?: unknown;
+    /** Enforcement policy recorded with the output schema for faithful revival. */
+    outputSchemaMode?: StructuredSubagentSchemaMode;
+    /** Whether revival must retain only the explicitly persisted tool names. */
+    restrictToolNames?: boolean;
     /** 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. */

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

@@ -1,3 +1,4 @@
+import type { ToolResultMessage } from "@oh-my-pi/pi-ai";
 export interface HistoryFormatOptions {
     /** Optional H1 prepended to the transcript. */
     title?: string;
@@ -24,6 +25,15 @@ export interface HistoryFormatOptions {
      * this so it sees what changed without re-reading the file.
      */
     expandEditDiffs?: boolean;
+    /**
+     * Chunked rendering support: a caller formatting one logical transcript in
+     * several calls (the advisor's chunked delta render) passes a result index
+     * built over the WHOLE delta plus one shared consumed-id set, so a toolCall
+     * finds its toolResult across chunk boundaries and the result is never
+     * re-rendered as an orphan in a later chunk.
+     */
+    toolResultIndex?: ReadonlyMap<string, ToolResultMessage>;
+    consumedToolCallIds?: Set<string>;
 }
 /**
  * Hidden custom messages that inject the primary agent's operative *constraints*

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

@@ -1,4 +1,5 @@
 import type { ImageContent, Message, MessageAttribution, ServiceTierByFamily, TextContent } from "@oh-my-pi/pi-ai";
+import type { StructuredSubagentSchemaMode } from "../task/types.js";
 import { ArtifactManager } from "./artifacts.js";
 import { type BlobPutOptions, type BlobPutResult } from "./blob-store.js";
 import { type BashExecutionMessage, type CustomMessage, type FileMentionMessage, type HookMessage, type PythonExecutionMessage } from "./messages.js";
@@ -48,6 +49,15 @@ export declare class SessionManager {
     /** Synchronous variant of {@link putBlob} for rebuild-only render paths. */
     putBlobSync(data: Buffer, options?: BlobPutOptions): BlobPutResult;
     captureState(): SessionManagerStateSnapshot;
+    /**
+     * Create an independent manager for the current logical session and branch.
+     * The clone shares the storage backend but owns its entry index and writer, so
+     * callers can finish session-owned work after this manager switches elsewhere.
+     * Set `persist` false when the original session is intentionally being dropped.
+     */
+    cloneCurrentSession(options?: {
+        persist?: boolean;
+    }): SessionManager;
     restoreState(snapshot: SessionManagerStateSnapshot): void;
     /** Switch to a different session file (resume / branch). */
     setSessionFile(sessionFile: string): Promise<void>;
@@ -140,6 +150,11 @@ export declare class SessionManager {
      * top-level entries via appendCompaction()/branchWithSummary().
      */
     appendMessage(message: Message | CustomMessage | HookMessage | BashExecutionMessage | PythonExecutionMessage | FileMentionMessage): string;
+    /**
+     * Append to a non-active branch without changing the current leaf.
+     * Used by work that retains ownership of a branch across tree navigation.
+     */
+    appendMessageToBranch(message: Message | CustomMessage | HookMessage | BashExecutionMessage | PythonExecutionMessage | FileMentionMessage, parentId: string | null): string;
     /** Append a thinking level change as child of current leaf, then advance leaf. Returns entry id. */
     appendThinkingLevelChange(thinkingLevel?: string, configured?: string): string;
     appendServiceTierChange(serviceTier: ServiceTierByFamily | null): string;
@@ -155,6 +170,8 @@ export declare class SessionManager {
         task: string;
         tools: string[];
         outputSchema?: unknown;
+        outputSchemaMode?: StructuredSubagentSchemaMode;
+        restrictToolNames?: boolean;
         spawns?: string;
         readSummarize?: boolean;
     }): string;
@@ -279,6 +296,8 @@ export declare class SessionManager {
             task: string;
             tools: string[];
             outputSchema?: unknown;
+            outputSchemaMode?: StructuredSubagentSchemaMode;
+            restrictToolNames?: boolean;
             spawns?: string;
             readSummarize?: boolean;
         } | null;

package/dist/types/slash-commands/helpers/active-oauth-account.d.ts

@@ -1,5 +1,14 @@
 import type { UsageLimit, UsageReport } from "@oh-my-pi/pi-ai";
 import type { OAuthAccountIdentity } from "../../session/auth-storage.js";
+/**
+ * Session marker label for an active OAuth identity: the base identifier
+ * (email → accountId → projectId) suffixed with the organization when present
+ * and distinct. Same-email Anthropic multi-org accounts share the base, so the
+ * org suffix is the only field that tells the session's quota pool apart —
+ * mirrors the account-list rows (`formatUsageReportAccount`) and login success.
+ * Returns `undefined` when no identifier is recoverable.
+ */
+export declare function formatActiveAccountLabel(identity: OAuthAccountIdentity | undefined): string | undefined;
 /**
  * True when a single usage-limit column belongs to the given OAuth identity.
  *