cliskill 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2018 @@
+export { runCli } from './bootstrap/cli.js';
+import { z } from 'zod';
+import React from 'react';
+
+/**
+ * Schema for a single provider configuration.
+ * Supports any AI model provider with arbitrary base URLs.
+ */
+declare const providerSchema: z.ZodObject<{
+    /** Unique name for this provider profile */
+    name: z.ZodString;
+    /** Base URL for the API endpoint */
+    baseUrl: z.ZodString;
+    /** API key (can also be set via environment variable) */
+    apiKey: z.ZodOptional<z.ZodString>;
+    /** Default model to use */
+    model: z.ZodString;
+    /** API format: "openai-compatible" | "messages-compatible" | "glm-compatible" | "custom" */
+    format: z.ZodEnum<["openai-compatible", "messages-compatible", "glm-compatible", "custom"]>;
+    /** Custom headers to send with each request */
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    /** Request timeout in milliseconds */
+    timeout: z.ZodDefault<z.ZodNumber>;
+    /** Maximum tokens in response — 65536 allows large file writes without truncation */
+    maxTokens: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    baseUrl: string;
+    model: string;
+    format: "custom" | "openai-compatible" | "messages-compatible" | "glm-compatible";
+    timeout: number;
+    maxTokens: number;
+    apiKey?: string | undefined;
+    headers?: Record<string, string> | undefined;
+}, {
+    name: string;
+    baseUrl: string;
+    model: string;
+    format: "custom" | "openai-compatible" | "messages-compatible" | "glm-compatible";
+    apiKey?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    timeout?: number | undefined;
+    maxTokens?: number | undefined;
+}>;
+type ProviderConfig = z.infer<typeof providerSchema>;
+/**
+ * Schema for the main application configuration.
+ */
+declare const appConfigSchema: z.ZodObject<{
+    /** Default provider name to use */
+    defaultProvider: z.ZodOptional<z.ZodString>;
+    /** Provider configurations */
+    providers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Unique name for this provider profile */
+        name: z.ZodString;
+        /** Base URL for the API endpoint */
+        baseUrl: z.ZodString;
+        /** API key (can also be set via environment variable) */
+        apiKey: z.ZodOptional<z.ZodString>;
+        /** Default model to use */
+        model: z.ZodString;
+        /** API format: "openai-compatible" | "messages-compatible" | "glm-compatible" | "custom" */
+        format: z.ZodEnum<["openai-compatible", "messages-compatible", "glm-compatible", "custom"]>;
+        /** Custom headers to send with each request */
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /** Request timeout in milliseconds */
+        timeout: z.ZodDefault<z.ZodNumber>;
+        /** Maximum tokens in response — 65536 allows large file writes without truncation */
+        maxTokens: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        baseUrl: string;
+        model: string;
+        format: "custom" | "openai-compatible" | "messages-compatible" | "glm-compatible";
+        timeout: number;
+        maxTokens: number;
+        apiKey?: string | undefined;
+        headers?: Record<string, string> | undefined;
+    }, {
+        name: string;
+        baseUrl: string;
+        model: string;
+        format: "custom" | "openai-compatible" | "messages-compatible" | "glm-compatible";
+        apiKey?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        timeout?: number | undefined;
+        maxTokens?: number | undefined;
+    }>, "many">>;
+    /** Permission mode: "ask" | "auto-accept" | "plan" */
+    permissionMode: z.ZodDefault<z.ZodEnum<["ask", "auto-accept", "plan"]>>;
+    /** Enable verbose logging */
+    verbose: z.ZodDefault<z.ZodBoolean>;
+    /** Maximum context tokens before compaction */
+    maxContextTokens: z.ZodDefault<z.ZodNumber>;
+    /** Custom system prompt additions */
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    /** Auto mode — automatic tool approval without subscription gates */
+    autoMode: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        trustLevel: z.ZodDefault<z.ZodEnum<["full-auto", "safe-auto", "ask"]>>;
+        autoApprovedTools: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        autoApprovedCommands: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        maxAutoActions: z.ZodDefault<z.ZodNumber>;
+        requireConfirmationFor: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        trustLevel: "ask" | "full-auto" | "safe-auto";
+        autoApprovedTools: string[];
+        autoApprovedCommands: string[];
+        maxAutoActions: number;
+        requireConfirmationFor: string[];
+    }, {
+        enabled?: boolean | undefined;
+        trustLevel?: "ask" | "full-auto" | "safe-auto" | undefined;
+        autoApprovedTools?: string[] | undefined;
+        autoApprovedCommands?: string[] | undefined;
+        maxAutoActions?: number | undefined;
+        requireConfirmationFor?: string[] | undefined;
+    }>>;
+    /** Fast mode — response speed optimizations without upsell */
+    fastMode: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        reducedPrompts: z.ZodDefault<z.ZodBoolean>;
+        skipOptionalChecks: z.ZodDefault<z.ZodBoolean>;
+        preloadTools: z.ZodDefault<z.ZodBoolean>;
+        streamingOptimizations: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        reducedPrompts: boolean;
+        skipOptionalChecks: boolean;
+        preloadTools: boolean;
+        streamingOptimizations: boolean;
+    }, {
+        enabled?: boolean | undefined;
+        reducedPrompts?: boolean | undefined;
+        skipOptionalChecks?: boolean | undefined;
+        preloadTools?: boolean | undefined;
+        streamingOptimizations?: boolean | undefined;
+    }>>;
+    /** Model access — unrestricted model selection */
+    models: z.ZodDefault<z.ZodObject<{
+        aliases: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            alias: z.ZodString;
+            model: z.ZodString;
+            provider: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            model: string;
+            alias: string;
+            provider?: string | undefined;
+        }, {
+            model: string;
+            alias: string;
+            provider?: string | undefined;
+        }>, "many">>;
+        defaultModel: z.ZodDefault<z.ZodString>;
+        fallbackModel: z.ZodDefault<z.ZodString>;
+        maxContextTokens: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxContextTokens: number;
+        aliases: {
+            model: string;
+            alias: string;
+            provider?: string | undefined;
+        }[];
+        defaultModel: string;
+        fallbackModel: string;
+    }, {
+        maxContextTokens?: number | undefined;
+        aliases?: {
+            model: string;
+            alias: string;
+            provider?: string | undefined;
+        }[] | undefined;
+        defaultModel?: string | undefined;
+        fallbackModel?: string | undefined;
+    }>>;
+    /** Remote SSH session configuration */
+    remote: z.ZodDefault<z.ZodObject<{
+        defaultHost: z.ZodOptional<z.ZodString>;
+        defaultPort: z.ZodDefault<z.ZodNumber>;
+        defaultUsername: z.ZodOptional<z.ZodString>;
+        privateKeyPath: z.ZodOptional<z.ZodString>;
+        keepAlive: z.ZodDefault<z.ZodBoolean>;
+        connectionTimeout: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        defaultPort: number;
+        keepAlive: boolean;
+        connectionTimeout: number;
+        defaultHost?: string | undefined;
+        defaultUsername?: string | undefined;
+        privateKeyPath?: string | undefined;
+    }, {
+        defaultHost?: string | undefined;
+        defaultPort?: number | undefined;
+        defaultUsername?: string | undefined;
+        privateKeyPath?: string | undefined;
+        keepAlive?: boolean | undefined;
+        connectionTimeout?: number | undefined;
+    }>>;
+    /** Context window — no subscription limits */
+    contextWindow: z.ZodDefault<z.ZodObject<{
+        maxTokens: z.ZodDefault<z.ZodNumber>;
+        compactionThreshold: z.ZodDefault<z.ZodNumber>;
+        warningThreshold: z.ZodDefault<z.ZodNumber>;
+        strategy: z.ZodDefault<z.ZodEnum<["sliding", "compaction", "hybrid"]>>;
+    }, "strip", z.ZodTypeAny, {
+        maxTokens: number;
+        compactionThreshold: number;
+        warningThreshold: number;
+        strategy: "sliding" | "compaction" | "hybrid";
+    }, {
+        maxTokens?: number | undefined;
+        compactionThreshold?: number | undefined;
+        warningThreshold?: number | undefined;
+        strategy?: "sliding" | "compaction" | "hybrid" | undefined;
+    }>>;
+    /** Theme configuration for terminal output */
+    theme: z.ZodDefault<z.ZodObject<{
+        name: z.ZodDefault<z.ZodEnum<["dark", "light", "light-daltonized", "dark-daltonized", "light-ansi", "dark-ansi", "auto"]>>;
+    }, "strip", z.ZodTypeAny, {
+        name: "dark" | "light" | "light-daltonized" | "dark-daltonized" | "light-ansi" | "dark-ansi" | "auto";
+    }, {
+        name?: "dark" | "light" | "light-daltonized" | "dark-daltonized" | "light-ansi" | "dark-ansi" | "auto" | undefined;
+    }>>;
+    /** Housekeeping — background maintenance tasks */
+    housekeeping: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        cleanupInterval: z.ZodDefault<z.ZodNumber>;
+        maxHistoryAge: z.ZodDefault<z.ZodNumber>;
+        maxMemorySize: z.ZodDefault<z.ZodNumber>;
+        idleThreshold: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        cleanupInterval: number;
+        maxHistoryAge: number;
+        maxMemorySize: number;
+        idleThreshold: number;
+    }, {
+        enabled?: boolean | undefined;
+        cleanupInterval?: number | undefined;
+        maxHistoryAge?: number | undefined;
+        maxMemorySize?: number | undefined;
+        idleThreshold?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    providers: {
+        name: string;
+        baseUrl: string;
+        model: string;
+        format: "custom" | "openai-compatible" | "messages-compatible" | "glm-compatible";
+        timeout: number;
+        maxTokens: number;
+        apiKey?: string | undefined;
+        headers?: Record<string, string> | undefined;
+    }[];
+    permissionMode: "ask" | "auto-accept" | "plan";
+    verbose: boolean;
+    maxContextTokens: number;
+    autoMode: {
+        enabled: boolean;
+        trustLevel: "ask" | "full-auto" | "safe-auto";
+        autoApprovedTools: string[];
+        autoApprovedCommands: string[];
+        maxAutoActions: number;
+        requireConfirmationFor: string[];
+    };
+    fastMode: {
+        enabled: boolean;
+        reducedPrompts: boolean;
+        skipOptionalChecks: boolean;
+        preloadTools: boolean;
+        streamingOptimizations: boolean;
+    };
+    models: {
+        maxContextTokens: number;
+        aliases: {
+            model: string;
+            alias: string;
+            provider?: string | undefined;
+        }[];
+        defaultModel: string;
+        fallbackModel: string;
+    };
+    remote: {
+        defaultPort: number;
+        keepAlive: boolean;
+        connectionTimeout: number;
+        defaultHost?: string | undefined;
+        defaultUsername?: string | undefined;
+        privateKeyPath?: string | undefined;
+    };
+    contextWindow: {
+        maxTokens: number;
+        compactionThreshold: number;
+        warningThreshold: number;
+        strategy: "sliding" | "compaction" | "hybrid";
+    };
+    theme: {
+        name: "dark" | "light" | "light-daltonized" | "dark-daltonized" | "light-ansi" | "dark-ansi" | "auto";
+    };
+    housekeeping: {
+        enabled: boolean;
+        cleanupInterval: number;
+        maxHistoryAge: number;
+        maxMemorySize: number;
+        idleThreshold: number;
+    };
+    defaultProvider?: string | undefined;
+    systemPrompt?: string | undefined;
+}, {
+    defaultProvider?: string | undefined;
+    providers?: {
+        name: string;
+        baseUrl: string;
+        model: string;
+        format: "custom" | "openai-compatible" | "messages-compatible" | "glm-compatible";
+        apiKey?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        timeout?: number | undefined;
+        maxTokens?: number | undefined;
+    }[] | undefined;
+    permissionMode?: "ask" | "auto-accept" | "plan" | undefined;
+    verbose?: boolean | undefined;
+    maxContextTokens?: number | undefined;
+    systemPrompt?: string | undefined;
+    autoMode?: {
+        enabled?: boolean | undefined;
+        trustLevel?: "ask" | "full-auto" | "safe-auto" | undefined;
+        autoApprovedTools?: string[] | undefined;
+        autoApprovedCommands?: string[] | undefined;
+        maxAutoActions?: number | undefined;
+        requireConfirmationFor?: string[] | undefined;
+    } | undefined;
+    fastMode?: {
+        enabled?: boolean | undefined;
+        reducedPrompts?: boolean | undefined;
+        skipOptionalChecks?: boolean | undefined;
+        preloadTools?: boolean | undefined;
+        streamingOptimizations?: boolean | undefined;
+    } | undefined;
+    models?: {
+        maxContextTokens?: number | undefined;
+        aliases?: {
+            model: string;
+            alias: string;
+            provider?: string | undefined;
+        }[] | undefined;
+        defaultModel?: string | undefined;
+        fallbackModel?: string | undefined;
+    } | undefined;
+    remote?: {
+        defaultHost?: string | undefined;
+        defaultPort?: number | undefined;
+        defaultUsername?: string | undefined;
+        privateKeyPath?: string | undefined;
+        keepAlive?: boolean | undefined;
+        connectionTimeout?: number | undefined;
+    } | undefined;
+    contextWindow?: {
+        maxTokens?: number | undefined;
+        compactionThreshold?: number | undefined;
+        warningThreshold?: number | undefined;
+        strategy?: "sliding" | "compaction" | "hybrid" | undefined;
+    } | undefined;
+    theme?: {
+        name?: "dark" | "light" | "light-daltonized" | "dark-daltonized" | "light-ansi" | "dark-ansi" | "auto" | undefined;
+    } | undefined;
+    housekeeping?: {
+        enabled?: boolean | undefined;
+        cleanupInterval?: number | undefined;
+        maxHistoryAge?: number | undefined;
+        maxMemorySize?: number | undefined;
+        idleThreshold?: number | undefined;
+    } | undefined;
+}>;
+type AppConfig = z.infer<typeof appConfigSchema>;
+
+type Role = 'system' | 'user' | 'assistant';
+type TextBlock = {
+    type: 'text';
+    text: string;
+};
+type ToolUseBlock = {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+};
+type ToolResultBlock = {
+    type: 'tool_result';
+    toolUseId: string;
+    content: string;
+    isError?: boolean;
+};
+type ContentBlock = TextBlock | ToolUseBlock | ToolResultBlock;
+interface Message {
+    role: Role;
+    content: ContentBlock[];
+}
+interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+type StreamEvent = {
+    type: 'text_delta';
+    text: string;
+} | {
+    type: 'tool_use_start';
+    id: string;
+    name: string;
+} | {
+    type: 'tool_use_delta';
+    id: string;
+    inputDelta: string;
+} | {
+    type: 'tool_use_end';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+} | {
+    type: 'message_start';
+    model: string;
+} | {
+    type: 'message_end';
+    stopReason: 'end_turn' | 'tool_use' | 'max_tokens';
+    usage: UsageStats;
+};
+interface UsageStats {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+}
+interface CompletionRequest {
+    messages: Message[];
+    tools?: ToolDefinition[];
+    systemPrompt?: string;
+    maxTokens?: number;
+    temperature?: number;
+    stopSequences?: string[];
+    stream?: boolean;
+    /** External abort signal — linked with per-request timeout via AbortSignal.any() */
+    signal?: AbortSignal;
+}
+interface CompletionResult {
+    message: Message;
+    stopReason: 'end_turn' | 'tool_use' | 'max_tokens';
+    usage: UsageStats;
+    model: string;
+}
+
+interface ProviderAdapter {
+    readonly name: string;
+    readonly config: ProviderConfig;
+    complete(request: CompletionRequest): Promise<CompletionResult>;
+    stream(request: CompletionRequest): AsyncGenerator<StreamEvent>;
+    validate(): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    estimateTokens(messages: {
+        content: string;
+    }[]): number;
+    dispose(): void;
+}
+declare abstract class BaseAdapter implements ProviderAdapter {
+    abstract readonly name: string;
+    abstract readonly config: ProviderConfig;
+    abstract complete(request: CompletionRequest): Promise<CompletionResult>;
+    abstract stream(request: CompletionRequest): AsyncGenerator<StreamEvent>;
+    abstract validate(): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    abstract dispose(): void;
+    private readonly rateLimitHandler;
+    estimateTokens(messages: {
+        content: string;
+    }[]): number;
+    protected buildUrl(path: string): string;
+    protected buildHeaders(): Record<string, string>;
+    /**
+     * Build an AbortSignal that combines the per-request timeout with an
+     * optional external signal (e.g. from a parent agent or user cancel).
+     * Uses AbortSignal.any() so EITHER source triggers abort.
+     */
+    protected buildSignal(external?: AbortSignal): AbortSignal;
+    /**
+     * Fetch with automatic retry for rate-limit (429), server errors (5xx),
+     * and network failures (TypeError: fetch failed).
+     * `optionsFactory` is called per-attempt to create fresh AbortSignal timeouts.
+     */
+    protected fetchWithRetry(url: string, optionsFactory: () => RequestInit): Promise<Response>;
+}
+
+/** Events emitted by the agent loop */
+type LoopEvent = {
+    type: 'assistant_text';
+    text: string;
+} | {
+    type: 'tool_start';
+    toolName: string;
+    toolId: string;
+} | {
+    type: 'tool_result';
+    toolName: string;
+    toolId: string;
+    result: string;
+    isError: boolean;
+} | {
+    type: 'turn_complete';
+    turnNumber: number;
+    stopReason: string;
+} | {
+    type: 'usage_update';
+    inputTokens: number;
+    outputTokens: number;
+} | {
+    type: 'loop_complete';
+    totalTurns: number;
+    usage: UsageStats;
+    messages: Message[];
+} | {
+    type: 'context_compacted';
+    summary: string;
+    removedCount: number;
+} | {
+    type: 'error';
+    error: Error;
+};
+/** Context passed to tools during execution */
+interface ToolExecutionContext {
+    /** Working directory for the tool */
+    cwd: string;
+    /** Abort signal for cancellation */
+    abortSignal: AbortSignal;
+    /** Permission checker — returns true if operation is allowed */
+    checkPermission: (operation: string, details?: string) => Promise<boolean>;
+    /** Session identifier for per-session state isolation */
+    sessionId?: string;
+}
+
+/** Risk level of a tool operation */
+type RiskLevel = 'readonly' | 'safe' | 'destructive' | 'critical';
+/** Definition of a tool that can be used by the AI */
+interface ToolContract {
+    /** Unique name of the tool */
+    name: string;
+    /** Description shown to the AI model */
+    description: string;
+    /** Zod schema for input validation */
+    inputSchema: z.ZodType;
+    /** Risk level — determines permission requirements */
+    riskLevel: RiskLevel;
+    /** Whether this tool can run concurrently with other tools */
+    concurrencySafe: boolean;
+    /** Whether this tool only reads data (no side effects) */
+    readOnly: boolean;
+    /**
+     * Execute the tool with validated input.
+     * Returns a string result to be sent back to the model.
+     */
+    execute(input: z.infer<this['inputSchema']>, context: ToolExecutionContext): Promise<string>;
+    /**
+     * Generate the tool definition for the AI model's tool list.
+     */
+    toToolDefinition(): {
+        name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+    };
+}
+/**
+ * Base class for tools with common functionality.
+ */
+declare abstract class BaseTool<T extends z.ZodType> implements ToolContract {
+    abstract name: string;
+    abstract description: string;
+    abstract inputSchema: T;
+    abstract riskLevel: RiskLevel;
+    abstract concurrencySafe: boolean;
+    abstract readOnly: boolean;
+    abstract execute(input: z.infer<T>, context: ToolExecutionContext): Promise<string>;
+    toToolDefinition(): {
+        name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+    };
+}
+
+/**
+ * Registry of available tools.
+ * Manages tool registration and provides tool definitions for AI requests.
+ */
+declare class ToolRegistry {
+    private tools;
+    /** Register a tool */
+    register(tool: ToolContract): void;
+    /** Get a tool by name */
+    get(name: string): ToolContract | undefined;
+    /** Get all registered tools */
+    getAll(): ToolContract[];
+    /** Get tool definitions for AI model requests */
+    getToolDefinitions(): ToolDefinition[];
+    /** Check if a tool exists */
+    has(name: string): boolean;
+    /** Unregister a tool */
+    unregister(name: string): void;
+    /** Clear all tools */
+    clear(): void;
+}
+
+declare class AdapterRegistry {
+    private adapters;
+    register(config: ProviderConfig): ProviderAdapter;
+    get(name: string): ProviderAdapter | undefined;
+    getAll(): ProviderAdapter[];
+    unregister(name: string): void;
+    disposeAll(): void;
+    private createAdapter;
+}
+
+/** Alias mapping for model names */
+interface ModelAlias {
+    alias: string;
+    model: string;
+    provider?: string;
+}
+/** Configuration for unrestricted model access */
+interface ModelAccessConfig {
+    aliases: ModelAlias[];
+    defaultModel: string;
+    fallbackModel: string;
+    maxContextTokens: number;
+}
+/**
+ * Manages model name resolution with alias support.
+ * No subscription restrictions — all models available to everyone.
+ */
+declare class ModelAccessManager {
+    private config;
+    private aliasMap;
+    constructor(config: ModelAccessConfig);
+    /** Resolve a model name or alias to the actual model identifier */
+    resolveModelName(nameOrAlias: string): string;
+    /** Get the provider for a model alias, if specified */
+    getProviderForAlias(nameOrAlias: string): string | undefined;
+    /** Get the effective model to use (with fallback) */
+    getEffectiveModel(requestedModel?: string): string;
+    /** Get fallback model when primary is unavailable */
+    getFallbackModel(): string;
+    /** Get max context tokens (no subscription limits) */
+    getMaxContextTokens(): number;
+    /** List all available aliases */
+    listAliases(): ModelAlias[];
+    /** Add or update an alias at runtime */
+    setAlias(alias: ModelAlias): void;
+    /** Remove an alias */
+    removeAlias(aliasName: string): boolean;
+    /** Check if a name is a known alias */
+    isAlias(name: string): boolean;
+    /** Get current config */
+    getConfig(): Readonly<ModelAccessConfig>;
+    /** Update configuration */
+    updateConfig(partial: Partial<ModelAccessConfig>): void;
+}
+
+/** Task categories for model selection heuristics */
+type TaskCategory = 'reasoning' | 'code' | 'fast' | 'creative' | 'analysis' | 'default';
+interface ModelRouterConfig {
+    /** Default model/alias to use when no specific model is requested */
+    defaultModel: string;
+    /** Model preferences per task category */
+    preferences: Partial<Record<TaskCategory, string>>;
+}
+declare class ModelRouter {
+    private registry;
+    private modelAccess;
+    private config;
+    constructor(registry: AdapterRegistry, modelAccess: ModelAccessManager, config?: Partial<ModelRouterConfig>);
+    /** Resolve a model name or alias to a concrete adapter */
+    resolve(modelOrAlias?: string): ProviderAdapter | null;
+    /** Auto-select the best adapter based on a task description */
+    autoSelect(taskDescription: string): ProviderAdapter | null;
+    /** Classify a task description into a task category */
+    classifyTask(text: string): TaskCategory;
+    /** Get model capabilities category from model name */
+    getModelCategory(modelName: string): TaskCategory;
+    /** List all available models across all adapters */
+    listAvailableModels(): Array<{
+        provider: string;
+        model: string;
+        category: TaskCategory;
+    }>;
+    /** Get the effective model name for a given alias or name */
+    getEffectiveModel(requestedModel?: string): string;
+    private findAdapterForModel;
+}
+
+/** Trust level for auto mode */
+type TrustLevel = 'full-auto' | 'safe-auto' | 'ask';
+/** Configuration for auto mode behavior */
+interface AutoModeConfig {
+    enabled: boolean;
+    trustLevel: TrustLevel;
+    autoApprovedTools: string[];
+    autoApprovedCommands: string[];
+    maxAutoActions: number;
+    requireConfirmationFor: string[];
+}
+/** Result of an auto-approval check */
+interface AutoApprovalResult {
+    approved: boolean;
+    reason: string;
+}
+/**
+ * Manages automatic approval of tool executions based on trust level,
+ * whitelists, and blacklists. No subscription checks — fully free.
+ */
+declare class AutoModeManager {
+    private config;
+    private actionCount;
+    constructor(config: AutoModeConfig);
+    /** Check if a tool execution should be auto-approved */
+    shouldAutoApprove(toolName: string, riskLevel: RiskLevel, content?: string): AutoApprovalResult;
+    /** Get current auto action count */
+    getActionCount(): number;
+    /** Reset action counter */
+    resetActionCount(): void;
+    /** Update configuration at runtime */
+    updateConfig(partial: Partial<AutoModeConfig>): void;
+    /** Get current config */
+    getConfig(): Readonly<AutoModeConfig>;
+    /** Check if auto mode is effectively active */
+    isActive(): boolean;
+    private isBlacklisted;
+    private isToolWhitelisted;
+    private isRiskApproved;
+    private isCommandSafe;
+}
+
+/** Configuration for fast mode optimizations */
+interface FastModeConfig {
+    enabled: boolean;
+    reducedPrompts: boolean;
+    skipOptionalChecks: boolean;
+    preloadTools: boolean;
+    streamingOptimizations: boolean;
+}
+/**
+ * Manages fast mode optimizations for quicker agent responses.
+ * No upsell messages — simply works when enabled.
+ */
+declare class FastModeManager {
+    private config;
+    constructor(config: FastModeConfig);
+    /** Check if fast mode is active */
+    isActive(): boolean;
+    /** Get the system prompt modifier based on fast mode settings */
+    getSystemPromptModifier(): string;
+    /** Check if optional checks should be skipped */
+    shouldSkipOptionalChecks(): boolean;
+    /** Check if tools should be preloaded */
+    shouldPreloadTools(): boolean;
+    /** Check if streaming optimizations are enabled */
+    hasStreamingOptimizations(): boolean;
+    /** Get streaming batch size (smaller = more responsive, larger = faster throughput) */
+    getStreamingBatchSize(): number;
+    /** Get tool execution concurrency limit */
+    getToolConcurrency(): number;
+    /** Get the delay between turns (ms). Always 0 — no artificial delays. */
+    getInterTurnDelay(): number;
+    /** Get current config */
+    getConfig(): Readonly<FastModeConfig>;
+    /** Update configuration at runtime */
+    updateConfig(partial: Partial<FastModeConfig>): void;
+}
+
+/** Role definition for a plan mode agent */
+interface PlanAgentRole {
+    name: string;
+    description: string;
+    systemPromptSuffix: string;
+    allowedTools: string[];
+    maxSteps: number;
+}
+/** Configuration for plan mode */
+interface PlanModeConfig {
+    enabled: boolean;
+    maxParallelAgents: number;
+    agentRoles: PlanAgentRole[];
+    planningStrategy: 'sequential' | 'parallel' | 'adaptive';
+    maxStepsPerAgent: number;
+    contextSharing: boolean;
+}
+/** Single step in a plan */
+interface PlanStep {
+    id: string;
+    description: string;
+    assignedAgent: string;
+    status: 'pending' | 'in-progress' | 'completed' | 'failed';
+    result?: string;
+    dependencies: string[];
+}
+/** A plan with steps and metadata */
+interface Plan {
+    id: string;
+    goal: string;
+    steps: PlanStep[];
+    status: 'planning' | 'executing' | 'completed' | 'failed';
+    createdAt: Date;
+    completedAt?: Date;
+}
+/** Statistics for plan execution */
+interface PlanStats {
+    totalSteps: number;
+    completedSteps: number;
+    failedSteps: number;
+    totalDuration: number;
+    agentStats: Record<string, {
+        steps: number;
+        success: number;
+        failed: number;
+    }>;
+}
+/**
+ * Manages plan mode lifecycle: creation, configuration, state.
+ * Does NOT execute plans — that is PlanExecutor's job.
+ */
+declare class PlanModeManager {
+    private config;
+    private activePlan;
+    constructor(config?: Partial<PlanModeConfig>);
+    /** Current configuration */
+    getConfig(): PlanModeConfig;
+    /** Update configuration */
+    updateConfig(partial: Partial<PlanModeConfig>): void;
+    /** Whether plan mode is enabled */
+    isEnabled(): boolean;
+    /** Enable plan mode */
+    enable(): void;
+    /** Disable plan mode */
+    disable(): void;
+    /** Get the active plan */
+    getActivePlan(): Plan | null;
+    /** Create a new plan from a goal */
+    createPlan(goal: string, steps: Omit<PlanStep, 'status'>[]): Plan;
+    /** Mark plan as executing */
+    startExecution(plan: Plan): void;
+    /** Mark plan as completed */
+    completePlan(plan: Plan): void;
+    /** Mark plan as failed */
+    failPlan(plan: Plan): void;
+    /** Get a role by name */
+    getRole(name: string): PlanAgentRole | undefined;
+    /** Get all roles */
+    getRoles(): PlanAgentRole[];
+    /** Compute statistics for a plan */
+    computeStats(plan: Plan): PlanStats;
+    /** Format a plan as a human-readable string */
+    formatPlan(plan: Plan): string;
+    /** Format execution stats as a human-readable report */
+    formatStats(stats: PlanStats): string;
+}
+
+interface ContextWindowConfig {
+    maxTokens: number;
+    compactionThreshold: number;
+    warningThreshold: number;
+    strategy: 'sliding' | 'compaction' | 'hybrid';
+}
+interface ContextUsage {
+    usedTokens: number;
+    maxTokens: number;
+    remainingTokens: number;
+    usagePercent: number;
+    needsWarning: boolean;
+    needsCompaction: boolean;
+}
+declare class ContextWindowManager {
+    private readonly config;
+    constructor(config?: Partial<ContextWindowConfig>);
+    getCurrentUsage(messages: Message[], systemPrompt?: string): ContextUsage;
+    needsCompaction(messages: Message[], systemPrompt?: string): boolean;
+    estimateTokens(content: string): number;
+    getMaxTokens(): number;
+    getConfig(): Readonly<ContextWindowConfig>;
+    getCompactionThreshold(): number;
+    getWarningThreshold(): number;
+    getStrategy(): ContextWindowConfig['strategy'];
+    calculateMessagesTokens(messages: Message[]): number;
+}
+
+interface QueryEngineConfig {
+    maxTurns: number;
+    maxTokens: number;
+    compactionThreshold: number;
+    systemPrompt?: string;
+    verbose?: boolean;
+    /** Permission checker forwarded from parent context (e.g. agent-tool) */
+    checkPermission?: (operation: string, details?: string) => Promise<boolean>;
+    /** External abort signal — linked to adapter requests via AbortSignal.any() */
+    signal?: AbortSignal;
+}
+interface QueryResult {
+    messages: Message[];
+    totalTokens: {
+        input: number;
+        output: number;
+    };
+    totalCost: number;
+    duration: number;
+    turns: number;
+    compacted: boolean;
+}
+type QueryEvent = {
+    type: 'text_delta';
+    text: string;
+} | {
+    type: 'tool_use';
+    name: string;
+    input: unknown;
+} | {
+    type: 'tool_result';
+    name: string;
+    output: string;
+    isError?: boolean;
+} | {
+    type: 'compaction';
+    summary: string;
+    removedCount: number;
+} | {
+    type: 'cost_update';
+    cost: number;
+    tokens: {
+        input: number;
+        output: number;
+    };
+} | {
+    type: 'turn_start';
+    turn: number;
+} | {
+    type: 'turn_end';
+    turn: number;
+} | {
+    type: 'complete';
+    result: QueryResult;
+} | {
+    type: 'error';
+    error: Error;
+};
+declare class QueryEngine {
+    private config;
+    private adapter;
+    private tools;
+    private executor;
+    private compactor;
+    private costTracker;
+    private abortController;
+    constructor(config: Partial<QueryEngineConfig>, adapter: ProviderAdapter, tools: ToolRegistry);
+    run(prompt: string): AsyncGenerator<QueryEvent>;
+    abort(): void;
+}
+
+interface LoopDeps {
+    adapter: ProviderAdapter;
+    toolRegistry: ToolRegistry;
+    config: AppConfig;
+    systemPrompt: string;
+    cwd: string;
+    abortSignal: AbortSignal;
+    /** Permission callback — returns true if operation is allowed */
+    onPermissionRequest: (operation: string, details?: string) => Promise<boolean>;
+    /** Auto mode manager (optional — created from config if not provided) */
+    autoModeManager?: AutoModeManager;
+    /** Fast mode manager (optional — created from config if not provided) */
+    fastModeManager?: FastModeManager;
+    /** Plan mode manager (optional — enables multi-agent plan execution) */
+    planModeManager?: PlanModeManager;
+    /** Context window manager (optional — created from config if not provided) */
+    contextWindowManager?: ContextWindowManager;
+    /** Session history — messages from previous turns in this conversation */
+    sessionHistory?: Message[];
+}
+/**
+ * Run the autonomous agent loop.
+ * Yields LoopEvents as the agent processes the user's input,
+ * calls tools, and generates responses.
+ *
+ * If `deps.sessionHistory` is provided, the loop continues an existing
+ * conversation — the history is prepended so the model sees the full context.
+ */
+declare function runAgentLoop(userMessage: string, deps: LoopDeps): AsyncGenerator<LoopEvent>;
+/**
+ * Create a default tool registry with built-in tools.
+ * When a ModelRouter is provided, the AgentTool is also registered
+ * with full model routing capabilities.
+ */
+declare function createDefaultToolRegistry(modelRouter?: ModelRouter): ToolRegistry;
+
+/**
+ * Adapter for chat/completions-compatible APIs.
+ * Works with any provider implementing the /chat/completions endpoint.
+ */
+declare class GenericCompatAdapter extends BaseAdapter {
+    readonly config: ProviderConfig;
+    readonly name: string;
+    constructor(config: ProviderConfig, name?: string);
+    complete(request: CompletionRequest): Promise<CompletionResult>;
+    stream(request: CompletionRequest): AsyncGenerator<StreamEvent>;
+    validate(): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    dispose(): void;
+    private buildRequestBody;
+    private mapMessage;
+    private mapTool;
+    private mapResponse;
+    private parseSSEStream;
+    /** Track active tool calls: index → { id, name, args } for emitting tool_use_end */
+    private activeToolCalls;
+    private processChunk;
+}
+
+declare const enterPlanInputSchema: z.ZodObject<{
+    plan_prompt: z.ZodString;
+    agents: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    strategy: z.ZodOptional<z.ZodDefault<z.ZodEnum<["sequential", "parallel", "adaptive"]>>>;
+}, "strip", z.ZodTypeAny, {
+    plan_prompt: string;
+    strategy?: "sequential" | "parallel" | "adaptive" | undefined;
+    agents?: number | undefined;
+}, {
+    plan_prompt: string;
+    strategy?: "sequential" | "parallel" | "adaptive" | undefined;
+    agents?: number | undefined;
+}>;
+type EnterPlanInput = z.infer<typeof enterPlanInputSchema>;
+declare class EnterPlanModeTool extends BaseTool<typeof enterPlanInputSchema> {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        plan_prompt: z.ZodString;
+        agents: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        strategy: z.ZodOptional<z.ZodDefault<z.ZodEnum<["sequential", "parallel", "adaptive"]>>>;
+    }, "strip", z.ZodTypeAny, {
+        plan_prompt: string;
+        strategy?: "sequential" | "parallel" | "adaptive" | undefined;
+        agents?: number | undefined;
+    }, {
+        plan_prompt: string;
+        strategy?: "sequential" | "parallel" | "adaptive" | undefined;
+        agents?: number | undefined;
+    }>;
+    riskLevel: "safe";
+    concurrencySafe: boolean;
+    readOnly: boolean;
+    execute(input: EnterPlanInput, context: ToolExecutionContext): Promise<string>;
+}
+
+declare const exitPlanInputSchema: z.ZodObject<{
+    plan: z.ZodString;
+    confirmed: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    plan: string;
+    confirmed: boolean;
+}, {
+    plan: string;
+    confirmed: boolean;
+}>;
+type ExitPlanInput = z.infer<typeof exitPlanInputSchema>;
+declare class ExitPlanModeTool extends BaseTool<typeof exitPlanInputSchema> {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        plan: z.ZodString;
+        confirmed: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        plan: string;
+        confirmed: boolean;
+    }, {
+        plan: string;
+        confirmed: boolean;
+    }>;
+    riskLevel: "safe";
+    concurrencySafe: boolean;
+    readOnly: boolean;
+    execute(input: ExitPlanInput, context: ToolExecutionContext): Promise<string>;
+}
+
+declare const webSearchInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    max_results: z.ZodDefault<z.ZodNumber>;
+    search_engine: z.ZodDefault<z.ZodEnum<["duckduckgo", "google"]>>;
+}, "strip", z.ZodTypeAny, {
+    max_results: number;
+    query: string;
+    search_engine: "duckduckgo" | "google";
+}, {
+    query: string;
+    max_results?: number | undefined;
+    search_engine?: "duckduckgo" | "google" | undefined;
+}>;
+type WebSearchInput = z.infer<typeof webSearchInputSchema>;
+declare class WebSearchTool extends BaseTool<typeof webSearchInputSchema> {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        query: z.ZodString;
+        max_results: z.ZodDefault<z.ZodNumber>;
+        search_engine: z.ZodDefault<z.ZodEnum<["duckduckgo", "google"]>>;
+    }, "strip", z.ZodTypeAny, {
+        max_results: number;
+        query: string;
+        search_engine: "duckduckgo" | "google";
+    }, {
+        query: string;
+        max_results?: number | undefined;
+        search_engine?: "duckduckgo" | "google" | undefined;
+    }>;
+    riskLevel: "safe";
+    concurrencySafe: boolean;
+    readOnly: boolean;
+    execute(input: WebSearchInput, _context: ToolExecutionContext): Promise<string>;
+    private fallbackLiteSearch;
+}
+
+declare const lspInputSchema: z.ZodObject<{
+    operation: z.ZodEnum<["go_to_definition", "find_references", "hover", "document_symbols", "workspace_symbols"]>;
+    file_path: z.ZodString;
+    line: z.ZodOptional<z.ZodNumber>;
+    character: z.ZodOptional<z.ZodNumber>;
+    query: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    operation: "go_to_definition" | "find_references" | "hover" | "document_symbols" | "workspace_symbols";
+    file_path: string;
+    query?: string | undefined;
+    line?: number | undefined;
+    character?: number | undefined;
+}, {
+    operation: "go_to_definition" | "find_references" | "hover" | "document_symbols" | "workspace_symbols";
+    file_path: string;
+    query?: string | undefined;
+    line?: number | undefined;
+    character?: number | undefined;
+}>;
+type LspInput = z.infer<typeof lspInputSchema>;
+declare class LspTool extends BaseTool<typeof lspInputSchema> {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        operation: z.ZodEnum<["go_to_definition", "find_references", "hover", "document_symbols", "workspace_symbols"]>;
+        file_path: z.ZodString;
+        line: z.ZodOptional<z.ZodNumber>;
+        character: z.ZodOptional<z.ZodNumber>;
+        query: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        operation: "go_to_definition" | "find_references" | "hover" | "document_symbols" | "workspace_symbols";
+        file_path: string;
+        query?: string | undefined;
+        line?: number | undefined;
+        character?: number | undefined;
+    }, {
+        operation: "go_to_definition" | "find_references" | "hover" | "document_symbols" | "workspace_symbols";
+        file_path: string;
+        query?: string | undefined;
+        line?: number | undefined;
+        character?: number | undefined;
+    }>;
+    riskLevel: "readonly";
+    concurrencySafe: boolean;
+    readOnly: boolean;
+    execute(input: LspInput, context: ToolExecutionContext): Promise<string>;
+    private goToDefinition;
+    private findReferences;
+    private hover;
+    private documentSymbols;
+    private workspaceSymbols;
+    private extractNameAtPosition;
+}
+
+declare const agentInputSchema: z.ZodObject<{
+    task: z.ZodString;
+    working_directory: z.ZodOptional<z.ZodString>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    max_turns: z.ZodDefault<z.ZodNumber>;
+    model: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    task: string;
+    max_turns: number;
+    model?: string | undefined;
+    timeout?: number | undefined;
+    working_directory?: string | undefined;
+    tools?: string[] | undefined;
+}, {
+    task: string;
+    model?: string | undefined;
+    timeout?: number | undefined;
+    working_directory?: string | undefined;
+    tools?: string[] | undefined;
+    max_turns?: number | undefined;
+}>;
+type AgentInput = z.infer<typeof agentInputSchema>;
+/** Router factory type — injected at registration time */
+type ModelRouterFactory = () => ModelRouter;
+/** Registry factory type — provides the parent registry for tool filtering */
+type RegistryFactory = () => ToolRegistry;
+declare class AgentTool extends BaseTool<typeof agentInputSchema> {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        task: z.ZodString;
+        working_directory: z.ZodOptional<z.ZodString>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        max_turns: z.ZodDefault<z.ZodNumber>;
+        model: z.ZodOptional<z.ZodString>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        task: string;
+        max_turns: number;
+        model?: string | undefined;
+        timeout?: number | undefined;
+        working_directory?: string | undefined;
+        tools?: string[] | undefined;
+    }, {
+        task: string;
+        model?: string | undefined;
+        timeout?: number | undefined;
+        working_directory?: string | undefined;
+        tools?: string[] | undefined;
+        max_turns?: number | undefined;
+    }>;
+    riskLevel: "destructive";
+    concurrencySafe: boolean;
+    readOnly: boolean;
+    private modelRouterFactory;
+    private registryFactory;
+    constructor(modelRouterFactory: ModelRouterFactory, registryFactory: RegistryFactory);
+    execute(input: AgentInput, context: ToolExecutionContext): Promise<string>;
+}
+
+/** A memory entry stored in the memory system */
+interface MemoryEntry {
+    /** Unique ID */
+    id: string;
+    /** Topic/category */
+    topic: string;
+    /** Memory content */
+    content: string;
+    /** When this memory was created */
+    createdAt: number;
+    /** When this memory was last accessed */
+    lastAccessedAt: number;
+    /** Relevance score (0-1) for ranking */
+    relevance?: number;
+}
+/** Configuration for the memory system */
+interface MemoryConfig {
+    /** Directory to store memory files */
+    memoryDir: string;
+    /** Maximum size of MEMORY.md entrypoint in characters */
+    maxEntrypointSize: number;
+    /** Maximum number of topic files */
+    maxTopicFiles: number;
+}
+
+/**
+ * File-based memory store.
+ * Stores memories in a directory structure:
+ *   .cliskill/memory/
+ *     MEMORY.md          — entrypoint (summary)
+ *     topics/
+ *       project.md       — topic-specific memories
+ *       preferences.md
+ *       ...
+ */
+declare class MemoryStore {
+    private config;
+    private rootDir;
+    private cache;
+    private loaded;
+    constructor(projectRoot: string, config?: Partial<MemoryConfig>);
+    /**
+     * Initialize the memory directory structure.
+     */
+    init(): Promise<void>;
+    /**
+     * Load all memories from disk into cache.
+     */
+    load(): Promise<void>;
+    /**
+     * Get a memory by topic.
+     */
+    get(topic: string): MemoryEntry | undefined;
+    /**
+     * Get all memories.
+     */
+    getAll(): MemoryEntry[];
+    /**
+     * Save a memory entry to disk.
+     */
+    set(topic: string, content: string): Promise<void>;
+    /**
+     * Delete a memory by topic.
+     */
+    delete(topic: string): Promise<boolean>;
+    /**
+     * Search memories by keyword.
+     */
+    search(query: string): MemoryEntry[];
+    /**
+     * Get the entrypoint (MEMORY.md) content.
+     */
+    getEntrypoint(): Promise<string>;
+    /**
+     * Update the entrypoint (MEMORY.md) content.
+     */
+    setEntrypoint(content: string): Promise<void>;
+    /**
+     * Build a context string from relevant memories for inclusion in system prompt.
+     */
+    buildContext(query?: string, maxTokens?: number): Promise<string>;
+}
+
+interface EnhancedMemoryEntry {
+    topic: string;
+    content: string;
+    timestamp: number;
+    relevanceScore?: number;
+    accessCount: number;
+    lastAccessed: number;
+    tags: string[];
+    source: 'user' | 'agent' | 'auto';
+}
+interface MemorySearchResult {
+    entry: EnhancedMemoryEntry;
+    score: number;
+    matchedTerms: string[];
+}
+interface EnhancedMemoryConfig {
+    maxEntriesPerTopic: number;
+    maxTotalSize: number;
+    autoExtract: boolean;
+    relevanceDecayDays: number;
+}
+
+declare class EnhancedMemoryStore {
+    private config;
+    private baseDir;
+    private entries;
+    private loaded;
+    constructor(baseDir: string, config?: Partial<EnhancedMemoryConfig>);
+    init(): Promise<void>;
+    load(): Promise<void>;
+    addMemory(topic: string, content: string, tags?: string[], source?: EnhancedMemoryEntry['source']): Promise<void>;
+    search(query: string, limit?: number): Promise<MemorySearchResult[]>;
+    extractMemories(text: string): Promise<string[]>;
+    getStats(): {
+        totalEntries: number;
+        totalSize: number;
+        topics: string[];
+    };
+    prune(): Promise<number>;
+    private getAllEntries;
+    private persist;
+}
+
+/** A skill definition loaded from a .md file or registered programmatically */
+interface SkillDefinition {
+    /** Unique name */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** Aliases for invocation */
+    aliases?: string[];
+    /** The prompt template to inject when skill is activated */
+    prompt: string;
+    /** List of tools this skill is allowed to use (empty = all) */
+    allowedTools?: string[];
+    /** Whether this skill is built-in or user-defined */
+    builtin: boolean;
+    /** Source file path (for user-defined skills) */
+    sourcePath?: string;
+}
+
+/**
+ * Registry of available skills.
+ * Manages skill registration, lookup, and loading from disk.
+ */
+declare class SkillRegistry {
+    private skills;
+    private aliasIndex;
+    /** Register a skill */
+    register(skill: SkillDefinition): void;
+    /** Get a skill by name or alias */
+    get(nameOrAlias: string): SkillDefinition | undefined;
+    /** Get all registered skills */
+    getAll(): SkillDefinition[];
+    /** Check if a skill exists */
+    has(name: string): boolean;
+    /** Unregister a skill */
+    unregister(name: string): void;
+    /**
+     * Load skills from a directory.
+     * Returns the number of skills loaded.
+     */
+    loadFromDir(dir: string): Promise<number>;
+    /**
+     * Load skills from standard locations:
+     * 1. ~/.cliskill/skills/ (global user skills)
+     * 2. .cliskill/skills/ (project skills)
+     */
+    loadStandardSkills(projectRoot: string): Promise<number>;
+    /**
+     * Get skill prompt for injection into system prompt.
+     */
+    getSkillPrompt(nameOrAlias: string): string | undefined;
+}
+
+/** Permission mode for the session */
+type PermissionMode = 'ask' | 'auto-accept' | 'plan';
+/** A rule that allows or denies an operation */
+interface PermissionRule {
+    /** Tool name pattern (e.g., "bash", "file_*") */
+    tool: string;
+    /** Content pattern (e.g., "git *", "rm *") */
+    contentPattern?: string;
+    /** Whether this rule allows or denies */
+    allow: boolean;
+}
+/** Result of a permission check */
+interface PermissionResult {
+    allowed: boolean;
+    reason?: string;
+}
+/**
+ * Permission manager that evaluates tool execution requests
+ * against configured rules and the current permission mode.
+ */
+declare class PermissionManager {
+    private mode;
+    private rules;
+    private sessionDecisions;
+    constructor(mode: PermissionMode, rules?: PermissionRule[]);
+    /**
+     * Check if a tool operation is allowed.
+     */
+    check(toolName: string, riskLevel: RiskLevel, content?: string): PermissionResult;
+    /**
+     * Record a user decision for the session.
+     */
+    recordDecision(toolName: string, content: string, allowed: boolean): void;
+    /**
+     * Add a permission rule.
+     */
+    addRule(rule: PermissionRule): void;
+    /**
+     * Set the permission mode.
+     */
+    setMode(mode: PermissionMode): void;
+    /**
+     * Get the current permission mode.
+     */
+    getMode(): PermissionMode;
+    private matchTool;
+    private matchContent;
+}
+
+/**
+ * Simple command inspector for shell commands.
+ * Analyzes commands for potential security risks without full AST parsing.
+ */
+/** Risk classification of a shell command */
+type CommandRisk = 'safe' | 'moderate' | 'dangerous';
+/** Result of command analysis */
+interface CommandAnalysis$1 {
+    risk: CommandRisk;
+    reason: string;
+    /** The base command (first word) */
+    baseCommand: string;
+    /** Whether the command modifies the filesystem */
+    modifiesFiles: boolean;
+    /** Whether the command accesses the network */
+    accessesNetwork: boolean;
+}
+/**
+ * Analyze a shell command for security risks.
+ */
+declare function inspectCommand(command: string): CommandAnalysis$1;
+
+interface ModelUsage {
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheCreationTokens: number;
+    totalRequests: number;
+}
+interface CostEntry {
+    timestamp: number;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheCreationTokens: number;
+    cost: number;
+}
+interface CostConfig {
+    prices: Record<string, {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+    }>;
+    budgetLimit?: number;
+}
+declare class CostTracker {
+    private entries;
+    private config;
+    private sessionStart;
+    constructor(config?: Partial<CostConfig>);
+    /** Record token usage for a model */
+    recordUsage(model: string, usage: Omit<ModelUsage, 'model' | 'totalRequests'>): CostEntry;
+    /** Get total session cost in USD */
+    getSessionTotal(): number;
+    /** Get aggregated usage by model */
+    getSessionUsage(): ModelUsage[];
+    /** Get all recorded entries */
+    getEntries(): CostEntry[];
+    /** Format cost as USD string */
+    formatCost(usd: number): string;
+    /** Format duration from ms to human-readable */
+    formatDuration(ms: number): string;
+    /** Check if budget limit is exceeded */
+    checkBudget(): {
+        exceeded: boolean;
+        used: number;
+        limit?: number;
+        percent?: number;
+    };
+    /** Get session duration in ms */
+    getSessionDuration(): number;
+    /** Reset for new session */
+    reset(): void;
+}
+
+interface TokenBudgetAnalysis {
+    usedTokens: number;
+    maxTokens: number;
+    remainingTokens: number;
+    usagePercent: number;
+    needsCompaction: boolean;
+}
+/**
+ * Estimate the number of tokens in a text string.
+ * Uses heuristic: ~4 chars per token for English, ~2.5 for other languages.
+ */
+declare function estimateTokens(text: string): number;
+/**
+ * Estimate total tokens for an array of messages.
+ * Adds overhead per message (~4 tokens).
+ */
+declare function estimateMessagesTokens(messages: Array<{
+    role: string;
+    content: unknown;
+}>): number;
+/**
+ * Analyze token budget for the current context.
+ * Returns usage stats and whether compaction is needed.
+ */
+declare function analyzeTokenBudget(context: {
+    messages: unknown[];
+    systemPrompt?: string;
+    maxTokens: number;
+}): TokenBudgetAnalysis;
+
+interface HistoryEntry {
+    content: string;
+    timestamp: number;
+    type: 'user' | 'paste';
+}
+interface HistoryConfig {
+    maxEntries: number;
+    filePath: string;
+}
+declare class HistoryManager {
+    private entries;
+    private config;
+    private cursorIndex;
+    constructor(config?: Partial<HistoryConfig>);
+    addEntry(content: string, type?: 'user' | 'paste'): void;
+    getEntries(): HistoryEntry[];
+    search(query: string): HistoryEntry[];
+    getRecent(count: number): HistoryEntry[];
+    clear(): void;
+    navigateUp(): string | null;
+    navigateDown(): string | null;
+    save(): Promise<void>;
+    load(): Promise<void>;
+    private resolvePath;
+}
+
+/**
+ * Streaming Tool Executor — executes tools concurrently based on safety classification.
+ * Adapted from Claude's StreamingToolExecutor.ts.
+ *
+ * - Concurrency-safe tools (readOnly) can run in parallel with each other
+ * - Non-safe tools (bash, file_write, etc.) must run exclusively
+ * - If a Bash tool errors, sibling tools are cancelled
+ * - Results are collected in the order tools were queued
+ */
+
+interface ToolCallRequest {
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+    concurrencySafe: boolean;
+}
+interface ToolCallResult {
+    id: string;
+    output: string;
+    isError: boolean;
+    duration: number;
+}
+interface ExecutorConfig {
+    abortOnError?: boolean;
+}
+interface ExecutorResult {
+    toolResult: ToolResultBlock;
+    event: Extract<LoopEvent, {
+        type: 'tool_result';
+    }>;
+}
+type ToolExecutionFn = (toolCall: {
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}, toolRegistry: ToolRegistry, toolContext: ToolExecutionContext, autoMode: AutoModeManager, onPermissionRequest: (operation: string, details?: string) => Promise<boolean>) => Promise<ExecutorResult>;
+/**
+ * Executes tools with concurrency control.
+ *
+ * Two usage patterns:
+ * 1. **Streaming (loop.ts)**: Create with full constructor, addTool(), getRemainingResults()
+ * 2. **Batch (query-engine.ts)**: Create with (tools, config), call executeTools()
+ */
+declare class StreamingToolExecutor {
+    private tools;
+    private hasBashError;
+    private bashErrorDescription;
+    private siblingAbortController;
+    private discarded;
+    private readonly toolRegistry;
+    private readonly executorConfig;
+    private readonly toolContext?;
+    private readonly autoMode?;
+    private readonly onPermissionRequest?;
+    private readonly executeFn?;
+    /**
+     * Constructor supports two patterns:
+     * 1. Batch mode: new StreamingToolExecutor(tools, config?)
+     * 2. Streaming mode: new StreamingToolExecutor(tools, context, autoMode, permFn, execFn)
+     */
+    constructor(tools: ToolRegistry, configOrContext?: ExecutorConfig | ToolExecutionContext, autoMode?: AutoModeManager, onPermissionRequest?: (operation: string, details?: string) => Promise<boolean>, executeFn?: ToolExecutionFn);
+    /** Discard all pending/in-progress tools */
+    discard(): void;
+    /** Add a tool to the execution queue. Starts immediately if conditions allow. */
+    addTool(toolCall: {
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+    }): void;
+    /** Get completed results in queue order (non-blocking) */
+    getCompletedResults(): Generator<ExecutorResult, void>;
+    /** Wait for all remaining tools and yield results as they complete */
+    getRemainingResults(): AsyncGenerator<ExecutorResult, void>;
+    /** Execute a batch of tool calls and return all results */
+    executeTools(requests: ToolCallRequest[], context: ToolExecutionContext): Promise<ToolCallResult[]>;
+    /** Cancel all running tools (backward-compatible alias for discard()) */
+    cancelAll(): void;
+    /** Get count of currently executing tools */
+    getActiveCount(): number;
+    private reset;
+    private canExecuteTool;
+    private processQueue;
+    private executeTool;
+    private createSyntheticError;
+    private hasCompletedResults;
+    private hasExecutingTools;
+    private hasUnfinishedTools;
+}
+
+interface CompactionConfig {
+    maxTokens: number;
+    compactionThreshold: number;
+    keepRecentMessages: number;
+}
+interface CompactionResult {
+    originalTokenCount: number;
+    compactedTokenCount: number;
+    summary: string;
+    removedMessages: number;
+    keptMessages: number;
+}
+interface MessageForCompaction {
+    role: 'user' | 'assistant';
+    content: string;
+    timestamp?: number;
+}
+declare class ContextCompactor {
+    private config;
+    private adapter;
+    constructor(config: CompactionConfig, adapter?: ProviderAdapter | null);
+    shouldCompact(messages: MessageForCompaction[]): boolean;
+    compact(messages: MessageForCompaction[], systemPrompt?: string): Promise<CompactionResult>;
+    private generateSummary;
+    private truncateMessages;
+    private estimateMessagesTokens;
+}
+
+type HookEvent = 'pre_tool_use' | 'post_tool_use' | 'pre_query' | 'post_query' | 'on_error' | 'on_stop';
+interface HookCondition {
+    tool_name?: string;
+    pattern?: string;
+}
+interface HookDefinition {
+    id: string;
+    event: HookEvent;
+    type: 'command' | 'function';
+    command?: string;
+    handler?: string;
+    condition?: HookCondition;
+    timeout: number;
+    enabled: boolean;
+}
+interface HookResult {
+    hookId: string;
+    success: boolean;
+    output?: string;
+    error?: string;
+    duration: number;
+}
+interface HookContext {
+    event: HookEvent;
+    toolName?: string;
+    toolInput?: unknown;
+    toolOutput?: string;
+    error?: Error;
+    workingDirectory: string;
+}
+
+declare class HookRegistry {
+    private hooks;
+    register(hook: HookDefinition): void;
+    unregister(id: string): void;
+    getHooksForEvent(event: HookEvent): HookDefinition[];
+    getAll(): HookDefinition[];
+    loadFromConfig(config: unknown): void;
+    clear(): void;
+}
+
+declare class HookExecutor {
+    private registry;
+    constructor(registry: HookRegistry);
+    executeHooks(event: HookContext['event'], context: HookContext): Promise<HookResult[]>;
+    private matchesCondition;
+    private executeOne;
+    private executeCommand;
+}
+
+interface ParsedCommand {
+    command: string;
+    args: string[];
+    operators: string[];
+    subCommands: ParsedCommand[];
+    redirections: Redirection[];
+    envVars: Record<string, string>;
+    isBackground: boolean;
+    isSubshell: boolean;
+}
+interface Redirection {
+    type: '>' | '>>' | '<' | '2>' | '2>>' | '&>' | '|';
+    target: string;
+}
+interface CommandAnalysis {
+    commands: string[];
+    isPipe: boolean;
+    isChained: boolean;
+    hasRedirection: boolean;
+    hasSubshell: boolean;
+    isBackground: boolean;
+    envVarCount: number;
+    estimatedRisk: 'safe' | 'moderate' | 'dangerous';
+}
+declare function parseCommand(input: string): ParsedCommand;
+declare function analyzeCommand(input: string): CommandAnalysis;
+
+interface MCPServerConfig {
+    name: string;
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+    transport: 'stdio';
+}
+interface MCPTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+interface MCPResource {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+}
+interface MCPPrompt {
+    name: string;
+    description?: string;
+    arguments?: Array<{
+        name: string;
+        description?: string;
+        required?: boolean;
+    }>;
+}
+interface JSONRPCRequest {
+    jsonrpc: '2.0';
+    id: number;
+    method: string;
+    params?: Record<string, unknown>;
+}
+interface JSONRPCResponse {
+    jsonrpc: '2.0';
+    id: number;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+
+declare class MCPClient {
+    private config;
+    private process;
+    private rl;
+    private connected;
+    private nextId;
+    private pendingRequests;
+    private buffer;
+    constructor(config: MCPServerConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    listTools(): Promise<MCPTool[]>;
+    callTool(name: string, args: Record<string, unknown>): Promise<unknown>;
+    listResources(): Promise<MCPResource[]>;
+    readResource(uri: string): Promise<unknown>;
+    listPrompts(): Promise<MCPPrompt[]>;
+    isConnected(): boolean;
+    private sendRequest;
+    private sendNotification;
+    private handleLine;
+    private cleanup;
+}
+
+declare class MCPConnectionManager {
+    private clients;
+    addServer(config: MCPServerConfig): Promise<void>;
+    removeServer(name: string): Promise<void>;
+    getConnectedServers(): string[];
+    getAllTools(): Promise<MCPTool[]>;
+    callTool(serverName: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
+    getToolsForServer(serverName: string): Promise<MCPTool[]>;
+    disconnectAll(): Promise<void>;
+}
+
+type TaskStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+interface TaskDefinition {
+    id: string;
+    name: string;
+    description: string;
+    type: 'agent' | 'shell' | 'custom';
+    status: TaskStatus;
+    createdAt: number;
+    startedAt?: number;
+    completedAt?: number;
+    error?: string;
+    result?: string;
+    progress?: number;
+}
+interface TaskEvents {
+    onProgress: (taskId: string, progress: number, message?: string) => void;
+    onComplete: (taskId: string, result: string) => void;
+    onError: (taskId: string, error: string) => void;
+    onStatusChange: (taskId: string, status: TaskStatus) => void;
+}
+type TaskEventName = keyof TaskEvents;
+type TaskEventHandler<E extends TaskEventName> = TaskEvents[E];
+
+declare class TaskManager {
+    private tasks;
+    private listeners;
+    private idCounter;
+    createTask(definition: Omit<TaskDefinition, 'id' | 'status' | 'createdAt'>): string;
+    cancelTask(id: string): void;
+    getTask(id: string): TaskDefinition | undefined;
+    listTasks(filter?: {
+        status?: TaskStatus;
+    }): TaskDefinition[];
+    getActiveCount(): number;
+    removeTask(id: string): void;
+    clearCompleted(): void;
+    on<E extends TaskEventName>(event: E, handler: TaskEventHandler<E>): void;
+    off<E extends TaskEventName>(event: E, handler: TaskEventHandler<E>): void;
+    /** @internal Update task status */
+    updateStatus(id: string, status: TaskStatus): void;
+    /** @internal Update task progress */
+    updateProgress(id: string, progress: number, message?: string): void;
+    /** @internal Set task result */
+    setResult(id: string, result: string): void;
+    /** @internal Set task error */
+    setError(id: string, error: string): void;
+    private emit;
+}
+
+declare function executeAgentTask(taskId: string, manager: TaskManager, adapter: ProviderAdapter, tools: ToolRegistry, prompt: string, signal?: AbortSignal): Promise<void>;
+declare function executeShellTask(taskId: string, manager: TaskManager, command: string, cwd: string, signal?: AbortSignal): Promise<void>;
+
+type AgentRole = 'coordinator' | 'worker' | 'reviewer';
+interface AgentConfig {
+    id: string;
+    name: string;
+    role: AgentRole;
+    model?: string;
+    tools?: string[];
+    maxTurns?: number;
+    systemPrompt?: string;
+}
+interface SwarmMessage {
+    from: string;
+    to: string | '*';
+    type: 'task' | 'result' | 'query' | 'response' | 'shutdown';
+    content: string;
+    timestamp: number;
+}
+interface SwarmResult {
+    agentId: string;
+    agentName: string;
+    task: string;
+    result: string;
+    success: boolean;
+    duration: number;
+    turns: number;
+}
+interface SubTask {
+    id: string;
+    description: string;
+    assignedTo?: string;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    result?: string;
+}
+
+declare class SwarmCoordinator {
+    private adapter;
+    private tools;
+    private agents;
+    private mailbox;
+    private abortController;
+    constructor(adapter: ProviderAdapter, tools: ToolRegistry);
+    addAgent(config: AgentConfig): void;
+    removeAgent(id: string): void;
+    getAgents(): AgentConfig[];
+    sendMessage(message: SwarmMessage): Promise<void>;
+    executeSwarm(task: string): Promise<SwarmResult[]>;
+    shutdown(): void;
+    private findAgentByRole;
+    private findAgentsByRole;
+    private decomposeTask;
+    private fallbackDecompose;
+    private assignSubtasks;
+    private executeParallel;
+    private reviewResults;
+    private createEngine;
+}
+
+interface ChatMessage {
+    id: string;
+    role: 'user' | 'assistant' | 'tool' | 'error';
+    content: string;
+    toolName?: string;
+    isError?: boolean;
+}
+interface StatusBarProps {
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    sessionStart: number;
+    toolCount: number;
+}
+type LoopEventHandler = (event: LoopEvent) => void;
+interface InkAppProps {
+    model: string;
+    toolCount: number;
+    onSubmit: (message: string, onEvent: LoopEventHandler) => Promise<void>;
+}
+declare const StatusBar: React.NamedExoticComponent<StatusBarProps>;
+declare const Spinner: React.NamedExoticComponent<{
+    label: string;
+}>;
+declare function InkApp({ model, toolCount, onSubmit }: InkAppProps): React.ReactElement;
+declare function renderInkApp(props: InkAppProps): void;
+declare function formatAnsiMessage(message: ChatMessage): string;
+declare function MessageList({ messages }: {
+    messages: ChatMessage[];
+}): React.ReactElement;
+
+export { AdapterRegistry, type AgentConfig, type AgentRole, AgentTool, type AppConfig, type ChatMessage, type CommandAnalysis, type CompactionConfig, type CompactionResult, type CompletionRequest, type CompletionResult, ContextCompactor, type CostConfig, type CostEntry, CostTracker, type EnhancedMemoryConfig, type EnhancedMemoryEntry, EnhancedMemoryStore, EnterPlanModeTool, type ExecutorConfig, ExitPlanModeTool, GenericCompatAdapter, type HistoryConfig, type HistoryEntry, HistoryManager, type HookCondition, type HookContext, type HookDefinition, type HookEvent, HookExecutor, HookRegistry, type HookResult, InkApp, type InkAppProps, type JSONRPCRequest, type JSONRPCResponse, type LoopEventHandler, LspTool, MCPClient, MCPConnectionManager, type MCPPrompt, type MCPResource, type MCPServerConfig, type MCPTool, type MemoryEntry, type MemorySearchResult, MemoryStore, type Message, type MessageForCompaction, MessageList, type ModelRouterFactory, type ModelUsage, type ParsedCommand, PermissionManager, type ProviderAdapter, type ProviderConfig, QueryEngine, type QueryEngineConfig, type QueryEvent, type QueryResult, type Redirection, type RegistryFactory, type SkillDefinition, SkillRegistry, Spinner, StatusBar, type StatusBarProps, type StreamEvent, StreamingToolExecutor, type SubTask, SwarmCoordinator, type SwarmMessage, type SwarmResult, type TaskDefinition, type TaskEventHandler, type TaskEventName, type TaskEvents, TaskManager, type TaskStatus, type TokenBudgetAnalysis, type ToolCallRequest, type ToolCallResult, type ToolContract, ToolRegistry, WebSearchTool, analyzeCommand, analyzeTokenBudget, createDefaultToolRegistry, estimateMessagesTokens, estimateTokens, executeAgentTask, executeShellTask, formatAnsiMessage, inspectCommand, parseCommand, renderInkApp, runAgentLoop };