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

package/dist/types/advisor/__tests__/advisor.test.d.ts

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

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

@@ -0,0 +1,58 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import { z } from "zod/v4";
+declare const adviseSchema: z.ZodObject<{
+    note: z.ZodString;
+    severity: z.ZodOptional<z.ZodEnum<{
+        blocker: "blocker";
+        concern: "concern";
+        nit: "nit";
+    }>>;
+}, z.core.$strip>;
+export type AdviseParams = z.infer<typeof adviseSchema>;
+export type AdvisorSeverity = "nit" | "concern" | "blocker";
+export interface AdviseDetails {
+    note: string;
+    severity?: AdvisorSeverity;
+}
+/** One queued advice note. */
+export interface AdvisorNote {
+    note: string;
+    severity?: AdvisorSeverity;
+}
+/** Details payload on the batched `advisor` custom message rendered in the transcript. */
+export interface AdvisorMessageDetails {
+    notes: AdvisorNote[];
+}
+/** Render one advisor card body from a batch of notes (prefix + one bullet per note). */
+export declare function formatAdvisorBatchContent(notes: readonly AdvisorNote[]): string;
+/**
+ * Whether advice at this severity should interrupt the running agent (delivered
+ * via the steering channel, aborting in-flight tools) rather than ride the
+ * non-interrupting aside queue that lands at the next step boundary. `concern`
+ * and `blocker` interrupt; a plain `nit` queues.
+ */
+export declare function isInterruptingSeverity(severity: AdvisorSeverity | undefined): boolean;
+/**
+ * Side-effect-free investigation tools handed to the advisor agent so it can
+ * inspect the workspace before weighing in. Names match the primary session's
+ * tool instances, which the advisor reuses.
+ */
+export declare const ADVISOR_READONLY_TOOL_NAMES: ReadonlySet<string>;
+export declare class AdviseTool implements AgentTool<typeof adviseSchema, AdviseDetails> {
+    private readonly onAdvice;
+    readonly name = "advise";
+    readonly label = "Advise";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        note: z.ZodString;
+        severity: z.ZodOptional<z.ZodEnum<{
+            blocker: "blocker";
+            concern: "concern";
+            nit: "nit";
+        }>>;
+    }, z.core.$strip>;
+    readonly intent: "omit";
+    constructor(onAdvice: (note: string, severity?: AdviseDetails["severity"]) => void);
+    execute(_toolCallId: string, args: AdviseParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<AdviseDetails>, _context?: AgentToolContext): Promise<AgentToolResult<AdviseDetails>>;
+}
+export {};

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

@@ -0,0 +1,3 @@
+export * from "./advise-tool";
+export * from "./runtime";
+export * from "./watchdog";

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

@@ -0,0 +1,52 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+/** Minimal slice of `Agent` the runtime drives — satisfied by pi-agent-core `Agent`. */
+export interface AdvisorAgent {
+    prompt(input: string): Promise<void>;
+    abort(reason?: unknown): void;
+    reset(): void;
+    readonly state: {
+        messages: AgentMessage[];
+    };
+}
+export interface AdvisorRuntimeHost {
+    /** Live primary transcript (use `agent.state.messages`). */
+    snapshotMessages(): AgentMessage[];
+    /** Surface one advice note to the primary (enqueues into the session YieldQueue). */
+    enqueueAdvice(note: string, severity?: "nit" | "concern" | "blocker"): void;
+    /**
+     * Pre-prompt context maintenance for the advisor's own append-only context.
+     * Promotes the advisor model to a larger sibling when its context nears the
+     * window (mirroring the primary's promote-first policy) and resolves `true`
+     * when the advisor should re-prime — reset and replay the current
+     * primary-bounded transcript — because promotion did not free enough room.
+     * Optional: hosts that omit it get no maintenance (context only shrinks when
+     * the primary's next compaction triggers {@link AdvisorRuntime.reset}).
+     */
+    maintainContext?(incomingTokens: number): Promise<boolean>;
+}
+export declare class AdvisorRuntime {
+    #private;
+    private readonly agent;
+    private readonly host;
+    private readonly retryDelayMs;
+    disposed: boolean;
+    constructor(agent: AdvisorAgent, host: AdvisorRuntimeHost, retryDelayMs?: number);
+    get backlog(): number;
+    onTurnEnd(messages?: AgentMessage[]): void;
+    waitForCatchup(maxMs: number, threshold: number, signal?: AbortSignal): Promise<void>;
+    dispose(): void;
+    /**
+     * Re-prime the advisor after a history rewrite (compaction, session
+     * switch/resume, branch). Clears the advisor's own (non-persisted) context
+     * and rewinds the cursor to 0 so the NEXT turn replays the full current —
+     * post-compaction — transcript, giving the advisor fresh context instead of
+     * leaving it blind to everything before the rewrite.
+     */
+    reset(): void;
+    /**
+     * Seed the cursor to the current transcript length when the advisor is enabled
+     * mid-session. Prevents the next turn from replaying the entire history to the
+     * advisor (which would be expensive and likely stale).
+     */
+    seedTo(count: number): void;
+}

package/dist/types/advisor/watchdog.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Discover and load WATCHDOG.md files walking up from cwd, project .omp folder, and user agent dir.
+ * Returns formatted watchdog file blocks ready to be appended to the advisor system prompt.
+ */
+export declare function discoverWatchdogFiles(cwd: string, agentDir?: string): Promise<string[]>;

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

@@ -3,7 +3,7 @@
  */
 import { type ThemeColor } from "../modes/theme/theme";
 import type { Settings } from "./settings";
-export type ModelRole = "default" | "smol" | "slow" | "vision" | "plan" | "designer" | "commit" | "title" | "task";
+export type ModelRole = "default" | "smol" | "slow" | "vision" | "plan" | "designer" | "commit" | "title" | "task" | "advisor";
 export interface ModelRoleInfo {
     tag?: string;
     name: string;

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

@@ -1,3 +1,4 @@
+import { type SearchProviderId } from "../web/search/types";
 /** Unified settings schema - single source of truth for all settings.
  *
  * Each setting is defined once here with:
@@ -177,6 +178,37 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Keep the display from idle-sleeping while a session is open (caffeinate -d)";
         };
     };
+    readonly "advisor.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "model";
+            readonly group: "Advisor";
+            readonly label: "Enable Advisor";
+            readonly description: "Pair a second model (assigned to the 'advisor' role) that passively reviews each turn and injects notes.";
+        };
+    };
+    readonly "advisor.subagents": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "model";
+            readonly group: "Advisor";
+            readonly label: "Advisor for Subagents";
+            readonly description: "Also enable the advisor on spawned task/eval subagents.";
+        };
+    };
+    readonly "advisor.syncBacklog": {
+        readonly type: "enum";
+        readonly values: readonly ["off", "1", "3", "5"];
+        readonly default: "off";
+        readonly ui: {
+            readonly tab: "model";
+            readonly group: "Advisor";
+            readonly label: "Advisor Sync Backlog";
+            readonly description: "Pause the main agent for up to 30 seconds if the advisor falls behind by this many turns. Off disables catch-up delays.";
+        };
+    };
     readonly shellPath: {
         readonly type: "string";
         readonly default: undefined;
@@ -1843,13 +1875,13 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly "tools.format": {
         readonly type: "enum";
-        readonly values: readonly ["auto", "native", "glm", "hermes", "kimi", "xml", "anthropic", "deepseek", "harmony", "pi", "qwen3"];
+        readonly values: readonly ["auto", "native", "glm", "hermes", "kimi", "xml", "anthropic", "deepseek", "harmony", "pi", "qwen3", "gemini", "gemma"];
         readonly default: "auto";
         readonly ui: {
             readonly tab: "context";
             readonly group: "Experimental";
-            readonly label: "Tool Call Format";
-            readonly description: "Controls how tools are exposed to the model. Auto uses native tool calls unless the selected model is marked as not supporting tools, then falls back to GLM-style in-band tool calls. Native forces provider-native tools; the other values force the named in-band syntax. Applies on session start.";
+            readonly label: "Tool Calling Mode";
+            readonly description: "Controls how tools are exposed to the model. Auto uses provider-native tool calls unless the selected model is marked as not supporting them, then falls back to the GLM owned dialect. Native forces provider-native tools; the other values force the named owned dialect. Applies on session start.";
             readonly options: readonly [{
                 readonly value: "auto";
                 readonly label: "Auto";
@@ -1889,11 +1921,19 @@ export declare const SETTINGS_SCHEMA: {
             }, {
                 readonly value: "pi";
                 readonly label: "Pi";
-                readonly description: "Use Pi-style in-band tool calls.";
+                readonly description: "Use the Pi owned dialect.";
             }, {
                 readonly value: "qwen3";
                 readonly label: "Qwen3";
-                readonly description: "Use Qwen3-style in-band tool calls.";
+                readonly description: "Use the Qwen3 owned dialect.";
+            }, {
+                readonly value: "gemini";
+                readonly label: "Gemini";
+                readonly description: "Use the Gemini owned dialect.";
+            }, {
+                readonly value: "gemma";
+                readonly label: "Gemma";
+                readonly description: "Use the Gemma owned dialect.";
             }];
         };
     };
@@ -3566,6 +3606,17 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Enable plan mode for read-only exploration and planning before execution";
         };
     };
+    readonly "plan.defaultOnStartup": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly group: "Modes";
+            readonly label: "Start in Plan Mode";
+            readonly description: "Automatically enter plan mode at the start of every new session";
+            readonly condition: "planModeEnabled";
+        };
+    };
     readonly "goal.enabled": {
         readonly type: "boolean";
         readonly default: true;
@@ -4081,6 +4132,16 @@ export declare const SETTINGS_SCHEMA: {
             }];
         };
     };
+    readonly "providers.webSearchExclude": {
+        readonly type: "array";
+        readonly default: SearchProviderId[];
+        readonly ui: {
+            readonly tab: "providers";
+            readonly group: "Services";
+            readonly label: "Excluded Web Search Providers";
+            readonly description: "Providers that web_search should never use, even as fallbacks";
+        };
+    };
     readonly "providers.image": {
         readonly type: "enum";
         readonly values: readonly ["auto", "openai", "antigravity", "xai", "gemini", "openrouter"];

package/dist/types/discovery/helpers.d.ts

@@ -67,6 +67,13 @@ export declare function getUserPath(ctx: LoadContext, source: SourceId, subpath:
  * Get project-level path for a source (cwd only).
  */
 export declare function getProjectPath(ctx: LoadContext, source: SourceId, subpath: string): string | null;
+/**
+ * Resolve GitHub Copilot CLI's user-global config root. Copilot stores per-user
+ * instructions/prompts/agents/MCP under `~/.copilot`, relocatable via the
+ * `COPILOT_HOME` env var (mirrors Copilot CLI's `--config-dir`). Falls back to
+ * `<home>/.copilot` when the override is unset.
+ */
+export declare function resolveCopilotHome(home: string): string;
 /**
  * Create source metadata for an item.
  */

package/dist/types/eval/__tests__/prelude-agent.test.d.ts

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

package/dist/types/extensibility/plugins/runtime-config.d.ts

@@ -0,0 +1,3 @@
+import type { PluginRuntimeConfig } from "./types";
+/** Normalizes persisted plugin runtime config across legacy lockfile shapes. */
+export declare function normalizePluginRuntimeConfig(config: Partial<PluginRuntimeConfig>): PluginRuntimeConfig;

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

@@ -0,0 +1,9 @@
+import { type Component } from "@oh-my-pi/pi-tui";
+import type { AdvisorMessageDetails } from "../../advisor";
+import type { Theme } from "../theme/theme";
+/**
+ * Display-only transcript card for advisor notes injected into the primary
+ * session. Mirrors the IRC card's glyph + quote-border conventions so passive
+ * advice reads as a distinct, non-interrupting aside rather than a user turn.
+ */
+export declare function createAdvisorMessageCard(details: AdvisorMessageDetails | undefined, getExpanded: () => boolean, uiTheme: Theme): Component;

package/dist/types/modes/components/assistant-message.d.ts

@@ -13,6 +13,7 @@ export declare class AssistantMessageComponent extends Container {
     constructor(message?: AssistantMessage, hideThinkingBlock?: boolean, onImageUpdate?: (() => void) | undefined, thinkingRenderers?: readonly AssistantThinkingRenderer[], imageBudget?: ImageBudget | undefined);
     invalidate(): void;
     setHideThinkingBlock(hide: boolean): void;
+    dispose(): void;
     /**
      * Toggle suppression of the inline `Error: …` line while the same error is
      * pinned in the banner above the editor. Re-renders so the change is visible.

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

@@ -10,10 +10,12 @@ export declare class CommandController {
     constructor(ctx: InteractiveModeContext);
     openInBrowser(urlOrPath: string): void;
     handleExportCommand(text: string): Promise<void>;
-    handleDumpCommand(): void;
+    handleDumpCommand(isRaw?: boolean): void;
+    handleAdvisorDumpCommand(isRaw?: boolean): void;
     handleDebugTranscriptCommand(): Promise<void>;
     handleShareCommand(): Promise<void>;
     handleSessionCommand(): Promise<void>;
+    handleAdvisorStatusCommand(): Promise<void>;
     handleJobsCommand(): Promise<void>;
     handleUsageCommand(reports?: UsageReport[] | null): Promise<void>;
     handleChangelogCommand(showFull?: boolean): Promise<void>;

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

@@ -268,11 +268,13 @@ export declare class InteractiveMode implements InteractiveModeContext {
     findLastAssistantMessage(): AssistantMessage | undefined;
     extractAssistantText(message: AssistantMessage): string;
     handleExportCommand(text: string): Promise<void>;
-    handleDumpCommand(): void;
+    handleDumpCommand(isRaw?: boolean): void;
+    handleAdvisorDumpCommand(isRaw?: boolean): void;
     handleDebugTranscriptCommand(): Promise<void>;
     handleShareCommand(): Promise<void>;
     handleTodoCommand(args: string): Promise<void>;
     handleSessionCommand(): Promise<void>;
+    handleAdvisorStatusCommand(): Promise<void>;
     handleJobsCommand(): Promise<void>;
     handleUsageCommand(reports?: UsageReport[] | null): Promise<void>;
     handleChangelogCommand(showFull?: boolean): Promise<void>;

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

@@ -45,6 +45,11 @@ export type SubmittedUserInput = {
      *  as a hidden agent-authored `developer` message rather than a visible user
      *  turn. Used by the `c`/`.` continue shortcut. */
     synthetic?: boolean;
+    /** Marks this submission as a deliberate user resume (set by the `.`/`c`
+     *  continue shortcut, which is also `synthetic`). Forwarded to
+     *  `session.prompt({ userInitiated })` so it clears advisor auto-resume
+     *  suppression even though it is synthetic. */
+    userInitiated?: boolean;
     display?: boolean;
     /** Queue intent if the session is (or becomes) busy when this submission is
      *  dispatched: "steer" (interrupt the active turn) or "followUp" (process after
@@ -250,13 +255,15 @@ export interface InteractiveModeContext {
     handleShareCommand(): Promise<void>;
     handleTodoCommand(args: string): Promise<void>;
     handleSessionCommand(): Promise<void>;
+    handleAdvisorStatusCommand(): Promise<void>;
     handleJobsCommand(): Promise<void>;
     handleUsageCommand(reports?: UsageReport[] | null): Promise<void>;
     handleChangelogCommand(showFull?: boolean): Promise<void>;
     handleHotkeysCommand(): void;
     handleToolsCommand(): void;
     handleContextCommand(): void;
-    handleDumpCommand(): void;
+    handleDumpCommand(isRaw?: boolean): void;
+    handleAdvisorDumpCommand(isRaw?: boolean): void;
     handleDebugTranscriptCommand(): Promise<void>;
     handleClearCommand(): Promise<void>;
     handleFreshCommand(): Promise<void>;

package/dist/types/sdk.d.ts

@@ -1,6 +1,6 @@
 import { type AgentTelemetryConfig, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { type Model } from "@oh-my-pi/pi-ai";
-import type { ToolCallSyntax } from "@oh-my-pi/pi-ai/grammar";
+import type { Dialect } from "@oh-my-pi/pi-ai/dialect";
 import { type Rule } from "./capability/rule";
 import { ModelRegistry } from "./config/model-registry";
 import { type PromptTemplate } from "./config/prompt-templates";
@@ -184,8 +184,8 @@ export interface CreateAgentSessionResult {
     /** Shared event bus for tool/extension communication */
     eventBus: EventBus;
 }
-export type ToolCallFormat = "auto" | "native" | ToolCallSyntax;
-export declare function resolveToolCallSyntax(format: ToolCallFormat, model: Pick<Model, "supportsTools"> | undefined): ToolCallSyntax | undefined;
+export type DialectFormat = "auto" | "native" | Dialect;
+export declare function resolveDialect(format: DialectFormat, model: Pick<Model, "supportsTools"> | undefined): Dialect | undefined;
 export type { PromptTemplate } from "./config/prompt-templates";
 export { Settings, type SkillsSettings } from "./config/settings";
 export type { CustomCommand, CustomCommandFactory } from "./extensibility/custom-commands/types";

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

@@ -13,7 +13,7 @@
  * Modes use this class and add their own I/O layer on top.
  */
 import type { InMemorySnapshotStore } from "@oh-my-pi/hashline";
-import { type Agent, type AgentEvent, type AgentMessage, type AgentState, type AgentTool, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import { Agent, type AgentEvent, type AgentMessage, type AgentState, type AgentTool, ThinkingLevel } 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 { Effort } from "@oh-my-pi/pi-ai";
@@ -228,6 +228,15 @@ export interface AgentSessionConfig {
      * so that credential sticky selection is consistent with the session's streaming calls.
      */
     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.
+     */
+    advisorReadOnlyTools?: AgentTool[];
+    /** Preloaded watchdog prompt content for the advisor. */
+    advisorWatchdogPrompt?: string;
 }
 /** Options for AgentSession.prompt() */
 export interface PromptOptions {
@@ -241,6 +250,12 @@ export interface PromptOptions {
     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). */
@@ -301,6 +316,27 @@ export interface SessionStats {
     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;
+        cacheRead: number;
+        cacheWrite: number;
+        total: number;
+    };
+    cost: number;
+    messages: {
+        user: number;
+        assistant: number;
+        total: number;
+    };
+}
 export interface FreshSessionResult {
     previousSessionId: string;
     sessionId: string;
@@ -1095,7 +1131,50 @@ export declare class AgentSession {
      * Format the entire session as plain text for clipboard export.
      * Includes user messages, assistant text, thinking blocks, tool calls, and tool results.
      */
-    formatSessionAsText(): string;
+    formatSessionAsText(options?: {
+        compact?: boolean;
+    }): string;
+    /**
+     * Enable or disable the advisor for this session. The setting is overridden for the session,
+     * and the runtime is started or stopped to match.
+     *
+     * @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;
+    /**
+     * 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;
+    /**
+     * 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.
      */

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

@@ -1,6 +1,10 @@
 export interface HistoryFormatOptions {
     /** Optional H1 prepended to the transcript. */
     title?: string;
+    /** Render assistant thinking blocks (default: elided). */
+    includeThinking?: boolean;
+    /** Render tool intent comment before tool call lines. */
+    includeToolIntent?: boolean;
 }
 /**
  * Format a session's message array as a concise markdown transcript.

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

@@ -250,8 +250,11 @@ export declare class SessionManager {
     /**
      * Open a specific session file.
      * @param sessionDir Optional dir for /new or /branch; defaults to the file's parent.
+     * @param options.initialCwd Cwd to use when the file is empty or missing.
      */
-    static open(filePath: string, sessionDir?: string, storage?: SessionStorage): Promise<SessionManager>;
+    static open(filePath: string, sessionDir?: string, storage?: SessionStorage, options?: {
+        initialCwd?: string;
+    }): Promise<SessionManager>;
     /** Continue the most recent session, or create a new one if none exists. */
     static continueRecent(cwd: string, sessionDir?: string, storage?: SessionStorage): Promise<SessionManager>;
     /** Create an in-memory session (no file persistence). */

package/dist/types/session/yield-queue.d.ts

@@ -4,6 +4,8 @@ export interface YieldDispatcher<P> {
     isStale?(entry: P): boolean;
     /** Produce one batched AgentMessage from non-stale entries. Return null to skip. */
     build(survivors: P[]): AgentMessage | null;
+    /** If true, entries for this kind are drained only by {@link drainLazy} and never trigger the idle flush. */
+    skipIdleFlush?: boolean;
 }
 export interface YieldQueueOptions {
     isStreaming: () => boolean;

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

@@ -26,6 +26,27 @@ export declare function formatResultOutputFallback(result: Pick<SingleResult, "o
  * the same agent ≥2× all without roles. Returns undefined when no nudge applies.
  */
 export declare function buildSpecializationAdvisory(agentName: string | undefined, items: TaskItem[], depthCapacity: boolean): string | undefined;
+/**
+ * Suggestion — never a rejection — nudging the spawner to coordinate via `irc`
+ * when one call creates ≥2 live siblings and it still holds spawn capacity.
+ * Returns undefined when there is nothing to coordinate or IRC is unavailable.
+ */
+export declare function buildCoordinationAdvisory(items: TaskItem[], depthCapacity: boolean, ircEnabled: boolean): string | undefined;
+/**
+ * Compose the non-blocking advisory appended to a `task` result: the
+ * specialization nudge, plus — only when the siblings keep running after this
+ * call (`willRunAsync`) — the coordination suggestion. Coordination is gated on
+ * async because a sync fanout's siblings have already finished, so a
+ * "coordinate while they run" hint would misfire. Returns undefined when
+ * neither applies.
+ */
+export declare function composeSpawnAdvisory(args: {
+    agentName: string | undefined;
+    items: TaskItem[];
+    depthCapacity: boolean;
+    ircEnabled: boolean;
+    willRunAsync: boolean;
+}): string | undefined;
 /**
  * Task tool - Delegate tasks to specialized agents.
  *

package/dist/types/tools/github-cache.d.ts

@@ -8,10 +8,11 @@
  *   helpers swallow open/IO failures and degrade to "no cache" so a corrupt or
  *   unreadable DB never blocks a `gh` call.
  *
- * TTL:
  *   Soft TTL → return cached row directly.
- *   Past soft TTL but within hard TTL → return cached row AND schedule a
- *     background refresh (errors logged, never thrown).
+ *   Stateful issue/PR rows past soft TTL but within hard TTL → refresh
+ *     synchronously, falling back to the cached row if the live fetch fails.
+ *   Expensive PR diff rows past soft TTL but within hard TTL → return cached
+ *     row AND schedule a background refresh (errors logged, never thrown).
  *   Past hard TTL → treat as miss and fetch fresh.
  */
 import { Database } from "bun:sqlite";
@@ -101,7 +102,7 @@ export interface CacheLookupOptions<T> {
     settings?: Settings | undefined;
     now?: number;
 }
-export type CacheStatus = "miss" | "fresh" | "stale" | "disabled";
+export type CacheStatus = "miss" | "fresh" | "refreshed" | "stale" | "disabled";
 export interface CacheLookupResult<T> {
     rendered: string;
     sourceUrl: string | undefined;

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

@@ -56,6 +56,7 @@ export declare class JobTool implements AgentTool<typeof jobSchema, JobToolDetai
 interface JobRenderArgs {
     poll?: string[];
     cancel?: string[];
+    list?: boolean;
 }
 export declare const jobToolRenderer: {
     inline: boolean;

package/dist/types/tools/path-utils.d.ts

@@ -1,6 +1,7 @@
 import { type LocalProtocolOptions } from "../internal-urls";
 export declare function expandTilde(filePath: string, home?: string): string;
 export declare function expandPath(filePath: string): string;
+export declare function normalizeWindowsDriveAliasPath(filePath: string, platform?: NodeJS.Platform): string;
 /**
  * Inclusive line range describing one selector segment (e.g. `50-100`,
  * `301-`, or `50+10`). `endLine` is `undefined` for open-ended ranges.

package/dist/types/tools/report-tool-issue.d.ts

@@ -66,7 +66,6 @@ export declare function __resetAutoQaConsentForTests(): void;
  * permanently locked into the false branch.
  */
 export declare function resolveAutoQaConsent(settings: Settings | undefined): Promise<boolean>;
-export declare function getAutoQaDbPath(): string;
 /**
  * Open (or return the cached handle for) the auto-QA SQLite database at
  * `~/.omp/agent/autoqa.db`. Idempotently runs schema creation, the

package/dist/types/web/search/index.d.ts

@@ -80,6 +80,6 @@ export declare class WebSearchTool implements AgentTool<typeof webSearchSchema,
 /** Web search tool as CustomTool (for TUI rendering support) */
 export declare const webSearchCustomTool: CustomTool<typeof webSearchSchema, SearchRenderDetails>;
 export declare function getSearchTools(): CustomTool<any, any>[];
-export { getSearchProvider, setPreferredSearchProvider } from "./provider";
+export { getSearchProvider, setExcludedSearchProviders, setPreferredSearchProvider } from "./provider";
 export type { SearchProviderId as SearchProvider, SearchResponse } from "./types";
-export { isSearchProviderPreference } from "./types";
+export { isSearchProviderId, isSearchProviderPreference } from "./types";

package/dist/types/web/search/provider.d.ts

@@ -13,6 +13,8 @@ export declare function getSearchProviderLabel(id: SearchProviderId): string;
 export declare function getSearchProvider(id: SearchProviderId): Promise<SearchProvider>;
 /** Set the preferred web search provider from settings */
 export declare function setPreferredSearchProvider(provider: SearchProviderId | "auto"): void;
+/** Set providers that web search should never use, including fallbacks. */
+export declare function setExcludedSearchProviders(providers: readonly SearchProviderId[]): void;
 /**
  * Determine which providers are configured and currently available.
  * Each candidate is loaded (and its `isAvailable()` called) only as the chain