@oh-my-pi/pi-coding-agent 16.2.1 → 16.2.3

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

@@ -10,3 +10,15 @@ export declare function resolvePath(filePath: string, cwd: string): string;
  * Create a no-op UI context for headless modes.
  */
 export declare function createNoOpUIContext(): HookUIContext;
+/**
+ * Raised by {@link withExitGuard} when a guarded callback synchronously
+ * attempts to terminate the host process. Callers catch this like any other
+ * load-time failure so the extension/hook is skipped with a logged error
+ * instead of taking the CLI down with it.
+ */
+export declare class ExtensionExitError extends Error {
+    readonly alias: string;
+    readonly code: number | string | undefined;
+    constructor(code: number | string | undefined, alias?: string);
+}
+export declare function withExitGuard<T>(fn: () => Promise<T>): Promise<T>;

package/dist/types/mcp/oauth-discovery.d.ts

@@ -1,9 +1,3 @@
-/**
- * MCP OAuth Auto-Discovery
- *
- * Automatically detects OAuth requirements from MCP server responses
- * and extracts authentication endpoints.
- */
 import type { FetchImpl } from "@oh-my-pi/pi-ai/types";
 export interface OAuthEndpoints {
     authorizationUrl: string;
@@ -21,11 +15,6 @@ export interface AuthDetectionResult {
     message?: string;
 }
 export declare function extractMcpAuthServerUrl(error: Error, serverUrl?: string): string | undefined;
-/**
- * Detect if an error indicates authentication is required.
- * Checks for common auth error patterns.
- */
-export declare function detectAuthError(error: Error): boolean;
 /**
  * Extract OAuth endpoints from error response.
  * Looks for WWW-Authenticate header format or JSON error bodies.

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

@@ -2,4 +2,5 @@
  * MCP transport exports.
  */
 export * from "./http";
+export * from "./sse";
 export * from "./stdio";

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

@@ -0,0 +1,20 @@
+import type { MCPRequestOptions, MCPSseServerConfig, MCPTransport } from "../../mcp/types";
+/** Legacy MCP HTTP+SSE transport from protocol revision 2024-11-05. */
+export declare class LegacySseTransport implements MCPTransport {
+    #private;
+    onClose?: () => void;
+    onError?: (error: Error) => void;
+    onNotification?: (method: string, params: unknown) => void;
+    onRequest?: (method: string, params: unknown) => Promise<unknown>;
+    /** Called on 401/403 to attempt token refresh. Returns updated headers or null. */
+    onAuthError?: () => Promise<Record<string, string> | null>;
+    constructor(config: MCPSseServerConfig);
+    get connected(): boolean;
+    get url(): string;
+    connect(): Promise<void>;
+    request<T = unknown>(method: string, params?: Record<string, unknown>, options?: MCPRequestOptions): Promise<T>;
+    notify(method: string, params?: Record<string, unknown>): Promise<void>;
+    close(): Promise<void>;
+}
+/** Create and connect a legacy HTTP+SSE transport. */
+export declare function createSseTransport(config: MCPSseServerConfig): Promise<LegacySseTransport>;

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

@@ -0,0 +1,59 @@
+/**
+ * Fullscreen `/advisor configure` overlay: a mouse- and keyboard-driven editor
+ * for the `WATCHDOG.yml` advisor roster at project or user level.
+ *
+ * It paints the entire alternate screen from row 0 (so SGR mouse rows index
+ * directly into the rendered frame) using the shared {@link ./overlay-box} chrome.
+ * The list screen is a two-pane split (the `/extensions` idiom): a clickable
+ * advisor/action sidebar on the left, and a scrollable preview of the highlighted
+ * advisor's model / tools / instructions on the right, filling the free space.
+ *
+ * Each screen is backed by a proven primitive — {@link SelectList} (list / detail
+ * / tools / thinking), {@link Input} (name), {@link ModelSelectorComponent} (the
+ * same rich `/model` picker, in direct-select mode), and {@link HookEditorComponent}
+ * (multiline instructions; Ctrl+G opens `$EDITOR`). The overlay edits an in-memory
+ * {@link WatchdogConfigDoc} and only touches disk + the live advisors via the host
+ * `save` callback.
+ */
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Model } from "@oh-my-pi/pi-ai";
+import { type Component, type TUI } from "@oh-my-pi/pi-tui";
+import { type AdvisorConfigScope, type WatchdogConfigDoc } from "../../advisor";
+import type { ModelRegistry } from "../../config/model-registry";
+import type { Settings } from "../../config/settings";
+/** 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). */
+    loadDoc: (scope: AdvisorConfigScope) => Promise<WatchdogConfigDoc>;
+    /** Persist the doc to the scope's file and rebuild the live advisors. */
+    save: (scope: AdvisorConfigScope, doc: WatchdogConfigDoc) => Promise<void>;
+    /** Tear down the overlay and restore the editor. */
+    close: () => void;
+    requestRender: () => void;
+    /** Surface a transient status/warning line to the user. */
+    notify: (message: string) => void;
+}
+export interface AdvisorConfigDeps {
+    modelRegistry: ModelRegistry;
+    settings: Settings;
+    scopedModels: ReadonlyArray<{
+        model: Model;
+        thinkingLevel?: ThinkingLevel;
+    }>;
+    availableToolNames: string[];
+    /** Formatted advisor-role model shown on the seeded default row (e.g. "anthropic/claude-..."). */
+    defaultModelLabel?: string;
+}
+/**
+ * Fullscreen advisor-configuration overlay. Implements {@link Component} directly
+ * (rather than extending Container) so it owns the whole frame and the mouse
+ * geometry needed to make every row clickable.
+ */
+export declare class AdvisorConfigOverlayComponent implements Component {
+    #private;
+    constructor(tui: TUI, deps: AdvisorConfigDeps, scope: AdvisorConfigScope, doc: WatchdogConfigDoc, callbacks: AdvisorConfigCallbacks);
+    render(width: number): readonly string[];
+    handleInput(data: string): void;
+    /** Forward enhanced-paste transports into a multiline instructions editor. */
+    pasteText(text: string): void;
+}

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

@@ -1,3 +1,4 @@
+export * from "./advisor-config";
 export * from "./assistant-message";
 export * from "./bash-execution";
 export * from "./bordered-loader";

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

@@ -1,5 +1,5 @@
 import type { Model } from "@oh-my-pi/pi-ai";
-import { Container, Input, type TUI } from "@oh-my-pi/pi-tui";
+import { Container, Input, type SgrMouseEvent, type TUI } from "@oh-my-pi/pi-tui";
 import type { ModelRegistry } from "../../config/model-registry";
 import type { Settings } from "../../config/settings";
 import { type ConfiguredThinkingLevel } from "../../thinking";
@@ -19,9 +19,17 @@ export declare class ModelSelectorComponent extends Container {
     #private;
     constructor(tui: TUI, _currentModel: Model | undefined, settings: Settings, modelRegistry: ModelRegistry, scopedModels: ReadonlyArray<ScopedModelItem>, onSelect: RoleSelectCallback, onCancel: () => void, options?: {
         temporaryOnly?: boolean;
+        directSelect?: boolean;
+        pickerHint?: string;
         initialSearchInput?: string;
         currentContextTokens?: number;
     });
+    /**
+     * Concatenate children like Container.render, recording where the model list
+     * lands so routed mouse events can be hit-tested against it.
+     */
+    render(width: number): readonly string[];
+    routeMouse(event: SgrMouseEvent, line: number, _col: number): void;
     handleInput(keyData: string): void;
     getSearchInput(): Input;
 }

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

@@ -34,6 +34,7 @@ export interface StatusLinePreviewSettings {
     separator?: StatusLineSeparatorStyle;
     sessionAccent?: boolean;
     transparent?: boolean;
+    compactThinkingLevel?: boolean;
 }
 export interface SettingsCallbacks {
     /** Called when any setting value changes */

package/dist/types/modes/components/status-line/component.d.ts

@@ -14,11 +14,38 @@ export declare class StatusLineComponent implements Component {
     getEffectiveSettingsForTest(): EffectiveStatusLineSettings;
     setAutoCompactEnabled(enabled: boolean): void;
     setSubagentCount(count: number): void;
-    /** Hub key label shown in the forced running-subagents badge. */
-    setSubagentHubHint(hint: string | undefined): void;
     /** Active subagent count as currently displayed (collab state mirroring). */
     get subagentCount(): number;
-    setSessionStartTime(time: number): void;
+    /**
+     * Reset the currently-attached session's active-time accumulators so
+     * the `time_spent` segment starts from zero. Called from `/clear`,
+     * fresh-session, and joined-collab paths; both the completed
+     * accumulator and any in-flight window are dropped, so a reset
+     * mid-turn ignores the running window (the matching `markActivityEnd`
+     * will see an idle meter and no-op).
+     */
+    resetActiveTime(): void;
+    /**
+     * Mark the currently-attached session as having started a unit of
+     * active processing. Idempotent: a second start while a window is
+     * already open is a no-op, so reentrant `agent_start` events (e.g.
+     * nested auto-compaction loops, focus-controller mid-turn attach onto
+     * an already-running window) do not double-count.
+     */
+    markActivityStart(): void;
+    /**
+     * Close the currently-attached session's open active-processing
+     * window, folding its elapsed time into the accumulator. Idempotent
+     * when the meter is already idle so callers can fire it on every
+     * `agent_end` without guarding.
+     */
+    markActivityEnd(): void;
+    /**
+     * Snapshot of total active-processing time for the currently-attached
+     * session, including any in-flight window. Exposed for the segment
+     * context builder; tests assert against this too.
+     */
+    getActiveMs(): number;
     setPlanModeStatus(status: {
         enabled: boolean;
         paused: boolean;

package/dist/types/modes/components/status-line/types.d.ts

@@ -41,6 +41,9 @@ export interface StatusLineSettings {
     /** Drop the theme's `statusLineBg` fill and powerline caps so the bar
      *  inherits the terminal's default background. */
     transparent?: boolean;
+    /** Replace the model-segment icon with the thinking-level glyph and drop the
+     *  " · <level>" suffix, so the thinking level reads as a single compact icon. */
+    compactThinkingLevel?: boolean;
 }
 export type EffectiveStatusLineSettings = Required<Pick<StatusLineSettings, "leftSegments" | "rightSegments" | "separator" | "segmentOptions">> & StatusLineSettings;
 export type RGB = readonly [number, number, number];
@@ -51,6 +54,8 @@ export interface SegmentContext {
     activeRepo: ActiveRepoContext | null;
     width: number;
     options: StatusLineSegmentOptions;
+    /** Render the model segment's thinking level as a compact leading glyph. */
+    compactThinkingLevel: boolean;
     planMode: {
         enabled: boolean;
         paused: boolean;
@@ -78,7 +83,14 @@ export interface SegmentContext {
     contextWindow: number;
     autoCompactEnabled: boolean;
     subagentCount: number;
-    sessionStartTime: number;
+    /**
+     * Active processing time accumulated this session, in ms — the union of
+     * every `agent_start`→`agent_end` window plus the currently-streaming
+     * window if the agent is running. Idle wall-clock never contributes, so
+     * this is what {@link StatusLineSegmentId.time_spent} renders instead of
+     * `Date.now() - sessionStart`.
+     */
+    activeMs: number;
     git: {
         branch: string | null;
         status: {

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

@@ -25,6 +25,7 @@ export declare class SelectorController {
         focus: Component;
     }): void;
     showSettingsSelector(): void;
+    showAdvisorConfigure(): void;
     showHistorySearch(): void;
     /**
      * Show the Extension Control Center dashboard.

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

@@ -109,11 +109,16 @@ export declare class InteractiveMode implements InteractiveModeContext {
     loopLimit: LoopLimitRuntime | undefined;
     todoPhases: TodoPhase[];
     hideThinkingBlock: boolean;
+    /** Whether the visible session has produced thinking content the user can reveal. */
+    get hasDisplayableThinkingContent(): boolean;
+    /** Record received reasoning content so Ctrl+T can reveal it even when model metadata says thinking is off. */
+    noteDisplayableThinkingContent(message: AgentMessage): boolean;
     /**
-     * Effective thinking-block visibility: hidden when the user's setting is on
-     * OR the session thinking level is "off". Some providers (MiniMax, GLM,
-     * DeepSeek) return thinking blocks even with reasoning disabled; this
-     * respects the user's intent when they set thinking to "off" (#626).
+     * Effective thinking-block visibility: hidden when the user's setting is on,
+     * or while thinking is "off" before the session has actually produced
+     * displayable thinking content. Some providers return thinking blocks without
+     * advertising reasoning support, so observed content unlocks the visibility
+     * toggle.
      */
     get effectiveHideThinkingBlock(): boolean;
     proseOnlyThinking: boolean;
@@ -319,6 +324,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     executeCompaction(customInstructionsOrOptions?: string | CompactOptions, isAuto?: boolean): Promise<CompactionOutcome>;
     openInBrowser(urlOrPath: string): void;
     showSettingsSelector(): void;
+    showAdvisorConfigure(): void;
     showHistorySearch(): void;
     showExtensionsDashboard(): void;
     showAgentsDashboard(): void;

package/dist/types/modes/skill-command.d.ts

@@ -0,0 +1,32 @@
+import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
+import { type CustomMessage, SKILL_PROMPT_MESSAGE_TYPE, type SkillPromptDetails } from "../session/messages";
+import type { InteractiveModeContext } from "./types";
+type SkillCommandHost = Pick<InteractiveModeContext, "skillCommands" | "session" | "showError">;
+type SkillPromptMessage = Pick<CustomMessage<SkillPromptDetails>, "customType" | "content" | "display" | "details" | "attribution"> & {
+    customType: typeof SKILL_PROMPT_MESSAGE_TYPE;
+    content: string | (TextContent | ImageContent)[];
+    display: true;
+    details: SkillPromptDetails;
+    attribution: "user";
+};
+type SkillPromptOptions = {
+    streamingBehavior: "steer" | "followUp";
+    queueChipText: string;
+};
+interface InvokeSkillCommandOptions {
+    propagateErrors?: boolean;
+    queueOnly?: boolean;
+    images?: ImageContent[];
+}
+/** Built custom-message payload and delivery options for a `/skill:` command. */
+export interface BuiltSkillCommandPrompt {
+    message: SkillPromptMessage;
+    options: SkillPromptOptions;
+}
+/** Return true when `text` names a registered `/skill:<name>` command. */
+export declare function isKnownSkillCommand(ctx: SkillCommandHost, text: string): boolean;
+/** Build the user-attributed custom message for a registered `/skill:<name>` command. */
+export declare function buildSkillCommandPrompt(ctx: SkillCommandHost, text: string, streamingBehavior: "steer" | "followUp", images?: ImageContent[]): Promise<BuiltSkillCommandPrompt | undefined>;
+/** Invoke a registered `/skill:<name>` command as a user-attributed custom message. */
+export declare function invokeSkillCommandFromText(ctx: SkillCommandHost, text: string, streamingBehavior: "steer" | "followUp", options?: InvokeSkillCommandOptions): Promise<boolean>;
+export {};

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

@@ -142,10 +142,14 @@ export interface InteractiveModeContext {
     hideThinkingBlock: boolean;
     /**
      * Effective thinking-block visibility: true when hidden by user setting OR
-     * thinking level is "off". Read this in render paths instead of
-     * {@link hideThinkingBlock} so blocks are auto-hidden when thinking is off.
+     * thinking level is "off" before the session has produced displayable
+     * thinking content.
      */
     readonly effectiveHideThinkingBlock: boolean;
+    /** Whether this visible session has produced thinking content the user can reveal. */
+    readonly hasDisplayableThinkingContent: boolean;
+    /** Record a message whose thinking content makes Ctrl+T meaningful even at thinking level "off"; returns true on first observation. */
+    noteDisplayableThinkingContent(message: AgentMessage): boolean;
     proseOnlyThinking: boolean;
     compactionQueuedMessages: CompactionQueuedMessage[];
     pendingTools: Map<string, ToolExecutionHandle>;
@@ -316,6 +320,7 @@ export interface InteractiveModeContext {
     refreshSlashCommandState(cwd?: string): Promise<void>;
     applyCwdChange(newCwd: string): Promise<void>;
     showSettingsSelector(): void;
+    showAdvisorConfigure(): void;
     showHistorySearch(): void;
     showExtensionsDashboard(): void;
     showAgentsDashboard(): 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 type { Model } from "@oh-my-pi/pi-ai";
 import type { Dialect } from "@oh-my-pi/pi-ai/dialect";
 import { type Rule } from "./capability/rule";
 import { ModelRegistry } from "./config/model-registry";

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

@@ -13,10 +13,11 @@
  * Modes use this class and add their own I/O layer on top.
  */
 import type { InMemorySnapshotStore } from "@oh-my-pi/hashline";
-import { Agent, type AgentEvent, type AgentMessage, type AgentState, type AgentTool, ThinkingLevel, type ToolChoiceDirective } from "@oh-my-pi/pi-agent-core";
+import { Agent, type AgentEvent, type AgentMessage, type AgentState, type AgentTool, type StreamFn, ThinkingLevel, type ToolChoiceDirective } from "@oh-my-pi/pi-agent-core";
 import { type CompactionResult, type ShakeConfig } from "@oh-my-pi/pi-agent-core/compaction";
-import type { AssistantMessage, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ResetCreditAccountStatus, ResetCreditRedeemOutcome, ResetCreditTarget, ServiceTier, SimpleStreamOptions, TextContent, ToolChoice, UsageReport } from "@oh-my-pi/pi-ai";
+import type { AssistantMessage, Context, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ResetCreditAccountStatus, ResetCreditRedeemOutcome, ResetCreditTarget, ServiceTier, SimpleStreamOptions, TextContent, ToolChoice, UsageReport } from "@oh-my-pi/pi-ai";
 import { Effort } from "@oh-my-pi/pi-ai";
+import { type AdvisorConfig } from "../advisor";
 import { type AsyncJob, type AsyncJobDeliveryState, AsyncJobManager } from "../async";
 import type { Rule } from "../capability/rule";
 import type { ModelRegistry } from "../config/model-registry";
@@ -72,6 +73,7 @@ export type AgentSessionEvent = AgentEvent | {
     maxAttempts: number;
     delayMs: number;
     errorMessage: string;
+    errorId?: number;
 } | {
     type: "auto_retry_end";
     success: boolean;
@@ -160,6 +162,21 @@ export interface AgentSessionConfig {
     builtInToolNames?: Iterable<string>;
     /** Current session pre-LLM message transform pipeline */
     transformContext?: (messages: AgentMessage[], signal?: AbortSignal) => AgentMessage[] | Promise<AgentMessage[]>;
+    /**
+     * Per-request transform applied after `convertToLlm` and before the
+     * provider call. Used for snapcompact, secret obfuscation, and image
+     * clamping. When supplied via {@link createAgentSession}, the advisor agent
+     * inherits this so its requests undergo the same shaping as the main turn.
+     */
+    transformProviderContext?: (context: Context, model: Model) => Context | Promise<Context>;
+    /**
+     * Stream wrapper passed to the advisor agent so its requests apply the
+     * session's `providers.openrouterVariant`, `providers.antigravityEndpoint`,
+     * `providers.maxInFlightRequests`, and `model.loopGuard.*` settings —
+     * keeping OpenRouter sticky-routing / response caching consistent with the
+     * main agent. Defaults to plain `streamSimple` when omitted.
+     */
+    advisorStreamFn?: StreamFn;
     /** Provider payload hook used by the active session request path */
     onPayload?: SimpleStreamOptions["onPayload"];
     /** Provider response hook used by the active session request path */
@@ -231,20 +248,29 @@ export interface AgentSessionConfig {
      */
     providerSessionId?: string;
     /**
-     * Hard-isolated read-only tools (read/search/find) for the advisor agent,
-     * pre-built in `createAgentSession` against a distinct `ToolSession` so the
-     * advisor's reads never share the primary's snapshot/seen-lines/conflict
-     * caches. Undefined when the advisor is disabled.
+     * Full advisor toolset, pre-built in `createAgentSession` against a distinct,
+     * advisor-scoped `ToolSession` (its own `-advisor` session/agent id) so the
+     * advisor's tool state stays isolated from the primary. The advisor is a full
+     * agent; its config `tools` selects a subset (default read/grep/glob). Undefined
+     * when the advisor is disabled.
      */
-    advisorReadOnlyTools?: AgentTool[];
+    advisorTools?: AgentTool[];
     /** Preloaded watchdog prompt content for the advisor. */
     advisorWatchdogPrompt?: string;
+    /** Preloaded YAML top-level `instructions` shared baseline, kept separate from
+     *  `advisorWatchdogPrompt` so `/advisor configure` can swap it live. */
+    advisorSharedInstructions?: string;
     /**
      * Preloaded project context files (AGENTS.md, etc.) rendered as a system-prompt
      * block for the advisor — the same standing instructions the primary agent
      * receives, so the reviewer holds the agent to them.
      */
     advisorContextPrompt?: string;
+    /**
+     * Advisors discovered from `WATCHDOG.yml`. Empty/undefined runs a single
+     * legacy advisor on the `advisor` role (byte-for-byte the pre-config path).
+     */
+    advisorConfigs?: AdvisorConfig[];
     /**
      * Strip tool descriptions from provider-bound tool specs on side requests
      * (handoff). Must match the session-start value used to build the system
@@ -340,6 +366,7 @@ export interface SessionStats {
     tokens: {
         input: number;
         output: number;
+        reasoning: number;
         cacheRead: number;
         cacheWrite: number;
         total: number;
@@ -357,6 +384,7 @@ export interface AdvisorStats {
     tokens: {
         input: number;
         output: number;
+        reasoning: number;
         cacheRead: number;
         cacheWrite: number;
         total: number;
@@ -367,6 +395,18 @@ export interface AdvisorStats {
         assistant: number;
         total: number;
     };
+    /** 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. */
+export interface PerAdvisorStat {
+    name: string;
+    model: Model;
+    contextWindow: number;
+    contextTokens: number;
+    tokens: AdvisorStats["tokens"];
+    cost: number;
+    messages: AdvisorStats["messages"];
 }
 export interface FreshSessionResult {
     previousSessionId: string;
@@ -378,6 +418,7 @@ export type RestoredQueuedMessage = {
     text: string;
     images?: ImageContent[];
 };
+type SessionNameTrigger = "replan";
 export declare class AgentSession {
     #private;
     readonly agent: Agent;
@@ -682,6 +723,7 @@ export declare class AgentSession {
     prompt(text: string, options?: PromptOptions): Promise<boolean>;
     promptCustomMessage<T = unknown>(message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice"> & {
         queueChipText?: string;
+        queueOnly?: boolean;
     }): Promise<void>;
     /**
      * Queue a steering message to interrupt the agent mid-run.
@@ -781,7 +823,7 @@ export declare class AgentSession {
     /**
      * Set a display name for the current session.
      */
-    setSessionName(name: string, source?: "auto" | "user"): Promise<boolean>;
+    setSessionName(name: string, source?: "auto" | "user", trigger?: SessionNameTrigger): Promise<boolean>;
     /**
      * Fork the current session, creating a new session file with the exact same state.
      * Copies all entries and artifacts to the new session.
@@ -792,16 +834,22 @@ export declare class AgentSession {
     /**
      * Set model directly.
      * Validates that a credential source is configured (synchronously, without
-     * refreshing OAuth or running command-backed key programs) and saves to the
-     * active session. Persists settings only when requested. The concrete key is
-     * resolved lazily per request, so switching never blocks the event loop.
+     * refreshing OAuth or running command-backed key programs). The active
+     * session switches by default; when `currentContextTokens` is provided and
+     * exceeds the refreshed candidate's context window, the live switch is
+     * skipped while role persistence still runs. Returns whether the active
+     * model actually switched, computed against the refreshed metadata so
+     * dynamic providers (e.g. llama.cpp) honor their post-load contextWindow.
      * @throws Error if no API key available for the model
      */
     setModel(model: Model, role?: string, options?: {
         selector?: string;
         thinkingLevel?: ThinkingLevel;
         persist?: boolean;
-    }): Promise<void>;
+        currentContextTokens?: number;
+    }): Promise<{
+        switched: boolean;
+    }>;
     /**
      * Set model temporarily (for this session only).
      * Validates that a credential source is configured (synchronously, without
@@ -1242,6 +1290,15 @@ export declare class AgentSession {
      * @returns true when the advisor is actively running after the call.
      */
     toggleAdvisorEnabled(): boolean;
+    /**
+     * Replace the live advisor roster from an edited `WATCHDOG.yml` (the `/advisor
+     * configure` save path). Swaps the configs + shared baseline, then rebuilds the
+     * runtimes in place so the change applies without a restart. When the advisor is
+     * disabled the new configs are simply stored for the next enable.
+     *
+     * @returns the number of advisors active after the rebuild.
+     */
+    applyAdvisorConfigs(advisors: AdvisorConfig[], sharedInstructions: string | undefined): number;
     /**
      * Whether the advisor setting is enabled for this session.
      */
@@ -1253,6 +1310,21 @@ export declare class AgentSession {
      * not merely the setting. Drives the status-line badge and `/dump advisor`.
      */
     isAdvisorActive(): boolean;
+    /**
+     * The names of the tools available to advisors this session (the pool a
+     * `/advisor configure` editor lists). The advisor is a full agent, so this is the
+     * full built tool set; a tool whose optional factory returns null (e.g. lsp with
+     * no servers) is absent.
+     */
+    getAdvisorAvailableToolNames(): string[];
+    /**
+     * The live advisor `Agent`, or `undefined` when no advisor runtime is
+     * attached. Surfaced for diagnostics (`/dump advisor` already serializes
+     * its transcript via {@link formatAdvisorHistoryAsText}) and so callers can
+     * verify the advisor inherits the session's provider-shaping options
+     * (`streamFn`, `promptCacheKey`, `providerSessionState`, ...).
+     */
+    getAdvisorAgent(): Agent | undefined;
     /**
      * Return structured advisor stats for the status command and TUI panel.
      */

package/dist/types/session/indexed-session-storage.d.ts

@@ -1,16 +1,21 @@
 import type { SessionStorage, SessionStorageStat, SessionStorageWriter } from "./session-storage";
+import { type SessionTitleUpdate } from "./session-title-slot";
 export interface SessionStorageIndexEntry {
     path: string;
     size: number;
     mtimeMs: number;
+    title?: string;
+    titleSource?: SessionTitleUpdate["source"];
+    titleUpdatedAt?: string;
 }
 export interface SessionStorageBackend {
     init(): Promise<void>;
     loadIndex(): Promise<Iterable<SessionStorageIndexEntry>>;
     readFull(path: string): Promise<string | null>;
     readSlices(path: string, prefixBytes: number, suffixBytes: number): Promise<[string, string]>;
-    writeFull(path: string, content: string, mtimeMs: number): Promise<void>;
+    writeFull(path: string, content: string, mtimeMs: number, title?: SessionTitleUpdate): Promise<void>;
     append(path: string, line: string, mtimeMs: number): Promise<void>;
+    updateSessionTitle(path: string, title: SessionTitleUpdate, mtimeMs: number): Promise<void>;
     truncate(path: string, mtimeMs: number): Promise<void>;
     remove(paths: string[]): Promise<void>;
     move(src: string, dst: string, mtimeMs: number): Promise<void>;
@@ -24,6 +29,7 @@ export declare class IndexedSessionStorage implements SessionStorage {
     ensureDirSync(_dir: string): void;
     existsSync(path: string): boolean;
     writeTextSync(path: string, content: string): void;
+    updateSessionTitle(path: string, title: SessionTitleUpdate): Promise<void>;
     statSync(path: string): SessionStorageStat;
     listFilesSync(dir: string, pattern: string): string[];
     exists(path: string): Promise<boolean>;