@deimoscloud/coreai 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2978 @@
+/**
+ * CoreAI Configuration Types
+ *
+ * TypeScript types corresponding to the JSON schema at schemas/coreai.config.schema.json
+ */
+type ProjectType = 'software' | 'infrastructure' | 'data' | 'mobile';
+type IssueTrackerProvider = 'jira' | 'linear' | 'github-issues' | 'azure-devops';
+type GitProvider = 'github' | 'gitlab' | 'bitbucket' | 'azure-devops';
+type DocumentationProvider = 'confluence' | 'notion' | 'github-wiki' | 'local';
+type StateProvider = 'confluence' | 'notion' | 's3' | 'github-repo' | 'local';
+type AdapterStrategy = 'mcp' | 'native' | 'auto';
+interface ProjectConfig {
+    name: string;
+    type?: ProjectType;
+    root?: string;
+}
+interface TeamConfig {
+    agents?: string[];
+}
+interface IssueTrackerConfig {
+    project_key?: string;
+    base_url?: string;
+    [key: string]: unknown;
+}
+interface IssueTrackerIntegration {
+    provider: IssueTrackerProvider;
+    config?: IssueTrackerConfig;
+    strategy?: AdapterStrategy;
+}
+interface GitConfig {
+    owner?: string;
+    repo?: string;
+    default_branch?: string;
+    [key: string]: unknown;
+}
+interface GitIntegration {
+    provider: GitProvider;
+    config?: GitConfig;
+    strategy?: AdapterStrategy;
+}
+interface DocumentationConfig {
+    space_key?: string;
+    base_url?: string;
+    base_path?: string;
+    [key: string]: unknown;
+}
+interface DocumentationIntegration {
+    provider: DocumentationProvider;
+    config?: DocumentationConfig;
+    strategy?: AdapterStrategy;
+}
+interface StateConfig {
+    space_key?: string;
+    base_path?: string;
+    bucket?: string;
+    [key: string]: unknown;
+}
+interface StateIntegration {
+    provider: StateProvider;
+    config?: StateConfig;
+    strategy?: AdapterStrategy;
+}
+interface IntegrationsConfig {
+    issue_tracker?: IssueTrackerIntegration;
+    git?: GitIntegration;
+    documentation?: DocumentationIntegration;
+    state?: StateIntegration;
+}
+interface QualityGate {
+    command: string;
+    required?: boolean;
+}
+type QualityGatesConfig = Record<string, QualityGate>;
+interface TechStackConfig {
+    primary_language?: string;
+    frameworks?: string[];
+    cloud?: string;
+    [key: string]: unknown;
+}
+interface McpConfig {
+    expose_adapters?: boolean;
+}
+/**
+ * Cache configuration
+ */
+interface CacheConfig {
+    /**
+     * Enable caching (default: true)
+     */
+    enabled?: boolean;
+    /**
+     * Cache directory path (default: .coreai/cache)
+     */
+    path?: string;
+    /**
+     * Default TTL in seconds (default: 3600)
+     */
+    ttl?: number;
+    /**
+     * Maximum cache size in bytes (default: 100MB)
+     */
+    max_size?: number;
+    /**
+     * Maximum number of entries (default: 1000)
+     */
+    max_entries?: number;
+    /**
+     * Enable automatic cleanup of expired entries (default: true)
+     */
+    auto_cleanup?: boolean;
+}
+interface CoreAIConfig {
+    version?: '1.0';
+    project?: ProjectConfig;
+    team?: TeamConfig;
+    integrations?: IntegrationsConfig;
+    quality_gates?: QualityGatesConfig;
+    tech_stack?: TechStackConfig;
+    mcp?: McpConfig;
+    cache?: CacheConfig;
+}
+/**
+ * Configuration with all defaults applied
+ */
+interface ResolvedCoreAIConfig extends CoreAIConfig {
+    project: Required<ProjectConfig>;
+    team: Required<TeamConfig>;
+}
+
+/**
+ * Configuration Loader
+ *
+ * Handles config file discovery, parsing, validation, and defaults.
+ */
+
+declare class ConfigError extends Error {
+    readonly code: ConfigErrorCode;
+    readonly details?: unknown | undefined;
+    constructor(message: string, code: ConfigErrorCode, details?: unknown | undefined);
+}
+type ConfigErrorCode = 'NOT_FOUND' | 'PARSE_ERROR' | 'VALIDATION_ERROR' | 'READ_ERROR';
+/**
+ * Find the config file by walking up the directory tree
+ */
+declare function findConfigFile(startDir?: string): string | null;
+/**
+ * Load and validate configuration from a file path
+ */
+declare function loadConfigFromFile(filePath: string): ResolvedCoreAIConfig;
+/**
+ * Load configuration by searching for config file
+ */
+declare function loadConfig(startDir?: string): ResolvedCoreAIConfig;
+/**
+ * Check if a config file exists in the given directory or parent directories
+ */
+declare function configExists(startDir?: string): boolean;
+/**
+ * Get the path to the config file, or null if not found
+ */
+declare function getConfigPath(startDir?: string): string | null;
+
+/**
+ * CoreAI Agent Types
+ *
+ * TypeScript types corresponding to the JSON schema at schemas/agent.schema.json
+ */
+type AgentType = 'ic-engineer' | 'manager' | 'specialist' | 'coordinator';
+type WorkflowType = 'ticket-implementation' | 'bug-investigation' | 'code-review' | 'planning-estimation';
+interface AgentExpertise {
+    primary?: string[];
+    tech_stack?: string;
+    [key: string]: unknown;
+}
+interface AgentPrinciples {
+    code_quality?: string[];
+    testing?: string[];
+    security?: string[];
+    performance?: string[];
+    [key: string]: string[] | undefined;
+}
+interface AgentBehaviors {
+    workflow?: WorkflowType;
+    quality_gates?: string;
+    [key: string]: unknown;
+}
+interface AgentContextSources {
+    shared?: string[];
+    personal?: string[];
+}
+interface AgentCommunication {
+    inbox?: string;
+    outbox?: string;
+}
+/**
+ * Raw agent definition as loaded from YAML (before variable resolution)
+ */
+interface AgentDefinition {
+    role: string;
+    type: AgentType;
+    display_name: string;
+    description: string;
+    responsibilities?: string[];
+    expertise?: AgentExpertise;
+    skills?: string[];
+    principles?: AgentPrinciples;
+    behaviors?: AgentBehaviors;
+    context_sources?: AgentContextSources;
+    communication?: AgentCommunication;
+}
+/**
+ * Agent definition after variable resolution
+ */
+interface ResolvedAgentDefinition extends AgentDefinition {
+    expertise?: AgentExpertise & {
+        tech_stack?: Record<string, unknown>;
+    };
+    behaviors?: AgentBehaviors & {
+        quality_gates?: Record<string, unknown>;
+    };
+}
+/**
+ * Agent source location
+ */
+type AgentSource = 'core' | 'custom' | 'override';
+/**
+ * Agent metadata including source information
+ */
+interface AgentMetadata {
+    definition: AgentDefinition;
+    source: AgentSource;
+    filePath: string;
+}
+
+/**
+ * Agent Loader
+ *
+ * Handles loading and validating agent YAML definitions.
+ */
+
+declare class AgentError extends Error {
+    readonly code: AgentErrorCode;
+    readonly details?: unknown | undefined;
+    constructor(message: string, code: AgentErrorCode, details?: unknown | undefined);
+}
+type AgentErrorCode = 'NOT_FOUND' | 'PARSE_ERROR' | 'VALIDATION_ERROR' | 'READ_ERROR';
+/**
+ * Parse YAML content into an agent definition
+ */
+declare function parseAgentYaml(content: string, filePath?: string): unknown;
+/**
+ * Validate parsed YAML against agent schema
+ */
+declare function validateAgentDefinition(agent: unknown): AgentDefinition;
+/**
+ * Load and validate an agent definition from a file
+ */
+declare function loadAgentFromFile(filePath: string): AgentDefinition;
+/**
+ * Load all agents from a directory
+ */
+declare function loadAgentsFromDirectory(dir: string, source: AgentSource): Map<string, AgentMetadata>;
+/**
+ * Get the agent role name from a filename
+ */
+declare function getRoleFromFilename(filePath: string): string;
+
+/**
+ * Variable Resolution System
+ *
+ * Resolves variable placeholders in agent definitions.
+ * Supports: ${config.*}, ${agent.*}, ${remote.*}
+ */
+
+/**
+ * Context for variable resolution
+ */
+interface ResolutionContext {
+    config?: CoreAIConfig;
+    agent?: AgentDefinition;
+}
+/**
+ * Options for variable resolution
+ */
+interface ResolutionOptions {
+    /**
+     * If true, throw an error for unresolved variables.
+     * If false, leave unresolved variables as-is.
+     * Default: false
+     */
+    strict?: boolean;
+}
+/**
+ * Error thrown when variable resolution fails
+ */
+declare class ResolutionError extends Error {
+    readonly variable: string;
+    readonly path?: string | undefined;
+    constructor(message: string, variable: string, path?: string | undefined);
+}
+/**
+ * Resolve all variables in a string
+ */
+declare function resolveString(input: string, context: ResolutionContext, options?: ResolutionOptions): string;
+/**
+ * Check if a string contains variable placeholders
+ */
+declare function hasVariables(input: string): boolean;
+/**
+ * Extract all variable references from a string
+ */
+declare function extractVariables$1(input: string): string[];
+/**
+ * Recursively resolve all variables in an object
+ */
+declare function resolveObject<T>(obj: T, context: ResolutionContext, options?: ResolutionOptions): T;
+/**
+ * Resolve all variables in an agent definition
+ */
+declare function resolveAgentDefinition(agent: AgentDefinition, config?: CoreAIConfig, options?: ResolutionOptions): AgentDefinition;
+
+/**
+ * Agent Compiler
+ *
+ * Transforms YAML agent definitions into Claude-compatible Markdown files.
+ */
+
+/**
+ * Options for compiling agents
+ */
+interface CompileOptions {
+    /**
+     * Output directory for compiled markdown files.
+     * Default: .claude/agents
+     */
+    outputDir?: string;
+    /**
+     * Core agents directory (built-in agents).
+     * Default: uses package's agents/ directory
+     */
+    coreAgentsDir?: string;
+    /**
+     * Custom agents directory (project-specific agents).
+     * Default: coreai/agents in project root
+     */
+    customAgentsDir?: string;
+    /**
+     * Project root directory.
+     * Default: process.cwd()
+     */
+    projectRoot?: string;
+    /**
+     * Filter function to select which agents to compile.
+     * Returns true to include the agent, false to exclude.
+     */
+    filter?: (agent: AgentDefinition) => boolean;
+}
+/**
+ * Result of compiling agents
+ */
+interface CompileResult {
+    /**
+     * Successfully compiled agents
+     */
+    compiled: {
+        role: string;
+        source: AgentSource;
+        outputPath: string;
+    }[];
+    /**
+     * Agents that failed to compile
+     */
+    errors: {
+        role: string;
+        source: AgentSource;
+        error: string;
+    }[];
+}
+/**
+ * Generate markdown content from a resolved agent definition
+ */
+declare function generateAgentMarkdown(agent: AgentDefinition): string;
+/**
+ * Compile a single agent to markdown
+ */
+declare function compileAgent(agent: AgentDefinition, config?: CoreAIConfig): string;
+/**
+ * Load all agents from core and custom directories
+ */
+declare function loadAllAgents(options?: CompileOptions): Map<string, AgentMetadata>;
+/**
+ * Filter agents based on team configuration
+ */
+declare function filterAgentsByTeam(agents: Map<string, AgentMetadata>, config?: CoreAIConfig): Map<string, AgentMetadata>;
+/**
+ * Compile all agents and write to output directory
+ */
+declare function compileAgents(config?: CoreAIConfig, options?: CompileOptions): CompileResult;
+/**
+ * Get the default core agents directory
+ */
+declare function getCoreAgentsDir(): string;
+
+/**
+ * Adapter Types
+ *
+ * Common types used across all adapters.
+ */
+/**
+ * The type of adapter
+ */
+type AdapterType = 'issue_tracker' | 'git' | 'documentation' | 'state';
+/**
+ * How the adapter connects to the service
+ */
+type AdapterImplementation = 'mcp' | 'native' | 'mock';
+/**
+ * Base metadata for all adapters
+ */
+interface AdapterInfo {
+    /**
+     * Type of adapter
+     */
+    type: AdapterType;
+    /**
+     * Provider name (e.g., 'github', 'jira', 'confluence')
+     */
+    provider: string;
+    /**
+     * How this adapter is implemented
+     */
+    implementation: AdapterImplementation;
+    /**
+     * Whether the adapter is currently connected/available
+     */
+    connected: boolean;
+}
+/**
+ * Common issue status values
+ */
+type IssueStatus = 'backlog' | 'todo' | 'in_progress' | 'in_review' | 'done' | 'closed' | string;
+/**
+ * Common pull request status values
+ */
+type PullRequestStatus = 'open' | 'merged' | 'closed' | 'draft';
+/**
+ * Common review decision values
+ */
+type ReviewDecision = 'approve' | 'request_changes' | 'comment';
+/**
+ * Issue data structure
+ */
+interface Issue {
+    id: string;
+    key: string;
+    title: string;
+    description?: string;
+    status: IssueStatus;
+    assignee?: string;
+    reporter?: string;
+    labels?: string[];
+    priority?: string;
+    created_at?: string;
+    updated_at?: string;
+    url?: string;
+}
+/**
+ * Data for creating an issue
+ */
+interface CreateIssueData {
+    title: string;
+    description?: string;
+    assignee?: string;
+    labels?: string[];
+    priority?: string;
+    type?: string;
+}
+/**
+ * Data for updating an issue
+ */
+interface UpdateIssueData {
+    title?: string;
+    description?: string;
+    assignee?: string;
+    labels?: string[];
+    priority?: string;
+    status?: IssueStatus;
+}
+/**
+ * Query parameters for listing issues
+ */
+interface IssueQuery {
+    assignee?: string;
+    status?: IssueStatus | IssueStatus[];
+    labels?: string[];
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Pull request data structure
+ */
+interface PullRequest {
+    id: string;
+    number: number;
+    title: string;
+    description?: string;
+    status: PullRequestStatus;
+    author?: string;
+    source_branch: string;
+    target_branch: string;
+    created_at?: string;
+    updated_at?: string;
+    merged_at?: string;
+    url?: string;
+    reviewers?: string[];
+}
+/**
+ * Data for creating a pull request
+ */
+interface CreatePullRequestData {
+    title: string;
+    description?: string;
+    source_branch: string;
+    target_branch: string;
+    draft?: boolean;
+    reviewers?: string[];
+}
+/**
+ * Query parameters for listing pull requests
+ */
+interface PullRequestQuery {
+    status?: PullRequestStatus | PullRequestStatus[];
+    author?: string;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Review data for a pull request
+ */
+interface Review {
+    id: string;
+    pull_request_id: string;
+    author: string;
+    decision: ReviewDecision;
+    body?: string;
+    created_at?: string;
+}
+/**
+ * Data for creating a review
+ */
+interface CreateReviewData {
+    decision: ReviewDecision;
+    body?: string;
+    comments?: ReviewComment[];
+}
+/**
+ * Comment on a specific line in a review
+ */
+interface ReviewComment {
+    path: string;
+    line: number;
+    body: string;
+}
+/**
+ * Documentation page data structure
+ */
+interface DocumentationPage {
+    id: string;
+    title: string;
+    content?: string;
+    path?: string;
+    url?: string;
+    parent_id?: string;
+    created_at?: string;
+    updated_at?: string;
+}
+/**
+ * Query parameters for searching documentation
+ */
+interface DocumentationQuery {
+    query: string;
+    space?: string;
+    limit?: number;
+}
+/**
+ * File/directory entry for state provider
+ */
+interface StateEntry {
+    path: string;
+    name: string;
+    type: 'file' | 'directory';
+    size?: number;
+    modified_at?: string;
+}
+/**
+ * Options for state operations
+ */
+interface StateOptions {
+    /**
+     * Create parent directories if they don't exist
+     */
+    recursive?: boolean;
+    /**
+     * Encoding for text content
+     */
+    encoding?: BufferEncoding;
+}
+/**
+ * Adapter error with context
+ */
+declare class AdapterError extends Error {
+    readonly code: AdapterErrorCode;
+    readonly adapter?: AdapterInfo;
+    constructor(message: string, code: AdapterErrorCode, adapter?: AdapterInfo, cause?: Error);
+}
+/**
+ * Error codes for adapter operations
+ */
+type AdapterErrorCode = 'not_found' | 'unauthorized' | 'forbidden' | 'rate_limited' | 'network_error' | 'invalid_request' | 'not_implemented' | 'connection_failed' | 'provider_error' | 'operation_failed' | 'invalid_operation' | 'not_connected' | 'invalid_config';
+
+/**
+ * Adapter Interfaces
+ *
+ * Abstract interfaces for integration adapters that can be implemented
+ * via MCP servers or native API clients.
+ */
+
+/**
+ * Base interface that all adapters implement
+ */
+interface BaseAdapter {
+    /**
+     * Get adapter metadata
+     */
+    getInfo(): AdapterInfo;
+    /**
+     * Check if the adapter is connected and available
+     */
+    isConnected(): boolean;
+    /**
+     * Connect to the service (if needed)
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the service
+     */
+    disconnect(): Promise<void>;
+}
+/**
+ * Issue Tracker Adapter
+ *
+ * For integrating with issue tracking systems like Jira, Linear, GitHub Issues, etc.
+ */
+interface IssueTrackerAdapter extends BaseAdapter {
+    /**
+     * Get a single issue by ID or key
+     */
+    getIssue(idOrKey: string): Promise<Issue>;
+    /**
+     * List issues matching the query
+     */
+    listIssues(query?: IssueQuery): Promise<Issue[]>;
+    /**
+     * Create a new issue
+     */
+    createIssue(data: CreateIssueData): Promise<Issue>;
+    /**
+     * Update an existing issue
+     */
+    updateIssue(idOrKey: string, data: UpdateIssueData): Promise<Issue>;
+    /**
+     * Transition an issue to a new status
+     */
+    transitionIssue(idOrKey: string, status: IssueStatus): Promise<Issue>;
+    /**
+     * Add a comment to an issue
+     */
+    addComment(idOrKey: string, comment: string): Promise<void>;
+    /**
+     * Get available transitions/statuses for an issue
+     */
+    getTransitions?(idOrKey: string): Promise<IssueStatus[]>;
+    /**
+     * Assign an issue to a user
+     */
+    assignIssue?(idOrKey: string, assignee: string): Promise<Issue>;
+    /**
+     * Link two issues together
+     */
+    linkIssues?(sourceKey: string, targetKey: string, linkType: string): Promise<void>;
+}
+/**
+ * Git Provider Adapter
+ *
+ * For integrating with Git hosting services like GitHub, GitLab, Bitbucket, etc.
+ */
+interface GitProviderAdapter extends BaseAdapter {
+    /**
+     * Get a pull request by ID or number
+     */
+    getPullRequest(idOrNumber: string | number): Promise<PullRequest>;
+    /**
+     * List pull requests matching the query
+     */
+    listPullRequests(query?: PullRequestQuery): Promise<PullRequest[]>;
+    /**
+     * Create a new pull request
+     */
+    createPullRequest(data: CreatePullRequestData): Promise<PullRequest>;
+    /**
+     * Update a pull request
+     */
+    updatePullRequest?(idOrNumber: string | number, data: Partial<CreatePullRequestData>): Promise<PullRequest>;
+    /**
+     * Merge a pull request
+     */
+    mergePullRequest(idOrNumber: string | number, options?: {
+        method?: 'merge' | 'squash' | 'rebase';
+        message?: string;
+    }): Promise<void>;
+    /**
+     * Close a pull request without merging
+     */
+    closePullRequest(idOrNumber: string | number): Promise<void>;
+    /**
+     * Add a review to a pull request
+     */
+    addReview(idOrNumber: string | number, review: CreateReviewData): Promise<Review>;
+    /**
+     * Get reviews for a pull request
+     */
+    getReviews?(idOrNumber: string | number): Promise<Review[]>;
+    /**
+     * Request reviewers for a pull request
+     */
+    requestReviewers?(idOrNumber: string | number, reviewers: string[]): Promise<void>;
+    /**
+     * Add a comment to a pull request
+     */
+    addPullRequestComment?(idOrNumber: string | number, comment: string): Promise<void>;
+    /**
+     * Get the diff for a pull request
+     */
+    getPullRequestDiff?(idOrNumber: string | number): Promise<string>;
+    /**
+     * Get files changed in a pull request
+     */
+    getPullRequestFiles?(idOrNumber: string | number): Promise<string[]>;
+}
+/**
+ * Documentation Provider Adapter
+ *
+ * For integrating with documentation systems like Confluence, Notion, GitHub Wiki, etc.
+ */
+interface DocumentationProviderAdapter extends BaseAdapter {
+    /**
+     * Get a documentation page by ID
+     */
+    getPage(id: string): Promise<DocumentationPage>;
+    /**
+     * Get page content (may be separate from metadata in some systems)
+     */
+    getPageContent(id: string): Promise<string>;
+    /**
+     * Search for documentation pages
+     */
+    searchPages(query: DocumentationQuery): Promise<DocumentationPage[]>;
+    /**
+     * List pages in a space or parent
+     */
+    listPages?(parentId?: string): Promise<DocumentationPage[]>;
+    /**
+     * Create a new page
+     */
+    createPage?(title: string, content: string, parentId?: string): Promise<DocumentationPage>;
+    /**
+     * Update an existing page
+     */
+    updatePage?(id: string, title?: string, content?: string): Promise<DocumentationPage>;
+}
+/**
+ * State Provider Adapter
+ *
+ * For managing local state like KnowledgeLibrary, which may be stored
+ * on the filesystem, in a cloud bucket, or in a documentation system.
+ */
+interface StateProviderAdapter extends BaseAdapter {
+    /**
+     * Read content from a path
+     */
+    read(path: string, options?: StateOptions): Promise<string>;
+    /**
+     * Write content to a path
+     */
+    write(path: string, content: string, options?: StateOptions): Promise<void>;
+    /**
+     * Check if a path exists
+     */
+    exists(path: string): Promise<boolean>;
+    /**
+     * List entries in a directory
+     */
+    list(path: string): Promise<StateEntry[]>;
+    /**
+     * Delete a file or directory
+     */
+    delete(path: string, options?: StateOptions): Promise<void>;
+    /**
+     * Create a directory
+     */
+    mkdir?(path: string, options?: StateOptions): Promise<void>;
+    /**
+     * Move/rename a file or directory
+     */
+    move?(source: string, destination: string): Promise<void>;
+    /**
+     * Copy a file or directory
+     */
+    copy?(source: string, destination: string): Promise<void>;
+}
+/**
+ * Union type of all adapter types
+ */
+type Adapter = IssueTrackerAdapter | GitProviderAdapter | DocumentationProviderAdapter | StateProviderAdapter;
+
+/**
+ * Adapter Factory
+ *
+ * Creates and manages adapter instances based on configuration.
+ */
+
+/**
+ * Options for creating an adapter
+ */
+interface AdapterFactoryOptions {
+    /**
+     * Override the strategy from config
+     */
+    strategy?: AdapterStrategy;
+    /**
+     * Force a specific implementation
+     */
+    implementation?: AdapterImplementation;
+}
+/**
+ * Adapter Factory
+ *
+ * Creates adapter instances based on configuration and available implementations.
+ */
+declare class AdapterFactory {
+    private config;
+    private adapters;
+    /**
+     * Registry of adapter creators by type
+     */
+    private creators;
+    constructor(config: CoreAIConfig);
+    /**
+     * Register an adapter creator
+     */
+    registerCreator<T extends AdapterType>(type: T, implementation: AdapterImplementation, creator: (config: CoreAIConfig) => Promise<Adapter>): void;
+    /**
+     * Get an issue tracker adapter
+     */
+    getIssueTracker(options?: AdapterFactoryOptions): Promise<IssueTrackerAdapter>;
+    /**
+     * Get a git provider adapter
+     */
+    getGitProvider(options?: AdapterFactoryOptions): Promise<GitProviderAdapter>;
+    /**
+     * Get a documentation provider adapter
+     */
+    getDocumentationProvider(options?: AdapterFactoryOptions): Promise<DocumentationProviderAdapter>;
+    /**
+     * Get a state provider adapter
+     */
+    getStateProvider(options?: AdapterFactoryOptions): Promise<StateProviderAdapter>;
+    /**
+     * Get an adapter by type
+     */
+    getAdapter(type: AdapterType, options?: AdapterFactoryOptions): Promise<Adapter>;
+    /**
+     * Check if an adapter type is configured
+     */
+    hasIntegration(type: AdapterType): boolean;
+    /**
+     * Get information about a configured integration
+     */
+    getIntegrationInfo(type: AdapterType): {
+        provider: string;
+        strategy: AdapterStrategy;
+    } | null;
+    /**
+     * Disconnect and clear all cached adapters
+     */
+    disconnectAll(): Promise<void>;
+    /**
+     * Get the strategy for an adapter type
+     */
+    private getStrategy;
+    /**
+     * Select the implementation based on strategy and availability
+     */
+    private selectImplementation;
+    /**
+     * Create an adapter instance
+     */
+    private createAdapter;
+}
+/**
+ * Create an adapter factory from configuration
+ */
+declare function createAdapterFactory(config: CoreAIConfig): AdapterFactory;
+/**
+ * Create adapter info helper
+ */
+declare function createAdapterInfo(type: AdapterType, provider: string, implementation: AdapterImplementation, connected?: boolean): AdapterInfo;
+
+/**
+ * Cache Types
+ *
+ * Type definitions for the shared context cache system.
+ */
+/**
+ * Source type for cached content
+ */
+type CacheSource = 'confluence' | 'github' | 'notion' | 'local' | 'custom';
+/**
+ * Cache entry status
+ */
+type CacheStatus = 'valid' | 'stale' | 'expired' | 'error';
+/**
+ * Metadata for a cached entry
+ */
+interface CacheMetadata {
+    /**
+     * Unique key for this cache entry
+     */
+    key: string;
+    /**
+     * Source provider (e.g., 'confluence', 'github')
+     */
+    source: CacheSource;
+    /**
+     * Original source URL or identifier
+     */
+    sourceUrl: string;
+    /**
+     * When the content was cached
+     */
+    cachedAt: string;
+    /**
+     * When the content expires (ISO date string)
+     */
+    expiresAt: string;
+    /**
+     * ETag or version hash from source (for conditional fetching)
+     */
+    etag?: string;
+    /**
+     * Content hash for integrity checking
+     */
+    contentHash: string;
+    /**
+     * Size in bytes
+     */
+    size: number;
+    /**
+     * Content type (e.g., 'text/markdown', 'application/json')
+     */
+    contentType: string;
+    /**
+     * Original title or name
+     */
+    title?: string;
+    /**
+     * Last modified timestamp from source
+     */
+    lastModified?: string;
+    /**
+     * Custom tags for categorization
+     */
+    tags?: string[];
+}
+/**
+ * A cached content entry
+ */
+interface CacheEntry<T = string> {
+    /**
+     * Entry metadata
+     */
+    metadata: CacheMetadata;
+    /**
+     * The cached content
+     */
+    content: T;
+}
+/**
+ * Options for cache operations
+ */
+interface CacheOptions {
+    /**
+     * Time-to-live in seconds (default: 3600 = 1 hour)
+     */
+    ttl?: number;
+    /**
+     * Force refresh even if cached
+     */
+    forceRefresh?: boolean;
+    /**
+     * Skip cache and fetch directly
+     */
+    skipCache?: boolean;
+    /**
+     * Custom tags to apply
+     */
+    tags?: string[];
+}
+/**
+ * Options for listing cache entries
+ */
+interface CacheListOptions {
+    /**
+     * Filter by source
+     */
+    source?: CacheSource;
+    /**
+     * Filter by tag
+     */
+    tag?: string;
+    /**
+     * Filter by status
+     */
+    status?: CacheStatus;
+    /**
+     * Maximum entries to return
+     */
+    limit?: number;
+}
+/**
+ * Cache statistics
+ */
+interface CacheStats {
+    /**
+     * Total number of entries
+     */
+    totalEntries: number;
+    /**
+     * Total size in bytes
+     */
+    totalSize: number;
+    /**
+     * Number of valid entries
+     */
+    validEntries: number;
+    /**
+     * Number of stale entries
+     */
+    staleEntries: number;
+    /**
+     * Number of expired entries
+     */
+    expiredEntries: number;
+    /**
+     * Entries by source
+     */
+    bySource: Record<CacheSource, number>;
+    /**
+     * Oldest entry timestamp
+     */
+    oldestEntry?: string;
+    /**
+     * Newest entry timestamp
+     */
+    newestEntry?: string;
+}
+/**
+ * Result of a sync operation
+ */
+interface SyncResult {
+    /**
+     * Number of entries added
+     */
+    added: number;
+    /**
+     * Number of entries updated
+     */
+    updated: number;
+    /**
+     * Number of entries removed
+     */
+    removed: number;
+    /**
+     * Number of entries that failed to sync
+     */
+    failed: number;
+    /**
+     * Error messages for failed entries
+     */
+    errors: {
+        key: string;
+        error: string;
+    }[];
+    /**
+     * Duration of sync in milliseconds
+     */
+    duration: number;
+}
+/**
+ * Cache error codes
+ */
+type CacheErrorCode = 'not_found' | 'expired' | 'invalid_key' | 'write_failed' | 'read_failed' | 'fetch_failed' | 'invalid_config' | 'storage_full';
+/**
+ * Cache-specific error
+ */
+declare class CacheError extends Error {
+    readonly code: CacheErrorCode;
+    readonly key?: string | undefined;
+    readonly cause?: Error | undefined;
+    constructor(message: string, code: CacheErrorCode, key?: string | undefined, cause?: Error | undefined);
+}
+/**
+ * Default cache directory paths
+ */
+declare const CACHE_PATHS: {
+    /**
+     * Root cache directory (relative to project root)
+     */
+    readonly ROOT: ".coreai/cache";
+    /**
+     * Content storage directory
+     */
+    readonly CONTENT: ".coreai/cache/content";
+    /**
+     * Metadata storage directory
+     */
+    readonly METADATA: ".coreai/cache/metadata";
+    /**
+     * Index file for fast lookups
+     */
+    readonly INDEX: ".coreai/cache/index.json";
+    /**
+     * Lock file for concurrent access
+     */
+    readonly LOCK: ".coreai/cache/.lock";
+};
+/**
+ * Default cache configuration
+ */
+declare const DEFAULT_CACHE_CONFIG: {
+    /**
+     * Default TTL in seconds (1 hour)
+     */
+    readonly ttl: 3600;
+    /**
+     * Maximum cache size in bytes (100MB)
+     */
+    readonly maxSize: number;
+    /**
+     * Maximum number of entries
+     */
+    readonly maxEntries: 1000;
+    /**
+     * Enable automatic cleanup of expired entries
+     */
+    readonly autoCleanup: true;
+    /**
+     * Cleanup interval in seconds (1 hour)
+     */
+    readonly cleanupInterval: 3600;
+};
+
+/**
+ * Cache Interfaces
+ *
+ * Interface definitions for the cache system.
+ */
+
+/**
+ * Cache provider interface
+ *
+ * Defines the contract for cache implementations.
+ */
+interface CacheProvider {
+    /**
+     * Initialize the cache (create directories, load index)
+     */
+    initialize(): Promise<void>;
+    /**
+     * Check if the cache is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Get a cached entry by key
+     *
+     * @param key - Cache key
+     * @param options - Optional cache options
+     * @returns The cached entry or null if not found/expired
+     */
+    get<T = string>(key: string, options?: CacheOptions): Promise<CacheEntry<T> | null>;
+    /**
+     * Get the content only (convenience method)
+     *
+     * @param key - Cache key
+     * @param options - Optional cache options
+     * @returns The cached content or null if not found/expired
+     */
+    getContent<T = string>(key: string, options?: CacheOptions): Promise<T | null>;
+    /**
+     * Set a cache entry
+     *
+     * @param key - Cache key
+     * @param content - Content to cache
+     * @param metadata - Partial metadata (key and cachedAt will be set automatically)
+     * @param options - Optional cache options
+     */
+    set<T = string>(key: string, content: T, metadata: Partial<CacheMetadata>, options?: CacheOptions): Promise<void>;
+    /**
+     * Check if a key exists in the cache
+     *
+     * @param key - Cache key
+     * @returns True if the key exists (regardless of expiration)
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Delete a cache entry
+     *
+     * @param key - Cache key
+     * @returns True if the entry was deleted
+     */
+    delete(key: string): Promise<boolean>;
+    /**
+     * Get the status of a cache entry
+     *
+     * @param key - Cache key
+     * @returns The cache status or null if not found
+     */
+    getStatus(key: string): Promise<CacheStatus | null>;
+    /**
+     * Get metadata for a cache entry
+     *
+     * @param key - Cache key
+     * @returns The metadata or null if not found
+     */
+    getMetadata(key: string): Promise<CacheMetadata | null>;
+    /**
+     * Update metadata for a cache entry
+     *
+     * @param key - Cache key
+     * @param metadata - Partial metadata to update
+     */
+    updateMetadata(key: string, metadata: Partial<CacheMetadata>): Promise<void>;
+    /**
+     * List cache entries
+     *
+     * @param options - List filter options
+     * @returns Array of metadata entries
+     */
+    list(options?: CacheListOptions): Promise<CacheMetadata[]>;
+    /**
+     * Get cache statistics
+     */
+    getStats(): Promise<CacheStats>;
+    /**
+     * Clear all cache entries
+     *
+     * @returns Number of entries cleared
+     */
+    clear(): Promise<number>;
+    /**
+     * Clear expired entries only
+     *
+     * @returns Number of entries cleared
+     */
+    clearExpired(): Promise<number>;
+    /**
+     * Clear entries by source
+     *
+     * @param source - Source to clear
+     * @returns Number of entries cleared
+     */
+    clearBySource(source: string): Promise<number>;
+    /**
+     * Clear entries by tag
+     *
+     * @param tag - Tag to clear
+     * @returns Number of entries cleared
+     */
+    clearByTag(tag: string): Promise<number>;
+}
+/**
+ * Remote fetcher interface
+ *
+ * Used by the cache to fetch content from remote sources.
+ */
+interface RemoteFetcher {
+    /**
+     * Fetch content from a remote source
+     *
+     * @param url - Source URL or identifier
+     * @param options - Fetch options
+     * @returns The fetched content and metadata
+     */
+    fetch(url: string, options?: FetchOptions): Promise<{
+        content: string;
+        metadata: Partial<CacheMetadata>;
+    }>;
+    /**
+     * Check if content has changed (conditional fetch)
+     *
+     * @param url - Source URL or identifier
+     * @param etag - Previous ETag
+     * @returns True if content has changed
+     */
+    hasChanged(url: string, etag?: string): Promise<boolean>;
+}
+/**
+ * Options for remote fetching
+ */
+interface FetchOptions {
+    /**
+     * Request timeout in milliseconds
+     */
+    timeout?: number;
+    /**
+     * ETag for conditional fetching
+     */
+    etag?: string;
+    /**
+     * Custom headers
+     */
+    headers?: Record<string, string>;
+}
+/**
+ * Cache manager interface
+ *
+ * Higher-level interface that combines caching with remote fetching.
+ */
+interface CacheManager$1 {
+    /**
+     * Get content with cache-first strategy
+     *
+     * 1. Check cache
+     * 2. If cached and valid, return cached content
+     * 3. If stale or missing, fetch from remote
+     * 4. Cache the fetched content
+     * 5. Return the content
+     *
+     * @param key - Cache key
+     * @param url - Remote URL to fetch if not cached
+     * @param options - Cache and fetch options
+     */
+    getWithFallback<T = string>(key: string, url: string, options?: CacheOptions & FetchOptions): Promise<CacheEntry<T>>;
+    /**
+     * Sync all entries from a source
+     *
+     * @param source - Source to sync
+     * @param options - Sync options
+     */
+    syncSource(source: string, options?: SyncOptions): Promise<SyncResult>;
+    /**
+     * Sync specific entries
+     *
+     * @param keys - Keys to sync
+     * @param options - Sync options
+     */
+    syncEntries(keys: string[], options?: SyncOptions): Promise<SyncResult>;
+    /**
+     * Register a fetcher for a source
+     *
+     * @param source - Source identifier
+     * @param fetcher - Fetcher implementation
+     */
+    registerFetcher(source: string, fetcher: RemoteFetcher): void;
+    /**
+     * Check if a fetcher is registered for a source
+     *
+     * @param source - Source identifier
+     */
+    hasFetcher(source: string): boolean;
+    /**
+     * Get the underlying cache provider
+     */
+    getCache(): CacheProvider;
+}
+/**
+ * Options for sync operations
+ */
+interface SyncOptions {
+    /**
+     * Force refresh all entries
+     */
+    force?: boolean;
+    /**
+     * Continue on error
+     */
+    continueOnError?: boolean;
+    /**
+     * Maximum concurrent fetches
+     */
+    concurrency?: number;
+    /**
+     * Progress callback
+     */
+    onProgress?: (completed: number, total: number) => void;
+}
+
+/**
+ * File-based Cache Provider
+ *
+ * Implements CacheProvider using the local filesystem.
+ * Stores content in files with separate metadata JSON files.
+ */
+
+/**
+ * Options for creating a file cache provider
+ */
+interface FileCacheProviderOptions {
+    /**
+     * Base path for cache storage (project root)
+     */
+    basePath: string;
+    /**
+     * Default TTL in seconds
+     */
+    ttl?: number;
+    /**
+     * Maximum cache size in bytes
+     */
+    maxSize?: number;
+    /**
+     * Maximum number of entries
+     */
+    maxEntries?: number;
+}
+/**
+ * File-based cache provider implementation
+ */
+declare class FileCacheProvider implements CacheProvider {
+    private basePath;
+    private cachePath;
+    private contentPath;
+    private metadataPath;
+    private indexPath;
+    private ttl;
+    private maxSize;
+    private maxEntries;
+    private initialized;
+    private index;
+    constructor(options: FileCacheProviderOptions);
+    /**
+     * Initialize the cache (create directories, load index)
+     */
+    initialize(): Promise<void>;
+    /**
+     * Check if the cache is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Get a cached entry by key
+     */
+    get<T = string>(key: string, options?: CacheOptions): Promise<CacheEntry<T> | null>;
+    /**
+     * Get the content only (convenience method)
+     */
+    getContent<T = string>(key: string, options?: CacheOptions): Promise<T | null>;
+    /**
+     * Set a cache entry
+     */
+    set<T = string>(key: string, content: T, metadata: Partial<CacheMetadata>, options?: CacheOptions): Promise<void>;
+    /**
+     * Check if a key exists in the cache
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Delete a cache entry
+     */
+    delete(key: string): Promise<boolean>;
+    /**
+     * Get the status of a cache entry
+     */
+    getStatus(key: string): Promise<CacheStatus | null>;
+    /**
+     * Get metadata for a cache entry
+     */
+    getMetadata(key: string): Promise<CacheMetadata | null>;
+    /**
+     * Update metadata for a cache entry
+     */
+    updateMetadata(key: string, metadata: Partial<CacheMetadata>): Promise<void>;
+    /**
+     * List cache entries
+     */
+    list(options?: CacheListOptions): Promise<CacheMetadata[]>;
+    /**
+     * Get cache statistics
+     */
+    getStats(): Promise<CacheStats>;
+    /**
+     * Clear all cache entries
+     */
+    clear(): Promise<number>;
+    /**
+     * Clear expired entries only
+     */
+    clearExpired(): Promise<number>;
+    /**
+     * Clear entries by source
+     */
+    clearBySource(source: string): Promise<number>;
+    /**
+     * Clear entries by tag
+     */
+    clearByTag(tag: string): Promise<number>;
+    private ensureInitialized;
+    private loadIndex;
+    private saveIndex;
+    private createEmptyIndex;
+    private rebuildIndex;
+    private getEntryStatus;
+    private sanitizeKey;
+    private hashContent;
+}
+/**
+ * Create a file cache provider
+ */
+declare function createFileCacheProvider(options: FileCacheProviderOptions): FileCacheProvider;
+
+/**
+ * Cache Manager
+ *
+ * Higher-level cache management that combines caching with remote fetching.
+ * Implements cache-first resolution with remote fallback strategy.
+ */
+
+/**
+ * Options for creating a cache manager
+ */
+interface CacheManagerOptions {
+    /**
+     * The underlying cache provider
+     */
+    cache: CacheProvider;
+    /**
+     * Default TTL in seconds
+     */
+    defaultTtl?: number;
+    /**
+     * Default source for new entries
+     */
+    defaultSource?: CacheSource;
+}
+/**
+ * Cache manager implementation
+ *
+ * Provides cache-first resolution strategy:
+ * 1. Check cache for valid entry
+ * 2. If cached and valid, return cached content
+ * 3. If stale or missing, fetch from remote
+ * 4. Cache the fetched content
+ * 5. Return the content
+ */
+declare class CacheManager implements CacheManager$1 {
+    private cache;
+    private fetchers;
+    private defaultTtl;
+    private defaultSource;
+    constructor(options: CacheManagerOptions);
+    /**
+     * Get content with cache-first strategy
+     */
+    getWithFallback<T = string>(key: string, url: string, options?: CacheOptions & FetchOptions): Promise<CacheEntry<T>>;
+    /**
+     * Sync all entries from a source
+     */
+    syncSource(source: string, options?: SyncOptions): Promise<SyncResult>;
+    /**
+     * Sync specific entries
+     */
+    syncEntries(keys: string[], options?: SyncOptions): Promise<SyncResult>;
+    /**
+     * Register a fetcher for a source
+     */
+    registerFetcher(source: string, fetcher: RemoteFetcher): void;
+    /**
+     * Get the underlying cache provider
+     */
+    getCache(): CacheProvider;
+    /**
+     * Check if a fetcher is registered for a source
+     */
+    hasFetcher(source: string): boolean;
+    /**
+     * Get all registered sources
+     */
+    getRegisteredSources(): string[];
+    private fetchAndCache;
+    private getSourceFromUrl;
+    private chunkArray;
+}
+/**
+ * Create a cache manager
+ */
+declare function createCacheManager(options: CacheManagerOptions): CacheManager;
+
+/**
+ * Context Loader
+ *
+ * Loads shared context from remote documentation providers with cache-first resolution.
+ * Handles first-run scenarios when cache is empty.
+ */
+
+/**
+ * Context source definition
+ */
+interface ContextSource {
+    /**
+     * Unique identifier for this context
+     */
+    key: string;
+    /**
+     * Remote URL to fetch from
+     */
+    url: string;
+    /**
+     * Optional title for the context
+     */
+    title?: string;
+    /**
+     * Optional tags for categorization
+     */
+    tags?: string[];
+    /**
+     * Whether this context is required (fail if cannot load)
+     */
+    required?: boolean;
+}
+/**
+ * Context load result
+ */
+interface ContextLoadResult {
+    /**
+     * Successfully loaded contexts
+     */
+    loaded: {
+        key: string;
+        content: string;
+        fromCache: boolean;
+        metadata: CacheMetadata;
+    }[];
+    /**
+     * Failed contexts
+     */
+    failed: {
+        key: string;
+        error: string;
+        required: boolean;
+    }[];
+    /**
+     * Total duration in milliseconds
+     */
+    duration: number;
+}
+/**
+ * Options for the context loader
+ */
+interface ContextLoaderOptions {
+    /**
+     * The cache manager to use
+     */
+    cacheManager: CacheManager$1;
+    /**
+     * Default TTL for cached contexts (seconds)
+     */
+    defaultTtl?: number;
+    /**
+     * Whether to fail on any required context failure
+     */
+    failOnRequired?: boolean;
+    /**
+     * Maximum concurrent fetches
+     */
+    concurrency?: number;
+}
+/**
+ * Options for loading contexts
+ */
+interface LoadOptions extends CacheOptions, FetchOptions {
+    /**
+     * Continue loading other contexts if one fails
+     */
+    continueOnError?: boolean;
+    /**
+     * Progress callback
+     */
+    onProgress?: (loaded: number, total: number, current: string) => void;
+}
+/**
+ * Context Loader
+ *
+ * Provides cache-first context resolution with graceful degradation
+ * for first-run scenarios when the cache is empty.
+ */
+declare class ContextLoader {
+    private cacheManager;
+    private defaultTtl;
+    private failOnRequired;
+    private concurrency;
+    constructor(options: ContextLoaderOptions);
+    /**
+     * Load a single context
+     */
+    load(source: ContextSource, options?: LoadOptions): Promise<CacheEntry<string>>;
+    /**
+     * Load multiple contexts
+     */
+    loadMany(sources: ContextSource[], options?: LoadOptions): Promise<ContextLoadResult>;
+    /**
+     * Load contexts by tag
+     */
+    loadByTag(tag: string, _options?: LoadOptions): Promise<ContextLoadResult>;
+    /**
+     * Refresh all contexts (sync from remote)
+     */
+    refresh(sources: ContextSource[], options?: LoadOptions): Promise<ContextLoadResult>;
+    /**
+     * Check if all required contexts are available (cached or fetchable)
+     */
+    checkAvailability(sources: ContextSource[]): Promise<{
+        available: string[];
+        missing: string[];
+        errors: string[];
+    }>;
+    /**
+     * Get the cache manager
+     */
+    getCacheManager(): CacheManager$1;
+    private getSourceFromHostname;
+    private chunkArray;
+}
+/**
+ * Create a context loader
+ */
+declare function createContextLoader(options: ContextLoaderOptions): ContextLoader;
+
+/**
+ * Command Framework Types
+ *
+ * Type definitions for the CoreAI command registration and execution system.
+ */
+
+/**
+ * Command category for organization
+ */
+type CommandCategory = 'core' | 'optional' | 'custom';
+/**
+ * Integration dependency for a command
+ */
+interface IntegrationDependency {
+    /**
+     * Adapter type required
+     */
+    type: AdapterType;
+    /**
+     * Whether this integration is required or optional
+     * If required and missing, command won't be registered
+     * If optional and missing, command degrades gracefully
+     */
+    required: boolean;
+    /**
+     * Description of what this integration is used for
+     */
+    description?: string;
+}
+/**
+ * Command metadata parsed from markdown frontmatter
+ */
+interface CommandMetadata {
+    /**
+     * Command name (derived from filename)
+     */
+    name: string;
+    /**
+     * Human-readable description
+     */
+    description: string;
+    /**
+     * Hint for command arguments
+     */
+    argumentHint?: string;
+    /**
+     * Command category
+     */
+    category: CommandCategory;
+    /**
+     * Integration dependencies
+     */
+    dependencies: IntegrationDependency[];
+    /**
+     * Path to the source markdown file
+     */
+    sourcePath: string;
+    /**
+     * Whether command is available (all required deps satisfied)
+     */
+    available: boolean;
+    /**
+     * Reason command is unavailable (if not available)
+     */
+    unavailableReason?: string;
+}
+/**
+ * Runtime context available during command execution
+ */
+interface CommandContext {
+    /**
+     * Loaded configuration (may be null if no config file)
+     */
+    config: ResolvedCoreAIConfig | null;
+    /**
+     * Adapter factory for accessing integrations
+     */
+    adapterFactory: AdapterFactory | null;
+    /**
+     * Project root directory
+     */
+    projectRoot: string;
+    /**
+     * Check if an integration is available
+     */
+    hasIntegration(type: AdapterType): boolean;
+    /**
+     * Get adapter with graceful handling
+     * Returns null if not available instead of throwing
+     */
+    getAdapterSafe<T>(type: AdapterType): Promise<T | null>;
+}
+/**
+ * Base options available to all commands
+ */
+interface BaseCommandOptions {
+    /**
+     * Output format
+     */
+    format?: 'text' | 'json';
+    /**
+     * Verbose output
+     */
+    verbose?: boolean;
+    /**
+     * Project root directory override
+     */
+    projectRoot?: string;
+}
+/**
+ * Result of command execution
+ */
+interface CommandResult<T = unknown> {
+    /**
+     * Whether command completed successfully
+     */
+    success: boolean;
+    /**
+     * Result data (command-specific)
+     */
+    data?: T;
+    /**
+     * Error message if failed
+     */
+    error?: string;
+    /**
+     * Warnings that occurred during execution
+     */
+    warnings?: string[];
+    /**
+     * Steps that were skipped due to missing integrations
+     */
+    skippedSteps?: {
+        step: string;
+        reason: string;
+    }[];
+}
+/**
+ * Command handler function signature
+ */
+type CommandHandler<TOptions = BaseCommandOptions, TResult = unknown> = (args: string[], options: TOptions, context: CommandContext) => Promise<CommandResult<TResult>>;
+/**
+ * Command definition for programmatic commands
+ */
+interface CommandDefinition<TOptions = BaseCommandOptions, TResult = unknown> {
+    /**
+     * Command name
+     */
+    name: string;
+    /**
+     * Human-readable description
+     */
+    description: string;
+    /**
+     * Command category
+     */
+    category: CommandCategory;
+    /**
+     * Integration dependencies
+     */
+    dependencies?: IntegrationDependency[];
+    /**
+     * Option definitions for Commander.js
+     */
+    options?: CommandOptionDefinition[];
+    /**
+     * Positional argument definitions
+     */
+    arguments?: CommandArgumentDefinition[];
+    /**
+     * Command handler
+     */
+    handler: CommandHandler<TOptions, TResult>;
+    /**
+     * Subcommands (for command groups like 'agents list', 'agents show')
+     */
+    subcommands?: CommandDefinition[];
+}
+/**
+ * Command option definition
+ */
+interface CommandOptionDefinition {
+    /**
+     * Option flags (e.g., '-f, --force')
+     */
+    flags: string;
+    /**
+     * Description
+     */
+    description: string;
+    /**
+     * Default value
+     */
+    defaultValue?: unknown;
+    /**
+     * Whether option is required
+     */
+    required?: boolean;
+}
+/**
+ * Command argument definition
+ */
+interface CommandArgumentDefinition {
+    /**
+     * Argument name
+     */
+    name: string;
+    /**
+     * Description
+     */
+    description: string;
+    /**
+     * Whether argument is required
+     */
+    required?: boolean;
+    /**
+     * Default value
+     */
+    defaultValue?: unknown;
+}
+/**
+ * Markdown command definition (parsed from file)
+ */
+interface MarkdownCommand {
+    /**
+     * Command metadata
+     */
+    metadata: CommandMetadata;
+    /**
+     * Raw markdown content (instructions for agents)
+     */
+    content: string;
+    /**
+     * Parsed sections from markdown
+     */
+    sections: {
+        title?: string;
+        instructions?: string;
+        fallbacks?: string;
+        outputFormat?: string;
+    };
+}
+/**
+ * Command registry entry
+ */
+interface RegistryEntry {
+    /**
+     * Command metadata
+     */
+    metadata: CommandMetadata;
+    /**
+     * Command definition (for programmatic commands)
+     */
+    definition?: CommandDefinition;
+    /**
+     * Markdown command (for agent commands)
+     */
+    markdownCommand?: MarkdownCommand;
+    /**
+     * Source type
+     */
+    source: 'programmatic' | 'markdown';
+}
+/**
+ * Options for loading commands from directory
+ */
+interface CommandLoaderOptions {
+    /**
+     * Directory to load commands from
+     */
+    directory: string;
+    /**
+     * Category to assign to loaded commands
+     */
+    category: CommandCategory;
+    /**
+     * Recursively search subdirectories
+     */
+    recursive?: boolean;
+    /**
+     * Filter function to include/exclude commands
+     */
+    filter?: (metadata: CommandMetadata) => boolean;
+}
+/**
+ * Result of loading commands
+ */
+interface CommandLoadResult {
+    /**
+     * Successfully loaded commands
+     */
+    loaded: MarkdownCommand[];
+    /**
+     * Failed to load
+     */
+    errors: {
+        path: string;
+        error: string;
+    }[];
+}
+
+/**
+ * Command Context
+ *
+ * Runtime context for command execution with graceful degradation support.
+ */
+
+/**
+ * Options for creating a command context
+ */
+interface CreateContextOptions {
+    /**
+     * Project root directory
+     */
+    projectRoot?: string;
+    /**
+     * Pre-loaded configuration (if already loaded)
+     */
+    config?: ResolvedCoreAIConfig;
+    /**
+     * Pre-created adapter factory (if already created)
+     */
+    adapterFactory?: AdapterFactory;
+}
+/**
+ * Create a command execution context
+ *
+ * Handles configuration loading and adapter factory creation with graceful fallbacks.
+ */
+declare function createCommandContext(options?: CreateContextOptions): CommandContext;
+/**
+ * Cleanup resources in a command context
+ */
+declare function cleanupContext(context: CommandContext): Promise<void>;
+/**
+ * Execute a function with automatic context cleanup
+ */
+declare function withContext<T>(options: CreateContextOptions, fn: (context: CommandContext) => Promise<T>): Promise<T>;
+
+/**
+ * Command Registry
+ *
+ * Central registry for command registration and discovery.
+ */
+
+/**
+ * Command Registry
+ *
+ * Manages registration and lookup of commands.
+ */
+declare class CommandRegistry {
+    private commands;
+    private adapterFactory;
+    /**
+     * Set the adapter factory for dependency checking
+     */
+    setAdapterFactory(factory: AdapterFactory | null): void;
+    /**
+     * Register a programmatic command
+     */
+    register(definition: CommandDefinition): void;
+    /**
+     * Register a markdown command
+     */
+    registerMarkdown(command: MarkdownCommand): void;
+    /**
+     * Register multiple commands
+     */
+    registerAll(definitions: CommandDefinition[]): void;
+    /**
+     * Register multiple markdown commands
+     */
+    registerAllMarkdown(commands: MarkdownCommand[]): void;
+    /**
+     * Unregister a command
+     */
+    unregister(name: string): boolean;
+    /**
+     * Get a command by name
+     */
+    get(name: string): RegistryEntry | undefined;
+    /**
+     * Check if a command exists
+     */
+    has(name: string): boolean;
+    /**
+     * Get all registered commands
+     */
+    getAll(): RegistryEntry[];
+    /**
+     * Get available commands (dependencies satisfied)
+     */
+    getAvailable(): RegistryEntry[];
+    /**
+     * Get unavailable commands
+     */
+    getUnavailable(): RegistryEntry[];
+    /**
+     * Get commands by category
+     */
+    getByCategory(category: CommandCategory): RegistryEntry[];
+    /**
+     * Get command names
+     */
+    getNames(): string[];
+    /**
+     * Clear all registered commands
+     */
+    clear(): void;
+    /**
+     * Get the number of registered commands
+     */
+    get size(): number;
+    /**
+     * Check and update availability for a command metadata
+     */
+    private checkAvailability;
+    /**
+     * Get missing dependencies
+     */
+    private getMissingDependencies;
+    /**
+     * Update availability for all commands
+     */
+    private updateAvailability;
+    /**
+     * Get dependency status for a command
+     */
+    getDependencyStatus(name: string): {
+        satisfied: IntegrationDependency[];
+        missing: IntegrationDependency[];
+    } | null;
+}
+/**
+ * Create a new command registry
+ */
+declare function createCommandRegistry(): CommandRegistry;
+/**
+ * Get or create the global command registry
+ */
+declare function getGlobalRegistry(): CommandRegistry;
+/**
+ * Reset the global registry (primarily for testing)
+ */
+declare function resetGlobalRegistry(): void;
+
+/**
+ * Command Loader
+ *
+ * Loads commands from markdown files in the coreai/commands/ directory.
+ */
+
+/**
+ * Load a single command from a markdown file
+ */
+declare function loadCommandFromFile(filePath: string, baseDir: string, categoryOverride?: CommandCategory): Promise<MarkdownCommand>;
+/**
+ * Load commands from a directory
+ */
+declare function loadCommandsFromDirectory(options: CommandLoaderOptions): Promise<CommandLoadResult>;
+/**
+ * Load commands from the default CoreAI commands directory
+ */
+declare function loadCoreAICommands(projectRoot: string): Promise<CommandLoadResult>;
+/**
+ * Load commands from both core and custom directories
+ */
+declare function loadAllCommands(coreCommandsDir: string, customCommandsDir?: string): Promise<CommandLoadResult>;
+
+/**
+ * Command Runner
+ *
+ * Executes commands with graceful degradation support.
+ */
+
+/**
+ * Options for running a command
+ */
+interface RunCommandOptions extends BaseCommandOptions {
+    /**
+     * Pre-created command context
+     */
+    context?: CommandContext;
+    /**
+     * Whether to clean up context after execution
+     */
+    cleanupAfter?: boolean;
+}
+/**
+ * Run a registered command
+ */
+declare function runCommand<TResult = unknown>(registry: CommandRegistry, name: string, args: string[], options?: RunCommandOptions): Promise<CommandResult<TResult>>;
+/**
+ * Execute a step with graceful degradation
+ *
+ * If the required integration is not available, returns a skip result instead of failing.
+ */
+declare function executeWithDegradation<T>(context: CommandContext, dependency: IntegrationDependency, step: () => Promise<T>, fallback?: () => Promise<T>): Promise<{
+    result: T | null;
+    skipped: boolean;
+    reason?: string;
+}>;
+/**
+ * Create a command handler with automatic degradation tracking
+ */
+declare function createDegradingHandler<TOptions extends BaseCommandOptions, TResult>(handler: (args: string[], options: TOptions, context: CommandContext, track: StepTracker) => Promise<TResult>): CommandDefinition<TOptions, TResult>['handler'];
+/**
+ * Tracks skipped steps and warnings during command execution
+ */
+declare class StepTracker {
+    readonly skippedSteps: {
+        step: string;
+        reason: string;
+    }[];
+    readonly warnings: string[];
+    /**
+     * Record a skipped step
+     */
+    skip(step: string, reason: string): void;
+    /**
+     * Record a warning
+     */
+    warn(message: string): void;
+    /**
+     * Execute a step with optional fallback
+     */
+    tryStep<T>(stepName: string, context: CommandContext, dependency: IntegrationDependency, step: () => Promise<T>, fallback?: () => Promise<T>): Promise<T | null>;
+}
+
+/**
+ * Skill Types
+ *
+ * Type definitions for skill generation and templates.
+ */
+
+/**
+ * Skill category
+ */
+type SkillCategory = 'core' | 'optional' | 'custom';
+/**
+ * Integration dependency for a skill
+ */
+interface SkillDependency {
+    /**
+     * Integration type required
+     */
+    type: AdapterType;
+    /**
+     * Whether this integration is required (vs optional)
+     */
+    required: boolean;
+    /**
+     * Description of why this integration is needed
+     */
+    description?: string;
+}
+/**
+ * Skill template definition
+ */
+interface SkillTemplate {
+    /**
+     * Template name/identifier
+     */
+    name: string;
+    /**
+     * Human-readable description
+     */
+    description: string;
+    /**
+     * Hint for command arguments
+     */
+    argumentHint?: string;
+    /**
+     * Skill category
+     */
+    category: SkillCategory;
+    /**
+     * Integration dependencies
+     */
+    dependencies?: SkillDependency[];
+    /**
+     * Markdown content with placeholders
+     */
+    content: string;
+}
+/**
+ * Variables available for substitution in skill templates
+ */
+interface SkillVariables {
+    PROJECT_NAME?: string;
+    PROJECT_ROOT?: string;
+    PROJECT_TYPE?: string;
+    JIRA_PROJECT?: string;
+    JIRA_URL?: string;
+    LINEAR_TEAM?: string;
+    GITHUB_REPO?: string;
+    GITHUB_OWNER?: string;
+    GITLAB_PROJECT?: string;
+    DEFAULT_BRANCH?: string;
+    CONFLUENCE_SPACE?: string;
+    CONFLUENCE_URL?: string;
+    NOTION_WORKSPACE?: string;
+    DOCS_PATH?: string;
+    LINT_CMD?: string;
+    TEST_CMD?: string;
+    BUILD_CMD?: string;
+    STATIC_ANALYSIS_CMD?: string;
+    PRIMARY_LANGUAGE?: string;
+    [key: string]: string | undefined;
+}
+/**
+ * Options for generating skills
+ */
+interface GenerateSkillsOptions {
+    /**
+     * Project root directory
+     */
+    projectRoot?: string;
+    /**
+     * Output directory for generated skills
+     * Default: .claude/commands
+     */
+    outputDir?: string;
+    /**
+     * Directory containing custom skill templates
+     */
+    customTemplatesDir?: string;
+    /**
+     * Whether to include core skills
+     * Default: true
+     */
+    includeCoreSkills?: boolean;
+    /**
+     * Whether to include optional skills based on integrations
+     * Default: true
+     */
+    includeOptionalSkills?: boolean;
+    /**
+     * Specific skills to generate (by name)
+     * If not specified, generates all applicable skills
+     */
+    skills?: string[];
+    /**
+     * Whether to overwrite existing skills
+     * Default: false
+     */
+    overwrite?: boolean;
+    /**
+     * Additional variables for substitution
+     */
+    variables?: Record<string, string>;
+}
+/**
+ * Result of generating a single skill
+ */
+interface GeneratedSkill {
+    /**
+     * Skill name
+     */
+    name: string;
+    /**
+     * Category of the skill
+     */
+    category: SkillCategory;
+    /**
+     * Output path where skill was written
+     */
+    outputPath: string;
+    /**
+     * Whether the skill was newly created or updated
+     */
+    action: 'created' | 'updated' | 'skipped';
+    /**
+     * Reason for skipping (if applicable)
+     */
+    skipReason?: string;
+}
+/**
+ * Error from skill generation
+ */
+interface SkillError {
+    /**
+     * Skill name that failed
+     */
+    name: string;
+    /**
+     * Error message
+     */
+    error: string;
+}
+/**
+ * Result of skill generation
+ */
+interface GenerateSkillsResult {
+    /**
+     * Successfully generated skills
+     */
+    generated: GeneratedSkill[];
+    /**
+     * Skills that failed to generate
+     */
+    errors: SkillError[];
+    /**
+     * Variables used for substitution
+     */
+    variables: SkillVariables;
+}
+
+/**
+ * Skill Generator
+ *
+ * Generates Claude skills from templates based on project configuration.
+ * Skills are output to .claude/commands/ directory.
+ */
+
+/**
+ * Extract variables from config for template substitution
+ */
+declare function extractVariables(config?: ResolvedCoreAIConfig | null): SkillVariables;
+/**
+ * Substitute variables in template content
+ */
+declare function substituteVariables(content: string, variables: SkillVariables): string;
+/**
+ * Check if a skill's dependencies are satisfied
+ */
+declare function checkDependencies(skill: SkillTemplate, config?: ResolvedCoreAIConfig | null): {
+    satisfied: boolean;
+    missing: SkillDependency[];
+};
+/**
+ * Load custom skill templates from a directory
+ */
+declare function loadCustomTemplates(templatesDir: string): SkillTemplate[];
+/**
+ * Generate skills from templates
+ */
+declare function generateSkills(config: ResolvedCoreAIConfig | undefined, options?: GenerateSkillsOptions): GenerateSkillsResult;
+/**
+ * Format skill generation result for display
+ */
+declare function formatGenerateResult(result: GenerateSkillsResult): string;
+
+/**
+ * Built-in Skill Templates
+ *
+ * Core skill templates that are included with CoreAI.
+ * These templates use {{VARIABLE}} placeholders for substitution.
+ */
+
+/**
+ * All built-in skill templates
+ */
+declare const builtInSkills: SkillTemplate[];
+
+/**
+ * KnowledgeLibrary Types
+ *
+ * Type definitions for local agent state management.
+ */
+/**
+ * Message type for inbox/outbox messages
+ */
+type MessageType = 'task-assignment' | 'completion-report' | 'review-request' | 'feedback' | 'status-update' | 'question' | 'response';
+/**
+ * Priority levels for messages
+ */
+type MessagePriority = 'P0' | 'P1' | 'P2' | 'P3';
+/**
+ * Message metadata from frontmatter
+ */
+interface MessageMetadata {
+    /**
+     * Message type
+     */
+    type: MessageType;
+    /**
+     * Sender agent name
+     */
+    from: string;
+    /**
+     * Recipient agent name
+     */
+    to: string;
+    /**
+     * Timestamp of the message
+     */
+    date: Date;
+    /**
+     * Associated ticket key (optional)
+     */
+    ticket?: string;
+    /**
+     * Message priority (optional)
+     */
+    priority?: MessagePriority;
+    /**
+     * Message subject
+     */
+    subject?: string;
+}
+/**
+ * An inbox/outbox message
+ */
+interface Message {
+    /**
+     * Message filename
+     */
+    filename: string;
+    /**
+     * Full file path
+     */
+    path: string;
+    /**
+     * Message metadata from frontmatter
+     */
+    metadata: MessageMetadata;
+    /**
+     * Raw message content (including frontmatter)
+     */
+    rawContent: string;
+    /**
+     * Message body (excluding frontmatter)
+     */
+    body: string;
+}
+/**
+ * Agent context state
+ */
+interface AgentContext {
+    /**
+     * Current task or assignment
+     */
+    currentTask?: string;
+    /**
+     * Current ticket being worked on
+     */
+    currentTicket?: string;
+    /**
+     * Current state/status
+     */
+    status?: string;
+    /**
+     * Last updated timestamp
+     */
+    lastUpdated: Date;
+    /**
+     * Additional context notes
+     */
+    notes?: string;
+}
+/**
+ * Agent objective entry
+ */
+interface Objective {
+    /**
+     * Objective description
+     */
+    description: string;
+    /**
+     * Success criteria
+     */
+    successCriteria?: string[];
+    /**
+     * Deadline (optional)
+     */
+    deadline?: Date;
+    /**
+     * Priority
+     */
+    priority?: MessagePriority;
+    /**
+     * Status
+     */
+    status: 'pending' | 'in_progress' | 'completed' | 'blocked';
+}
+/**
+ * Decision log entry
+ */
+interface Decision {
+    /**
+     * Decision timestamp
+     */
+    date: Date;
+    /**
+     * What was decided
+     */
+    decision: string;
+    /**
+     * Context/reasoning
+     */
+    reasoning?: string;
+    /**
+     * Related ticket or task
+     */
+    relatedTo?: string;
+}
+/**
+ * Dependency tracking entry
+ */
+interface Dependency {
+    /**
+     * What this agent/task depends on
+     */
+    blockedBy?: string[];
+    /**
+     * What depends on this agent/task
+     */
+    blocking?: string[];
+    /**
+     * Last updated
+     */
+    lastUpdated: Date;
+}
+/**
+ * Agent control state (objectives, decisions, dependencies)
+ */
+interface AgentControl {
+    objectives: Objective[];
+    decisions: Decision[];
+    dependencies: Dependency;
+}
+/**
+ * Directory paths within an agent's KnowledgeLibrary
+ */
+interface AgentDirectories {
+    /**
+     * Root directory for this agent
+     */
+    root: string;
+    /**
+     * Inbox for incoming messages
+     */
+    inbox: string;
+    /**
+     * Processed messages archive
+     */
+    inboxProcessed: string;
+    /**
+     * Outbox for sent messages
+     */
+    outbox: string;
+    /**
+     * Context directory
+     */
+    context: string;
+    /**
+     * Control directory (objectives, decisions, dependencies)
+     */
+    control: string;
+    /**
+     * Historical records
+     */
+    history: string;
+    /**
+     * Technical notes and research
+     */
+    tech: string;
+}
+/**
+ * Full KnowledgeLibrary state for an agent
+ */
+interface AgentKnowledgeState {
+    /**
+     * Agent name/identifier
+     */
+    agentName: string;
+    /**
+     * Directory paths
+     */
+    directories: AgentDirectories;
+    /**
+     * Current context
+     */
+    context?: AgentContext;
+    /**
+     * Control state
+     */
+    control?: AgentControl;
+    /**
+     * Unprocessed inbox messages
+     */
+    pendingMessages: Message[];
+    /**
+     * Initialization status
+     */
+    initialized: boolean;
+}
+/**
+ * Options for initializing KnowledgeLibrary
+ */
+interface InitKnowledgeLibraryOptions {
+    /**
+     * Project root directory
+     */
+    projectRoot?: string;
+    /**
+     * Base directory for KnowledgeLibrary
+     * Default: KnowledgeLibrary
+     */
+    basePath?: string;
+    /**
+     * Whether to create default files
+     */
+    createDefaults?: boolean;
+}
+/**
+ * Result of KnowledgeLibrary initialization
+ */
+interface InitKnowledgeLibraryResult {
+    /**
+     * Whether initialization was successful
+     */
+    success: boolean;
+    /**
+     * Created directories
+     */
+    createdDirs: string[];
+    /**
+     * Created files
+     */
+    createdFiles: string[];
+    /**
+     * Error message if failed
+     */
+    error?: string;
+}
+/**
+ * Options for reading messages
+ */
+interface ReadMessagesOptions {
+    /**
+     * Filter by message type
+     */
+    type?: MessageType;
+    /**
+     * Filter by sender
+     */
+    from?: string;
+    /**
+     * Filter by priority
+     */
+    priority?: MessagePriority;
+    /**
+     * Include processed messages
+     */
+    includeProcessed?: boolean;
+    /**
+     * Maximum number of messages to return
+     */
+    limit?: number;
+}
+/**
+ * Options for writing a message
+ */
+interface WriteMessageOptions {
+    /**
+     * Message type
+     */
+    type: MessageType;
+    /**
+     * Sender agent
+     */
+    from: string;
+    /**
+     * Recipient agent
+     */
+    to: string;
+    /**
+     * Message subject
+     */
+    subject: string;
+    /**
+     * Message body content
+     */
+    body: string;
+    /**
+     * Associated ticket key
+     */
+    ticket?: string;
+    /**
+     * Message priority
+     */
+    priority?: MessagePriority;
+}
+/**
+ * Global KnowledgeLibrary state
+ */
+interface KnowledgeLibraryState {
+    /**
+     * Base path for KnowledgeLibrary
+     */
+    basePath: string;
+    /**
+     * Global context file path
+     */
+    contextPath: string;
+    /**
+     * Architecture notes file path
+     */
+    architecturePath: string;
+    /**
+     * PRD file path
+     */
+    prdPath: string;
+    /**
+     * List of initialized agents
+     */
+    agents: string[];
+}
+
+/**
+ * KnowledgeLibrary Manager
+ *
+ * Manages the KnowledgeLibrary directory structure and agent state.
+ */
+
+/**
+ * Default KnowledgeLibrary base path
+ */
+declare const DEFAULT_KNOWLEDGE_LIBRARY_PATH = "KnowledgeLibrary";
+/**
+ * Standard files in a KnowledgeLibrary
+ */
+declare const STANDARD_FILES: {
+    readonly context: "context.txt";
+    readonly architecture: "architecture.txt";
+    readonly prd: "prd.txt";
+};
+/**
+ * Standard directories for each agent
+ */
+declare const AGENT_DIRECTORIES: readonly ["inbox", "inbox/processed", "outbox", "context", "control", "history", "tech"];
+/**
+ * Standard files in an agent's control directory
+ */
+declare const CONTROL_FILES: {
+    readonly objectives: "objectives.txt";
+    readonly decisions: "decisions.txt";
+    readonly dependencies: "dependencies.txt";
+};
+/**
+ * Get the path to an agent's directories
+ */
+declare function getAgentDirectories(basePath: string, agentName: string): AgentDirectories;
+/**
+ * Initialize the KnowledgeLibrary base structure
+ */
+declare function initKnowledgeLibrary(options?: InitKnowledgeLibraryOptions): InitKnowledgeLibraryResult;
+/**
+ * Initialize an agent's KnowledgeLibrary directories
+ */
+declare function initAgentKnowledgeLibrary(agentName: string, options?: InitKnowledgeLibraryOptions): InitKnowledgeLibraryResult;
+/**
+ * Check if a KnowledgeLibrary exists for an agent
+ */
+declare function agentKnowledgeLibraryExists(agentName: string, options?: {
+    projectRoot?: string;
+    basePath?: string;
+}): boolean;
+/**
+ * Get the KnowledgeLibrary state for an agent
+ */
+declare function getAgentKnowledgeState(agentName: string, options?: {
+    projectRoot?: string;
+    basePath?: string;
+}): AgentKnowledgeState;
+/**
+ * Generate a message filename
+ */
+declare function generateMessageFilename(from: string, subject: string): string;
+/**
+ * Read inbox messages for an agent
+ */
+declare function readInboxMessages(agentName: string, options?: {
+    projectRoot?: string;
+    basePath?: string;
+} & ReadMessagesOptions): Message[];
+/**
+ * Write a message to an agent's inbox
+ */
+declare function writeInboxMessage(options: WriteMessageOptions & {
+    projectRoot?: string;
+    basePath?: string;
+}): {
+    success: boolean;
+    path?: string;
+    error?: string;
+};
+/**
+ * Mark a message as processed (move to processed folder)
+ */
+declare function markMessageProcessed(agentName: string, messageFilename: string, options?: {
+    projectRoot?: string;
+    basePath?: string;
+}): {
+    success: boolean;
+    error?: string;
+};
+/**
+ * Get global KnowledgeLibrary state
+ */
+declare function getKnowledgeLibraryState(options?: {
+    projectRoot?: string;
+    basePath?: string;
+}): KnowledgeLibraryState | null;
+/**
+ * Update agent context
+ */
+declare function updateAgentContext(agentName: string, context: Partial<AgentContext>, options?: {
+    projectRoot?: string;
+    basePath?: string;
+}): {
+    success: boolean;
+    error?: string;
+};
+/**
+ * Format KnowledgeLibrary state for display
+ */
+declare function formatKnowledgeLibraryState(state: KnowledgeLibraryState | null): string;
+/**
+ * Format agent knowledge state for display
+ */
+declare function formatAgentKnowledgeState(state: AgentKnowledgeState): string;
+
+/**
+ * CoreAI - A configurable, team-ready AI agent orchestration platform.
+ *
+ * This is the main library export for programmatic usage.
+ */
+declare const VERSION = "0.1.0";
+
+export { AGENT_DIRECTORIES, type Adapter, AdapterError, type AdapterErrorCode, AdapterFactory, type AdapterFactoryOptions, type AdapterImplementation, type AdapterInfo, type AdapterType, type AgentContext, type AgentControl, type AgentDefinition, type AgentDirectories, AgentError, type AgentErrorCode, type AgentKnowledgeState, type AgentMetadata, type AgentSource, type AgentType, type BaseAdapter, type BaseCommandOptions, CACHE_PATHS, CONTROL_FILES, type CacheConfig, type CacheEntry, CacheError, type CacheErrorCode, type CacheListOptions, type CacheManager$1 as CacheManager, type CacheManagerOptions, type CacheMetadata, type CacheOptions, type CacheProvider, type CacheSource, type CacheStats, type CacheStatus, type CommandArgumentDefinition, type CommandCategory, type CommandContext, type CommandDefinition, type CommandHandler, type CommandLoadResult, type CommandLoaderOptions, type CommandMetadata, type CommandOptionDefinition, CommandRegistry, type CommandResult, type CompileOptions, type CompileResult, ConfigError, type ConfigErrorCode, type ContextLoadResult, ContextLoader, type ContextLoaderOptions, type ContextSource, type CoreAIConfig, type CreateContextOptions, type CreateIssueData, type CreatePullRequestData, type CreateReviewData, DEFAULT_CACHE_CONFIG, DEFAULT_KNOWLEDGE_LIBRARY_PATH, type Decision, type Dependency, type DocumentationPage, type DocumentationProviderAdapter, type DocumentationQuery, type FetchOptions, CacheManager as FileCacheManager, FileCacheProvider, type FileCacheProviderOptions, type GenerateSkillsOptions, type GenerateSkillsResult, type GeneratedSkill, type GitProviderAdapter, type InitKnowledgeLibraryOptions, type InitKnowledgeLibraryResult, type IntegrationDependency, type IntegrationsConfig, type Issue, type IssueQuery, type IssueStatus, type IssueTrackerAdapter, type KnowledgeLibraryState, type LoadOptions, type MarkdownCommand, type Message, type MessageMetadata, type MessagePriority, type MessageType, type Objective, type ProjectConfig, type PullRequest, type PullRequestQuery, type PullRequestStatus, type QualityGatesConfig, type ReadMessagesOptions, type RegistryEntry, type RemoteFetcher, type ResolutionContext, ResolutionError, type ResolutionOptions, type ResolvedAgentDefinition, type ResolvedCoreAIConfig, type Review, type ReviewComment, type ReviewDecision, type RunCommandOptions, STANDARD_FILES, type SkillCategory, type SkillDependency, type SkillError, type SkillTemplate, type SkillVariables, type StateEntry, type StateOptions, type StateProviderAdapter, StepTracker, type SyncOptions, type SyncResult, type TeamConfig, type TechStackConfig, type UpdateIssueData, VERSION, type WorkflowType, type WriteMessageOptions, agentKnowledgeLibraryExists, builtInSkills, checkDependencies, cleanupContext, compileAgent, compileAgents, configExists, createAdapterFactory, createAdapterInfo, createCacheManager, createCommandContext, createCommandRegistry, createContextLoader, createDegradingHandler, createFileCacheProvider, executeWithDegradation, extractVariables as extractSkillVariables, extractVariables$1 as extractVariables, filterAgentsByTeam, findConfigFile, formatAgentKnowledgeState, formatGenerateResult, formatKnowledgeLibraryState, generateAgentMarkdown, generateMessageFilename, generateSkills, getAgentDirectories, getAgentKnowledgeState, getConfigPath, getCoreAgentsDir, getGlobalRegistry, getKnowledgeLibraryState, getRoleFromFilename, hasVariables, initAgentKnowledgeLibrary, initKnowledgeLibrary, loadAgentFromFile, loadAgentsFromDirectory, loadAllAgents, loadAllCommands, loadCommandFromFile, loadCommandsFromDirectory, loadConfig, loadConfigFromFile, loadCoreAICommands, loadCustomTemplates, markMessageProcessed, parseAgentYaml, readInboxMessages, resetGlobalRegistry, resolveAgentDefinition, resolveObject, resolveString, runCommand, substituteVariables, updateAgentContext, validateAgentDefinition, withContext, writeInboxMessage };