@sayknow-cli/coding-agent 0.3.12 → 0.3.13

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

@@ -1,55 +0,0 @@
-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;
-}
-/** Tracks when a rule was last injected (for repeat gating). */
-export interface TtsrInjectionRecord {
-    name: string;
-    lastInjectedAt: number;
-    repeatMode?: "once" | "after-gap";
-    repeatGap?: number;
-}
-export declare class TtsrManager {
-    #private;
-    constructor(settings?: Partial<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[];
-    /** Get full injected rule records (for persistence). */
-    getInjectedRecords(): TtsrInjectionRecord[];
-    /** Restore injected state from legacy rule names or persisted records. */
-    restoreInjected(records: string[] | TtsrInjectionRecord[]): 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;
-    /** Restore message counter after session resume. */
-    restoreMessageCount(messageCount: number): void;
-    /** Get settings. */
-    getSettings(): Required<TtsrSettings>;
-}

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

@@ -1,9 +0,0 @@
-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/index.d.ts

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

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

@@ -1,29 +0,0 @@
-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

@@ -1,106 +0,0 @@
-/**
- * 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 sayknow-cli 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

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

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

@@ -1,69 +0,0 @@
-import type { AgentToolResult } from "@sayknow-cli/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("@sayknow-cli/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("@sayknow-cli/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 (~/.skc/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("@sayknow-cli/ai").TSchema, any>[];
-    errors: ToolLoadError[];
-    setUIContext: (uiContext: HookUIContext, hasUI: boolean) => void;
-}>;
-export {};

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

@@ -1,229 +0,0 @@
-/**
- * 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 "@sayknow-cli/agent-core";
-import type { CompactionResult } from "@sayknow-cli/agent-core/compaction";
-import type { Model, Static, TSchema } from "@sayknow-cli/ai";
-import type { Component } from "@sayknow-cli/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("@sayknow-cli/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 sayknow-cli 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;
-    unbounded?: boolean;
-} | {
-    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;
-    /** Tool scheduling mode; exclusive tools do not run in parallel with other tools in a model turn. */
-    concurrency?: "shared" | "exclusive";
-    /** 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

@@ -1,24 +0,0 @@
-/**
- * CustomToolAdapter wraps CustomTool instances into AgentTool for use with the agent.
- */
-import type { AgentTool, AgentToolUpdateCallback } from "@sayknow-cli/agent-core";
-import type { Static, TSchema } from "@sayknow-cli/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;
-    readonly concurrency: "shared" | "exclusive" | undefined;
-    constructor(tool: CustomTool<TParams, TDetails>, getContext: () => CustomToolContext);
-    execute(toolCallId: string, params: Static<TParams>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TDetails, TParams>, context?: CustomToolContext): Promise<import("@sayknow-cli/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

@@ -1,26 +0,0 @@
-/**
- * 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 "@sayknow-cli/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

@@ -1,29 +0,0 @@
-/**
- * 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

@@ -1,9 +0,0 @@
-/**
- * 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 "./prefix-command-bridge";
-export * from "./runner";
-export * from "./types";
-export * from "./wrapper";

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

@@ -1,43 +0,0 @@
-import type { ThinkingLevel } from "@sayknow-cli/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>;