@oh-my-pi/pi-coding-agent 15.1.1 → 15.1.3

package/dist/types/export/ttsr.d.ts

@@ -0,0 +1,44 @@
+import type { Rule } from "../capability/rule";
+import type { TtsrSettings } from "../config/settings";
+export type TtsrMatchSource = "text" | "thinking" | "tool";
+/** Context about the stream content currently being checked against TTSR rules. */
+export interface TtsrMatchContext {
+    source: TtsrMatchSource;
+    /** Tool name for tool argument deltas, e.g. "edit" or "write". */
+    toolName?: string;
+    /** Candidate file paths associated with the current stream chunk. */
+    filePaths?: string[];
+    /** Stable key to isolate buffering (for example a tool call ID). */
+    streamKey?: string;
+}
+export declare class TtsrManager {
+    #private;
+    constructor(settings?: TtsrSettings);
+    /** Add a TTSR rule to be monitored. */
+    addRule(rule: Rule): boolean;
+    /**
+     * Add a stream chunk to its scoped buffer and return matching rules.
+     *
+     * Buffers are isolated by source/tool key so matches don't bleed across
+     * assistant prose, thinking text, and unrelated tool argument streams.
+     */
+    checkDelta(delta: string, context: TtsrMatchContext): Rule[];
+    /** Mark rules as injected (won't trigger again until conditions allow). */
+    markInjected(rulesToMark: Rule[]): void;
+    /** Mark rule names as injected (won't trigger again until conditions allow). */
+    markInjectedByNames(ruleNames: string[]): void;
+    /** Get names of all injected rules (for persistence). */
+    getInjectedRuleNames(): string[];
+    /** Restore injected state from a list of rule names. */
+    restoreInjected(ruleNames: string[]): void;
+    /** Reset stream buffers (called on new turn). */
+    resetBuffer(): void;
+    /** Check if any TTSR rules are registered. */
+    hasRules(): boolean;
+    /** Increment message counter (call after each turn). */
+    incrementMessageCount(): void;
+    /** Get current message count. */
+    getMessageCount(): number;
+    /** Get settings. */
+    getSettings(): Required<TtsrSettings>;
+}

package/dist/types/extensibility/custom-commands/bundled/ci-green/index.d.ts

@@ -0,0 +1,9 @@
+import type { CustomCommand, CustomCommandAPI } from "../../../../extensibility/custom-commands/types";
+import type { HookCommandContext } from "../../../../extensibility/hooks/types";
+export declare class GreenCommand implements CustomCommand {
+    private api;
+    name: string;
+    description: string;
+    constructor(api: CustomCommandAPI);
+    execute(_args: string[], _ctx: HookCommandContext): Promise<string>;
+}

package/dist/types/extensibility/custom-commands/bundled/review/index.d.ts

@@ -0,0 +1,10 @@
+import type { CustomCommand, CustomCommandAPI } from "../../../../extensibility/custom-commands/types";
+import type { HookCommandContext } from "../../../../extensibility/hooks/types";
+export declare class ReviewCommand implements CustomCommand {
+    private api;
+    name: string;
+    description: string;
+    constructor(api: CustomCommandAPI);
+    execute(args: string[], ctx: HookCommandContext): Promise<string | undefined>;
+}
+export default ReviewCommand;

package/dist/types/extensibility/custom-commands/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./loader";
+export type * from "./types";

package/dist/types/extensibility/custom-commands/loader.d.ts

@@ -0,0 +1,29 @@
+import type { CustomCommandSource, CustomCommandsLoadResult } from "./types";
+export interface DiscoverCustomCommandsOptions {
+    /** Current working directory. Default: getProjectDir() */
+    cwd?: string;
+    /** Agent config directory. Default: from getAgentDir() */
+    agentDir?: string;
+}
+export interface DiscoverCustomCommandsResult {
+    /** Paths to command modules */
+    paths: Array<{
+        path: string;
+        source: CustomCommandSource;
+    }>;
+}
+/**
+ * Discover custom command modules (TypeScript slash commands).
+ * Markdown slash commands are handled by core/slash-commands.ts.
+ */
+export declare function discoverCustomCommands(options?: DiscoverCustomCommandsOptions): Promise<DiscoverCustomCommandsResult>;
+export interface LoadCustomCommandsOptions {
+    /** Current working directory. Default: getProjectDir() */
+    cwd?: string;
+    /** Agent config directory. Default: from getAgentDir() */
+    agentDir?: string;
+}
+/**
+ * Discover and load custom commands from standard locations.
+ */
+export declare function loadCustomCommands(options?: LoadCustomCommandsOptions): Promise<CustomCommandsLoadResult>;

package/dist/types/extensibility/custom-commands/types.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Custom command types.
+ *
+ * Custom commands are TypeScript modules that define executable slash commands.
+ * Unlike markdown commands which expand to prompts, custom commands can execute
+ * arbitrary logic with full access to the hook context.
+ */
+import type { ExecOptions, ExecResult, HookCommandContext } from "../../extensibility/hooks/types";
+export type { ExecOptions, ExecResult, HookCommandContext };
+/**
+ * API passed to custom command factory.
+ * Similar to HookAPI but focused on command needs.
+ */
+export interface CustomCommandAPI {
+    /** Current working directory */
+    cwd: string;
+    /** Execute a shell command */
+    exec(command: string, args: string[], options?: ExecOptions): Promise<ExecResult>;
+    /** Injected zod-backed typebox shim (legacy/compat). */
+    typebox: typeof import("../typebox");
+    /** Injected zod module for Zod-authored custom commands. */
+    zod: typeof import("zod/v4");
+    /** Injected pi-coding-agent exports */
+    pi: typeof import("../..");
+}
+/**
+ * Custom command definition.
+ *
+ * Commands can either:
+ * - Return a string to be sent to the LLM as a prompt
+ * - Return void/undefined to do nothing (fire-and-forget)
+ *
+ * @example
+ * ```typescript
+ * const factory: CustomCommandFactory = (pi) => ({
+ *	  name: "deploy",
+ *	  description: "Deploy current branch to staging",
+ *	  async execute(args, ctx) {
+ *		 const env = args[0] || "staging";
+ *		 const confirmed = await ctx.ui.confirm("Deploy", `Deploy to ${env}?`);
+ *		 if (!confirmed) return;
+ *
+ *		 const result = await pi.exec("./deploy.sh", [env]);
+ *		 if (result.exitCode !== 0) {
+ *			ctx.ui.notify(`Deploy failed: ${result.stderr}`, "error");
+ *			return;
+ *		 }
+ *
+ *		 ctx.ui.notify("Deploy successful!", "info");
+ *		 // No return = no prompt sent to LLM
+ *	  }
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Return a prompt to send to the LLM
+ * const factory: CustomCommandFactory = (pi) => ({
+ *	  name: "git:status",
+ *	  description: "Show git status and suggest actions",
+ *	  async execute(args, ctx) {
+ *		 const result = await pi.exec("git", ["status", "--porcelain"]);
+ *		 return `Here's the git status:\n\`\`\`\n${result.stdout}\`\`\`\nSuggest what to do next.`;
+ *	  }
+ * });
+ * ```
+ */
+export interface CustomCommand {
+    /** Command name (can include namespace like "git:commit") */
+    name: string;
+    /** Description shown in command autocomplete */
+    description: string;
+    /**
+     * Execute the command.
+     * @param args - Parsed command arguments
+     * @param ctx - Command context with UI and session control
+     * @returns String to send as prompt, or void for fire-and-forget
+     */
+    execute(args: string[], ctx: HookCommandContext): Promise<string | undefined> | string | undefined;
+}
+/**
+ * Factory function that creates custom command(s).
+ * Can return a single command or an array of commands.
+ */
+export type CustomCommandFactory = (api: CustomCommandAPI) => CustomCommand | CustomCommand[] | Promise<CustomCommand | CustomCommand[]>;
+/** Source of a loaded custom command */
+export type CustomCommandSource = "bundled" | "user" | "project";
+/** Loaded custom command with metadata */
+export interface LoadedCustomCommand {
+    /** Original path to the command module */
+    path: string;
+    /** Resolved absolute path */
+    resolvedPath: string;
+    /** The command definition */
+    command: CustomCommand;
+    /** Where the command was loaded from */
+    source: CustomCommandSource;
+}
+/** Result from loading custom commands */
+export interface CustomCommandsLoadResult {
+    commands: LoadedCustomCommand[];
+    errors: Array<{
+        path: string;
+        error: string;
+    }>;
+}

package/dist/types/extensibility/custom-tools/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Custom tools module.
+ */
+export * from "./loader";
+export type * from "./types";
+export * from "./wrapper";

package/dist/types/extensibility/custom-tools/loader.d.ts

@@ -0,0 +1,69 @@
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { HookUIContext } from "../../extensibility/hooks/types";
+import type { LoadedCustomTool, ToolLoadError } from "./types";
+/** Tool path with optional source metadata */
+interface ToolPathWithSource {
+    path: string;
+    source?: {
+        provider: string;
+        providerName: string;
+        level: "user" | "project";
+    };
+}
+/**
+ * Loads custom tools from paths with conflict detection and error handling.
+ *
+ * Manages a shared API instance passed to all tool factories, providing access to
+ * execution context, UI, logger, and injected dependencies. The UI context can be
+ * updated after loading via setUIContext().
+ */
+export declare class CustomToolLoader {
+    #private;
+    tools: LoadedCustomTool[];
+    errors: ToolLoadError[];
+    constructor(pi: typeof import("@oh-my-pi/pi-coding-agent"), cwd: string, builtInToolNames: string[], pushPendingAction?: (action: {
+        label: string;
+        sourceToolName: string;
+        apply(reason: string): Promise<AgentToolResult<unknown>>;
+        reject?(reason: string): Promise<AgentToolResult<unknown> | undefined>;
+    }) => void);
+    load(pathsWithSources: ToolPathWithSource[]): Promise<void>;
+    setUIContext(uiContext: HookUIContext, hasUI: boolean): void;
+}
+/**
+ * Load all tools from configuration.
+ * @param pathsWithSources - Array of tool paths with optional source metadata
+ * @param cwd - Current working directory for resolving relative paths
+ * @param builtInToolNames - Names of built-in tools to check for conflicts
+ */
+export declare function loadCustomTools(pathsWithSources: ToolPathWithSource[], cwd: string, builtInToolNames: string[], pushPendingAction?: (action: {
+    label: string;
+    sourceToolName: string;
+    apply(reason: string): Promise<AgentToolResult<unknown>>;
+    reject?(reason: string): Promise<AgentToolResult<unknown> | undefined>;
+}) => void): Promise<{
+    tools: LoadedCustomTool<import("@oh-my-pi/pi-ai").TSchema, any>[];
+    errors: ToolLoadError[];
+    setUIContext: (uiContext: HookUIContext, hasUI: boolean) => void;
+}>;
+/**
+ * Discover and load tools from standard locations via capability system:
+ * 1. User and project tools discovered by capability providers
+ * 2. Installed plugins (~/.omp/plugins/node_modules/*)
+ * 3. Explicitly configured paths from settings or CLI
+ *
+ * @param configuredPaths - Explicit paths from settings.json and CLI --tool flags
+ * @param cwd - Current working directory
+ * @param builtInToolNames - Names of built-in tools to check for conflicts
+ */
+export declare function discoverAndLoadCustomTools(configuredPaths: string[], cwd: string, builtInToolNames: string[], pushPendingAction?: (action: {
+    label: string;
+    sourceToolName: string;
+    apply(reason: string): Promise<AgentToolResult<unknown>>;
+    reject?(reason: string): Promise<AgentToolResult<unknown> | undefined>;
+}) => void): Promise<{
+    tools: LoadedCustomTool<import("@oh-my-pi/pi-ai").TSchema, any>[];
+    errors: ToolLoadError[];
+    setUIContext: (uiContext: HookUIContext, hasUI: boolean) => void;
+}>;
+export {};

package/dist/types/extensibility/custom-tools/types.d.ts

@@ -0,0 +1,226 @@
+/**
+ * Custom tool types.
+ *
+ * Custom tools are TypeScript modules that define additional tools for the agent.
+ * They can provide custom rendering for tool calls and results in the TUI.
+ */
+import type { AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
+import type { Model, Static, TSchema } from "@oh-my-pi/pi-ai";
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { Rule } from "../../capability/rule";
+import type { ModelRegistry } from "../../config/model-registry";
+import type { Settings } from "../../config/settings";
+import type { ExecOptions, ExecResult } from "../../exec/exec";
+import type { HookUIContext } from "../../extensibility/hooks/types";
+import type { Theme } from "../../modes/theme/theme";
+import type { ReadonlySessionManager } from "../../session/session-manager";
+import type { TodoItem } from "../../tools/todo-write";
+/** Alias for clarity */
+export type CustomToolUIContext = HookUIContext;
+export type { ExecOptions, ExecResult } from "../../exec/exec";
+/** Re-export for custom tools to use in execute signature */
+export type { AgentToolResult, AgentToolUpdateCallback };
+/** Pending action entry consumed by the hidden resolve tool */
+export interface CustomToolPendingAction {
+    /** Human-readable preview label shown in resolve flow */
+    label: string;
+    /** Apply callback invoked when resolve(action="apply") is called */
+    apply(reason: string): Promise<AgentToolResult<unknown>>;
+    /** Optional reject callback invoked when resolve(action="discard") is called */
+    reject?(reason: string): Promise<AgentToolResult<unknown> | undefined>;
+    /** Optional details metadata stored with the pending action */
+    details?: unknown;
+    /** Optional source tool name shown by resolve renderer (defaults to "custom_tool") */
+    sourceToolName?: string;
+}
+/** API passed to custom tool factory (stable across session changes) */
+export interface CustomToolAPI {
+    /** Current working directory */
+    cwd: string;
+    /** Execute a command */
+    exec(command: string, args: string[], options?: ExecOptions): Promise<ExecResult>;
+    /** UI methods for user interaction (select, confirm, input, notify, custom) */
+    ui: CustomToolUIContext;
+    /** Whether UI is available (false in print/RPC mode) */
+    hasUI: boolean;
+    /** File logger for error/warning/debug messages */
+    logger: typeof import("@oh-my-pi/pi-utils").logger;
+    /** Injected zod-backed typebox shim (legacy/compat — Zod-authored tools are preferred). */
+    typebox: typeof import("../typebox");
+    /** Injected zod module for Zod-authored custom tools. */
+    zod: typeof import("zod/v4");
+    /** Injected pi-coding-agent exports */
+    pi: typeof import("../..");
+    /** Push a preview action that can later be resolved with the hidden resolve tool */
+    pushPendingAction(action: CustomToolPendingAction): void;
+}
+/**
+ * Context passed to tool execute and onSession callbacks.
+ * Provides access to session state and model information.
+ */
+export interface CustomToolContext {
+    /** Session manager (read-only) */
+    sessionManager: ReadonlySessionManager;
+    /** Model registry - use for API key resolution and model retrieval */
+    modelRegistry: ModelRegistry;
+    /** Current model (may be undefined if no model is selected yet) */
+    model: Model | undefined;
+    /** Whether the agent is idle (not streaming) */
+    isIdle(): boolean;
+    /** Whether there are queued messages waiting to be processed */
+    hasQueuedMessages(): boolean;
+    /** Abort the current agent operation (fire-and-forget, does not wait) */
+    abort(): void;
+    /** Settings instance for the current session. Prefer over the global singleton. */
+    settings?: Settings;
+}
+/** Session event passed to onSession callback */
+export type CustomToolSessionEvent = {
+    /** Reason for the session event */
+    reason: "start" | "switch" | "branch" | "tree" | "shutdown";
+    /** Previous session file path, or undefined for "start" and "shutdown" */
+    previousSessionFile: string | undefined;
+} | {
+    reason: "auto_compaction_start";
+    trigger: "threshold" | "overflow" | "idle";
+    action: "context-full" | "handoff";
+} | {
+    reason: "auto_compaction_end";
+    action: "context-full" | "handoff";
+    result: CompactionResult | undefined;
+    aborted: boolean;
+    willRetry: boolean;
+    errorMessage?: string;
+} | {
+    reason: "auto_retry_start";
+    attempt: number;
+    maxAttempts: number;
+    delayMs: number;
+    errorMessage: string;
+} | {
+    reason: "auto_retry_end";
+    success: boolean;
+    attempt: number;
+    finalError?: string;
+} | {
+    reason: "ttsr_triggered";
+    rules: Rule[];
+} | {
+    reason: "todo_reminder";
+    todos: TodoItem[];
+    attempt: number;
+    maxAttempts: number;
+};
+/** Rendering options passed to renderResult */
+export interface RenderResultOptions {
+    /** Whether the result view is expanded */
+    expanded: boolean;
+    /** Whether this is a partial/streaming result */
+    isPartial: boolean;
+    /** Current spinner frame index for animated elements (0-9, only provided during partial results) */
+    spinnerFrame?: number;
+}
+export type CustomToolResult<TDetails = any> = AgentToolResult<TDetails>;
+/**
+ * Custom tool definition.
+ *
+ * Custom tools are standalone - they don't extend AgentTool directly.
+ * When loaded, they are wrapped in an AgentTool for the agent to use.
+ *
+ * The execute callback receives a ToolContext with access to session state,
+ * model registry, and current model.
+ *
+ * @example
+ * ```typescript
+ * const factory: CustomToolFactory = (pi) => ({
+ *   name: "my_tool",
+ *   label: "My Tool",
+ *   description: "Does something useful",
+ *   parameters: Type.Object({ input: Type.String() }),
+ *
+ *   async execute(toolCallId, params, onUpdate, ctx, signal) {
+ *     // Access session state via ctx.sessionManager
+ *     // Access model registry via ctx.modelRegistry
+ *     // Current model via ctx.model
+ *     return { content: [{ type: "text", text: "Done" }] };
+ *   },
+ *
+ *   onSession(event, ctx) {
+ *     if (event.reason === "shutdown") {
+ *       // Cleanup
+ *     }
+ *     // Reconstruct state from ctx.sessionManager.getEntries()
+ *   }
+ * });
+ * ```
+ */
+export interface CustomTool<TParams extends TSchema = TSchema, TDetails = any> {
+    /** Tool name (used in LLM tool calls) */
+    name: string;
+    /** Human-readable label for UI */
+    label: string;
+    /** If true, tool is strictly typed and validated against the parameters schema before execution */
+    strict?: boolean;
+    /** Description for LLM */
+    description: string;
+    /** Parameter schema (Zod or TypeBox; TypeBox is auto-lifted to Zod at registration). */
+    parameters: TParams;
+    /** If true, tool is excluded unless explicitly listed in --tools or agent's tools field */
+    hidden?: boolean;
+    /** If true, tool may stage deferred changes that require explicit resolve/discard. */
+    deferrable?: boolean;
+    /** MCP server name for discovery/search metadata when this tool fronts an MCP server. */
+    mcpServerName?: string;
+    /** Original MCP tool name for discovery/search metadata. */
+    mcpToolName?: string;
+    /**
+     * Execute the tool.
+     * @param toolCallId - Unique ID for this tool call
+     * @param params - Parsed parameters matching the schema
+     * @param onUpdate - Callback for streaming partial results (for UI, not LLM)
+     * @param ctx - Context with session manager, model registry, and current model
+     * @param signal - Optional abort signal for cancellation
+     */
+    execute(toolCallId: string, params: Static<TParams>, onUpdate: AgentToolUpdateCallback<TDetails, TParams> | undefined, ctx: CustomToolContext, signal?: AbortSignal): Promise<AgentToolResult<TDetails, TParams>>;
+    /** Called on session lifecycle events - use to reconstruct state or cleanup resources */
+    onSession?: (event: CustomToolSessionEvent, ctx: CustomToolContext) => void | Promise<void>;
+    /** Custom rendering for tool call display - return a Component */
+    renderCall?: (args: Static<TParams>, options: RenderResultOptions, theme: Theme) => Component;
+    /** Custom rendering for tool result display - return a Component */
+    renderResult?: (result: CustomToolResult<TDetails>, options: RenderResultOptions, theme: Theme, args?: Static<TParams>) => Component;
+}
+/** Factory function that creates a custom tool or array of tools */
+export type CustomToolFactory = (pi: CustomToolAPI) => CustomTool<any, any> | CustomTool<any, any>[] | Promise<CustomTool<any, any> | CustomTool<any, any>[]>;
+/** Loaded custom tool with metadata and wrapped AgentTool */
+export interface LoadedCustomTool<TParams extends TSchema = TSchema, TDetails = any> {
+    /** Original path (as specified) */
+    path: string;
+    /** Resolved absolute path */
+    resolvedPath: string;
+    /** The original custom tool instance */
+    tool: CustomTool<TParams, TDetails>;
+    /** Source metadata (provider and level) */
+    source?: {
+        provider: string;
+        providerName: string;
+        level: "user" | "project";
+    };
+}
+/** Error with source metadata */
+export interface ToolLoadError {
+    path: string;
+    error: string;
+    source?: {
+        provider: string;
+        providerName: string;
+        level: "user" | "project";
+    };
+}
+/** Result from loading custom tools */
+export interface CustomToolsLoadResult {
+    tools: LoadedCustomTool[];
+    errors: ToolLoadError[];
+    /** Update the UI context for all loaded tools. Call when mode initializes. */
+    setUIContext(uiContext: CustomToolUIContext, hasUI: boolean): void;
+}

package/dist/types/extensibility/custom-tools/wrapper.d.ts

@@ -0,0 +1,23 @@
+/**
+ * CustomToolAdapter wraps CustomTool instances into AgentTool for use with the agent.
+ */
+import type { AgentTool, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { Static, TSchema } from "@oh-my-pi/pi-ai";
+import type { Theme } from "../../modes/theme/theme";
+import type { CustomTool, CustomToolContext } from "./types";
+export declare class CustomToolAdapter<TParams extends TSchema = TSchema, TDetails = any, TTheme extends Theme = Theme> implements AgentTool<TParams, TDetails, TTheme> {
+    private tool;
+    private getContext;
+    name: string;
+    label: string;
+    description: string;
+    parameters: TParams;
+    readonly strict: boolean | undefined;
+    constructor(tool: CustomTool<TParams, TDetails>, getContext: () => CustomToolContext);
+    execute(toolCallId: string, params: Static<TParams>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TDetails, TParams>, context?: CustomToolContext): Promise<import("@oh-my-pi/pi-agent-core").AgentToolResult<TDetails, TParams>>;
+    /**
+     * Backward-compatible export of factory function for existing callers.
+     * Prefer CustomToolAdapter constructor directly.
+     */
+    static wrap<TParams extends TSchema = TSchema, TDetails = any, TTheme extends Theme = Theme>(tool: CustomTool<TParams, TDetails>, getContext: () => CustomToolContext): AgentTool<TParams, TDetails, TTheme>;
+}

package/dist/types/extensibility/extensions/compact-handler.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Helper for wiring the `compact` action of an {@link ExtensionContext}.
+ *
+ * Extension-facing APIs accept `string | CompactOptions`, but `AgentSession.compact`
+ * takes two positional arguments `(instructions, options)`. This helper splits the
+ * union so the same adapter can be reused by print-mode, rpc-mode, and the executor.
+ */
+import type { Model } from "@oh-my-pi/pi-ai";
+import type { CompactOptions } from "./types";
+interface CompactableSession {
+    compact(instructions?: string, options?: CompactOptions): Promise<unknown>;
+}
+export declare function runExtensionCompact(session: CompactableSession, instructionsOrOptions: string | CompactOptions | undefined): Promise<void>;
+interface SetModelCapableSession {
+    modelRegistry: {
+        getApiKey(model: Model): Promise<string | undefined>;
+    };
+    setModel(model: Model): Promise<unknown>;
+}
+/**
+ * Helper for wiring the `setModel` action of an {@link ExtensionContext}.
+ *
+ * Returns false when no API key is available for the requested model.
+ */
+export declare function runExtensionSetModel(session: SetModelCapableSession, model: Model): Promise<boolean>;
+export {};

package/dist/types/extensibility/extensions/get-commands-handler.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Helper for wiring the `getCommands` action of {@link ExtensionAPI}.
+ *
+ * Centralizes the union over the three slash-command sources the runtime
+ * exposes so the five wiring sites (interactive UI, ACP, RPC, print, child
+ * task executor) cannot drift:
+ *   - extension-registered hook commands (`source: "extension"`)
+ *   - prompt commands loaded as `LoadedCustomCommand` — user/project/bundled
+ *     custom commands and MCP prompts (`source: "prompt"`)
+ *   - skill commands derived from `session.skills`, gated on
+ *     `skillsSettings.enableSkillCommands` (`source: "skill"`)
+ *
+ * Built-in slash commands are intentionally excluded; `getCommands()` is the
+ * surface extensions use to discover dynamic commands they did not register
+ * themselves. Each frontend (interactive-mode, ACP) prepends its own builtins.
+ */
+import type { SkillsSettings } from "../../config/settings";
+import type { LoadedCustomCommand } from "../custom-commands";
+import { type Skill } from "../skills";
+import type { SlashCommandInfo } from "../slash-commands";
+import type { ExtensionRunner } from "./runner";
+interface CommandsCapableSession {
+    readonly extensionRunner?: ExtensionRunner;
+    readonly customCommands: ReadonlyArray<LoadedCustomCommand>;
+    readonly skills: ReadonlyArray<Skill>;
+    readonly skillsSettings?: SkillsSettings;
+}
+export declare function getSessionSlashCommands(session: CommandsCapableSession): SlashCommandInfo[];
+export {};

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

@@ -0,0 +1,8 @@
+/**
+ * Extension system for lifecycle events and custom tools.
+ */
+export type { SlashCommandInfo, SlashCommandLocation, SlashCommandSource } from "../slash-commands";
+export { discoverAndLoadExtensions, ExtensionRuntimeNotInitializedError, loadExtensionFromFactory, loadExtensions, } from "./loader";
+export * from "./runner";
+export * from "./types";
+export * from "./wrapper";

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

@@ -0,0 +1,43 @@
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import { EventBus } from "../../utils/event-bus";
+import type { Extension, ExtensionFactory, ExtensionRuntime as IExtensionRuntime, LoadExtensionsResult } from "./types";
+export declare class ExtensionRuntimeNotInitializedError extends Error {
+    constructor();
+}
+/**
+ * Extension runtime with throwing stubs for action methods.
+ * These are replaced with real implementations during initialization.
+ */
+export declare class ExtensionRuntime implements IExtensionRuntime {
+    flagValues: Map<string, string | boolean>;
+    pendingProviderRegistrations: Array<{
+        name: string;
+        config: import("./types").ProviderConfig;
+        sourceId: string;
+    }>;
+    sendMessage(): void;
+    sendUserMessage(): void;
+    appendEntry(): void;
+    setLabel(): void;
+    getActiveTools(): string[];
+    getAllTools(): string[];
+    setActiveTools(): Promise<void>;
+    getCommands(): never;
+    setModel(): Promise<boolean>;
+    getThinkingLevel(): ThinkingLevel;
+    setThinkingLevel(): void;
+    getSessionName(): string | undefined;
+    setSessionName(): Promise<void>;
+}
+/**
+ * Create an Extension from an inline factory function.
+ */
+export declare function loadExtensionFromFactory(factory: ExtensionFactory, cwd: string, eventBus: EventBus, runtime: IExtensionRuntime, name?: string): Promise<Extension>;
+/**
+ * Load extensions from paths.
+ */
+export declare function loadExtensions(paths: string[], cwd: string, eventBus?: EventBus): Promise<LoadExtensionsResult>;
+/**
+ * Discover and load extensions from standard locations.
+ */
+export declare function discoverAndLoadExtensions(configuredPaths: string[], cwd: string, eventBus?: EventBus, disabledExtensionIds?: string[]): Promise<LoadExtensionsResult>;