jeopi-cli 16.2.13 → 16.2.14

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

@@ -1,1417 +0,0 @@
-/**
- * AgentSession - Core abstraction for agent lifecycle and session management.
- *
- * This class is shared between all run modes (interactive, print, rpc).
- * It encapsulates:
- * - Agent state access
- * - Event subscription with automatic session persistence
- * - Model and thinking level management
- * - Compaction (manual and auto)
- * - Bash execution
- * - Session switching and branching
- *
- * Modes use this class and add their own I/O layer on top.
- */
-import { Agent, type AgentEvent, type AgentMessage, type AgentState, type AgentTool, type StreamFn, ThinkingLevel, type ToolChoiceDirective } from "jeopi-agent-core";
-import { type CompactionResult, type ShakeConfig } from "jeopi-agent-core/compaction";
-import type { AssistantMessage, Context, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ResetCreditAccountStatus, ResetCreditRedeemOutcome, ResetCreditTarget, ServiceTier, ServiceTierByFamily, ServiceTierFamily, SimpleStreamOptions, TextContent, ToolChoice, UsageReport } from "jeopi-ai";
-import { Effort } from "jeopi-ai";
-import type { InMemorySnapshotStore } from "jeopi-hashline";
-import { postmortem } from "jeopi-utils";
-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";
-import { type ResolvedModelRoleValue } from "../config/model-resolver";
-import { type PromptTemplate } from "../config/prompt-templates";
-import type { Settings, SkillsSettings } from "../config/settings";
-import { RawSseDebugBuffer } from "../debug/raw-sse-buffer";
-import { type PythonResult } from "../eval/py/executor";
-import { type BashResult } from "../exec/bash-executor";
-import type { TtsrManager } from "../export/ttsr";
-import type { LoadedCustomCommand } from "../extensibility/custom-commands";
-import type { CustomTool } from "../extensibility/custom-tools/types";
-import type { ExtensionRunner } from "../extensibility/extensions";
-import type { CompactOptions, ContextUsage } from "../extensibility/extensions/types";
-import type { Skill, SkillWarning } from "../extensibility/skills";
-import { type FileSlashCommand } from "../extensibility/slash-commands";
-import { GoalRuntime } from "../goals/runtime";
-import type { Goal, GoalModeState } from "../goals/state";
-import type { HindsightSessionState } from "../hindsight/state";
-import { type IrcMessage } from "../irc/bus";
-import { type MnemopiSessionState } from "../mnemopi/state";
-import type { PlanModeState } from "../plan-mode/state";
-import { type SecretObfuscator } from "../secrets/obfuscator";
-import { type ConfiguredThinkingLevel } from "../thinking";
-import { type DiscoverableTool, type DiscoverableToolSearchIndex } from "../tool-discovery/tool-index";
-import type { CheckpointState, CompletedRewindState } from "../tools/checkpoint";
-import { type TodoItem, type TodoPhase } from "../tools/todo";
-import type { ClientBridge } from "./client-bridge";
-import { type CustomMessage } from "./messages";
-import type { BuildSessionContextOptions, SessionContext } from "./session-context";
-import type { BranchSummaryEntry, NewSessionOptions } from "./session-entries";
-import { type SessionManager } from "./session-manager";
-import type { ShakeMode, ShakeResult } from "./shake-types";
-import { ToolChoiceQueue } from "./tool-choice-queue";
-import { YieldQueue } from "./yield-queue";
-/** Session-specific events that extend the core AgentEvent */
-export type AgentSessionEvent = AgentEvent | {
-    type: "auto_compaction_start";
-    reason: "threshold" | "overflow" | "idle" | "incomplete";
-    action: "context-full" | "handoff" | "shake" | "snapcompact";
-} | {
-    type: "auto_compaction_end";
-    action: "context-full" | "handoff" | "shake" | "snapcompact";
-    result: CompactionResult | undefined;
-    aborted: boolean;
-    willRetry: boolean;
-    errorMessage?: string;
-    /** True when compaction was skipped for a benign reason (no model, no candidates, nothing to compact). */
-    skipped?: boolean;
-} | {
-    type: "auto_retry_start";
-    attempt: number;
-    maxAttempts: number;
-    delayMs: number;
-    errorMessage: string;
-    errorId?: number;
-} | {
-    type: "auto_retry_end";
-    success: boolean;
-    attempt: number;
-    finalError?: string;
-} | {
-    type: "retry_fallback_applied";
-    from: string;
-    to: string;
-    role: string;
-} | {
-    type: "retry_fallback_succeeded";
-    model: string;
-    role: string;
-} | {
-    type: "ttsr_triggered";
-    rules: Rule[];
-} | {
-    type: "todo_reminder";
-    todos: TodoItem[];
-    attempt: number;
-    maxAttempts: number;
-} | {
-    type: "todo_auto_clear";
-} | {
-    type: "irc_message";
-    message: CustomMessage;
-} | {
-    type: "notice";
-    level: "info" | "warning" | "error";
-    message: string;
-    source?: string;
-} | {
-    type: "thinking_level_changed";
-    thinkingLevel: ThinkingLevel | undefined;
-    /** The user-configured selector when it differs from the effective level (e.g. `auto`). */
-    configured?: ConfiguredThinkingLevel;
-    /** The level `auto` resolved to this turn, once classified. */
-    resolved?: Effort;
-} | {
-    type: "goal_updated";
-    goal: Goal | null;
-    state?: GoalModeState;
-};
-/** Listener function for agent session events */
-export type AgentSessionEventListener = (event: AgentSessionEvent) => void;
-/**
- * Budget for callers on the user-visible `/quit` / `/exit` shutdown path that
- * want to cap how long they wait for `MnemopiSessionState.dispose()` to finish
- * its consolidate pass. Consolidate fires fresh LLM fact extractions, each a
- * 1–3 s round-trip, so interactive shutdown passes this budget to keep the
- * UI responsive. Callers that keep the process/session host alive must omit it
- * so dispose still awaits the full consolidate-then-close pipeline.
- */
-export declare const SHUTDOWN_CONSOLIDATE_BUDGET_MS = 1500;
-export interface AgentSessionDisposeOptions {
-    mnemopiConsolidateTimeoutMs?: number;
-    /**
-     * Postmortem reason that triggered this dispose (signal/fatal teardown
-     * paths). When set, the persisted `session_exit` diagnostic records it
-     * instead of the generic `"dispose"` used for normal programmatic disposal
-     * (`/quit`, test teardown, subagent completion).
-     */
-    reason?: postmortem.Reason;
-}
-export type CommandMetadataChangedListener = () => void | Promise<void>;
-export type AsyncJobSnapshotItem = Pick<AsyncJob, "id" | "type" | "status" | "label" | "startTime">;
-export interface AsyncJobSnapshot {
-    running: AsyncJobSnapshotItem[];
-    recent: AsyncJobSnapshotItem[];
-    delivery: AsyncJobDeliveryState;
-}
-export type { ShakeMode, ShakeResult };
-export interface AgentSessionConfig {
-    agent: Agent;
-    sessionManager: SessionManager;
-    settings: Settings;
-    /** Whether the caller explicitly requested yolo/auto-approve behavior for this session. */
-    autoApprove?: boolean;
-    /** Models to cycle through with Ctrl+P (from --models flag) */
-    scopedModels?: Array<{
-        model: Model;
-        thinkingLevel?: ThinkingLevel;
-    }>;
-    /** Initial session thinking selector. */
-    thinkingLevel?: ConfiguredThinkingLevel;
-    /** Initial per-family service tiers (OpenAI / Anthropic / Google) for the live session. */
-    serviceTierByFamily?: ServiceTierByFamily;
-    /** Prompt templates for expansion */
-    promptTemplates?: PromptTemplate[];
-    /** File-based slash commands for expansion */
-    slashCommands?: FileSlashCommand[];
-    /** Extension runner (created in main.ts with wrapped tools) */
-    extensionRunner?: ExtensionRunner;
-    /** Loaded skills (already discovered by SDK) */
-    skills?: Skill[];
-    /** Skill loading warnings (already captured by SDK) */
-    skillWarnings?: SkillWarning[];
-    /** Custom commands (TypeScript slash commands) */
-    customCommands?: LoadedCustomCommand[];
-    skillsSettings?: SkillsSettings;
-    /** Model registry for API key resolution and model discovery */
-    modelRegistry: ModelRegistry;
-    /** Tool registry for LSP and settings */
-    toolRegistry?: Map<string, AgentTool>;
-    /** Tool names whose current registry entry is still the built-in implementation. */
-    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 side-channel requests (`/btw`, `/omfg`, IRC
-     * auto-replies, and handoff generation) so they apply the same provider
-     * shaping and host-level request wrappers as normal agent turns. Defaults
-     * to plain `streamSimple` when omitted.
-     */
-    sideStreamFn?: StreamFn;
-    /**
-     * 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;
-    /** Hint that OpenAI Codex requests should prefer websocket transport when supported. */
-    preferWebsockets?: boolean;
-    /** Provider payload hook used by the active session request path */
-    onPayload?: SimpleStreamOptions["onPayload"];
-    /** Provider response hook used by the active session request path */
-    onResponse?: SimpleStreamOptions["onResponse"];
-    /** Raw SSE hook used by the active session request path */
-    onSseEvent?: SimpleStreamOptions["onSseEvent"];
-    /** Per-session raw SSE diagnostic buffer */
-    rawSseDebugBuffer?: RawSseDebugBuffer;
-    /** Current session message-to-LLM conversion pipeline */
-    convertToLlm?: (messages: AgentMessage[]) => Message[] | Promise<Message[]>;
-    /** System prompt builder that can consider tool availability. Returns ordered provider-facing blocks. */
-    rebuildSystemPrompt?: (toolNames: string[], tools: Map<string, AgentTool>) => Promise<{
-        systemPrompt: string[];
-    }>;
-    /** Rebuild the SSH tool from current capability discovery results. */
-    reloadSshTool?: () => Promise<AgentTool | null>;
-    requestedToolNames?: ReadonlySet<string>;
-    /**
-     * Optional accessor for live MCP server instructions. Read by the session's
-     * `rebuildSystemPrompt`-skip optimization to detect server-side instruction
-     * changes (e.g. an MCP server upgrade) that would otherwise pass the tool-set
-     * signature comparison and silently keep a stale prompt cached.
-     */
-    getMcpServerInstructions?: () => Map<string, string> | undefined;
-    /** Enable hidden-by-default MCP tool discovery for this session. */
-    mcpDiscoveryEnabled?: boolean;
-    /** MCP tool names to activate for the current session when discovery mode is enabled. */
-    initialSelectedMCPToolNames?: string[];
-    /** Whether constructor-provided MCP defaults should be persisted immediately. */
-    persistInitialMCPToolSelection?: boolean;
-    /** MCP server names whose tools should seed discovery-mode sessions whenever those servers are connected. */
-    defaultSelectedMCPServerNames?: string[];
-    /** MCP tool names that should seed brand-new sessions created from this AgentSession. */
-    defaultSelectedMCPToolNames?: string[];
-    /** TTSR manager for time-traveling stream rules */
-    ttsrManager?: TtsrManager;
-    /** Secret obfuscator for deobfuscating streaming edit content */
-    obfuscator?: SecretObfuscator;
-    /** Inherited eval executor session id from a parent agent. */
-    parentEvalSessionId?: string;
-    /** Logical owner for retained eval kernels created by this session. */
-    evalKernelOwnerId?: string;
-    /**
-     * AsyncJobManager that this session installed as the process-global instance.
-     * Only set for top-level sessions; subagents inherit the parent's manager and
-     * **MUST NOT** dispose it on their own teardown.
-     */
-    ownedAsyncJobManager?: AsyncJobManager;
-    /**
-     * AsyncJobManager reachable by this session for scoped job actions.
-     *
-     * Top-level owners receive their own manager, subagents receive the inherited
-     * parent manager, and secondary in-process top-level sessions receive
-     * `undefined` so job snapshots and ACP drains cannot observe the primary's
-     * state.
-     */
-    asyncJobManager?: AsyncJobManager;
-    /** Agent identity (registry id like "Main" or "Alice") used for IRC routing. */
-    agentId?: string;
-    /** Whether this session is the top-level agent or a subagent. Drives eager-task
-     *  prelude gating so a top-level session created with a custom `agentId` still
-     *  receives the always-mode reminder. Defaults to "main". */
-    agentKind?: "main" | "sub";
-    /**
-     * Override the provider-facing session ID for all API requests from this session.
-     * When absent, `sessionManager.getSessionId()` is used. Needed when benchmark or
-     * SDK callers issue probes / prewarming with an explicit `--provider-session-id`
-     * so that credential sticky selection is consistent with the session's streaming calls.
-     */
-    providerSessionId?: string;
-    /**
-     * 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.
-     */
-    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
-     * prompt so inline descriptors are not also sent through provider schemas.
-     */
-    pruneToolDescriptions?: boolean;
-    /**
-     * Disconnect this session's OWNED MCP manager on dispose. Provided only when
-     * the session created the manager (top-level sessions); subagents reuse a
-     * parent's manager via `options.mcpManager` and omit this so a child's
-     * teardown never tears down the shared servers.
-     */
-    disconnectOwnedMcpManager?: () => Promise<void>;
-    /**
-     * Override the bundled system prompt used by automatic session-title
-     * generation paths (initial title + replan refresh). Source-of-truth is
-     * `TITLE_SYSTEM.md` discovered via {@link discoverTitleSystemPromptFile} and
-     * resolved through {@link resolvePromptInput}; refresh after a `/move`-style
-     * cwd change via {@link AgentSession.setTitleSystemPrompt}.
-     */
-    titleSystemPrompt?: string;
-}
-/** Options for AgentSession.prompt() */
-export interface PromptOptions {
-    /** Whether to expand file-based prompt templates (default: true) */
-    expandPromptTemplates?: boolean;
-    /** Image attachments */
-    images?: ImageContent[];
-    /** When streaming, how to queue the message: "steer" (interrupt) or "followUp" (wait). */
-    streamingBehavior?: "steer" | "followUp";
-    /** Optional tool choice override for the next LLM call. */
-    toolChoice?: ToolChoice;
-    /** Send as developer/system message instead of user. Providers that support it use the developer role; others fall back to user. */
-    synthetic?: boolean;
-    /** Marks this prompt as a deliberate user action (typed message, `.`/`c`
-     *  continue). Clears advisor auto-resume suppression that a user interrupt set.
-     *  Defaults to `!synthetic`; manual-continue is synthetic yet user-initiated, so
-     *  it sets this explicitly. Agent-initiated synthetic prompts (auto-continue,
-     *  plan re-prime, reminders) leave it unset and keep suppression latched. */
-    userInitiated?: boolean;
-    /** Explicit billing/initiator attribution for the prompt. Defaults to user prompts as `user` and synthetic prompts as `agent`. */
-    attribution?: MessageAttribution;
-    /** Skip pre-send compaction checks for this prompt (internal use for maintenance flows). */
-    skipCompactionCheck?: boolean;
-}
-/** Result from a handoff operation. */
-export interface HandoffResult {
-    document: string;
-    savedPath?: string;
-}
-export interface SessionHandoffOptions {
-    autoTriggered?: boolean;
-    signal?: AbortSignal;
-}
-/** Result from cycleModel() */
-export interface ModelCycleResult {
-    model: Model;
-    thinkingLevel: ThinkingLevel | undefined;
-    /** Whether cycling through scoped models (--models flag) or all available */
-    isScoped: boolean;
-}
-/** Result from cycleRoleModels() */
-export interface RoleModelCycleResult {
-    model: Model;
-    thinkingLevel: ThinkingLevel | undefined;
-    role: string;
-}
-/** A configured role resolved to a concrete model, used by role cycling and
- *  the plan-approval model slider. */
-export interface ResolvedRoleModel {
-    role: string;
-    model: Model;
-    thinkingLevel?: ConfiguredThinkingLevel;
-    explicitThinkingLevel: boolean;
-}
-/** The set of resolvable role models plus the index of the currently active
- *  one within {@link ResolvedRoleModel.role} order. */
-export interface RoleModelCycle {
-    models: ResolvedRoleModel[];
-    currentIndex: number;
-}
-export interface ContextUsageBreakdown {
-    contextWindow: number;
-    anchored: boolean;
-    usedTokens: number;
-    systemPromptTokens: number;
-    systemToolsTokens: number;
-    systemContextTokens: number;
-    skillsTokens: number;
-    messagesTokens: number;
-}
-/** Session statistics for /session command */
-export interface SessionStats {
-    sessionFile: string | undefined;
-    sessionId: string;
-    userMessages: number;
-    assistantMessages: number;
-    toolCalls: number;
-    toolResults: number;
-    totalMessages: number;
-    tokens: {
-        input: number;
-        output: number;
-        reasoning: number;
-        cacheRead: number;
-        cacheWrite: number;
-        total: number;
-    };
-    premiumRequests: number;
-    cost: number;
-}
-/** Advisor statistics for /advisor status command. */
-export interface AdvisorStats {
-    configured: boolean;
-    active: boolean;
-    model?: Model;
-    contextWindow: number;
-    contextTokens: number;
-    tokens: {
-        input: number;
-        output: number;
-        reasoning: number;
-        cacheRead: number;
-        cacheWrite: number;
-        total: number;
-    };
-    cost: number;
-    messages: {
-        user: number;
-        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;
-    sessionId: string;
-    closedProviderSessions: number;
-}
-/** Entry returned by {@link AgentSession.clearQueue} / {@link AgentSession.popLastQueuedMessage}. */
-export type RestoredQueuedMessage = {
-    text: string;
-    images?: ImageContent[];
-};
-type SessionNameTrigger = "replan";
-export declare class AgentSession {
-    #private;
-    readonly agent: Agent;
-    readonly sessionManager: SessionManager;
-    readonly settings: Settings;
-    readonly yieldQueue: YieldQueue;
-    fileSnapshotStore?: InMemorySnapshotStore;
-    readonly configWarnings: string[];
-    readonly rawSseDebugBuffer: RawSseDebugBuffer;
-    constructor(config: AgentSessionConfig);
-    /** Model registry for API key resolution and model discovery */
-    get modelRegistry(): ModelRegistry;
-    get asyncJobManager(): AsyncJobManager | undefined;
-    getAgentId(): string | undefined;
-    /**
-     * The per-turn tool-choice directive for the agent loop's `getToolChoice`. Priority:
-     *   1. a HARD forced choice from the queue (genuine forces: user-force, eager-todo, …) —
-     *      consuming (advances the queue generator);
-     *   2. else, when a non-forcing preview is pending, a {@link SoftToolRequirement} — a
-     *      PEEK (advances/pops nothing), so the agent-loop injects the reminder once per head
-     *      and escalates to a forced `resolve` only if the model declines. A compliant turn
-     *      pays ZERO tool_choice change (no prompt-cache messages-cache invalidation);
-     *   3. else undefined.
-     */
-    nextToolChoiceDirective(): ToolChoiceDirective | undefined;
-    /** Peek the head non-forcing pending preview invoker, for the `resolve` tool's dispatch. */
-    peekPendingInvoker(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
-    /** Clear stale non-forcing pending preview invokers after `resolve` proves none can run. */
-    clearPendingInvokers(): void;
-    /**
-     * Force the next model call to target a specific active tool, then terminate
-     * the agent loop. Pushes a two-step sequence [forced, "none"] so the model
-     * calls exactly the forced tool once and then cannot call another.
-     */
-    setForcedToolChoice(toolName: string): void;
-    /** The tool-choice queue: forces forthcoming tool invocations and carries handlers. */
-    get toolChoiceQueue(): ToolChoiceQueue;
-    /** Peek the in-flight directive's invocation handler for use by the resolve tool. */
-    peekQueueInvoker(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
-    peekStandingResolveHandler(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
-    setStandingResolveHandler(handler: ((input: unknown) => Promise<unknown> | unknown) | null): void;
-    setSessionSwitchReconciler(reconciler: (() => Promise<void>) | null): void;
-    /** Provider-scoped mutable state store for transport/session caches. */
-    get providerSessionState(): Map<string, ProviderSessionState>;
-    /** Hint forwarded to provider calls that support websocket transport. */
-    get preferWebsockets(): boolean | undefined;
-    getHindsightSessionState(): HindsightSessionState | undefined;
-    setHindsightSessionState(state: HindsightSessionState | undefined): HindsightSessionState | undefined;
-    getMnemopiSessionState(): MnemopiSessionState | undefined;
-    /** TTSR manager for time-traveling stream rules */
-    get ttsrManager(): TtsrManager | undefined;
-    /** Secret obfuscator, when secrets are configured; /share redaction reuses it. */
-    get obfuscator(): SecretObfuscator | undefined;
-    /** Whether a TTSR abort is pending (stream was aborted to inject rules) */
-    get isTtsrAbortPending(): boolean;
-    /** Whether an expected internal plan-mode abort is pending. Consumed by
-     *  `#handleAgentEvent` to stamp `SILENT_ABORT_MARKER` on the next aborted
-     *  assistant message_end; callers clear it in `finally`. */
-    get isPlanInternalAbortPending(): boolean;
-    /** Arm the silent-abort marker for the next aborted assistant message_end.
-     *  Caller MUST clear via `clearPlanInternalAbortPending()` in a `finally`
-     *  to guarantee no leak. */
-    markPlanInternalAbortPending(): void;
-    /** Unconditionally clear the silent-abort flag. Idempotent: safe when the
-     *  flag was never set OR was already consumed by `#handleAgentEvent`. */
-    clearPlanInternalAbortPending(): void;
-    getAsyncJobSnapshot(options?: {
-        recentLimit?: number;
-    }): AsyncJobSnapshot | null;
-    /**
-     * Emit a UI-only notice to the session. Surfaces in interactive mode as a
-     * `showWarning` / `showError` / `showStatus` line; non-interactive modes
-     * receive the event through the normal subscribe stream.
-     *
-     * Notices are NOT added to agent state and never reach the LLM — use this
-     * for out-of-band conditions the user should see but the model shouldn't
-     * react to (e.g. background queue flush failures).
-     */
-    emitNotice(level: "info" | "warning" | "error", message: string, source?: string): void;
-    /**
-     * Subscribe to agent events.
-     * Session persistence is handled internally (saves messages on message_end).
-     * Multiple listeners can be added. Returns unsubscribe function for this listener.
-     */
-    subscribe(listener: AgentSessionEventListener): () => void;
-    subscribeCommandMetadataChanged(listener: CommandMetadataChangedListener): () => 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;
-    markMovedFromEmptySessionFile(sessionFile: string): void;
-    /**
-     * Synchronously mark the session as disposing so new work is rejected
-     * immediately: eval starts throw, queued asides are dropped, and the
-     * aside provider is detached. Idempotent; `dispose()` runs it first.
-     *
-     * Wrappers that await other teardown before delegating to `dispose()` MUST
-     * call this before their first await — otherwise work started in that async
-     * gap slips past the disposal guards.
-     */
-    beginDispose(): void;
-    dispose(options?: AgentSessionDisposeOptions): Promise<void>;
-    freshSession(): FreshSessionResult | undefined;
-    /** Full agent state */
-    get state(): AgentState;
-    /** Current model (may be undefined if not yet selected) */
-    get model(): Model | undefined;
-    /** Effective thinking level applied to the agent (the resolved level when `auto`). */
-    get thinkingLevel(): ThinkingLevel | undefined;
-    /** The selector the user configured: `auto` when auto mode is active, else the effective level. */
-    configuredThinkingLevel(): ConfiguredThinkingLevel | undefined;
-    /** True when `auto` thinking mode is active. */
-    get isAutoThinking(): boolean;
-    /** The level `auto` resolved to for the current turn (undefined until classified). */
-    autoResolvedThinkingLevel(): Effort | undefined;
-    /** Live per-family service tiers (OpenAI / Anthropic / Google). */
-    get serviceTierByFamily(): ServiceTierByFamily;
-    /** Whether agent is currently streaming a response */
-    get isStreaming(): boolean;
-    get isAborting(): boolean;
-    /** Wait until streaming and deferred recovery work are fully settled. */
-    waitForIdle(): Promise<void>;
-    drainAsyncJobDeliveriesForAcp(options?: {
-        timeoutMs?: number;
-    }): Promise<boolean>;
-    /** Most recent assistant message in agent state. */
-    getLastAssistantMessage(): AssistantMessage | undefined;
-    /** Current effective system prompt blocks (includes any per-turn extension modifications) */
-    get systemPrompt(): string[];
-    /** Current retry attempt (0 if not retrying) */
-    get retryAttempt(): number;
-    /**
-     * Get the names of currently active tools.
-     * Returns the names of tools currently set on the agent.
-     */
-    getActiveToolNames(): string[];
-    /** Whether the edit tool is registered in this session. */
-    get hasEditTool(): boolean;
-    /**
-     * Get a tool by name from the registry.
-     */
-    getToolByName(name: string): AgentTool | undefined;
-    /** True when the current registry entry for `name` came from a built-in factory. */
-    hasBuiltInTool(name: string): boolean;
-    /**
-     * Get all configured tool names (built-in via --tools or default, plus custom tools).
-     */
-    getAllToolNames(): string[];
-    isMCPDiscoveryEnabled(): boolean;
-    /**
-     * Flip MCP discovery on after deferred discovery learns the real tool count.
-     * UI sessions resolve `tools.discoveryMode: "auto"` before MCP servers
-     * connect, so a large MCP toolset discovered later must be able to upgrade
-     * the session from the force-activate path to the discovery path. One-way:
-     * discovery is never downgraded mid-session.
-     */
-    enableMCPDiscovery(): void;
-    getSelectedMCPToolNames(): string[];
-    activateDiscoveredMCPTools(toolNames: string[]): Promise<string[]>;
-    isToolDiscoveryEnabled(): boolean;
-    getDiscoverableTools(filter?: {
-        source?: DiscoverableTool["source"];
-    }): DiscoverableTool[];
-    getDiscoverableToolSearchIndex(): DiscoverableToolSearchIndex;
-    getSelectedDiscoveredToolNames(): string[];
-    activateDiscoveredTools(toolNames: string[]): Promise<string[]>;
-    /**
-     * Reload the SSH tool from disk-backed capability discovery and make the
-     * refreshed definition visible to the next model call without restarting.
-     */
-    refreshSshTool(options?: {
-        activateIfAvailable?: boolean;
-    }): Promise<void>;
-    /**
-     * Set active tools by name.
-     * Only tools in the registry can be enabled. Unknown tool names are ignored.
-     * Also rebuilds the system prompt to reflect the new tool set.
-     * Changes take effect before the next model call.
-     */
-    setActiveToolsByName(toolNames: string[]): Promise<void>;
-    /** Rebuild the base system prompt using the current active tool set. */
-    refreshBaseSystemPrompt(): Promise<void>;
-    /**
-     * Replace MCP tools in the registry and recompute the visible MCP tool set immediately.
-     * This allows /mcp add/remove/reauth to take effect without restarting the session.
-     *
-     * @param mcpTools The new MCP tools to register.
-     * @param options.activateAll When true, force-activates every newly registered MCP tool
-     *   regardless of prior selection state. Used when an ACP client provisions MCP servers
-     *   for a session where MCP discovery is disabled.
-     */
-    refreshMCPTools(mcpTools: CustomTool[], options?: {
-        activateAll?: boolean;
-    }): Promise<void>;
-    /**
-     * Replace RPC host-owned tools and refresh the active tool set before the next model call.
-     */
-    refreshRpcHostTools(rpcTools: AgentTool[]): Promise<void>;
-    /** Whether auto-compaction is currently running */
-    get isCompacting(): boolean;
-    /**
-     * Whether idle-flush tasks, auto-continuations, or other short-lived
-     * post-prompt work are pending.  True in the brief window after
-     * `session.prompt()` returns but before a scheduled background delivery
-     * (e.g. an async-job result) has finished its own streaming turn.
-     * Loop-mode and similar auto-submit paths should treat this as a block
-     * to avoid racing against the delivery turn.
-     */
-    get hasPostPromptWork(): boolean;
-    /** All messages including custom types like BashExecutionMessage */
-    get messages(): AgentMessage[];
-    /** Latest image attachments addressable by tools as `Image #N` or `attachment://N`. */
-    getImageAttachments(): {
-        label: string;
-        uri: string;
-        image: ImageContent;
-    }[];
-    buildDisplaySessionContext(): SessionContext;
-    /**
-     * Transcript for TUI display. Full history is kept for export/resume-style
-     * callers; live chat can collapse compacted history to keep the hot render
-     * surface bounded. Display-only — NEVER feed the result to
-     * `agent.replaceMessages` or a provider.
-     */
-    buildTranscriptSessionContext(options?: Pick<BuildSessionContextOptions, "collapseCompactedHistory">): SessionContext;
-    /** Convert session messages using the same pre-LLM pipeline as the active session. */
-    convertMessagesToLlm(messages: AgentMessage[], signal?: AbortSignal): Promise<Message[]>;
-    /** Apply session-level stream hooks to a direct side request. */
-    prepareSimpleStreamOptions(options: SimpleStreamOptions, provider?: string): SimpleStreamOptions;
-    /** Current steering mode */
-    get steeringMode(): "all" | "one-at-a-time";
-    /** Current follow-up mode */
-    get followUpMode(): "all" | "one-at-a-time";
-    /** Current interrupt mode */
-    get interruptMode(): "immediate" | "wait";
-    /** Current session file path, or undefined if sessions are disabled */
-    get sessionFile(): string | undefined;
-    /** Current session ID */
-    get sessionId(): string;
-    getEvalSessionId(): string | null;
-    /** Current session display name, if set */
-    get sessionName(): string | undefined;
-    /** Scoped models for cycling (from --models flag) */
-    get scopedModels(): ReadonlyArray<{
-        model: Model;
-        thinkingLevel?: ThinkingLevel;
-    }>;
-    /** Prompt templates */
-    getPlanModeState(): PlanModeState | undefined;
-    setPlanModeState(state: PlanModeState | undefined): void;
-    getGoalModeState(): GoalModeState | undefined;
-    setGoalModeState(state: GoalModeState | undefined): void;
-    get goalRuntime(): GoalRuntime;
-    markPlanReferenceSent(): void;
-    setPlanReferencePath(path: string): void;
-    getPlanReferencePath(): string;
-    get clientBridge(): ClientBridge | undefined;
-    setClientBridge(bridge: ClientBridge | undefined): void;
-    getCheckpointState(): CheckpointState | undefined;
-    getLastCompletedRewind(): CompletedRewindState | undefined;
-    setCheckpointState(state: CheckpointState | undefined): void;
-    /**
-     * Inject the plan mode context message into the conversation history.
-     */
-    sendPlanModeContext(options?: {
-        deliverAs?: "steer" | "followUp" | "nextTurn";
-    }): Promise<void>;
-    sendGoalModeContext(options?: {
-        deliverAs?: "steer" | "followUp" | "nextTurn";
-    }): Promise<void>;
-    resolveRoleModel(role: string): Model | undefined;
-    /**
-     * Resolve a role to its model AND thinking level.
-     * Unlike resolveRoleModel(), this preserves the thinking level suffix
-     * from role configuration (e.g., "anthropic/claude-sonnet-4-5:xhigh").
-     */
-    resolveRoleModelWithThinking(role: string): ResolvedModelRoleValue;
-    get promptTemplates(): ReadonlyArray<PromptTemplate>;
-    /** Replace file-based slash commands used for prompt expansion. */
-    setSlashCommands(slashCommands: FileSlashCommand[]): void;
-    /** Custom commands (TypeScript slash commands and MCP prompts) */
-    get customCommands(): ReadonlyArray<LoadedCustomCommand>;
-    /** MCP prompt commands only, for command-list metadata. */
-    get mcpPromptCommands(): ReadonlyArray<LoadedCustomCommand>;
-    /** Update the MCP prompt commands list. Called when server prompts are (re)loaded. */
-    setMCPPromptCommands(commands: LoadedCustomCommand[]): void;
-    /**
-     * Send a prompt to the agent.
-     * - Handles extension commands (registered via pi.registerCommand) immediately, even during streaming
-     * - Expands file-based prompt templates by default
-     * - During streaming, queues via steer() or followUp() based on streamingBehavior option
-     * - Validates model and API key before sending (when not streaming)
-     * @throws Error if streaming and no streamingBehavior specified
-     * @throws Error if no model selected or no API key available (when not streaming)
-     */
-    /**
-     * Returns `false` when the command was fully handled locally (extension or
-     * custom-TS command consumed without calling the LLM). Returns `true` when
-     * the prompt was forwarded to the agent — either directly or queued as a
-     * steer/follow-up. Callers that render a UI or manage turn lifecycle (e.g.
-     * the ACP agent) use this to know whether to expect an `agent_end` event.
-     */
-    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.
-     */
-    steer(text: string, images?: ImageContent[]): Promise<void>;
-    /**
-     * Queue a follow-up message to process after the agent would otherwise stop.
-     */
-    followUp(text: string, images?: ImageContent[]): Promise<void>;
-    queueDeferredMessage(message: CustomMessage): void;
-    /**
-     * Send a custom message to the session. Creates a CustomMessageEntry.
-     *
-     * Handles three cases:
-     * - Streaming: queue as steer/follow-up or store for next turn
-     * - Not streaming + triggerTurn: appends to state/session, starts new turn unless the client cannot own it
-     * - Not streaming + no trigger: appends to state/session, no turn
-     *
-     * @returns true iff this call synchronously started a new turn (awaited
-     * `agent.prompt`); false when the message was queued/appended without a turn
-     * — including when `triggerTurn` is downgraded because the client defers
-     * agent-initiated turns. Callers that must mirror the resulting `agent_end`
-     * use this to avoid acting on a turn that never ran.
-     */
-    sendCustomMessage<T = unknown>(message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: {
-        triggerTurn?: boolean;
-        deliverAs?: "steer" | "followUp" | "nextTurn";
-        queueChipText?: string;
-    }): Promise<boolean>;
-    /**
-     * Send a user message to the agent.
-     * When deliverAs is set, queue the message instead of starting a new turn.
-     *
-     * @param content User message content (string or content array)
-     * @param options.deliverAs Delivery mode: "steer" or "followUp"
-     */
-    sendUserMessage(content: string | (TextContent | ImageContent)[], options?: {
-        deliverAs?: "steer" | "followUp";
-    }): Promise<void>;
-    /** 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).
-     *  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[];
-        followUp: readonly string[];
-    };
-    /**
-     * 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;
-    /** Skills loaded by SDK (empty if --no-skills or skills: [] was passed) */
-    get skills(): readonly Skill[];
-    /** Skill loading warnings captured by SDK */
-    get skillWarnings(): readonly SkillWarning[];
-    getTodoPhases(): TodoPhase[];
-    setTodoPhases(phases: TodoPhase[]): void;
-    /** 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. */
-    get titleSystemPrompt(): string | undefined;
-    /** Replace the title-generation system prompt override. Called by
-     *  {@link InteractiveMode.refreshTitleSystemPrompt} after the session cwd
-     *  changes (e.g. `/move` relocation) so the next replan refresh resolves
-     *  against the destination project's override. */
-    setTitleSystemPrompt(prompt: string | undefined): void;
-    /**
-     * Abort current operation and wait for agent to become idle.
-     *
-     * `reason` (e.g. `USER_INTERRUPT_LABEL`) rides the agent's `AbortController`
-     * and surfaces verbatim on the aborted assistant message's `errorMessage`, so
-     * the transcript can distinguish a deliberate user interrupt from an opaque
-     * abort. Omit it for internal/lifecycle aborts.
-     */
-    abort(options?: {
-        goalReason?: "interrupted" | "internal";
-        reason?: string;
-        /** Internal `/compact` startup keeps the manual-compaction marker alive while aborting the active turn. */
-        preserveCompaction?: boolean;
-    }): Promise<void>;
-    /**
-     * Start a new session, optionally with initial messages and parent tracking.
-     * Clears all messages and starts a new session.
-     * Listeners are preserved and will continue receiving events.
-     * @param options - Optional initial messages and parent session path
-     * @returns true if completed, false if cancelled by hook
-     */
-    newSession(options?: NewSessionOptions): Promise<boolean>;
-    /**
-     * Set a display name for the current session.
-     */
-    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.
-     * Unlike newSession(), this preserves all messages in the agent state.
-     * @returns true if completed, false if cancelled by hook or not persisting
-     */
-    fork(): Promise<boolean>;
-    /**
-     * Set model directly.
-     * Validates that a credential source is configured (synchronously, without
-     * 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;
-        currentContextTokens?: number;
-    }): Promise<{
-        switched: boolean;
-    }>;
-    /**
-     * Set model temporarily (for this session only).
-     * Validates that a credential source is configured (synchronously, without
-     * refreshing OAuth or running command-backed key programs), saves to session
-     * log but NOT to settings.
-     * @throws Error if no API key available for the model
-     */
-    setModelTemporary(model: Model, thinkingLevel?: ConfiguredThinkingLevel, options?: {
-        ephemeral?: boolean;
-    }): Promise<void>;
-    /**
-     * Cycle to next/previous model.
-     * Uses scoped models (from --models flag) if available, otherwise all available models.
-     * @param direction - "forward" (default) or "backward"
-     * @returns The new model info, or undefined if only one model available
-     */
-    cycleModel(direction?: "forward" | "backward"): Promise<ModelCycleResult | undefined>;
-    /**
-     * Resolve the configured role models in the given order plus the index of
-     * the currently active one. Roles that have no configured model, or whose
-     * configured model is not currently available, are skipped. The `default`
-     * role falls back to the active model when no explicit assignment exists.
-     *
-     * Returns `undefined` only when there is no current model or no available
-     * models at all; an empty `models` array is never returned (callers should
-     * still guard on `models.length`).
-     */
-    getRoleModelCycle(roleOrder: readonly string[]): RoleModelCycle | undefined;
-    /**
-     * Apply a resolved role model as the active model without changing global
-     * settings. Shared with role cycling and the plan-approval model slider.
-     */
-    applyRoleModel(entry: ResolvedRoleModel): Promise<void>;
-    /**
-     * Cycle through configured role models in a fixed order.
-     * Skips missing roles and changes only the active session model.
-     * @param roleOrder - Order of roles to cycle through (e.g., ["slow", "default", "smol"])
-     * @param direction - "forward" (default) or "backward"
-     */
-    cycleRoleModels(roleOrder: readonly string[], direction?: "forward" | "backward"): Promise<RoleModelCycleResult | undefined>;
-    /**
-     * Get all available models with valid API keys, filtered by `enabledModels` when configured.
-     * See {@link filterAvailableModelsByEnabledPatterns} for supported pattern forms and limitations.
-     */
-    getAvailableModels(): Model[];
-    /**
-     * Set the thinking level. `auto` enables per-turn classification; the selector
-     * itself is never written to the session log, but resolved concrete levels are
-     * persisted when real user turns are classified so resumed sessions keep the
-     * last resolved effort instead of reverting to pending auto.
-     */
-    setThinkingLevel(level: ConfiguredThinkingLevel | undefined, persist?: boolean): void;
-    /**
-     * Cycle to next thinking level: off → auto → minimal..xhigh → off.
-     * @returns New selector, or undefined if model doesn't support thinking
-     */
-    cycleThinkingLevel(): ConfiguredThinkingLevel | undefined;
-    /**
-     * True when the currently selected model's family is set to `priority` — the
-     * `/fast` on/off state for the active model. Returns false when no model is
-     * selected or the model exposes no service-tier family (e.g. Fireworks, which
-     * has its own Providers › Fireworks Tier toggle).
-     *
-     * For "is priority actually applied to the next request?" use
-     * {@link isFastModeActive} instead.
-     */
-    isFastModeEnabled(): boolean;
-    /**
-     * True when `priority` is actually realized on the wire for the currently
-     * selected model (OpenAI/Google `service_tier`, direct Anthropic fast mode,
-     * or Fireworks priority). Returns false for tiers the active model can't
-     * realize and when no model is selected.
-     */
-    isFastModeActive(): boolean;
-    /** Set one family's tier (or clear it with `undefined`); persists the change. */
-    setServiceTierFamily(family: ServiceTierFamily, tier: ServiceTier | undefined): void;
-    /**
-     * `/fast on|off` targets the family of the currently selected model: it sets
-     * (or clears) that family's `priority` tier. Models without a service-tier
-     * family (Fireworks, or providers with no tier knob) have nothing to toggle.
-     */
-    setFastMode(enabled: boolean): void;
-    toggleFastMode(): boolean;
-    /**
-     * Get available thinking levels for current model.
-     */
-    getAvailableThinkingLevels(): ReadonlyArray<Effort>;
-    /**
-     * Set steering mode.
-     * Saves to settings.
-     */
-    setSteeringMode(mode: "all" | "one-at-a-time"): void;
-    /**
-     * Set follow-up mode.
-     * Saves to settings.
-     */
-    setFollowUpMode(mode: "all" | "one-at-a-time"): void;
-    /**
-     * Set interrupt mode.
-     * Saves to settings.
-     */
-    setInterruptMode(mode: "immediate" | "wait"): void;
-    /**
-     * Strip image content blocks from every message on the current branch and
-     * persist the rewrite. Walks `SessionManager.getBranch()` in place — both
-     * `SessionMessageEntry.message` and `CustomMessageEntry.content` arrays
-     * are mutated, then `rewriteEntries` durably commits the new shape. The
-     * agent's runtime view is rebuilt from the freshly-mutated entries so any
-     * provider sessions caching message identity (Codex Responses) are torn
-     * down to force a clean replay on the next turn.
-     *
-     * No-op when the branch carries no images; returns `{ removed: 0 }` and
-     * skips the disk rewrite.
-     */
-    dropImages(): Promise<{
-        removed: number;
-    }>;
-    /**
-     * Surgically reduce context by dropping heavy content ("shake").
-     *
-     * - `images` delegates to {@link dropImages}.
-     * - `elide` replaces whole tool-call results and large fenced/XML blocks
-     *   with short placeholders that embed an `artifact://` recovery link.
-     *
-     * Mutates the branch in place, persists via `rewriteEntries`, replays the
-     * rebuilt context through the agent, and tears down provider sessions that
-     * cache message identity — same rewrite contract as {@link dropImages}.
-     *
-     * No-op (zero counts) when nothing is eligible.
-     */
-    shake(mode: ShakeMode, opts?: {
-        config?: ShakeConfig;
-        signal?: AbortSignal;
-    }): Promise<ShakeResult>;
-    /**
-     * Manually compact the session context.
-     * Aborts current agent operation first.
-     * @param customInstructions Optional instructions for the compaction summary
-     * @param options Optional callbacks for completion/error handling
-     */
-    compact(customInstructions?: string, options?: CompactOptions): Promise<CompactionResult>;
-    /**
-     * Cancel in-progress context maintenance (manual compaction, auto-compaction, or auto-handoff).
-     */
-    abortCompaction(): void;
-    /** Trigger idle compaction through the auto-compaction flow (with UI events). */
-    runIdleCompaction(): Promise<void>;
-    /**
-     * Cancel in-progress branch summarization.
-     */
-    abortBranchSummary(): void;
-    /**
-     * Cancel in-progress handoff generation.
-     */
-    abortHandoff(): void;
-    /**
-     * Check if handoff generation is in progress.
-     */
-    get isGeneratingHandoff(): boolean;
-    /**
-     * Generate a handoff document with a oneshot LLM call, then start a new session with it.
-     *
-     * @param customInstructions Optional focus for the handoff document
-     * @param options Handoff execution options
-     * @returns The handoff document text, or undefined if cancelled/failed
-     */
-    handoff(customInstructions?: string, options?: SessionHandoffOptions): Promise<HandoffResult | undefined>;
-    /**
-     * Toggle auto-compaction setting.
-     */
-    setAutoCompactionEnabled(enabled: boolean): void;
-    /** Whether auto-compaction is enabled */
-    get autoCompactionEnabled(): boolean;
-    /**
-     * Cancel in-progress retry.
-     */
-    abortRetry(): void;
-    /** Whether auto-retry is currently in progress */
-    get isRetrying(): boolean;
-    /** Whether auto-retry is enabled */
-    get autoRetryEnabled(): boolean;
-    /**
-     * Toggle auto-retry setting.
-     */
-    setAutoRetryEnabled(enabled: boolean): void;
-    /**
-     * Manually retry the last failed assistant turn.
-     * Removes the error message from agent state and re-attempts with a fresh retry budget.
-     * @returns true if retry was initiated, false if no failed turn to retry or agent is busy
-     */
-    retry(): Promise<boolean>;
-    /**
-     * Execute a bash command.
-     * Adds result to agent context and session.
-     * @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)
-     * @param options.useUserShell If true, allow caller to request configured user-shell routing
-     */
-    executeBash(command: string, onChunk?: (chunk: string) => void, options?: {
-        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.
-     */
-    recordBashResult(command: string, result: BashResult, options?: {
-        excludeFromContext?: boolean;
-    }): void;
-    /**
-     * Cancel running bash command.
-     */
-    abortBash(): void;
-    /** Whether a bash command is currently running */
-    get isBashRunning(): boolean;
-    /** Whether there are pending bash messages waiting to be flushed */
-    get hasPendingBashMessages(): boolean;
-    /**
-     * Execute Python code in the shared kernel.
-     * Uses the same kernel session as eval's Python backend, allowing collaborative editing.
-     * @param code The Python code to execute
-     * @param onChunk Optional streaming callback for output
-     * @param options.excludeFromContext If true, execution won't be sent to LLM ($$ prefix)
-     */
-    executePython(code: string, onChunk?: (chunk: string) => void, options?: {
-        excludeFromContext?: boolean;
-    }): Promise<PythonResult>;
-    assertEvalExecutionAllowed(): void;
-    /**
-     * Track Python work started outside AgentSession.executePython so dispose can await and abort it too.
-     */
-    trackEvalExecution<T>(execution: Promise<T>, abortController: AbortController): Promise<T>;
-    /**
-     * Record a Python execution result in session history.
-     */
-    recordPythonResult(code: string, result: PythonResult, options?: {
-        excludeFromContext?: boolean;
-    }): void;
-    /**
-     * Cancel running Python execution.
-     */
-    abortEval(): void;
-    /** Whether a Python execution is currently running */
-    get isEvalRunning(): boolean;
-    /** Whether there are pending Python messages waiting to be flushed */
-    get hasPendingPythonMessages(): boolean;
-    /**
-     * Surfaces (and consumes) pending IRC incoming records before the next model
-     * step can inject them automatically.
-     *
-     * The inbox tool injects the formatted body into the tool result, so the
-     * model sees it once via the result. Leaving the record in either pending
-     * IRC queue would deliver it a second time at the next step boundary —
-     * including on `peek`, which is why peek also drains here.
-     */
-    drainPendingIrcInboxMessages(agentId: string): IrcMessage[];
-    /**
-     * Deliver an IRC message into this session (recipient side; called by the
-     * IrcBus). Emits the `irc_message` session event for UI cards and injects
-     * the rendered message into the model's context as an `irc:incoming`
-     * custom message:
-     *
-     * - mid-turn → queued on the aside channel and folded in at the next step
-     *   boundary (non-interrupting, like async-result deliveries) → "injected";
-     * - idle → starts a real turn with the message so the recipient wakes
-     *   → "woken".
-     *
-     * Never blocks on the recipient's turn: the wake turn is fire-and-forget.
-     *
-     * When the sender expects a reply (`send await:true`) and this session is
-     * mid-turn with async execution disabled, the next step boundary may be
-     * gated on the sender's own batch finishing (blocking task spawns), so a
-     * real reply turn can never happen in time. In that case an ephemeral
-     * side-channel auto-reply is generated from the current context (the old
-     * `respondAsBackground` path) and sent back over the bus on this agent's
-     * behalf.
-     */
-    deliverIrcMessage(msg: IrcMessage, opts?: {
-        expectsReply?: boolean;
-    }): Promise<"injected" | "woken">;
-    /**
-     * Emit an IRC relay observation event on this session for UI rendering only.
-     * Does not persist the record to history. Called by the IrcBus to surface
-     * agent↔agent traffic on the main session.
-     */
-    emitIrcRelayObservation(record: CustomMessage): void;
-    /**
-     * Run a single ephemeral side-channel turn against this session's current
-     * model + system prompt + history. The main turn's tool catalog is sent
-     * to preserve the prompt cache, but the model is reminded not to call
-     * tools and any tool calls are discarded. The side request
-     * does not block on, or interfere with, any in-flight main turn. The
-     * session's history and persisted state are NOT modified by this call.
-     *
-     * Used by `BtwController` (`/btw`) and `OmfgController` (`/omfg`) to share
-     * the snapshot + stream pipeline. The snapshot includes any in-flight
-     * streaming assistant text so the model sees the half-finished response
-     * rather than missing context.
-     */
-    runEphemeralTurn(args: {
-        promptText: string;
-        onTextDelta?: (delta: string) => void;
-        signal?: AbortSignal;
-        dedupeReply?: boolean;
-    }): Promise<{
-        replyText: string;
-        assistantMessage: AssistantMessage;
-    }>;
-    /**
-     * Reload the current session from disk.
-     *
-     * Intended for extension commands and headless modes to re-read the current session
-     * file and re-emit session_switch hooks.
-     */
-    reload(): Promise<void>;
-    /**
-     * Switch to a different session file.
-     * Aborts current operation, loads messages, restores model/thinking.
-     * Listeners are preserved and will continue receiving events.
-     * @returns true if switch completed, false if cancelled by hook
-     */
-    switchSession(sessionPath: string): Promise<boolean>;
-    /**
-     * Create a branch from a specific entry.
-     * Emits before_branch/branch session events to hooks.
-     *
-     * @param entryId ID of the entry to branch from
-     * @returns Object with:
-     *   - selectedText: The text of the selected user message (for editor pre-fill)
-     *   - cancelled: True if a hook cancelled the branch
-     */
-    branch(entryId: string): Promise<{
-        selectedText: string;
-        cancelled: boolean;
-    }>;
-    branchFromBtw(question: string, assistantMessage: AssistantMessage): Promise<{
-        cancelled: boolean;
-        sessionFile: string | undefined;
-    }>;
-    /**
-     * Navigate to a different node in the session tree.
-     * Unlike branch() which creates a new session file, this stays in the same file.
-     *
-     * @param targetId The entry ID to navigate to
-     * @param options.summarize Whether user wants to summarize abandoned branch
-     * @param options.customInstructions Custom instructions for summarizer
-     * @returns Result with editorText (if user message) and cancelled status
-     */
-    navigateTree(targetId: string, options?: {
-        summarize?: boolean;
-        customInstructions?: string;
-    }): Promise<{
-        editorText?: string;
-        cancelled: boolean;
-        aborted?: boolean;
-        summaryEntry?: BranchSummaryEntry;
-        /** Raw session context built during navigation — pass to renderInitialMessages to skip a second O(N) walk. */
-        sessionContext?: SessionContext;
-    }>;
-    /**
-     * Get all user messages from session for branch selector.
-     */
-    getUserMessagesForBranching(): Array<{
-        entryId: string;
-        text: string;
-    }>;
-    /**
-     * Get session statistics.
-     */
-    getSessionStats(): SessionStats;
-    /**
-     * Get current context usage statistics.
-     * Uses the last assistant message's usage data when available,
-     * otherwise estimates tokens for all messages.
-     */
-    getContextBreakdown(options?: {
-        contextWindow?: number;
-        pendingMessages?: AgentMessage[];
-    }): ContextUsageBreakdown | undefined;
-    getContextUsage(options?: {
-        contextWindow?: number;
-    }): ContextUsage | undefined;
-    /**
-     * Monotonic counter that changes whenever the in-flight pending context
-     * snapshot is set or cleared. Status-line context memoization keys on this so
-     * a value computed mid-turn cannot persist after the turn ends/aborts.
-     */
-    get contextUsageRevision(): number;
-    fetchUsageReports(signal?: AbortSignal): Promise<UsageReport[] | null>;
-    /**
-     * Redeem one saved Codex rate-limit reset for a specific account, injecting
-     * the provider base URL like {@link AgentSession.fetchUsageReports}. Powers
-     * the `/usage reset` command and auto-redeem. Never throws for business
-     * outcomes — inspect the returned `code`.
-     */
-    redeemResetCredit(target: ResetCreditTarget, signal?: AbortSignal): Promise<ResetCreditRedeemOutcome>;
-    /**
-     * List saved Codex rate-limit resets per stored account, fetched live from
-     * the dedicated credits endpoint (bypasses the usage cache). Powers the
-     * `/usage reset` account selector.
-     */
-    listResetCredits(signal?: AbortSignal): Promise<ResetCreditAccountStatus[]>;
-    /**
-     * Export session to HTML.
-     * @param outputPath Optional output path (defaults to session directory)
-     * @returns Path to exported file
-     */
-    exportToHtml(outputPath?: string): Promise<string>;
-    /**
-     * Get text content of last assistant message.
-     * Useful for /copy command.
-     * @returns Text content, or undefined if no assistant message exists
-     */
-    getLastAssistantText(): string | undefined;
-    hasCopyCandidateAssistantMessage(): boolean;
-    /**
-     * Get text content of the most recent visible handoff message.
-     * Fresh handoff sessions store the handoff context as a custom message, not
-     * an assistant message, so callers that copy the "last" message can use this
-     * as a fallback before the new session has an assistant response.
-     */
-    getLastVisibleHandoffText(): string | undefined;
-    /**
-     * 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(): string;
-    /**
-     * Dump the current session's LLM-facing request context as JSON to a
-     * auto-named file in `os.tmpdir()`. This is the synchronous
-     * `convertToLlm`-boundary snapshot — system prompt, tools (wire schemas),
-     * thinking/service tier, and converted messages — with no network round-trip
-     * and no arming flag, so advisor/side requests cannot intercept it.
-     *
-     * The file persists on disk and may contain the same raw context/secrets
-     * as `/dump`; treat the path accordingly.
-     *
-     * @returns the written file path, or `undefined` when there are no messages.
-     */
-    dumpLlmRequestToTmpDir(): Promise<string | undefined>;
-    /**
-     * Enable or disable the advisor for this session. The setting is overridden for the session,
-     * and the runtime is started or stopped to match.
-     *
-     * @returns true when the advisor is actively running after the call.
-     */
-    setAdvisorEnabled(enabled: boolean): boolean;
-    /**
-     * Toggle the advisor setting and start/stop the runtime accordingly.
-     *
-     * @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.
-     */
-    isAdvisorEnabled(): boolean;
-    /**
-     * Whether a live advisor agent is attached to this session. True only when
-     * `advisor.enabled` is set AND a model resolved for the `advisor` role AND
-     * the advisor applies to this agent kind — i.e. the actual runtime exists,
-     * 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.
-     */
-    getAdvisorStats(): AdvisorStats;
-    /**
-     * Format a concise advisor status line for ACP/text output.
-     */
-    formatAdvisorStatus(): string;
-    /**
-     * Format the advisor agent's own transcript (its system prompt, config,
-     * tools, and the markdown deltas it received plus its thinking/advise/read
-     * calls) as plain text — the advisor-side equivalent of
-     * {@link formatSessionAsText}. Returns null when no advisor is active.
-     */
-    formatAdvisorHistoryAsText(options?: {
-        compact?: boolean;
-    }): string | null;
-    /**
-     * Check if extensions have handlers for a specific event type.
-     */
-    hasExtensionHandlers(eventType: string): boolean;
-    /**
-     * Get the extension runner (for setting UI context and error handlers).
-     */
-    get extensionRunner(): ExtensionRunner | undefined;
-}