aemeathcli 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2210 @@
+import Database from 'better-sqlite3';
+import { Socket } from 'node:net';
+
+/**
+ * Model-related types per PRD sections 7.1-7.5
+ */
+type ProviderName = "anthropic" | "openai" | "google" | "kimi" | "ollama";
+type ModelRole = "planning" | "coding" | "review" | "testing" | "bugfix" | "documentation";
+interface IModelInfo {
+    readonly id: string;
+    readonly name: string;
+    readonly provider: ProviderName;
+    readonly contextWindow: number;
+    readonly maxOutputTokens: number;
+    readonly inputPricePerMToken: number;
+    readonly outputPricePerMToken: number;
+    readonly supportsStreaming: boolean;
+    readonly supportsToolCalling: boolean;
+    readonly supportedRoles: readonly ModelRole[];
+    readonly description?: string | undefined;
+}
+interface IRoleConfig {
+    readonly primary: string;
+    readonly fallback: readonly string[];
+}
+type ModelResolutionSource = "user_override" | "role_config" | "fallback_chain" | "system_default";
+interface IModelResolution {
+    readonly modelId: string;
+    readonly provider: ProviderName;
+    readonly source: ModelResolutionSource;
+    readonly role?: ModelRole | undefined;
+}
+interface ITokenUsage {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly totalTokens: number;
+    readonly costUsd: number;
+}
+declare const SUPPORTED_MODELS: Record<string, IModelInfo>;
+declare const DEFAULT_MODEL_ID = "claude-sonnet-4-6";
+
+/**
+ * Message types per PRD sections 7.1, 8.4
+ */
+
+type MessageRole = "user" | "assistant" | "system" | "tool";
+interface IChatMessage {
+    readonly id: string;
+    readonly role: MessageRole;
+    readonly content: string;
+    readonly model?: string | undefined;
+    readonly provider?: ProviderName | undefined;
+    readonly toolCalls?: readonly IToolCall[] | undefined;
+    readonly tokenUsage?: ITokenUsage | undefined;
+    readonly createdAt: Date;
+}
+interface IToolCall {
+    readonly id: string;
+    readonly name: string;
+    readonly arguments: Record<string, unknown>;
+}
+interface IToolResult {
+    readonly toolCallId: string;
+    readonly name: string;
+    readonly content: string;
+    readonly isError: boolean;
+}
+type StreamChunkType = "text" | "tool_call" | "usage" | "done" | "error";
+interface IStreamChunk {
+    readonly type: StreamChunkType;
+    readonly content?: string | undefined;
+    readonly toolCall?: IToolCall | undefined;
+    readonly usage?: ITokenUsage | undefined;
+    readonly error?: string | undefined;
+}
+interface IChatRequest {
+    readonly model: string;
+    readonly messages: readonly IChatMessage[];
+    readonly system?: string | undefined;
+    readonly tools?: readonly IToolDefinition[] | undefined;
+    readonly maxTokens?: number | undefined;
+    readonly temperature?: number | undefined;
+}
+interface IChatResponse {
+    readonly id: string;
+    readonly model: string;
+    readonly provider: ProviderName;
+    readonly message: IChatMessage;
+    readonly usage: ITokenUsage;
+    readonly finishReason: "stop" | "tool_calls" | "max_tokens" | "error";
+}
+interface IToolParameter {
+    readonly name: string;
+    readonly type: string;
+    readonly description: string;
+    readonly required: boolean;
+    readonly default?: unknown | undefined;
+    readonly enum?: readonly string[] | undefined;
+}
+interface IToolDefinition {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: readonly IToolParameter[];
+}
+type AgentMessageType = "message" | "broadcast" | "shutdown_request" | "shutdown_response" | "plan_approval_request" | "plan_approval_response" | "task_update";
+interface IAgentMessage {
+    readonly type: AgentMessageType;
+    readonly senderId: string;
+    readonly recipientId?: string | undefined;
+    readonly content: string;
+    readonly summary?: string | undefined;
+    readonly requestId?: string | undefined;
+    readonly approve?: boolean | undefined;
+    readonly timestamp: Date;
+}
+
+/**
+ * Tool types per PRD sections 5.1, 14.4
+ */
+
+type PermissionMode = "strict" | "standard" | "permissive";
+type ToolCategory = "file" | "search" | "shell" | "web" | "git" | "mcp";
+interface IToolRegistration {
+    readonly definition: IToolDefinition;
+    readonly category: ToolCategory;
+    readonly requiresApproval: (mode: PermissionMode, args: Record<string, unknown>) => boolean;
+    readonly execute: (args: Record<string, unknown>) => Promise<IToolResult>;
+}
+interface IToolExecutionContext {
+    readonly workingDirectory: string;
+    readonly permissionMode: PermissionMode;
+    readonly projectRoot: string;
+    readonly allowedPaths: readonly string[];
+    readonly blockedCommands: readonly string[];
+}
+interface IToolRegistry {
+    register(tool: IToolRegistration): void;
+    get(name: string): IToolRegistration | undefined;
+    getAll(): readonly IToolRegistration[];
+    getDefinitions(): readonly IToolDefinition[];
+    execute(call: IToolCall, context: IToolExecutionContext): Promise<IToolResult>;
+}
+
+/**
+ * Team types per PRD section 8
+ */
+
+type TaskStatus = "pending" | "in_progress" | "completed" | "blocked";
+interface ITask {
+    readonly id: string;
+    subject: string;
+    description: string;
+    status: TaskStatus;
+    owner?: string | undefined;
+    model?: string | undefined;
+    role?: ModelRole | undefined;
+    blocks: string[];
+    blockedBy: string[];
+    readonly createdAt: Date;
+    updatedAt: Date;
+}
+type AgentStatus = "idle" | "active" | "error" | "shutdown";
+interface IAgentConfig {
+    readonly name: string;
+    readonly agentId: string;
+    readonly agentType: string;
+    readonly model: string;
+    readonly provider: ProviderName;
+    readonly role: ModelRole;
+}
+interface IAgentState {
+    readonly config: IAgentConfig;
+    status: AgentStatus;
+    currentTaskId?: string | undefined;
+    paneId?: string | undefined;
+}
+type TeamStatus = "active" | "completed" | "error";
+interface ITeamConfig {
+    readonly teamName: string;
+    readonly description?: string | undefined;
+    status: TeamStatus;
+    readonly members: readonly IAgentConfig[];
+    readonly createdAt: Date;
+}
+type IPCMethod = "agent.register" | "agent.streamChunk" | "agent.taskUpdate" | "agent.message" | "hub.taskAssign" | "hub.shutdown";
+interface IIPCMessage {
+    readonly jsonrpc: "2.0";
+    readonly method: IPCMethod;
+    readonly params: Record<string, unknown>;
+    readonly id?: number | undefined;
+}
+type PaneLayout = "auto" | "horizontal" | "vertical" | "grid";
+interface IPaneConfig {
+    readonly paneId: string;
+    readonly agentName: string;
+    readonly model: string;
+    readonly role: ModelRole;
+    readonly title: string;
+}
+interface ILayoutConfig {
+    readonly layout: PaneLayout;
+    readonly panes: readonly IPaneConfig[];
+    readonly maxPanes: number;
+}
+
+/**
+ * Configuration types per PRD section 17.3
+ */
+
+interface IProviderConfig {
+    readonly enabled: boolean;
+    readonly baseUrl?: string | undefined;
+}
+interface IPermissionConfig {
+    readonly mode: PermissionMode;
+    readonly allowedPaths: readonly string[];
+    readonly blockedCommands: readonly string[];
+}
+type PaneBackend = "tmux" | "iterm2";
+interface ISplitPanelConfig {
+    readonly enabled: boolean;
+    readonly backend: PaneBackend;
+    readonly defaultLayout: PaneLayout;
+    readonly maxPanes: number;
+}
+interface ICostConfig {
+    readonly budgetWarning: number;
+    readonly budgetHardStop: number;
+    readonly currency: string;
+}
+interface ITelemetryConfig {
+    readonly enabled: boolean;
+    readonly anonymized: boolean;
+}
+interface IOAuthProviderConfig {
+    readonly clientId: string;
+    readonly clientSecret?: string | undefined;
+    readonly authorizeUrl?: string | undefined;
+    readonly tokenUrl?: string | undefined;
+    readonly scope?: string | undefined;
+}
+interface IOAuthConfig {
+    readonly anthropic?: IOAuthProviderConfig | undefined;
+    readonly openai?: IOAuthProviderConfig | undefined;
+    readonly google?: IOAuthProviderConfig | undefined;
+    readonly kimi?: IOAuthProviderConfig | undefined;
+}
+interface IGlobalConfig {
+    readonly version: string;
+    readonly defaultModel: string;
+    readonly roles: Partial<Record<ModelRole, IRoleConfig>>;
+    readonly providers: Partial<Record<ProviderName, IProviderConfig>>;
+    readonly permissions: IPermissionConfig;
+    readonly splitPanel: ISplitPanelConfig;
+    readonly cost: ICostConfig;
+    readonly telemetry: ITelemetryConfig;
+    readonly oauth?: IOAuthConfig | undefined;
+}
+interface IMCPServerConfig {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly env?: Readonly<Record<string, string>> | undefined;
+}
+interface IMCPConfig {
+    readonly mcpServers: Readonly<Record<string, IMCPServerConfig>>;
+}
+interface ISkillFrontmatter {
+    readonly name: string;
+    readonly description: string;
+    readonly version: string;
+    readonly "allowed-tools"?: readonly string[] | undefined;
+    readonly triggers: readonly string[];
+    readonly "model-requirements"?: {
+        readonly "preferred-role"?: ModelRole | undefined;
+        readonly "min-context"?: number | undefined;
+    } | undefined;
+}
+interface ISkillDefinition {
+    readonly frontmatter: ISkillFrontmatter;
+    readonly body: string;
+    readonly filePath: string;
+}
+type AuthMethod = "native_login" | "api_key" | "env_variable" | "credential_helper";
+interface ICredential {
+    readonly provider: ProviderName;
+    readonly method: AuthMethod;
+    readonly token?: string | undefined;
+    readonly refreshToken?: string | undefined;
+    readonly expiresAt?: Date | undefined;
+    readonly email?: string | undefined;
+    readonly plan?: string | undefined;
+}
+declare const DEFAULT_CONFIG: IGlobalConfig;
+
+/**
+ * AemeathCLI Typed Error Hierarchy
+ * Per PRD section 15.5: Every error includes code, user message, diagnostic, recovery action
+ */
+interface IErrorContext {
+    readonly code: string;
+    readonly userMessage: string;
+    readonly diagnosticMessage?: string | undefined;
+    readonly suggestedRecovery?: string | undefined;
+}
+declare abstract class AemeathError extends Error {
+    abstract readonly code: string;
+    abstract readonly userMessage: string;
+    diagnosticMessage?: string | undefined;
+    suggestedRecovery?: string | undefined;
+    constructor(message: string, context?: Partial<IErrorContext>);
+}
+declare class AuthenticationError extends AemeathError {
+    readonly code: "AEMEATH_PROVIDER_AUTH_001";
+    readonly userMessage: string;
+    constructor(provider: string, message?: string);
+}
+declare class RateLimitError extends AemeathError {
+    readonly code: "AEMEATH_PROVIDER_RATE_001";
+    readonly userMessage: string;
+    readonly retryAfterMs: number;
+    constructor(provider: string, retryAfterMs: number);
+}
+declare class ContextOverflowError extends AemeathError {
+    readonly code: "AEMEATH_PROVIDER_CTX_001";
+    readonly userMessage: string;
+    constructor(model: string, maxTokens: number, currentTokens: number);
+}
+declare class ModelNotFoundError extends AemeathError {
+    readonly code: "AEMEATH_PROVIDER_MODEL_001";
+    readonly userMessage: string;
+    constructor(model: string);
+}
+declare class MissingConfigError extends AemeathError {
+    readonly code: "AEMEATH_CONFIG_MISS_001";
+    readonly userMessage: string;
+    constructor(key: string);
+}
+declare class InvalidConfigError extends AemeathError {
+    readonly code: "AEMEATH_CONFIG_INVALID_001";
+    readonly userMessage: string;
+    constructor(key: string, reason: string);
+}
+declare class FileNotFoundError extends AemeathError {
+    readonly code: "AEMEATH_TOOL_FILE_001";
+    readonly userMessage: string;
+    constructor(filePath: string);
+}
+declare class PermissionDeniedError extends AemeathError {
+    readonly code: "AEMEATH_TOOL_PERM_001";
+    readonly userMessage: string;
+    constructor(operation: string, resource: string);
+}
+declare class ExecutionTimeoutError extends AemeathError {
+    readonly code: "AEMEATH_TOOL_TIMEOUT_001";
+    readonly userMessage: string;
+    constructor(command: string, timeoutMs: number);
+}
+declare class AgentSpawnError extends AemeathError {
+    readonly code: "AEMEATH_TEAM_SPAWN_001";
+    readonly userMessage: string;
+    constructor(agentName: string, reason: string);
+}
+declare class IPCError extends AemeathError {
+    readonly code: "AEMEATH_TEAM_IPC_001";
+    readonly userMessage: string;
+    constructor(message: string);
+}
+declare class ServerConnectionError extends AemeathError {
+    readonly code: "AEMEATH_MCP_CONN_001";
+    readonly userMessage: string;
+    constructor(serverName: string, reason: string);
+}
+declare class ToolCallError extends AemeathError {
+    readonly code: "AEMEATH_MCP_TOOL_001";
+    readonly userMessage: string;
+    constructor(toolName: string, reason: string);
+}
+
+/**
+ * Typed event emitter per PRD section 6.1
+ * Core IPC backbone for the orchestration layer.
+ */
+type EventHandler<T = unknown> = (data: T) => void;
+interface IEventMap {
+    "model:request": {
+        model: string;
+        role?: string;
+    };
+    "model:response": {
+        model: string;
+        tokens: number;
+        cost: number;
+    };
+    "model:stream:chunk": {
+        model: string;
+        content: string;
+    };
+    "model:stream:done": {
+        model: string;
+        totalTokens: number;
+    };
+    "model:error": {
+        model: string;
+        error: Error;
+    };
+    "tool:call": {
+        name: string;
+        args: Record<string, unknown>;
+    };
+    "tool:result": {
+        name: string;
+        isError: boolean;
+        content: string;
+    };
+    "team:created": {
+        teamName: string;
+        agentCount: number;
+    };
+    "team:deleted": {
+        teamName: string;
+    };
+    "agent:spawned": {
+        agentName: string;
+        model: string;
+    };
+    "agent:status": {
+        agentName: string;
+        status: string;
+    };
+    "agent:message": {
+        from: string;
+        to: string;
+        content: string;
+    };
+    "task:created": {
+        taskId: string;
+        subject: string;
+    };
+    "task:updated": {
+        taskId: string;
+        status: string;
+    };
+    "task:completed": {
+        taskId: string;
+    };
+    "cost:updated": {
+        total: number;
+        provider: string;
+        delta: number;
+    };
+    "cost:warning": {
+        current: number;
+        limit: number;
+    };
+    "cost:exceeded": {
+        current: number;
+        limit: number;
+    };
+    "pane:created": {
+        paneId: string;
+        agentName: string;
+    };
+    "pane:closed": {
+        paneId: string;
+    };
+    "skill:activated": {
+        skillName: string;
+    };
+    "skill:deactivated": {
+        skillName: string;
+    };
+    "mcp:server:started": {
+        serverName: string;
+    };
+    "mcp:server:stopped": {
+        serverName: string;
+    };
+    "mcp:server:error": {
+        serverName: string;
+        error: string;
+    };
+    "config:changed": {
+        key: string;
+    };
+    "auth:login": {
+        provider: string;
+        email?: string;
+    };
+    "auth:logout": {
+        provider: string;
+    };
+}
+type EventName = keyof IEventMap;
+declare class EventBus {
+    private readonly listeners;
+    on<K extends EventName>(event: K, handler: EventHandler<IEventMap[K]>): () => void;
+    once<K extends EventName>(event: K, handler: EventHandler<IEventMap[K]>): () => void;
+    emit<K extends EventName>(event: K, data: IEventMap[K]): void;
+    removeAllListeners(event?: EventName): void;
+    listenerCount(event: EventName): number;
+}
+declare function getEventBus(): EventBus;
+
+/**
+ * Role-based model selection per PRD section 7.2
+ * Resolution pipeline: user override → role config → fallback chain → system default
+ */
+
+interface IModelRouterConfig {
+    readonly defaultModel: string;
+    readonly roles: Partial<Record<ModelRole, IRoleConfig>>;
+    readonly enabledProviders: readonly ProviderName[];
+}
+declare class ModelRouter {
+    private readonly config;
+    private userOverride;
+    constructor(config: IModelRouterConfig);
+    /**
+     * Set a temporary user override that takes highest priority.
+     */
+    setUserOverride(modelId: string | undefined): void;
+    /**
+     * Resolve the best model for a given role through the priority pipeline.
+     */
+    resolve(role?: ModelRole): IModelResolution;
+    /**
+     * Check if a model is available (provider is enabled and model is known).
+     */
+    isModelAvailable(modelId: string): boolean;
+    /**
+     * Get model info by ID. Throws if not found.
+     */
+    getModelInfo(modelId: string): IModelInfo;
+    /**
+     * Get all available models (from enabled providers).
+     */
+    getAvailableModels(): readonly IModelInfo[];
+    /**
+     * List models recommended for a specific role.
+     */
+    getModelsForRole(role: ModelRole): readonly IModelInfo[];
+    /**
+     * Validate that a model ID exists. Throws ModelNotFoundError if not.
+     */
+    private validateModel;
+}
+/**
+ * Create a ModelRouter from the global config.
+ */
+declare function createModelRouter(config: IGlobalConfig): ModelRouter;
+
+/**
+ * Context window management per PRD section 7.4
+ * - Token budgeting: 85% conversation, 15% buffer
+ * - Smart truncation: prioritize recent + system prompt
+ * - Compression: summarize old messages when approaching limits
+ * - File context tracking with LRU eviction
+ */
+
+interface IFileContextEntry {
+    readonly filePath: string;
+    readonly tokenCount: number;
+    lastAccessedAt: number;
+}
+declare class ContextManager {
+    private readonly maxTokens;
+    private readonly budgetTokens;
+    private readonly fileContext;
+    private currentTokenCount;
+    constructor(modelInfo: IModelInfo);
+    /**
+     * Get the available token budget for new content.
+     */
+    getAvailableBudget(): number;
+    /**
+     * Get total context usage.
+     */
+    getUsage(): {
+        used: number;
+        budget: number;
+        max: number;
+        percentage: number;
+    };
+    /**
+     * Trim messages to fit within the context window.
+     * Preserves system prompt and most recent messages.
+     */
+    trimMessages(messages: readonly IChatMessage[], systemPrompt?: string): IChatMessage[];
+    /**
+     * Track a file being added to context.
+     */
+    addFileContext(filePath: string, content: string): void;
+    /**
+     * Touch a file (update last accessed time).
+     */
+    touchFile(filePath: string): void;
+    /**
+     * Remove a file from context.
+     */
+    removeFileContext(filePath: string): void;
+    /**
+     * Evict least-recently-used files to free space.
+     */
+    evictLRU(tokensNeeded: number): string[];
+    /**
+     * Get all tracked files.
+     */
+    getTrackedFiles(): readonly IFileContextEntry[];
+    /**
+     * Reset context tracking (for model switch).
+     */
+    reset(): void;
+}
+
+/**
+ * Real-time cost tracking per PRD section 7.5
+ * - Per-request cost calculation
+ * - Session total
+ * - Breakdown by provider, model, and role
+ * - Configurable budget alerts
+ */
+
+interface ICostEntry$1 {
+    readonly provider: ProviderName;
+    readonly model: string;
+    readonly role?: ModelRole | undefined;
+    readonly usage: ITokenUsage;
+    readonly timestamp: Date;
+}
+interface ICostBreakdown {
+    readonly byProvider: Record<string, number>;
+    readonly byModel: Record<string, number>;
+    readonly byRole: Record<string, number>;
+}
+declare class CostTracker {
+    private readonly entries;
+    private readonly budgetConfig;
+    private warningEmitted;
+    constructor(budgetConfig: ICostConfig);
+    /**
+     * Record a cost entry from a model response.
+     */
+    record(provider: ProviderName, model: string, inputTokens: number, outputTokens: number, role?: ModelRole): ITokenUsage;
+    /**
+     * Get total session cost.
+     */
+    getSessionTotal(): number;
+    /**
+     * Get total token counts.
+     */
+    getSessionTokens(): {
+        input: number;
+        output: number;
+        total: number;
+    };
+    /**
+     * Get cost breakdown by provider, model, and role.
+     */
+    getBreakdown(): ICostBreakdown;
+    /**
+     * Check if budget hard stop has been exceeded.
+     */
+    isBudgetExceeded(): boolean;
+    /**
+     * Get formatted session summary.
+     */
+    getSummary(): string;
+    /**
+     * Get all cost entries (for export).
+     */
+    getEntries(): readonly ICostEntry$1[];
+    /**
+     * Reset cost tracking for a new session.
+     */
+    reset(): void;
+}
+
+/**
+ * Tool permission management per PRD section 14.4
+ * Permission modes: strict, standard, permissive
+ */
+
+interface IPermissionRequest {
+    readonly toolName: string;
+    readonly category: ToolCategory;
+    readonly operation: string;
+    readonly resource?: string;
+    readonly command?: string;
+}
+interface IPermissionResult {
+    readonly allowed: boolean;
+    readonly reason?: string;
+    readonly requiresUserApproval: boolean;
+}
+declare class PermissionManager {
+    private mode;
+    private readonly allowedPaths;
+    private readonly blockedCommands;
+    private readonly approvedOperations;
+    constructor(mode: PermissionMode, allowedPaths: readonly string[], blockedCommands: readonly string[]);
+    /**
+     * Check if an operation is permitted.
+     */
+    check(request: IPermissionRequest): IPermissionResult;
+    /**
+     * Record that the user has approved an operation.
+     */
+    approve(request: IPermissionRequest): void;
+    /**
+     * Update permission mode.
+     */
+    setMode(mode: PermissionMode): void;
+    /**
+     * Get current mode.
+     */
+    getMode(): PermissionMode;
+    private checkStandardMode;
+    private checkStrictMode;
+    private isReadOperation;
+    private isDangerousCommand;
+    private getOperationKey;
+}
+
+/**
+ * Agent team task coordination per PRD section 8
+ * Manages task creation, assignment, dependency resolution, and completion tracking.
+ */
+
+declare class TaskOrchestrator {
+    private readonly tasks;
+    /**
+     * Create a new task.
+     */
+    createTask(subject: string, description: string, options?: {
+        owner?: string;
+        model?: string;
+        role?: ModelRole;
+        blockedBy?: string[];
+    }): ITask;
+    /**
+     * Update task status.
+     */
+    updateStatus(taskId: string, status: TaskStatus): void;
+    /**
+     * Assign a task to an agent.
+     */
+    assignTask(taskId: string, owner: string, model?: string): void;
+    /**
+     * Get a task by ID. Throws if not found.
+     */
+    getTask(taskId: string): ITask;
+    /**
+     * Get all tasks.
+     */
+    getAllTasks(): readonly ITask[];
+    /**
+     * Get tasks by status.
+     */
+    getTasksByStatus(status: TaskStatus): readonly ITask[];
+    /**
+     * Get tasks assigned to an agent.
+     */
+    getTasksByOwner(owner: string): readonly ITask[];
+    /**
+     * Get tasks that are ready to be worked on (pending, not blocked).
+     */
+    getAvailableTasks(): readonly ITask[];
+    /**
+     * Check if all tasks are completed.
+     */
+    isAllComplete(): boolean;
+    /**
+     * Get progress summary.
+     */
+    getProgress(): {
+        total: number;
+        completed: number;
+        inProgress: number;
+        pending: number;
+        blocked: number;
+    };
+    /**
+     * Delete a task.
+     */
+    deleteTask(taskId: string): void;
+    /**
+     * When a task completes, check if any blocked tasks can now proceed.
+     */
+    private resolveBlockedTasks;
+}
+
+/**
+ * Unified provider interface per PRD section 7.1
+ * All AI providers implement IModelProvider for consistent access.
+ */
+
+/**
+ * Unified interface for all AI model providers.
+ * Adapters for Claude, OpenAI, Gemini, Kimi, and Ollama all implement this.
+ */
+interface IModelProvider {
+    readonly name: string;
+    readonly supportedModels: readonly string[];
+    /** Send a non-streaming chat request. */
+    chat(request: IChatRequest): Promise<IChatResponse>;
+    /** Send a streaming chat request returning an async iterable of chunks. */
+    stream(request: IChatRequest): AsyncIterable<IStreamChunk>;
+    /** Estimate token count for text using the specified model's tokenizer. */
+    countTokens(text: string, model: string): Promise<number>;
+    /** Retrieve static model metadata. */
+    getModelInfo(model: string): IModelInfo;
+    /** Dynamically fetch available model IDs from the provider API. Optional. */
+    listAvailableModels?(): Promise<readonly string[]>;
+}
+/**
+ * Options for constructing a provider adapter.
+ */
+interface IProviderOptions {
+    readonly apiKey?: string;
+    readonly baseUrl?: string;
+}
+
+/**
+ * Provider registry per PRD section 7.1
+ * Central registry for provider adapters — register, resolve, list.
+ */
+
+/**
+ * Singleton registry that maps provider names and model IDs to provider adapters.
+ */
+declare class ProviderRegistry {
+    private readonly providers;
+    private readonly modelToProvider;
+    /**
+     * Register a provider adapter.
+     * Automatically indexes all supported models to this provider.
+     */
+    register(provider: IModelProvider): void;
+    /**
+     * Get a provider adapter by its name (e.g. "anthropic", "openai").
+     */
+    getByName(name: string): IModelProvider | undefined;
+    /**
+     * Get the provider adapter that supports a given model ID.
+     * @throws ModelNotFoundError if no provider serves this model.
+     */
+    getForModel(modelId: string): IModelProvider;
+    /**
+     * Resolve a model string to its provider.
+     * Supports both model IDs ("claude-sonnet-4-6") and provider-prefixed
+     * forms ("anthropic:claude-sonnet-4-6").
+     */
+    resolve(modelString: string): {
+        provider: IModelProvider;
+        modelId: string;
+    };
+    /**
+     * List all registered model IDs across all providers.
+     */
+    listModels(): readonly IModelInfo[];
+    /**
+     * List all registered provider names.
+     */
+    listProviders(): readonly string[];
+    /**
+     * Check if a model ID is supported by any registered provider.
+     */
+    hasModel(modelId: string): boolean;
+    /**
+     * Check if a provider is registered.
+     */
+    hasProvider(name: string): boolean;
+    /**
+     * List available models from all providers.
+     * Uses dynamic API listing where supported, falls back to static models.
+     */
+    listAllAvailableModels(): Promise<Map<string, readonly string[]>>;
+}
+
+/**
+ * Claude (Anthropic) adapter via Vercel AI SDK per PRD section 7.1
+ * Supports Claude Opus 4.6, Sonnet 4.6, Haiku 4.5
+ */
+
+declare class ClaudeAdapter implements IModelProvider {
+    readonly name: ProviderName;
+    readonly supportedModels: readonly string[];
+    private readonly anthropic;
+    constructor(options?: IProviderOptions);
+    chat(request: IChatRequest): Promise<IChatResponse>;
+    stream(request: IChatRequest): AsyncIterable<IStreamChunk>;
+    countTokens(text: string, _model: string): Promise<number>;
+    getModelInfo(model: string): IModelInfo;
+}
+
+/**
+ * OpenAI adapter via Vercel AI SDK per PRD section 7.1
+ * Supports GPT-5.3 Codex, GPT-5.2, GPT-5.1 Codex series
+ */
+
+declare class OpenAIAdapter implements IModelProvider {
+    readonly name: ProviderName;
+    readonly supportedModels: readonly string[];
+    private readonly openai;
+    private readonly apiKey;
+    private readonly baseUrl;
+    constructor(options?: IProviderOptions);
+    chat(request: IChatRequest): Promise<IChatResponse>;
+    stream(request: IChatRequest): AsyncIterable<IStreamChunk>;
+    countTokens(text: string, _model: string): Promise<number>;
+    getModelInfo(model: string): IModelInfo;
+    listAvailableModels(): Promise<readonly string[]>;
+}
+
+/**
+ * Gemini (Google) adapter via Vercel AI SDK per PRD section 7.1
+ * Supports Gemini 2.5 Pro, Gemini 2.5 Flash
+ */
+
+declare class GeminiAdapter implements IModelProvider {
+    readonly name: ProviderName;
+    readonly supportedModels: readonly string[];
+    private readonly google;
+    constructor(options?: IProviderOptions);
+    chat(request: IChatRequest): Promise<IChatResponse>;
+    stream(request: IChatRequest): AsyncIterable<IStreamChunk>;
+    countTokens(text: string, _model: string): Promise<number>;
+    getModelInfo(model: string): IModelInfo;
+}
+
+/**
+ * Kimi (Moonshot) adapter — custom HTTP per PRD section 7.1
+ * Uses OpenAI-compatible API format via fetch().
+ * Supports Kimi Code (kimi-for-coding)
+ */
+
+declare class KimiAdapter implements IModelProvider {
+    readonly name: ProviderName;
+    readonly supportedModels: readonly string[];
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(options?: IProviderOptions);
+    chat(request: IChatRequest): Promise<IChatResponse>;
+    stream(request: IChatRequest): AsyncIterable<IStreamChunk>;
+    countTokens(text: string, _model: string): Promise<number>;
+    getModelInfo(model: string): IModelInfo;
+    listAvailableModels(): Promise<readonly string[]>;
+    private parseSSEStream;
+}
+
+/**
+ * Ollama adapter — custom HTTP for local models per PRD section 7.1
+ * Uses OpenAI-compatible API format at localhost:11434.
+ * Dynamic model listing from Ollama API.
+ */
+
+declare class OllamaAdapter implements IModelProvider {
+    readonly name: ProviderName;
+    private readonly baseUrl;
+    private cachedModels;
+    constructor(options?: IProviderOptions);
+    get supportedModels(): readonly string[];
+    /**
+     * Refresh available models from Ollama API.
+     * Call once during initialization.
+     */
+    refreshModels(): Promise<readonly string[]>;
+    chat(request: IChatRequest): Promise<IChatResponse>;
+    stream(request: IChatRequest): AsyncIterable<IStreamChunk>;
+    countTokens(text: string, _model: string): Promise<number>;
+    getModelInfo(model: string): IModelInfo;
+    listAvailableModels(): Promise<readonly string[]>;
+    private parseSSEStream;
+}
+
+/**
+ * Native CLI-backed provider adapters.
+ * Uses official provider CLIs in non-interactive mode when credentials come from native login.
+ */
+
+interface ICLIResult {
+    readonly text: string;
+    readonly inputTokens?: number | undefined;
+    readonly outputTokens?: number | undefined;
+    readonly finishReason?: IChatResponse["finishReason"] | undefined;
+}
+declare abstract class BaseNativeCLIAdapter implements IModelProvider {
+    abstract readonly name: ProviderName;
+    abstract readonly supportedModels: readonly string[];
+    protected abstract runCLI(model: string, prompt: string): Promise<ICLIResult>;
+    chat(request: IChatRequest): Promise<IChatResponse>;
+    stream(request: IChatRequest): AsyncIterable<IStreamChunk>;
+    countTokens(text: string, _model: string): Promise<number>;
+    getModelInfo(model: string): IModelInfo;
+    listAvailableModels(): Promise<readonly string[]>;
+}
+declare class ClaudeNativeCLIAdapter extends BaseNativeCLIAdapter {
+    readonly name: ProviderName;
+    readonly supportedModels: readonly ["claude-opus-4-6", "claude-opus-4-6-1m", "claude-sonnet-4-6", "claude-sonnet-4-6-1m", "claude-haiku-4-5"];
+    protected runCLI(model: string, prompt: string): Promise<ICLIResult>;
+}
+declare class CodexNativeCLIAdapter extends BaseNativeCLIAdapter {
+    readonly name: ProviderName;
+    readonly supportedModels: readonly ["gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.2-codex", "gpt-5.1-codex-max", "gpt-5.2", "gpt-5.1-codex-mini"];
+    protected runCLI(model: string, prompt: string): Promise<ICLIResult>;
+}
+declare class GeminiNativeCLIAdapter extends BaseNativeCLIAdapter {
+    readonly name: ProviderName;
+    readonly supportedModels: readonly ["gemini-3-pro-preview", "gemini-3-flash-preview", "gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.5-flash-lite"];
+    protected runCLI(model: string, prompt: string): Promise<ICLIResult>;
+}
+declare class KimiNativeCLIAdapter extends BaseNativeCLIAdapter {
+    readonly name: ProviderName;
+    readonly supportedModels: readonly ["kimi-for-coding"];
+    protected runCLI(_model: string, prompt: string): Promise<ICLIResult>;
+}
+
+/**
+ * Tool Registry — central registry for all built-in and MCP tools.
+ * Per PRD sections 5.1, 14.4
+ */
+
+declare class ToolRegistry implements IToolRegistry {
+    private readonly tools;
+    private readonly categoryIndex;
+    register(tool: IToolRegistration): void;
+    get(name: string): IToolRegistration | undefined;
+    getAll(): readonly IToolRegistration[];
+    getDefinitions(): readonly IToolDefinition[];
+    getByCategory(category: ToolCategory): readonly IToolRegistration[];
+    execute(call: IToolCall, context: IToolExecutionContext): Promise<IToolResult>;
+}
+
+/**
+ * Tools barrel export and default registry factory.
+ * Per PRD section 5.1
+ */
+
+declare function createDefaultRegistry(context: IToolExecutionContext): ToolRegistry;
+
+/**
+ * Credential storage per PRD section 13.6
+ * Primary: OS keychain via node-keytar
+ * Fallback: AES-256-GCM encrypted file
+ */
+
+declare class CredentialStore {
+    private keytarAvailable;
+    /**
+     * Store a credential for a provider.
+     */
+    set(provider: ProviderName, credential: ICredential): Promise<void>;
+    /**
+     * Get a credential for a provider.
+     */
+    get(provider: ProviderName): Promise<ICredential | undefined>;
+    /**
+     * Delete a credential for a provider.
+     */
+    delete(provider: ProviderName): Promise<void>;
+    /**
+     * Check if a credential exists for a provider.
+     */
+    has(provider: ProviderName): Promise<boolean>;
+    private getEncryptionKey;
+    private storeEncrypted;
+    private loadEncrypted;
+    private deleteEncrypted;
+    private encryptFile;
+    private decryptFile;
+    private isKeytarAvailable;
+    private getKeytar;
+}
+
+/**
+ * Multi-provider session lifecycle per PRD section 13.5
+ * Resolution priority: native login (CLI delegation) > API key > env variable > credential helper
+ *
+ * Credentials are obtained by delegating to official CLI tools:
+ *   - Claude Code CLI → macOS Keychain
+ *   - Codex CLI → ~/.codex/auth.json
+ *   - Gemini CLI → ~/.gemini/oauth_creds.json
+ *   - Kimi CLI → ~/.kimi/credentials/kimi-code.json
+ */
+
+declare class SessionManager {
+    private readonly credentialStore;
+    private readonly apiKeyFallback;
+    constructor(store?: CredentialStore);
+    /**
+     * Get the best available credential for a provider.
+     * Follows resolution priority from PRD section 13.5.
+     */
+    getActiveCredential(provider: ProviderName): Promise<ICredential>;
+    /**
+     * Check if a provider has any available credential.
+     */
+    isAuthenticated(provider: ProviderName): Promise<boolean>;
+    /**
+     * Get status info for a provider.
+     */
+    getStatus(provider: ProviderName): Promise<{
+        loggedIn: boolean;
+        method?: AuthMethod | undefined;
+        email?: string | undefined;
+        plan?: string | undefined;
+    }>;
+    /**
+     * Get the API key or token string for a provider.
+     */
+    getToken(provider: ProviderName): Promise<string>;
+    /**
+     * Re-read tokens from the official CLI's cached storage.
+     * This is the "refresh" mechanism — instead of doing HTTP refresh ourselves,
+     * we re-read from the CLI tool's cache which may have been refreshed by the CLI.
+     */
+    private refreshFromCliCache;
+    private loadLoginModule;
+    private isExpired;
+    private getFromEnvironment;
+}
+
+/**
+ * SQLite database store — PRD section 17.1
+ * Uses better-sqlite3 with WAL mode for concurrent reads.
+ * Runs migrations on startup. Provides raw query interface.
+ */
+
+declare class SqliteStore {
+    private db;
+    private closed;
+    get database(): Database.Database;
+    open(dbPath?: string): void;
+    private runMigrations;
+    prepare(sql: string): Database.Statement;
+    run(sql: string, ...params: readonly unknown[]): Database.RunResult;
+    get<T>(sql: string, ...params: readonly unknown[]): T | undefined;
+    all<T>(sql: string, ...params: readonly unknown[]): T[];
+    transaction<T>(fn: () => T): T;
+    close(): void;
+    private registerCleanupHandlers;
+}
+
+/**
+ * Configuration store — PRD sections 17.2, 17.3
+ * Loads/saves global and project config with Zod validation.
+ * Merges project config over global config.
+ * Watches for config file changes.
+ */
+
+type ConfigChangeCallback = (config: IGlobalConfig) => void;
+declare class ConfigStore {
+    private globalConfig;
+    private projectConfig;
+    private mergedConfig;
+    private watchers;
+    private changeCallbacks;
+    get config(): IGlobalConfig;
+    loadGlobal(configPath?: string): IGlobalConfig;
+    loadProject(projectRoot: string): IGlobalConfig;
+    saveGlobal(config?: IGlobalConfig, configPath?: string): void;
+    saveProject(projectRoot: string, config: Partial<IGlobalConfig>): void;
+    watchGlobal(configPath?: string): void;
+    watchProject(projectRoot: string): void;
+    onChange(callback: ConfigChangeCallback): void;
+    stopWatching(): void;
+    private watchConfigFile;
+    private rebuildMergedConfig;
+    private applyDefaults;
+}
+
+/**
+ * Conversation store types — database row types and public interfaces.
+ * Extracted to keep conversation-store.ts under 400 lines.
+ */
+
+interface IConversation {
+    readonly id: string;
+    readonly projectRoot: string;
+    readonly defaultModel: string | null;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly metadata: Record<string, unknown>;
+}
+interface IMessage {
+    readonly id: number;
+    readonly conversationId: string;
+    readonly role: MessageRole;
+    readonly model: string | null;
+    readonly provider: ProviderName | null;
+    readonly content: string;
+    readonly toolCalls: unknown[] | null;
+    readonly tokenUsage: IStoredTokenUsage | null;
+    readonly createdAt: string;
+}
+interface IStoredTokenUsage {
+    readonly input: number;
+    readonly output: number;
+    readonly cost: number;
+}
+interface IFileContext {
+    readonly id: number;
+    readonly conversationId: string;
+    readonly filePath: string;
+    readonly contentHash: string | null;
+    readonly tokenCount: number | null;
+    readonly addedAt: string;
+}
+interface ICostEntry {
+    readonly id: number;
+    readonly conversationId: string;
+    readonly provider: string;
+    readonly model: string;
+    readonly role: string | null;
+    readonly inputTokens: number | null;
+    readonly outputTokens: number | null;
+    readonly costUsd: number | null;
+    readonly createdAt: string;
+}
+interface IPaginationOptions {
+    readonly limit: number;
+    readonly offset: number;
+}
+interface IAddMessageParams {
+    readonly conversationId: string;
+    readonly role: MessageRole;
+    readonly content: string;
+    readonly model?: string;
+    readonly provider?: ProviderName;
+    readonly toolCalls?: unknown[];
+    readonly tokenUsage?: IStoredTokenUsage;
+}
+interface IAddCostParams {
+    readonly conversationId: string;
+    readonly provider: string;
+    readonly model: string;
+    readonly role?: string;
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly costUsd?: number;
+}
+interface IAddFileContextParams {
+    readonly conversationId: string;
+    readonly filePath: string;
+    readonly contentHash?: string;
+    readonly tokenCount?: number;
+}
+
+/**
+ * Conversation store — PRD section 17.1
+ * CRUD for conversations, messages, file context, and cost tracking.
+ * All queries use parameterized prepared statements.
+ */
+
+declare class ConversationStore {
+    private readonly store;
+    constructor(store: SqliteStore);
+    createConversation(projectRoot: string, defaultModel?: string, metadata?: Record<string, unknown>): IConversation;
+    getConversation(id: string): IConversation | undefined;
+    listConversations(projectRoot?: string): IConversation[];
+    deleteConversation(id: string): void;
+    addMessage(params: IAddMessageParams): IMessage;
+    getMessages(conversationId: string, pagination?: IPaginationOptions): IMessage[];
+    getMessageCount(conversationId: string): number;
+    addFileContext(params: IAddFileContextParams): IFileContext;
+    getFileContext(conversationId: string): IFileContext[];
+    removeFileContext(conversationId: string, filePath: string): void;
+    addCost(params: IAddCostParams): ICostEntry;
+    getConversationCost(conversationId: string): number;
+    getCostBreakdown(conversationId: string): ICostEntry[];
+    private mapConversationRow;
+    private mapMessageRow;
+    private mapFileContextRow;
+    private mapCostRow;
+}
+
+/**
+ * Inter-agent message routing per PRD section 8.4
+ * Supports: DM, broadcast, shutdown, plan approval, task updates.
+ * Message queue for busy agents with automatic drain on idle transition.
+ */
+
+/** Handler function invoked when an agent receives a message. */
+type MessageHandler$1 = (message: IAgentMessage) => void;
+/**
+ * Optional transport layer for remote message delivery (e.g., IPC hub).
+ * Implement this interface to bridge the message bus to Unix domain sockets.
+ */
+interface IMessageTransport {
+    send(agentId: string, message: IAgentMessage): Promise<boolean>;
+    onReceive(handler: (message: IAgentMessage) => void): () => void;
+}
+/** Options for constructing a MessageBus. */
+interface IMessageBusOptions {
+    readonly transport?: IMessageTransport;
+}
+declare class MessageBus {
+    private readonly handlers;
+    private readonly queues;
+    private readonly statuses;
+    private readonly transport;
+    private readonly transportUnsubscribe;
+    private destroyed;
+    constructor(options?: IMessageBusOptions);
+    /** Register an agent as available for message delivery. */
+    registerAgent(agentId: string): void;
+    /** Remove an agent from the bus. Pending messages are discarded. */
+    unregisterAgent(agentId: string): void;
+    /** Subscribe to messages delivered to an agent. Returns unsubscribe function. */
+    subscribe(agentId: string, handler: MessageHandler$1): () => void;
+    /** Route a message to its recipient(s). Returns true if delivered or queued. */
+    send(message: IAgentMessage): boolean;
+    /** Create a well-formed message and send it. Returns the created message. */
+    createAndSend(type: AgentMessageType, senderId: string, recipientId: string | undefined, content: string, extra?: {
+        summary?: string;
+        requestId?: string;
+        approve?: boolean;
+    }): IAgentMessage;
+    /** Update an agent's status. Drains the queue when transitioning to idle. */
+    setAgentStatus(agentId: string, status: AgentStatus): void;
+    /** Get the number of queued messages for an agent. */
+    getQueueSize(agentId: string): number;
+    /** Get all registered agent IDs. */
+    getRegisteredAgents(): readonly string[];
+    /** Tear down the message bus and release resources. */
+    destroy(): void;
+    private broadcastToAll;
+    private deliverToAgent;
+    private invokeHandlers;
+    private enqueue;
+    private drainQueue;
+    private routeIncoming;
+}
+
+/**
+ * File-based task persistence per PRD section 20.2
+ * Atomic writes for crash recovery: write to temp file, then rename.
+ * Store at getTasksDir()/teamName/taskId.json
+ */
+
+declare class TaskStore {
+    private readonly storeDir;
+    constructor(teamName: string);
+    /** Persist a task to disk with atomic write (temp + rename). */
+    save(task: ITask): void;
+    /** Load a single task by ID. Throws if not found. */
+    load(taskId: string): ITask;
+    /** Load all tasks for this team, sorted by creation time. */
+    loadAll(): ITask[];
+    /** Remove a task file from disk. Returns true if deleted. */
+    remove(taskId: string): boolean;
+    /** Check whether a task file exists on disk. */
+    exists(taskId: string): boolean;
+    /** Absolute path to this team's task store directory. */
+    getStorePath(): string;
+    private getTaskFilePath;
+    /** Remove orphaned .tmp files left from interrupted writes. */
+    private cleanupTempFiles;
+    private static serialize;
+    private static deserialize;
+}
+
+/**
+ * Plan approval workflow per PRD section 8.2 step 5
+ * Agent submits plan → Leader reviews → Approve or reject.
+ * Uses message bus for transport; includes configurable timeout.
+ */
+
+/** Result of a plan approval request. */
+interface IPlanApprovalResult {
+    readonly approved: boolean;
+    readonly feedback?: string | undefined;
+    readonly requestId: string;
+    readonly respondedBy: string;
+    readonly respondedAt: Date;
+}
+/** A pending plan awaiting leader review (for listing). */
+interface IPendingPlan {
+    readonly requestId: string;
+    readonly agentId: string;
+    readonly plan: string;
+    readonly submittedAt: Date;
+}
+/** Options for the PlanApproval workflow. */
+interface IPlanApprovalOptions {
+    readonly leaderId?: string;
+    readonly timeoutMs?: number;
+}
+declare class PlanApproval {
+    private readonly messageBus;
+    private readonly leaderId;
+    private readonly timeoutMs;
+    private readonly pending;
+    private destroyed;
+    constructor(messageBus: MessageBus, options?: IPlanApprovalOptions);
+    /**
+     * Submit a plan for approval. Returns a promise that resolves
+     * when the leader approves or rejects, or rejects on timeout.
+     */
+    submitPlan(agentId: string, plan: string): Promise<IPlanApprovalResult>;
+    /** Leader approves a pending plan. Returns false if no matching request. */
+    approvePlan(requestId: string, responderId: string): boolean;
+    /** Leader rejects a pending plan with feedback. */
+    rejectPlan(requestId: string, responderId: string, feedback: string): boolean;
+    /**
+     * Handle an incoming plan_approval_response message.
+     * Call this from a message bus subscription to close the request loop.
+     */
+    handleResponse(message: IAgentMessage): void;
+    /** Cancel a pending plan request. */
+    cancelPlan(requestId: string): boolean;
+    /** Get all pending plan requests (for leader UI). */
+    getPendingPlans(): readonly IPendingPlan[];
+    /** Get the count of pending plans. */
+    getPendingCount(): number;
+    /** Tear down: cancel all pending plans and release resources. */
+    destroy(): void;
+}
+
+/**
+ * Team creation and lifecycle management per PRD section 8.2
+ * Orchestrates agents, tasks, messaging, and plan approval for a team.
+ */
+
+/** Agent definition used when creating a team. */
+interface IAgentDefinition {
+    readonly name: string;
+    readonly agentType: string;
+    readonly model: string;
+    readonly provider: ProviderName;
+    readonly role: ModelRole;
+}
+/** Options for createTeam(). */
+interface ITeamCreateOptions {
+    readonly description?: string;
+    readonly agents: readonly IAgentDefinition[];
+    readonly sessionId?: string;
+    readonly cliEntryPoint?: string;
+}
+declare class TeamManager {
+    private readonly activeTeams;
+    /** Create a new team: config, directories, and agent process handles. */
+    createTeam(name: string, options: ITeamCreateOptions): Promise<ITeamConfig>;
+    /** Start all agent processes for a team. */
+    startAgents(teamName: string): Promise<void>;
+    /** Gracefully shutdown and remove a team. */
+    deleteTeam(name: string): Promise<void>;
+    /** List all teams from disk (active and inactive). */
+    listTeams(): ITeamConfig[];
+    /** Load a team config from disk. Throws if not found. */
+    getTeam(name: string): ITeamConfig;
+    /** Get the runtime state of a specific agent within an active team. */
+    getAgentState(teamName: string, agentName: string): IAgentState | undefined;
+    /** Get all agent states for an active team. */
+    getAgentStates(teamName: string): readonly IAgentState[];
+    /** Get the message bus for an active team. */
+    getMessageBus(teamName: string): MessageBus | undefined;
+    /** Get the task store for an active team. */
+    getTaskStore(teamName: string): TaskStore | undefined;
+    /** Get the plan approval handler for an active team. */
+    getPlanApproval(teamName: string): PlanApproval | undefined;
+    /** Register a callback for IPC messages from all agents in a team. Returns cleanup function. */
+    onAgentMessages(teamName: string, callback: (agentName: string, method: string, params: Record<string, unknown>) => void): () => void;
+    /** Assign a task to a specific agent via IPC. */
+    assignTask(teamName: string, agentName: string, taskId: string, subject: string, description: string): void;
+    /** Check whether a team is currently active in memory. */
+    isTeamActive(name: string): boolean;
+    /** Shut down all active teams. Call during application cleanup. */
+    shutdownAll(): Promise<void>;
+    private getActiveTeam;
+    private saveTeamConfig;
+    private loadTeamConfig;
+    private shutdownAgents;
+}
+
+/**
+ * Agent subprocess management per PRD sections 8.1, 9.4
+ * Each agent runs as a separate Node.js process (fork of aemeathcli).
+ * Parent–child IPC uses JSON-RPC 2.0 protocol (IIPCMessage).
+ */
+
+/** Configuration for spawning an agent process. */
+interface IAgentProcessOptions {
+    readonly teamName: string;
+    readonly sessionId: string;
+    readonly cliEntryPoint?: string | undefined;
+    readonly env?: Readonly<Record<string, string>>;
+    readonly shutdownTimeoutMs?: number;
+    readonly registrationTimeoutMs?: number;
+}
+/** Callback for IPC messages received from the child process. */
+type AgentMessageCallback = (method: string, params: Record<string, unknown>) => void;
+declare class AgentProcess {
+    private readonly config;
+    private readonly teamName;
+    private readonly sessionId;
+    private readonly cliEntryPoint;
+    private readonly customEnv;
+    private readonly shutdownTimeoutMs;
+    private readonly registrationTimeoutMs;
+    private readonly messageCallbacks;
+    private child;
+    private status;
+    private currentTaskId;
+    private nextMessageId;
+    constructor(config: IAgentConfig, options: IAgentProcessOptions);
+    /** Spawn the child process. Throws AgentSpawnError on failure. */
+    start(): Promise<void>;
+    /** Gracefully stop the agent. Falls back to SIGTERM after timeout. */
+    stop(): Promise<void>;
+    /** Kill and restart the agent process. */
+    restart(): Promise<void>;
+    /** Send a JSON-RPC 2.0 message to the child process. Returns message ID. */
+    sendIPC(method: IPCMethod, params: Record<string, unknown>): number;
+    /** Assign a task to this agent via IPC. */
+    assignTask(taskId: string, subject: string, description: string): number;
+    /** Register a callback for IPC messages from the child process. */
+    onMessage(callback: AgentMessageCallback): () => void;
+    /** Get the current agent state snapshot. */
+    getState(): IAgentState;
+    /** Get the current status. */
+    getStatus(): AgentStatus;
+    /** Get the child process PID, or undefined if not running. */
+    getPid(): number | undefined;
+    /** Check if the child process is alive. */
+    isAlive(): boolean;
+    private setupChildListeners;
+    private handleChildMessage;
+    /** Wait for the child to send agent.register. Rejects on timeout or early exit. */
+    private waitForRegistration;
+    private setStatus;
+    private notifyCallbacks;
+    private cleanup;
+}
+
+/**
+ * Layout engine for split-panel auto-layout computation per PRD section 9.2.
+ * Computes pane positions based on agent count and terminal dimensions.
+ */
+
+interface IPaneGeometry {
+    readonly paneId: string;
+    readonly row: number;
+    readonly col: number;
+    readonly widthPercent: number;
+    readonly heightPercent: number;
+    readonly splitDirection: "horizontal" | "vertical" | "none";
+}
+interface IComputedLayout {
+    readonly panes: readonly IPaneGeometry[];
+    readonly rows: number;
+    readonly cols: number;
+    readonly terminalWidth: number;
+    readonly terminalHeight: number;
+}
+interface ITerminalSize {
+    readonly columns: number;
+    readonly rows: number;
+}
+declare class LayoutEngine {
+    private readonly terminalSize;
+    constructor(terminalSize?: Partial<ITerminalSize>);
+    /**
+     * Compute the full layout for a set of pane configs.
+     */
+    computeLayout(config: ILayoutConfig): IComputedLayout;
+    /**
+     * Determine the best auto-layout for a given pane count (PRD section 9.2).
+     */
+    resolveAutoLayout(paneCount: number): Exclude<PaneLayout, "auto">;
+    /**
+     * Get the maximum number of panes the terminal can support.
+     */
+    getMaxPanes(): number;
+    /**
+     * Check if the terminal is large enough for the requested pane count.
+     */
+    canFitPanes(paneCount: number): boolean;
+    /**
+     * Get the grid dimensions for a given pane count and layout type.
+     */
+    private getGridDimensions;
+    /**
+     * Compute grid rows and columns for a given pane count.
+     * PRD section 9.2:
+     *   2 agents → horizontal split (50/50) → 1x2
+     *   3 agents → 1 top + 2 bottom → 2 rows
+     *   4 agents → 2x2 grid
+     *   5+ agents → leader top + grid bottom
+     */
+    private computeGridSize;
+    /**
+     * Compute per-pane geometries based on layout type.
+     */
+    private computeGeometries;
+    /**
+     * Horizontal split: all panes side by side.
+     */
+    private computeHorizontalLayout;
+    /**
+     * Vertical split: all panes stacked.
+     */
+    private computeVerticalLayout;
+    /**
+     * Grid layout per PRD section 9.2 rules:
+     *   3 agents → leader spans top, 2 on bottom
+     *   4 agents → 2x2 even grid
+     *   5+ agents → leader spans top, rest in grid below
+     */
+    private computeGridLayout;
+    /**
+     * Determine split direction based on position in grid.
+     */
+    private determineSplitDirection;
+    /**
+     * Detect terminal width from environment.
+     */
+    private detectTerminalWidth;
+    /**
+     * Detect terminal height from environment.
+     */
+    private detectTerminalHeight;
+}
+
+/**
+ * TmuxManager — Programmatic tmux control per PRD section 9.2.
+ * Creates sessions, splits panes, sends commands, manages lifecycle.
+ */
+
+interface ITmuxPaneInfo {
+    readonly paneId: string;
+    readonly tmuxPaneId: string;
+    readonly agentName: string;
+    readonly title: string;
+}
+interface ITmuxManagerOptions {
+    readonly sessionPrefix?: string;
+}
+declare class TmuxManager {
+    private readonly sessionPrefix;
+    private readonly layoutEngine;
+    private readonly panes;
+    private sessionName;
+    private disposed;
+    constructor(options?: ITmuxManagerOptions);
+    /**
+     * Check if tmux is available on this system.
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Create a new tmux session for a team.
+     */
+    createSession(teamName: string): Promise<string>;
+    /**
+     * Create split panes based on a layout configuration.
+     */
+    createPanes(layoutConfig: ILayoutConfig): Promise<IComputedLayout>;
+    /**
+     * Send a command string to a specific pane.
+     */
+    sendCommand(paneId: string, command: string): Promise<void>;
+    /**
+     * Resize a pane by tmux pane target.
+     */
+    resizePane(paneId: string, dimensions: {
+        width?: number;
+        height?: number;
+    }): Promise<void>;
+    /**
+     * Set the title for a tmux pane.
+     */
+    private setPaneTitle;
+    /**
+     * Kill a specific pane.
+     */
+    killPane(paneId: string): Promise<void>;
+    /**
+     * Attach to the tmux session (gives control to the user).
+     */
+    attachSession(): Promise<void>;
+    /**
+     * Check if the session still exists.
+     */
+    isSessionAlive(): Promise<boolean>;
+    /**
+     * Destroy the entire tmux session and all panes.
+     */
+    destroy(): Promise<void>;
+    /**
+     * Get the current session name.
+     */
+    getSessionName(): string | undefined;
+    /**
+     * Get all tracked pane info.
+     */
+    getPanes(): ReadonlyMap<string, ITmuxPaneInfo>;
+    private splitPane;
+    private getFirstPaneId;
+    private equalizeLayout;
+    private killSessionSilent;
+    private assertNotDisposed;
+    private assertSession;
+}
+
+/**
+ * iTerm2Manager — macOS iTerm2 Python API bridge per PRD section 9.3.
+ * Splits sessions into panes, sets profiles, sends commands.
+ * Graceful fallback if iTerm2 is not available.
+ */
+
+interface IITerm2PaneInfo {
+    readonly paneId: string;
+    readonly sessionId: string;
+    readonly agentName: string;
+    readonly title: string;
+}
+declare class ITerm2Manager {
+    private readonly panes;
+    private disposed;
+    /**
+     * Check if currently running inside iTerm2 on macOS.
+     */
+    isAvailable(): boolean;
+    /**
+     * Check if the iTerm2 Python API is accessible.
+     */
+    isPythonAPIAvailable(): Promise<boolean>;
+    /**
+     * Create panes in the current iTerm2 window based on layout config.
+     */
+    createPanes(layoutConfig: ILayoutConfig): Promise<void>;
+    /**
+     * Send a command to a specific pane via iTerm2 Python API.
+     */
+    sendCommand(paneId: string, command: string): Promise<void>;
+    /**
+     * Set the profile (colors) for a pane based on agent role.
+     */
+    setProfile(paneId: string, role: string): Promise<void>;
+    /**
+     * Destroy all managed iTerm2 panes.
+     */
+    destroy(): Promise<void>;
+    /**
+     * Get all tracked pane info.
+     */
+    getPanes(): ReadonlyMap<string, IITerm2PaneInfo>;
+    /**
+     * Register a pane that was created externally.
+     */
+    registerPane(info: IITerm2PaneInfo): void;
+    private buildCreatePanesScript;
+    private buildSplitCommands;
+    private shouldSplitVertically;
+    private buildSendCommandScript;
+    private buildSetProfileScript;
+    private buildCloseSessionScript;
+    private executePythonScript;
+    private assertNotDisposed;
+}
+
+/**
+ * IPCHub — Unix domain socket server for inter-agent communication.
+ * JSON-RPC 2.0 protocol with HMAC authentication per PRD section 9.4 & 14.5.
+ */
+
+type MethodHandler = (clientId: string, params: Record<string, unknown>, id: number | undefined, socket: Socket) => Promise<unknown>;
+declare class IPCHub {
+    private readonly sessionId;
+    private readonly hmacSecret;
+    private readonly socketPath;
+    private readonly clients;
+    private readonly handlers;
+    private server;
+    private disposed;
+    constructor(sessionId: string);
+    getHmacSecret(): string;
+    getSocketPath(): string;
+    getClientCount(): number;
+    getConnectedAgentIds(): readonly string[];
+    /** Start the Unix domain socket server. */
+    start(): Promise<void>;
+    /** Send a message to a specific registered client. */
+    sendToClient(agentId: string, message: IIPCMessage): void;
+    /** Broadcast a message to all connected clients. */
+    broadcast(message: IIPCMessage, excludeId?: string): void;
+    /** Register a custom method handler. */
+    onMethod(method: string, handler: MethodHandler): void;
+    /** Compute HMAC-SHA256 for a message. */
+    computeHmac(message: IIPCMessage): string;
+    /** Register a connected socket as a client (also called by agent.register). */
+    registerClientSocket(agentId: string, agentName: string, socket: Socket): void;
+    /** Gracefully shut down the hub and all connections. */
+    destroy(): Promise<void>;
+    private handleConnection;
+    private processRaw;
+    private registerDefaultHandlers;
+    private verifyHmac;
+    private isAuthEnvelope;
+    private write;
+    private sendResult;
+    private sendError;
+    private removeStaleSocket;
+    private setupProcessCleanup;
+    private assertAlive;
+}
+
+/**
+ * PaneProcess — IPC client connecting to the IPCHub from an agent process.
+ * JSON-RPC 2.0 with HMAC auth, reconnection, and heartbeat per PRD 9.4 & 20.2.
+ */
+
+interface IPaneProcessOptions {
+    readonly agentId: string;
+    readonly agentName: string;
+    readonly socketPath: string;
+    readonly hmacSecret: string;
+    readonly heartbeatIntervalMs?: number;
+    readonly reconnectMaxRetries?: number;
+}
+type MessageHandler = (message: IIPCMessage) => void;
+declare class PaneProcess {
+    private readonly agentId;
+    private readonly agentName;
+    private readonly socketPath;
+    private readonly hmacSecret;
+    private readonly heartbeatMs;
+    private readonly maxRetries;
+    private readonly msgHandlers;
+    private readonly pending;
+    private socket;
+    private heartbeatTimer;
+    private nextId;
+    private connected;
+    private disposed;
+    constructor(options: IPaneProcessOptions);
+    /** Connect to the IPC hub and register this agent. */
+    connect(): Promise<void>;
+    /** Send a JSON-RPC 2.0 request and wait for response. */
+    request(method: IPCMethod, params: Record<string, unknown>): Promise<unknown>;
+    /** Send a notification (no response expected). */
+    notify(method: IPCMethod, params: Record<string, unknown>): void;
+    /** Convenience: send a stream chunk. */
+    sendStreamChunk(content: string, model: string, taskId?: string): void;
+    /** Convenience: send a task status update. */
+    sendTaskUpdate(taskId: string, status: string): void;
+    /** Convenience: send a message to another agent via the hub. */
+    sendMessage(to: string, content: string): Promise<unknown>;
+    /** Register a handler for incoming messages of a specific method. */
+    onMessage(method: string, handler: MessageHandler): () => void;
+    isConnected(): boolean;
+    /** Gracefully disconnect from the hub. */
+    disconnect(): Promise<void>;
+    private establish;
+    private connectSocket;
+    private attemptReconnect;
+    private register;
+    private handleIncoming;
+    private resolveResponse;
+    private dispatch;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private sendAuthenticated;
+    private isResponse;
+    private isMessage;
+    private rejectAll;
+    private assertAlive;
+    private assertConnected;
+}
+
+/**
+ * SkillLoader — Parses YAML frontmatter + Markdown body from SKILL.md files.
+ * Per PRD section 10.2-10.3: YAML skill file format with Zod validation.
+ */
+
+declare class SkillLoader {
+    /**
+     * Parse a single SKILL.md file into an ISkillDefinition.
+     * Returns null if the file is malformed or invalid.
+     */
+    loadSkillFile(filePath: string): Promise<ISkillDefinition | null>;
+    /**
+     * Parse raw SKILL.md content string into an ISkillDefinition.
+     */
+    parseSkillContent(raw: string, filePath: string): ISkillDefinition | null;
+    /**
+     * Extract only name and description for progressive loading (~100 tokens).
+     */
+    loadSkillSummary(filePath: string): Promise<{
+        name: string;
+        description: string;
+    } | null>;
+    /**
+     * Split raw content into YAML frontmatter and Markdown body.
+     * Frontmatter is delimited by `---` at the start and a subsequent `---`.
+     */
+    private extractFrontmatter;
+}
+
+/**
+ * SkillRegistry — Discovers, indexes, and resolves skill definitions.
+ * Resolution priority: project > user > built-in (PRD section 10.4).
+ * Progressive loading: only name + description loaded initially (~100 tokens each).
+ */
+
+type SkillSource = "project" | "user" | "built-in";
+interface ISkillSummary {
+    readonly name: string;
+    readonly description: string;
+    readonly version: string;
+    readonly source: SkillSource;
+    readonly dirPath: string;
+}
+declare class SkillRegistry {
+    private readonly loader;
+    private readonly skills;
+    private readonly triggerIndex;
+    private initialized;
+    constructor(loader?: SkillLoader);
+    /**
+     * Initialize the registry by scanning all skill directories.
+     * Loads in priority order so higher-priority sources override lower ones.
+     */
+    initialize(projectRoot?: string): Promise<void>;
+    /**
+     * Get a full skill definition by name. Loads content on demand.
+     */
+    getByName(name: string): Promise<ISkillDefinition | null>;
+    /**
+     * Find a skill by trigger string (e.g. "$review" or "review").
+     */
+    getByTrigger(trigger: string): Promise<ISkillDefinition | null>;
+    /**
+     * Resolve a trigger string to a skill name without loading the full definition.
+     */
+    resolveTriger(trigger: string): string | undefined;
+    /**
+     * List all registered skill summaries.
+     */
+    listAll(): readonly ISkillSummary[];
+    /**
+     * Check if a skill exists by name.
+     */
+    has(name: string): boolean;
+    /**
+     * Get the count of registered skills.
+     */
+    get size(): number;
+    /**
+     * Reset the registry for re-initialization.
+     */
+    reset(): void;
+    /**
+     * Scan a directory for skill subdirectories containing SKILL.md.
+     */
+    private scanDirectory;
+    /**
+     * Register a single skill from its SKILL.md file path.
+     */
+    private registerSkillFromFile;
+    /**
+     * Index all triggers for a skill definition.
+     */
+    private registerTriggers;
+    /**
+     * Remove all trigger mappings associated with a skill name.
+     */
+    private removeTriggers;
+    /**
+     * Resolve the built-in skills directory relative to this module.
+     */
+    private getBuiltInSkillsDir;
+}
+
+/**
+ * SkillExecutor — Manages skill activation, context injection, and tool restriction.
+ * Per PRD section 10.3: Load full SKILL.md content into context on activation,
+ * restrict tools, and unload on deactivation.
+ */
+
+interface IActiveSkill {
+    readonly definition: ISkillDefinition;
+    readonly activatedAt: Date;
+    readonly previousAllowedTools: readonly string[] | null;
+}
+interface ISkillActivationResult {
+    readonly success: boolean;
+    readonly skill?: ISkillDefinition;
+    readonly errorMessage?: string;
+    readonly warnings?: readonly string[];
+}
+interface IModelCapabilities {
+    readonly contextWindow: number;
+    readonly currentRole?: ModelRole;
+}
+declare class SkillExecutor {
+    private readonly registry;
+    private activeSkill;
+    private baseAllowedTools;
+    constructor(registry: SkillRegistry);
+    /**
+     * Activate a skill by name.
+     */
+    activateByName(name: string, modelCapabilities?: IModelCapabilities): Promise<ISkillActivationResult>;
+    /**
+     * Activate a skill by trigger string (e.g. "$review" or "review").
+     */
+    activateByTrigger(trigger: string, modelCapabilities?: IModelCapabilities): Promise<ISkillActivationResult>;
+    /**
+     * Deactivate the currently active skill, restoring previous tool set.
+     */
+    deactivate(): void;
+    /**
+     * Get the currently active skill, or null if none.
+     */
+    getActiveSkill(): IActiveSkill | null;
+    /**
+     * Check if any skill is currently active.
+     */
+    isActive(): boolean;
+    /**
+     * Get the active skill's body content for context injection.
+     * Returns null if no skill is active.
+     */
+    getActiveSkillContent(): string | null;
+    /**
+     * Get the name of the currently active skill, or null.
+     */
+    getActiveSkillName(): string | null;
+    /**
+     * Get the allowed tool list under the current state.
+     * When a skill is active with allowed-tools, only those tools are permitted.
+     * Returns null when no restrictions are in effect.
+     */
+    getAllowedTools(): readonly string[] | null;
+    /**
+     * Check if a specific tool is allowed under the current skill restrictions.
+     */
+    isToolAllowed(toolName: string): boolean;
+    /**
+     * Set the base allowed tools (used when no skill is active).
+     */
+    setBaseAllowedTools(tools: readonly string[] | null): void;
+    /**
+     * Validate model requirements for a skill definition.
+     * Returns compatibility status and any warnings.
+     */
+    checkModelRequirements(definition: ISkillDefinition, capabilities: IModelCapabilities): {
+        compatible: boolean;
+        warnings: readonly string[];
+    };
+    /**
+     * Core activation logic. Deactivates any current skill first.
+     */
+    private activate;
+}
+
+/**
+ * MCP client per PRD section 11.1
+ * Wraps @modelcontextprotocol/sdk Client with typed, transport-agnostic interface.
+ * Supports stdio (local servers) and Streamable HTTP (remote servers).
+ */
+interface IMCPToolSchema {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: Readonly<Record<string, unknown>>;
+}
+interface IMCPCallResult {
+    readonly content: string;
+    readonly isError: boolean;
+}
+interface IMCPResource {
+    readonly uri: string;
+    readonly name: string;
+    readonly description: string;
+    readonly mimeType: string;
+}
+interface IStdioTransportConfig {
+    readonly type: "stdio";
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly env?: Readonly<Record<string, string>>;
+}
+interface IHttpTransportConfig {
+    readonly type: "streamable-http";
+    readonly url: string;
+}
+type MCPTransportConfig = IStdioTransportConfig | IHttpTransportConfig;
+interface IMCPClientOptions {
+    readonly serverName: string;
+    readonly transport: MCPTransportConfig;
+    readonly connectionTimeoutMs?: number;
+}
+declare class MCPClient {
+    private client;
+    private connected;
+    private readonly serverName;
+    private readonly transportConfig;
+    private readonly connectionTimeoutMs;
+    constructor(options: IMCPClientOptions);
+    get isConnected(): boolean;
+    get name(): string;
+    /** Establish connection to the MCP server. */
+    connect(): Promise<void>;
+    /** Gracefully close the MCP connection. */
+    disconnect(): Promise<void>;
+    /** Disconnect then reconnect to the server. */
+    reconnect(): Promise<void>;
+    /** List all tools exposed by this MCP server. */
+    listTools(): Promise<readonly IMCPToolSchema[]>;
+    /** Call a tool on this MCP server with the given arguments. */
+    callTool(toolName: string, args: Record<string, unknown>): Promise<IMCPCallResult>;
+    /** List resources exposed by this MCP server. */
+    listResources(): Promise<readonly IMCPResource[]>;
+    /** Read a specific resource by URI. */
+    readResource(uri: string): Promise<string>;
+    private connectWithTimeout;
+    private requireConnected;
+}
+
+/**
+ * MCP server lifecycle manager per PRD section 11.1
+ * Manages multiple MCP server connections: start, stop, health-check, restart, rate-limit.
+ */
+
+type ServerStatus = "stopped" | "connecting" | "connected" | "error";
+interface IRateLimitConfig {
+    readonly maxCallsPerMinute: number;
+}
+interface IServerManagerOptions {
+    readonly connectionTimeoutMs?: number;
+    readonly healthCheckIntervalMs?: number;
+    readonly maxConsecutiveFailures?: number;
+    readonly defaultRateLimit?: IRateLimitConfig | undefined;
+    readonly rateLimits?: Readonly<Record<string, IRateLimitConfig>> | undefined;
+}
+declare class MCPServerManager {
+    private readonly servers;
+    private readonly options;
+    private healthCheckTimer;
+    constructor(options?: IServerManagerOptions);
+    /** Start all servers defined in the MCP config. */
+    startAll(config: IMCPConfig): Promise<void>;
+    /** Start a single MCP server by name and config. */
+    startServer(name: string, serverConfig: IMCPServerConfig): Promise<void>;
+    /** Stop a single server by name. */
+    stopServer(name: string): Promise<void>;
+    /** Stop all managed servers and clean up. */
+    stopAll(): Promise<void>;
+    /** Get a connected client by server name. */
+    getClient(name: string): MCPClient | undefined;
+    /** Get all connected server names. */
+    getConnectedServers(): readonly string[];
+    /** Get the status of a server. */
+    getServerStatus(name: string): ServerStatus | undefined;
+    /** List tools from a specific server (with rate-limit check). */
+    listServerTools(name: string): Promise<readonly IMCPToolSchema[]>;
+    /** Check rate limit before allowing a call to the given server. Throws on exceeded. */
+    checkRateLimitFor(name: string): void;
+    /** Record a tool call for rate-limiting purposes. */
+    recordCall(name: string): void;
+    private startHealthChecks;
+    private stopHealthChecks;
+    private runHealthChecks;
+    private restartServer;
+    private checkRateLimit;
+    private getMaxCallsPerMinute;
+    private requireServer;
+}
+
+/**
+ * MCP tool bridge per PRD section 11.3
+ * Converts MCP tool schemas to AemeathCLI IToolDefinition format and back.
+ * Registers MCP tools into the unified tool registry with lazy loading.
+ * Tool namespacing: mcp__{serverName}__{toolName}
+ */
+
+declare class MCPToolBridge {
+    private readonly serverManager;
+    private readonly toolCache;
+    constructor(serverManager: MCPServerManager);
+    /**
+     * Discover tools from all connected MCP servers and register them.
+     * Uses lazy loading: definitions are fetched and cached on first request.
+     */
+    registerAll(registry: IToolRegistry): Promise<number>;
+    /**
+     * Register tools from a single MCP server.
+     * Fetches tool schemas and caches definitions.
+     */
+    registerServerTools(serverName: string, registry: IToolRegistry): Promise<number>;
+    /**
+     * Lazy-load tool definitions for a server.
+     * Returns cached definitions if already loaded.
+     */
+    loadToolDefinitions(serverName: string): Promise<readonly IToolDefinition[]>;
+    /**
+     * Execute an MCP tool call: validate, convert, call, return result.
+     */
+    executeTool(call: IToolCall): Promise<IToolResult>;
+    /** Invalidate cached tool definitions for a server (e.g. after config reload). */
+    invalidateCache(serverName?: string): void;
+    /** Check whether a tool name is an MCP-namespaced tool. */
+    isMCPTool(toolName: string): boolean;
+    /** Get all cached tool definitions across all servers. */
+    getAllDefinitions(): readonly IToolDefinition[];
+    private createRegistration;
+}
+
+export { AemeathError, type AgentMessageType, AgentProcess, AgentSpawnError, AuthenticationError, ClaudeAdapter, ClaudeNativeCLIAdapter, CodexNativeCLIAdapter, ConfigStore, ContextManager, ContextOverflowError, ConversationStore, CostTracker, CredentialStore, DEFAULT_CONFIG, DEFAULT_MODEL_ID, ExecutionTimeoutError, FileNotFoundError, GeminiAdapter, GeminiNativeCLIAdapter, type IAgentConfig, type IAgentMessage, type IAgentState, type IChatMessage, type IChatRequest, type IChatResponse, type ICredential, type IGlobalConfig, type ILayoutConfig, type IMCPConfig, type IModelInfo, type IModelProvider, type IModelResolution, IPCError, IPCHub, type IPaneConfig, type IProviderOptions, type IRoleConfig, type ISkillDefinition, type IStreamChunk, type ITask, type ITeamConfig, ITerm2Manager, type ITokenUsage, type IToolCall, type IToolDefinition, type IToolExecutionContext, type IToolParameter, type IToolRegistration, type IToolRegistry, type IToolResult, InvalidConfigError, KimiAdapter, KimiNativeCLIAdapter, LayoutEngine, MCPClient, MCPServerManager, MCPToolBridge, MessageBus, type MessageRole, MissingConfigError, ModelNotFoundError, type ModelRole, ModelRouter, OllamaAdapter, OpenAIAdapter, type PaneLayout, PaneProcess, PermissionDeniedError, PermissionManager, type PermissionMode, PlanApproval, type ProviderName, ProviderRegistry, RateLimitError, SUPPORTED_MODELS, ServerConnectionError, SessionManager, SkillExecutor, SkillLoader, SkillRegistry, SqliteStore, TaskOrchestrator, type TaskStatus, TaskStore, TeamManager, TmuxManager, ToolCallError, type ToolCategory, ToolRegistry, createDefaultRegistry, createModelRouter, getEventBus };