@skillkit/core 1.12.0 → 1.14.0

package/dist/index.d.ts

@@ -2350,7 +2350,7 @@ interface SearchOptions {
 /**
  * Search result
  */
-interface SearchResult {
+interface SearchResult$1 {
     skill: SkillSummary;
     relevance: number;
     matchedTerms: string[];
@@ -2427,7 +2427,7 @@ interface RecommendHybridSearchOptions extends SearchOptions {
 /**
  * Hybrid search result with additional metadata for RecommendationEngine
  */
-interface RecommendHybridSearchResult extends SearchResult {
+interface RecommendHybridSearchResult extends SearchResult$1 {
     hybridScore?: number;
     vectorSimilarity?: number;
     keywordScore?: number;
@@ -2654,7 +2654,7 @@ declare class RecommendationEngine {
     /**
      * Search skills by query (task-based search)
      */
-    search(options: SearchOptions): SearchResult[];
+    search(options: SearchOptions): SearchResult$1[];
     /**
      * Calculate search relevance for a skill
      */
@@ -4150,16 +4150,61 @@ interface MemorySearchResult {
     matchedTags: string[];
 }
 
+/**
+ * Auto-compression callback type
+ */
+type AutoCompressCallback = (observations: Observation[]) => Promise<void>;
+/**
+ * Observation store options
+ */
+interface ObservationStoreOptions {
+    compressionThreshold?: number;
+    autoCompress?: boolean;
+    onThresholdReached?: AutoCompressCallback;
+}
 declare class ObservationStore {
     private readonly filePath;
+    private readonly projectPath;
     private data;
     private sessionId;
-    constructor(projectPath: string, sessionId?: string);
+    private compressionThreshold;
+    private autoCompress;
+    private onThresholdReached?;
+    private compressionInProgress;
+    constructor(projectPath: string, sessionId?: string, options?: ObservationStoreOptions);
     private ensureDir;
     private load;
     private createEmpty;
     private save;
     add(type: ObservationType, content: ObservationContent, agent: AgentType, relevance?: number): Observation;
+    /**
+     * Check if auto-compression should trigger
+     */
+    private checkAutoCompression;
+    /**
+     * Set auto-compression callback
+     */
+    setAutoCompressCallback(callback: AutoCompressCallback): void;
+    /**
+     * Enable/disable auto-compression
+     */
+    setAutoCompress(enabled: boolean): void;
+    /**
+     * Set compression threshold
+     */
+    setCompressionThreshold(threshold: number): void;
+    /**
+     * Get compression threshold
+     */
+    getCompressionThreshold(): number;
+    /**
+     * Check if threshold is reached
+     */
+    isThresholdReached(): boolean;
+    /**
+     * Get project path
+     */
+    getProjectPath(): string;
     getAll(): Observation[];
     getByType(type: ObservationType): Observation[];
     getByRelevance(minRelevance: number): Observation[];
@@ -4861,6 +4906,646 @@ declare class MemoryInjector {
  */
 declare function createMemoryInjector(projectPath: string, projectName?: string, projectContext?: ProjectContext): MemoryInjector;
 
+/**
+ * Memory Hooks Types
+ *
+ * Types for Claude Code lifecycle hooks that integrate with SkillKit memory.
+ */
+
+/**
+ * Claude Code hook event types
+ */
+type ClaudeCodeHookEvent = 'SessionStart' | 'SessionResume' | 'SessionEnd' | 'PreToolUse' | 'PostToolUse' | 'UserPromptSubmit' | 'PreCompact' | 'Notification' | 'Stop';
+/**
+ * Tool use event for PostToolUse hook
+ */
+interface ToolUseEvent {
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+    tool_result?: string;
+    is_error?: boolean;
+    duration_ms?: number;
+}
+/**
+ * Session start event context
+ */
+interface SessionStartContext {
+    session_id: string;
+    project_path: string;
+    agent: AgentType;
+    timestamp: string;
+    working_directory?: string;
+}
+/**
+ * Session end event context
+ */
+interface SessionEndContext {
+    session_id: string;
+    project_path: string;
+    agent: AgentType;
+    timestamp: string;
+    duration_ms?: number;
+    tool_calls_count?: number;
+}
+/**
+ * Memory hook configuration
+ */
+interface MemoryHookConfig {
+    enabled: boolean;
+    autoInjectOnSessionStart: boolean;
+    autoCaptureToolUse: boolean;
+    autoCompressOnSessionEnd: boolean;
+    minRelevanceForCapture: number;
+    maxTokensForInjection: number;
+    compressionThreshold: number;
+    capturePatterns?: string[];
+    excludeTools?: string[];
+}
+/**
+ * Default memory hook configuration
+ */
+declare const DEFAULT_MEMORY_HOOK_CONFIG: MemoryHookConfig;
+/**
+ * Session start hook result
+ */
+interface SessionStartResult {
+    injected: boolean;
+    learnings: Learning[];
+    tokenCount: number;
+    formattedContent: string;
+}
+/**
+ * Tool use capture result
+ */
+interface ToolUseCaptureResult {
+    captured: boolean;
+    observation?: Observation;
+    reason?: string;
+}
+/**
+ * Session end hook result
+ */
+interface SessionEndResult {
+    compressed: boolean;
+    observationCount: number;
+    learningCount: number;
+    learnings: Learning[];
+}
+/**
+ * Hook script output format for Claude Code
+ */
+interface ClaudeCodeHookOutput {
+    continue: boolean;
+    message?: string;
+    inject?: string;
+    suppress?: boolean;
+}
+/**
+ * Memory hook statistics
+ */
+interface MemoryHookStats {
+    sessionId: string;
+    startedAt: string;
+    observationsCaptured: number;
+    learningsInjected: number;
+    tokensUsed: number;
+    toolCallsCaptured: number;
+    errorsRecorded: number;
+    solutionsRecorded: number;
+}
+
+/**
+ * Session Start Hook
+ *
+ * Injects relevant memories when a Claude Code session starts.
+ * This hook runs at the beginning of each session to provide context
+ * from previous sessions.
+ */
+
+/**
+ * Session Start Hook Handler
+ *
+ * Retrieves and formats relevant memories for injection at session start.
+ */
+declare class SessionStartHook {
+    private config;
+    private projectPath;
+    private agent;
+    constructor(projectPath: string, agent?: AgentType, config?: Partial<MemoryHookConfig>);
+    /**
+     * Execute the session start hook
+     */
+    execute(context: SessionStartContext): Promise<SessionStartResult>;
+    /**
+     * Generate Claude Code hook output format
+     */
+    generateHookOutput(context: SessionStartContext): Promise<ClaudeCodeHookOutput>;
+    /**
+     * Generate hook output from pre-computed result (avoids double execution)
+     */
+    generateHookOutputFromResult(result: SessionStartResult): ClaudeCodeHookOutput;
+    /**
+     * Format learnings for injection into Claude Code context
+     */
+    private formatInjection;
+    /**
+     * Get configuration
+     */
+    getConfig(): MemoryHookConfig;
+    /**
+     * Update configuration
+     */
+    setConfig(config: Partial<MemoryHookConfig>): void;
+}
+/**
+ * Create a session start hook handler
+ */
+declare function createSessionStartHook(projectPath: string, agent?: AgentType, config?: Partial<MemoryHookConfig>): SessionStartHook;
+/**
+ * Execute session start hook (standalone function for scripts)
+ */
+declare function executeSessionStartHook(projectPath: string, context: SessionStartContext, config?: Partial<MemoryHookConfig>): Promise<SessionStartResult>;
+
+/**
+ * Post Tool Use Hook
+ *
+ * Captures tool outcomes as observations after each tool use in Claude Code.
+ * This enables automatic memory capture without manual intervention.
+ */
+
+/**
+ * Post Tool Use Hook Handler
+ *
+ * Captures tool outcomes and stores them as observations.
+ */
+declare class PostToolUseHook {
+    private config;
+    private agent;
+    private store;
+    private pendingErrors;
+    constructor(projectPath: string, agent?: AgentType, config?: Partial<MemoryHookConfig>, sessionId?: string);
+    /**
+     * Execute the post tool use hook
+     */
+    execute(event: ToolUseEvent): Promise<ToolUseCaptureResult>;
+    /**
+     * Generate Claude Code hook output format
+     */
+    generateHookOutput(event: ToolUseEvent): Promise<ClaudeCodeHookOutput>;
+    /**
+     * Generate hook output from pre-computed result (avoids double execution)
+     */
+    generateHookOutputFromResult(event: ToolUseEvent, result: ToolUseCaptureResult): ClaudeCodeHookOutput;
+    /**
+     * Get configuration
+     */
+    getConfig(): MemoryHookConfig;
+    /**
+     * Update configuration
+     */
+    setConfig(config: Partial<MemoryHookConfig>): void;
+    /**
+     * Record an error explicitly
+     */
+    recordError(error: string, context: string): Observation;
+    /**
+     * Record a solution explicitly
+     */
+    recordSolution(solution: string, context: string, relatedError?: string): Observation;
+    /**
+     * Record a decision explicitly
+     */
+    recordDecision(decision: string, options: string[], context: string): Observation;
+    /**
+     * Record file modifications
+     */
+    recordFileChange(files: string[], action: string, context: string): Observation;
+    /**
+     * Get pending errors that haven't been resolved
+     */
+    getPendingErrors(): Array<{
+        error: string;
+        timestamp: string;
+    }>;
+    /**
+     * Clear old pending errors (older than 30 minutes)
+     */
+    clearOldPendingErrors(): number;
+    /**
+     * Get observation store
+     */
+    getStore(): ObservationStore;
+    /**
+     * Get observation count
+     */
+    getObservationCount(): number;
+    private shouldExcludeTool;
+    private calculateRelevance;
+    private getObservationType;
+    private extractContent;
+    private summarizeInput;
+    private extractContext;
+    private extractFiles;
+    private generateErrorId;
+    private findMatchingSolution;
+}
+/**
+ * Create a post tool use hook handler
+ */
+declare function createPostToolUseHook(projectPath: string, agent?: AgentType, config?: Partial<MemoryHookConfig>, sessionId?: string): PostToolUseHook;
+/**
+ * Execute post tool use hook (standalone function for scripts)
+ */
+declare function executePostToolUseHook(projectPath: string, event: ToolUseEvent, config?: Partial<MemoryHookConfig>, sessionId?: string): Promise<ToolUseCaptureResult>;
+
+/**
+ * Session End Hook
+ *
+ * Compresses observations to learnings when a Claude Code session ends.
+ * This enables automatic memory consolidation without manual intervention.
+ */
+
+/**
+ * Session End Hook Handler
+ *
+ * Compresses observations collected during the session into learnings.
+ */
+declare class SessionEndHook {
+    private config;
+    private projectPath;
+    private agent;
+    constructor(projectPath: string, agent?: AgentType, config?: Partial<MemoryHookConfig>);
+    /**
+     * Execute the session end hook
+     */
+    execute(context: SessionEndContext): Promise<SessionEndResult>;
+    /**
+     * Generate Claude Code hook output format
+     */
+    generateHookOutput(context: SessionEndContext): Promise<ClaudeCodeHookOutput>;
+    /**
+     * Generate hook output from pre-computed result (avoids double execution)
+     */
+    generateHookOutputFromResult(result: SessionEndResult): ClaudeCodeHookOutput;
+    /**
+     * Force compression regardless of settings
+     */
+    forceCompress(sessionId?: string): Promise<SessionEndResult>;
+    /**
+     * Preview what would be compressed (dry-run)
+     */
+    preview(sessionId?: string): Promise<{
+        wouldCompress: boolean;
+        observationCount: number;
+        estimatedLearnings: number;
+        observationTypes: Record<string, number>;
+    }>;
+    /**
+     * Get configuration
+     */
+    getConfig(): MemoryHookConfig;
+    /**
+     * Update configuration
+     */
+    setConfig(config: Partial<MemoryHookConfig>): void;
+}
+/**
+ * Create a session end hook handler
+ */
+declare function createSessionEndHook(projectPath: string, agent?: AgentType, config?: Partial<MemoryHookConfig>): SessionEndHook;
+/**
+ * Execute session end hook (standalone function for scripts)
+ */
+declare function executeSessionEndHook(projectPath: string, context: SessionEndContext, config?: Partial<MemoryHookConfig>): Promise<SessionEndResult>;
+
+/**
+ * Memory Hook Manager
+ *
+ * Unified manager for all memory lifecycle hooks.
+ * Provides a single interface for session memory management.
+ */
+
+/**
+ * Memory Hook Manager
+ *
+ * Coordinates all memory hooks for a session.
+ */
+declare class MemoryHookManager {
+    private config;
+    private projectPath;
+    private agent;
+    private sessionId;
+    private startedAt;
+    private sessionStartHook;
+    private postToolUseHook;
+    private sessionEndHook;
+    private stats;
+    constructor(projectPath: string, agent?: AgentType, config?: Partial<MemoryHookConfig>, sessionId?: string);
+    /**
+     * Handle session start
+     */
+    onSessionStart(workingDirectory?: string): Promise<ClaudeCodeHookOutput>;
+    /**
+     * Handle tool use
+     */
+    onToolUse(event: ToolUseEvent): Promise<ClaudeCodeHookOutput>;
+    /**
+     * Handle session end
+     */
+    onSessionEnd(toolCallsCount?: number): Promise<ClaudeCodeHookOutput>;
+    /**
+     * Record an error manually
+     */
+    recordError(error: string, context: string): Observation;
+    /**
+     * Record a solution manually
+     */
+    recordSolution(solution: string, context: string, relatedError?: string): Observation;
+    /**
+     * Record a decision manually
+     */
+    recordDecision(decision: string, options: string[], context: string): Observation;
+    /**
+     * Record file changes manually
+     */
+    recordFileChange(files: string[], action: string, context: string): Observation;
+    /**
+     * Force compression (regardless of threshold)
+     */
+    forceCompress(): Promise<Learning[]>;
+    /**
+     * Preview compression without executing
+     */
+    previewCompression(): Promise<{
+        wouldCompress: boolean;
+        observationCount: number;
+        estimatedLearnings: number;
+        observationTypes: Record<string, number>;
+    }>;
+    /**
+     * Get current stats
+     */
+    getStats(): MemoryHookStats;
+    /**
+     * Get session ID
+     */
+    getSessionId(): string;
+    /**
+     * Get observation count
+     */
+    getObservationCount(): number;
+    /**
+     * Get pending errors
+     */
+    getPendingErrors(): Array<{
+        error: string;
+        timestamp: string;
+    }>;
+    /**
+     * Get configuration
+     */
+    getConfig(): MemoryHookConfig;
+    /**
+     * Update configuration
+     */
+    setConfig(config: Partial<MemoryHookConfig>): void;
+    /**
+     * Check if auto-compression should trigger
+     */
+    private checkAutoCompression;
+    /**
+     * Generate Claude Code hooks.json configuration
+     */
+    generateClaudeCodeHooksConfig(): Record<string, unknown>;
+}
+/**
+ * Create a memory hook manager
+ */
+declare function createMemoryHookManager(projectPath: string, agent?: AgentType, config?: Partial<MemoryHookConfig>, sessionId?: string): MemoryHookManager;
+
+/**
+ * CLAUDE.md Auto-Updater
+ *
+ * Automatically updates CLAUDE.md with learnings from memory.
+ * Populates the LEARNED section with high-effectiveness insights.
+ */
+
+/**
+ * Update options
+ */
+interface ClaudeMdUpdateOptions {
+    minEffectiveness?: number;
+    maxLearnings?: number;
+    includeGlobal?: boolean;
+    preserveManualEntries?: boolean;
+    sectionTitle?: string;
+    addTimestamp?: boolean;
+}
+/**
+ * Parsed CLAUDE.md structure
+ */
+interface ParsedClaudeMd {
+    content: string;
+    sections: Map<string, {
+        start: number;
+        end: number;
+        content: string;
+    }>;
+    hasLearnedSection: boolean;
+    learnedSectionContent?: string;
+    learnedSectionRange?: {
+        start: number;
+        end: number;
+    };
+}
+/**
+ * Update result
+ */
+interface ClaudeMdUpdateResult {
+    updated: boolean;
+    path: string;
+    learningsAdded: number;
+    learningSummaries: string[];
+    previousLearnings: number;
+}
+/**
+ * CLAUDE.md Updater
+ *
+ * Manages automatic updates to CLAUDE.md with learnings from memory.
+ */
+declare class ClaudeMdUpdater {
+    private projectPath;
+    private claudeMdPath;
+    constructor(projectPath: string, claudeMdPath?: string);
+    /**
+     * Parse CLAUDE.md to extract structure
+     */
+    parse(): ParsedClaudeMd;
+    /**
+     * Get learnings to add to CLAUDE.md
+     */
+    getLearningsForClaudeMd(options?: ClaudeMdUpdateOptions): Learning[];
+    /**
+     * Format learnings as CLAUDE.md LEARNED section
+     */
+    formatLearnedSection(learnings: Learning[], options?: ClaudeMdUpdateOptions): string;
+    /**
+     * Update CLAUDE.md with learnings
+     */
+    update(options?: ClaudeMdUpdateOptions): ClaudeMdUpdateResult;
+    /**
+     * Preview update without writing
+     */
+    preview(options?: ClaudeMdUpdateOptions): {
+        learnings: Learning[];
+        formattedSection: string;
+        wouldUpdate: boolean;
+    };
+    /**
+     * Check if CLAUDE.md exists
+     */
+    exists(): boolean;
+    /**
+     * Get CLAUDE.md path
+     */
+    getPath(): string;
+    private categorizeLearnings;
+    private formatLearningTitle;
+    private extractSummary;
+    private extractManualEntries;
+    private combineWithManualEntries;
+    private countLearnings;
+    private createNewClaudeMd;
+}
+/**
+ * Create a CLAUDE.md updater
+ */
+declare function createClaudeMdUpdater(projectPath: string, claudeMdPath?: string): ClaudeMdUpdater;
+/**
+ * Update CLAUDE.md with learnings (standalone function)
+ */
+declare function updateClaudeMd(projectPath: string, options?: ClaudeMdUpdateOptions): ClaudeMdUpdateResult;
+/**
+ * Sync global CLAUDE.md with global learnings
+ */
+declare function syncGlobalClaudeMd(options?: ClaudeMdUpdateOptions): ClaudeMdUpdateResult;
+
+/**
+ * Progressive Disclosure System
+ *
+ * Implements 3-layer token-optimized retrieval for efficient context usage:
+ * - Layer 1: Index (titles, timestamps, IDs) - ~50-100 tokens
+ * - Layer 2: Timeline (context around observations) - ~200 tokens
+ * - Layer 3: Details (full content) - ~500-1000 tokens
+ */
+/**
+ * Index entry (Layer 1)
+ * Minimal information for fast scanning
+ */
+interface IndexEntry {
+    id: string;
+    title: string;
+    timestamp: string;
+    tags: string[];
+    scope: 'project' | 'global';
+    effectiveness?: number;
+    useCount: number;
+}
+/**
+ * Timeline entry (Layer 2)
+ * Context around the learning with activity timeline
+ */
+interface TimelineEntry extends IndexEntry {
+    excerpt: string;
+    frameworks?: string[];
+    patterns?: string[];
+    sourceCount: number;
+    lastUsed?: string;
+    activityTimeline?: ActivityPoint[];
+}
+/**
+ * Activity point for timeline
+ */
+interface ActivityPoint {
+    timestamp: string;
+    type: 'created' | 'used' | 'updated' | 'rated';
+    description?: string;
+}
+/**
+ * Details entry (Layer 3)
+ * Full content with all metadata
+ */
+interface DetailsEntry extends TimelineEntry {
+    content: string;
+    sourceObservations?: string[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Progressive disclosure options
+ */
+interface ProgressiveDisclosureOptions {
+    includeGlobal?: boolean;
+    minRelevance?: number;
+    maxResults?: number;
+}
+/**
+ * Progressive Disclosure Manager
+ *
+ * Provides 3-layer retrieval for optimal token usage.
+ */
+declare class ProgressiveDisclosureManager {
+    private projectStore;
+    private globalStore;
+    constructor(projectPath: string, projectName?: string);
+    /**
+     * Layer 1: Get index of all learnings
+     * Minimal tokens (~50-100 per entry)
+     */
+    getIndex(options?: ProgressiveDisclosureOptions): IndexEntry[];
+    /**
+     * Layer 2: Get timeline entries for specific IDs
+     * Medium tokens (~200 per entry)
+     */
+    getTimeline(ids: string[], options?: ProgressiveDisclosureOptions): TimelineEntry[];
+    /**
+     * Layer 3: Get full details for specific IDs
+     * High tokens (~500-1000 per entry)
+     */
+    getDetails(ids: string[], options?: ProgressiveDisclosureOptions): DetailsEntry[];
+    /**
+     * Smart retrieval with automatic layer selection
+     * Uses minimum tokens needed to satisfy the query.
+     *
+     * Note: tokensUsed reflects cumulative cost of the retrieval operation
+     * (index lookup + any deeper layer fetches), not just the returned entries.
+     * This is intentional since progressive disclosure requires scanning
+     * the index first before fetching timeline/details.
+     */
+    smartRetrieve(query: string, tokenBudget?: number, options?: ProgressiveDisclosureOptions): {
+        layer: 1 | 2 | 3;
+        entries: IndexEntry[] | TimelineEntry[] | DetailsEntry[];
+        tokensUsed: number;
+        tokensRemaining: number;
+    };
+    /**
+     * Estimate tokens for a given layer and count
+     */
+    estimateTokens(layer: 1 | 2 | 3, count: number): number;
+    /**
+     * Format entries for injection
+     */
+    formatForInjection(entries: IndexEntry[] | TimelineEntry[] | DetailsEntry[], layer: 1 | 2 | 3): string;
+    private toIndexEntry;
+    private toTimelineEntry;
+    private toDetailsEntry;
+    private buildActivityTimeline;
+    private findRelevantIds;
+}
+/**
+ * Create a progressive disclosure manager
+ */
+declare function createProgressiveDisclosureManager(projectPath: string, projectName?: string): ProgressiveDisclosureManager;
+
 /**
  * Team Collaboration Types
  */
@@ -5517,7 +6202,7 @@ interface MethodologyManagerOptions {
 /**
  * Result of pack/skill installation
  */
-interface InstallResult {
+interface InstallResult$1 {
     /** Whether installation succeeded */
     success: boolean;
     /** Installed items */
@@ -5693,15 +6378,15 @@ declare class MethodologyManager {
     /**
      * Install a methodology pack
      */
-    installPack(packName: string): Promise<InstallResult>;
+    installPack(packName: string): Promise<InstallResult$1>;
     /**
      * Install all available packs
      */
-    installAllPacks(): Promise<InstallResult>;
+    installAllPacks(): Promise<InstallResult$1>;
     /**
      * Install a single skill by ID
      */
-    installSkill(skillId: string): Promise<InstallResult>;
+    installSkill(skillId: string): Promise<InstallResult$1>;
     /**
      * Uninstall a pack
      */
@@ -7907,7 +8592,7 @@ interface GeneratedSkill {
     reasoning: string;
 }
 interface AIConfig {
-    provider: 'anthropic' | 'openai' | 'none';
+    provider: 'anthropic' | 'openai' | 'google' | 'ollama' | 'openrouter' | 'mock' | 'none';
     apiKey?: string;
     model?: string;
     maxTokens?: number;
@@ -7976,14 +8661,717 @@ declare abstract class BaseAIProvider implements AIProvider {
     protected parseGenerateResponse(response: string): GeneratedSkill;
 }
 
-declare class MockAIProvider extends BaseAIProvider {
+type ProviderName = 'anthropic' | 'openai' | 'google' | 'ollama' | 'openrouter' | 'mock';
+interface ProviderConfig {
+    apiKey?: string;
+    model?: string;
+    baseUrl?: string;
+    maxTokens?: number;
+    temperature?: number;
+}
+interface GenerationContext {
+    expertise: string;
+    contextChunks: ContextChunk[];
+    clarifications: ClarificationAnswer[];
+    targetAgents: string[];
+    composedFrom?: string[];
+    memoryPatterns?: MemoryPattern[];
+}
+interface ContextChunk {
+    source: 'docs' | 'codebase' | 'skills' | 'memory';
+    content: string;
+    relevance: number;
+    metadata?: Record<string, unknown>;
+}
+interface ClarificationQuestion {
+    id: string;
+    question: string;
+    options?: string[];
+    type: 'text' | 'select' | 'confirm' | 'multiselect';
+    context?: string;
+}
+interface ClarificationAnswer {
+    questionId: string;
+    answer: string | string[] | boolean;
+}
+interface MemoryPattern {
+    category: string;
+    pattern: string;
+    confidence: number;
+}
+interface GeneratedSkillResult extends GeneratedSkill {
+    composedFrom?: string[];
+    agentVariants?: Record<string, string>;
+}
+interface WizardContext {
+    expertise: string;
+    contextSources: ContextSourceConfig[];
+    composableSkills?: ComposableSkill[];
+    clarifications: ClarificationAnswer[];
+    targetAgents: string[];
+    memoryPersonalization: boolean;
+    gatheredContext?: ContextChunk[];
+}
+interface ContextSourceConfig {
+    name: 'docs' | 'codebase' | 'skills' | 'memory';
+    enabled: boolean;
+    weight?: number;
+}
+interface ComposableSkill {
     name: string;
-    search(query: string, skills: SearchableSkill[]): Promise<AISearchResult[]>;
-    generateSkill(example: SkillExample): Promise<GeneratedSkill>;
+    description?: string;
+    content: string;
+    trustScore: number;
+    relevance: number;
+    source?: string;
+}
+interface LLMProvider {
+    readonly name: ProviderName;
+    readonly displayName: string;
+    generateSkill(context: GenerationContext): Promise<GeneratedSkillResult>;
+    generateClarifications(context: WizardContext): Promise<ClarificationQuestion[]>;
+    optimizeForAgent(skillContent: string, agentId: string): Promise<string>;
+    search(query: string, skills: SearchableSkill[]): Promise<SearchResult[]>;
+    generateFromExample(example: SkillExample): Promise<GeneratedSkill>;
+    chat(messages: ChatMessage[]): Promise<string>;
+    isConfigured(): boolean;
+}
+interface SearchResult {
+    skill: SearchableSkill;
+    relevance: number;
+    reasoning: string;
+}
+interface ChatMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+interface ProviderCapabilities {
+    maxContextLength: number;
+    supportsStreaming: boolean;
+    supportsJSON: boolean;
+    supportsFunctionCalling: boolean;
+}
+
+declare class MockAIProvider implements LLMProvider, AIProvider {
+    readonly name: ProviderName;
+    readonly displayName = "Mock Provider";
+    isConfigured(): boolean;
+    chat(messages: ChatMessage[]): Promise<string>;
+    generateSkill(contextOrExample: GenerationContext | SkillExample): Promise<GeneratedSkillResult>;
+    generateClarifications(context: WizardContext): Promise<ClarificationQuestion[]>;
+    optimizeForAgent(skillContent: string, agentId: string): Promise<string>;
+    search(query: string, skills: SearchableSkill[]): Promise<SearchResult[] & AISearchResult[]>;
+    generateFromExample(example: SkillExample): Promise<GeneratedSkill>;
     private buildReasoning;
     private generateName;
     private generateTags;
     private generateContent;
+    private generateContentFromExample;
+}
+
+declare class AnthropicProvider implements LLMProvider {
+    readonly name: "anthropic";
+    readonly displayName = "Claude (Anthropic)";
+    private apiKey;
+    private model;
+    private maxTokens;
+    private temperature;
+    constructor(config?: ProviderConfig);
+    isConfigured(): boolean;
+    chat(messages: ChatMessage[]): Promise<string>;
+    generateSkill(context: GenerationContext): Promise<GeneratedSkillResult>;
+    generateClarifications(context: WizardContext): Promise<ClarificationQuestion[]>;
+    optimizeForAgent(skillContent: string, agentId: string): Promise<string>;
+    search(query: string, skills: SearchableSkill[]): Promise<SearchResult[]>;
+    generateFromExample(example: SkillExample): Promise<GeneratedSkill>;
+    private buildSearchPrompt;
+    private buildGeneratePrompt;
+    private parseSearchResponse;
+    private parseGenerateResponse;
+    private makeRequest;
+    private buildGenerationSystemPrompt;
+    private buildGenerationUserPrompt;
+    private parseGeneratedSkillResult;
+    private parseJSON;
+    private getAgentConstraints;
+}
+
+declare class OpenAIProvider implements LLMProvider {
+    readonly name: "openai";
+    readonly displayName = "GPT-4 (OpenAI)";
+    private apiKey;
+    private model;
+    private maxTokens;
+    private temperature;
+    private baseUrl;
+    constructor(config?: ProviderConfig);
+    isConfigured(): boolean;
+    chat(messages: ChatMessage[]): Promise<string>;
+    generateSkill(context: GenerationContext): Promise<GeneratedSkillResult>;
+    generateClarifications(context: WizardContext): Promise<ClarificationQuestion[]>;
+    optimizeForAgent(skillContent: string, agentId: string): Promise<string>;
+    search(query: string, skills: SearchableSkill[]): Promise<SearchResult[]>;
+    generateFromExample(example: SkillExample): Promise<GeneratedSkill>;
+    private makeRequest;
+    private buildGenerationSystemPrompt;
+    private buildGenerationUserPrompt;
+    private parseGeneratedSkillResult;
+    private parseJSON;
+    private getAgentConstraints;
+}
+
+declare class GoogleProvider implements LLMProvider {
+    readonly name: "google";
+    readonly displayName = "Gemini (Google)";
+    private apiKey;
+    private model;
+    private maxTokens;
+    private temperature;
+    constructor(config?: ProviderConfig);
+    isConfigured(): boolean;
+    chat(messages: ChatMessage[]): Promise<string>;
+    generateSkill(context: GenerationContext): Promise<GeneratedSkillResult>;
+    generateClarifications(context: WizardContext): Promise<ClarificationQuestion[]>;
+    optimizeForAgent(skillContent: string, agentId: string): Promise<string>;
+    search(query: string, skills: SearchableSkill[]): Promise<SearchResult[]>;
+    generateFromExample(example: SkillExample): Promise<GeneratedSkill>;
+    private makeRequest;
+    private buildGenerationSystemPrompt;
+    private buildGenerationUserPrompt;
+    private parseGeneratedSkillResult;
+    private parseJSON;
+    private getAgentConstraints;
+}
+
+declare class OllamaProvider implements LLMProvider {
+    readonly name: "ollama";
+    readonly displayName = "Ollama (Local)";
+    private baseUrl;
+    private model;
+    private temperature;
+    constructor(config?: ProviderConfig);
+    isConfigured(): boolean;
+    chat(messages: ChatMessage[]): Promise<string>;
+    generateSkill(context: GenerationContext): Promise<GeneratedSkillResult>;
+    generateClarifications(context: WizardContext): Promise<ClarificationQuestion[]>;
+    optimizeForAgent(skillContent: string, agentId: string): Promise<string>;
+    search(query: string, skills: SearchableSkill[]): Promise<SearchResult[]>;
+    generateFromExample(example: SkillExample): Promise<GeneratedSkill>;
+    private makeRequest;
+    private buildGenerationSystemPrompt;
+    private buildGenerationUserPrompt;
+    private parseGeneratedSkillResult;
+    private parseJSON;
+}
+
+declare class OpenRouterProvider implements LLMProvider {
+    readonly name: "openrouter";
+    readonly displayName = "OpenRouter (100+ Models)";
+    private apiKey;
+    private model;
+    private maxTokens;
+    private temperature;
+    constructor(config?: ProviderConfig);
+    isConfigured(): boolean;
+    chat(messages: ChatMessage[]): Promise<string>;
+    generateSkill(context: GenerationContext): Promise<GeneratedSkillResult>;
+    generateClarifications(context: WizardContext): Promise<ClarificationQuestion[]>;
+    optimizeForAgent(skillContent: string, agentId: string): Promise<string>;
+    search(query: string, skills: SearchableSkill[]): Promise<SearchResult[]>;
+    generateFromExample(example: SkillExample): Promise<GeneratedSkill>;
+    private makeRequest;
+    private buildGenerationSystemPrompt;
+    private buildGenerationUserPrompt;
+    private parseGeneratedSkillResult;
+    private parseJSON;
+    private getAgentConstraints;
+}
+
+interface ProviderDetectionResult {
+    provider: ProviderName;
+    displayName: string;
+    configured: boolean;
+    envVar?: string;
+}
+declare function detectProviders(): ProviderDetectionResult[];
+declare function getDefaultProvider(): ProviderName;
+declare function createProvider(providerName?: ProviderName, config?: ProviderConfig): LLMProvider;
+declare function isProviderConfigured(providerName: ProviderName): boolean;
+declare function getProviderEnvVars(): Record<ProviderName, string[]>;
+declare function getProviderModels(providerName: ProviderName): string[];
+declare class ProviderFactory {
+    private static instance;
+    private providerCache;
+    static getInstance(): ProviderFactory;
+    getProvider(providerName?: ProviderName, config?: ProviderConfig): LLMProvider;
+    clearCache(): void;
+    getDetectedProviders(): ProviderDetectionResult[];
+    getDefaultProviderName(): ProviderName;
+    isConfigured(providerName: ProviderName): boolean;
+}
+
+declare class DocsSource implements ContextSource {
+    readonly name: "docs";
+    readonly displayName = "Documentation (Context7)";
+    private libraryCache;
+    fetch(query: string, options?: ContextFetchOptions): Promise<ContextChunk[]>;
+    isAvailable(): Promise<boolean>;
+    private resolveLibraries;
+    private queryDocs;
+    private getKnownLibrary;
+    private getFallbackDocs;
+    private fallbackSearch;
+    private extractKeywords;
+    private formatDocChunk;
+}
+
+declare class CodebaseSource implements ContextSource {
+    readonly name: "codebase";
+    readonly displayName = "Local Codebase";
+    private projectPath;
+    constructor(projectPath: string);
+    fetch(query: string, options?: ContextFetchOptions): Promise<ContextChunk[]>;
+    isAvailable(): Promise<boolean>;
+    private analyzeCodebase;
+    private detectFrameworks;
+    private detectTestingSetup;
+    private extractConfigs;
+    private findRelevantCode;
+    private findFilesRecursive;
+    private calculateRelevance;
+    private extractRelevantSection;
+    private isRelevant;
+    private formatPattern;
+}
+
+declare class SkillsSource implements ContextSource {
+    readonly name: "skills";
+    readonly displayName = "Marketplace Skills";
+    fetch(query: string, options?: ContextFetchOptions): Promise<ContextChunk[]>;
+    isAvailable(): Promise<boolean>;
+    searchSkills(query: string, limit?: number): Promise<Array<{
+        skill: SkillSummary;
+        score: number;
+    }>>;
+    private scoreSkills;
+    private calculateScore;
+    private extractKeywords;
+    private formatSkill;
+}
+
+declare class MemorySource implements ContextSource {
+    readonly name: "memory";
+    readonly displayName = "Memory & Learnings";
+    private projectPath;
+    constructor(projectPath: string);
+    fetch(query: string, options?: ContextFetchOptions): Promise<ContextChunk[]>;
+    isAvailable(): Promise<boolean>;
+    getMemoryPatterns(keywords: string[]): Promise<MemoryPattern[]>;
+    private getLearnedEntries;
+    private parseLearnedSection;
+    private getRelevantObservations;
+    private filterRelevant;
+    private calculateRelevance;
+    private extractKeywords;
+    private formatObservation;
+    private findClaudeMd;
+}
+
+interface ContextSource {
+    readonly name: 'docs' | 'codebase' | 'skills' | 'memory';
+    readonly displayName: string;
+    fetch(query: string, options?: ContextFetchOptions): Promise<ContextChunk[]>;
+    isAvailable(): Promise<boolean>;
+}
+interface ContextFetchOptions {
+    maxChunks?: number;
+    minRelevance?: number;
+    projectPath?: string;
+}
+interface AggregatedContext {
+    chunks: ContextChunk[];
+    sources: SourceSummary[];
+    totalTokensEstimate: number;
+}
+interface SourceSummary {
+    name: string;
+    chunkCount: number;
+    status: 'success' | 'error' | 'unavailable';
+    error?: string;
+}
+interface ContextEngineOptions {
+    projectPath?: string;
+    maxTotalChunks?: number;
+    defaultSources?: ContextSourceConfig[];
+}
+declare class ContextEngine {
+    private sources;
+    private projectPath;
+    private maxTotalChunks;
+    constructor(options?: ContextEngineOptions);
+    gather(expertise: string, sourceConfigs?: ContextSourceConfig[]): Promise<AggregatedContext>;
+    gatherFromSource(sourceName: string, query: string, options?: ContextFetchOptions): Promise<ContextChunk[]>;
+    getAvailableSources(): string[];
+    checkSourceAvailability(): Promise<Record<string, boolean>>;
+    private getDefaultSourceConfigs;
+    private estimateTokens;
+}
+
+interface SkillAnalysis {
+    sections: SkillSection[];
+    patterns: string[];
+    complexity: number;
+    estimatedTokens: number;
+}
+interface SkillSection {
+    title: string;
+    content: string;
+    type: 'instruction' | 'example' | 'rule' | 'metadata' | 'trigger';
+    importance: number;
+}
+declare class SkillAnalyzer {
+    private skillsSource;
+    constructor();
+    findComposableSkills(query: string, limit?: number): Promise<ComposableSkill[]>;
+    analyzeSkillContent(content: string): {
+        sections: string[];
+        patterns: string[];
+        complexity: number;
+    };
+    parseSkillContent(content: string): SkillAnalysis;
+    findOverlappingSections(skills: ComposableSkill[]): Map<string, string[]>;
+    private classifySectionType;
+    private calculateSectionImportance;
+    private extractPatterns;
+    private calculateComplexity;
+    private normalizeTitle;
+    private generateSkillContent;
+    private estimateTrustScore;
+}
+
+interface MergeResult {
+    content: string;
+    report: MergeReport;
+}
+declare class SkillMerger {
+    private analyzer;
+    constructor(_provider?: LLMProvider);
+    merge(skills: ComposableSkill[], options?: ComposeOptions): Promise<MergeResult>;
+    private groupSections;
+    private sortSectionGroups;
+    private mergeSectionGroup;
+    private intelligentMerge;
+    private normalizeTitle;
+    private normalizeLine;
+    private isHeading;
+    private getSectionTypePriority;
+    private cleanupContent;
+}
+
+interface ComposeOptions {
+    preserveAll?: boolean;
+    conflictStrategy?: 'first' | 'merge' | 'best';
+    targetAgent?: string;
+}
+interface ComposedSkill {
+    name: string;
+    description: string;
+    content: string;
+    sourceSkills: string[];
+    mergeReport: MergeReport;
+}
+interface MergeReport {
+    sectionsPreserved: number;
+    conflictsResolved: number;
+    duplicatesRemoved: number;
+    totalSections: number;
+}
+interface CompositionResult {
+    skill: ComposedSkill;
+    warnings: string[];
+    suggestions: string[];
+}
+declare class SkillComposer {
+    private analyzer;
+    private merger;
+    private provider?;
+    constructor(provider?: LLMProvider);
+    findComposable(query: string, limit?: number): Promise<ComposableSkill[]>;
+    analyzeSkill(skillContent: string): Promise<{
+        sections: string[];
+        patterns: string[];
+        complexity: number;
+    }>;
+    compose(skills: ComposableSkill[], options?: ComposeOptions): Promise<CompositionResult>;
+    composeWithAI(skills: ComposableSkill[], expertise: string, options?: ComposeOptions): Promise<CompositionResult>;
+    private generateComposedName;
+    private generateComposedDescription;
+    private findCommonWords;
+    private extractThemes;
+}
+
+interface AgentConstraints {
+    maxContextLength: number;
+    supportsMarkdown: boolean;
+    supportsMCP: boolean;
+    supportsTools: boolean;
+    format: string;
+    fileExtension: string;
+}
+interface OptimizationResult {
+    content: string;
+    agentId: string;
+    changes: string[];
+    estimatedTokens: number;
+}
+declare class AgentOptimizer {
+    private provider?;
+    constructor(provider?: LLMProvider);
+    optimizeForAgent(content: string, agentId: string): Promise<OptimizationResult>;
+    optimizeForMultipleAgents(content: string, agentIds: string[]): Promise<Map<string, OptimizationResult>>;
+    getConstraints(agentId: string): AgentConstraints;
+    getSupportedAgents(): string[];
+    private truncateContent;
+    private splitIntoSections;
+    private prioritizeSections;
+    private getSectionPriority;
+    private removeMCPReferences;
+    private removeToolReferences;
+    private convertToCursorFormat;
+    private condenseContent;
+}
+
+interface CompatibilityScore {
+    score: number;
+    grade: 'A' | 'B' | 'C' | 'D' | 'F';
+    limitations: string[];
+    optimizations: string[];
+}
+interface CompatibilityMatrix {
+    [agentId: string]: CompatibilityScore;
+}
+interface SkillRequirements {
+    estimatedTokens: number;
+    usesMCP: boolean;
+    usesTools: boolean;
+    hasCodeExamples: boolean;
+    hasMarkdown: boolean;
+    complexity: 'low' | 'medium' | 'high';
+}
+declare class CompatibilityScorer {
+    private optimizer;
+    constructor();
+    scoreSkillForAgent(skillContent: string, agentId: string): CompatibilityScore;
+    generateMatrix(skillContent: string, agentIds?: string[]): CompatibilityMatrix;
+    getBestAgents(skillContent: string, limit?: number): Array<{
+        agentId: string;
+        score: CompatibilityScore;
+    }>;
+    analyzeSkillRequirements(content: string): SkillRequirements;
+    private calculateScore;
+    private assessComplexity;
+    private scoreToGrade;
+}
+
+interface TrustScore {
+    score: number;
+    grade: 'trusted' | 'review' | 'caution';
+    breakdown: TrustBreakdown;
+    warnings: string[];
+    recommendations: string[];
+}
+interface TrustBreakdown {
+    clarity: number;
+    boundaries: number;
+    specificity: number;
+    safety: number;
+}
+interface TrustScoreOptions {
+    weights?: Partial<TrustBreakdown>;
+    strictMode?: boolean;
+}
+declare class TrustScorer {
+    private weights;
+    private strictMode;
+    constructor(options?: TrustScoreOptions);
+    score(skillContent: string): TrustScore;
+    private scoreClarity;
+    private scoreBoundaries;
+    private scoreSpecificity;
+    private scoreSafety;
+    private generateRecommendations;
+    private scoreToGrade;
+}
+declare function quickTrustScore(content: string): number;
+
+interface InjectionDetectionResult {
+    isClean: boolean;
+    threats: InjectionThreat[];
+    riskLevel: 'none' | 'low' | 'medium' | 'high' | 'critical';
+    sanitizedContent?: string;
+}
+interface InjectionThreat {
+    type: InjectionType;
+    description: string;
+    location: {
+        start: number;
+        end: number;
+    };
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    pattern: string;
+}
+type InjectionType = 'instruction_override' | 'role_manipulation' | 'unicode_tricks' | 'delimiter_injection' | 'context_escape' | 'hidden_text' | 'recursive_prompt';
+interface InjectionPattern {
+    type: InjectionType;
+    pattern: RegExp;
+    description: string;
+    severity: InjectionThreat['severity'];
+}
+declare class InjectionDetector {
+    private patterns;
+    private customPatterns;
+    constructor();
+    detect(content: string): InjectionDetectionResult;
+    sanitize(content: string, threats?: InjectionThreat[]): string;
+    addCustomPattern(pattern: InjectionPattern): void;
+    removeCustomPattern(type: InjectionType): void;
+    private calculateRiskLevel;
+    private escapeRegex;
+}
+declare function quickInjectionCheck(content: string): boolean;
+declare function sanitizeSkillContent(content: string): string;
+
+type WizardStep = 'expertise' | 'context-sources' | 'composition' | 'clarification' | 'review' | 'install';
+interface WizardState {
+    currentStep: WizardStep;
+    expertise: string;
+    contextSources: ContextSourceConfig[];
+    composableSkills: ComposableSkill[];
+    clarifications: ClarificationAnswer[];
+    targetAgents: string[];
+    memoryPersonalization: boolean;
+    gatheredContext: ContextChunk[];
+    generatedQuestions: ClarificationQuestion[];
+    generatedSkill: GeneratedSkillPreview | null;
+    trustScore: TrustScore | null;
+    compatibilityMatrix: CompatibilityMatrix | null;
+    installResults: InstallResult[];
+    errors: WizardError[];
+}
+interface GeneratedSkillPreview {
+    name: string;
+    description: string;
+    content: string;
+    tags: string[];
+    confidence: number;
+    composedFrom: string[];
+    estimatedTokens: number;
+}
+interface InstallResult {
+    agentId: string;
+    success: boolean;
+    path: string;
+    optimized: boolean;
+    changes: string[];
+    error?: string;
+}
+interface WizardError {
+    step: WizardStep;
+    message: string;
+    recoverable: boolean;
+}
+interface WizardOptions {
+    projectPath?: string;
+    provider?: string;
+    model?: string;
+    skipClarification?: boolean;
+    skipComposition?: boolean;
+    autoInstall?: boolean;
+}
+interface StepResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    nextStep?: WizardStep;
+}
+interface WizardEvents {
+    onStepChange?: (step: WizardStep, state: WizardState) => void;
+    onProgress?: (message: string, progress?: number) => void;
+    onError?: (error: WizardError) => void;
+    onComplete?: (state: WizardState) => void;
+}
+declare function createInitialState(): WizardState;
+declare function getStepOrder(): WizardStep[];
+declare function getNextStep(current: WizardStep): WizardStep | null;
+declare function getPreviousStep(current: WizardStep): WizardStep | null;
+declare function getStepNumber(step: WizardStep): number;
+declare function getTotalSteps(): number;
+
+interface ClarificationOptions {
+    maxQuestions?: number;
+    includeCodeExamples?: boolean;
+    focusAreas?: string[];
+}
+declare class ClarificationGenerator {
+    private provider;
+    constructor(provider: LLMProvider);
+    generate(context: WizardContext, options?: ClarificationOptions): Promise<ClarificationQuestion[]>;
+    private filterRelevantQuestions;
+    private getFallbackQuestions;
+    refineQuestions(questions: ClarificationQuestion[], answers: Record<string, string | string[] | boolean>, _context: WizardContext): Promise<ClarificationQuestion[]>;
+}
+declare function createQuestionFromPattern(id: string, pattern: 'framework' | 'coverage' | 'style' | 'scope', customOptions?: string[]): ClarificationQuestion;
+
+interface StepHandler<TInput, TOutput> {
+    validate(input: TInput, state: WizardState): string | null;
+    execute(input: TInput, state: WizardState, options: StepExecutionOptions): Promise<StepResult<TOutput>>;
+}
+interface StepExecutionOptions {
+    provider?: LLMProvider;
+    projectPath: string;
+    wizardOptions: WizardOptions;
+}
+declare const STEP_HANDLERS: Record<WizardStep, StepHandler<unknown, unknown>>;
+
+interface WizardConfig {
+    provider?: LLMProvider;
+    projectPath?: string;
+    options?: WizardOptions;
+    events?: WizardEvents;
+}
+declare class SkillWizard {
+    private state;
+    private provider;
+    private projectPath;
+    private options;
+    private events;
+    constructor(config?: WizardConfig);
+    getState(): Readonly<WizardState>;
+    getCurrentStep(): WizardStep;
+    getProgress(): {
+        current: number;
+        total: number;
+        percentage: number;
+    };
+    executeStep<T>(input: T): Promise<StepResult<unknown>>;
+    setExpertise(expertise: string): Promise<StepResult<unknown>>;
+    setContextSources(sources: ContextSourceConfig[]): Promise<StepResult<unknown>>;
+    selectSkillsForComposition(skills: ComposableSkill[], searchQuery?: string): Promise<StepResult<unknown>>;
+    answerClarifications(answers: ClarificationAnswer[]): Promise<StepResult<unknown>>;
+    generateSkill(): Promise<StepResult<unknown>>;
+    approveSkill(): Promise<StepResult<unknown>>;
+    installToAgents(agentIds: string[]): Promise<StepResult<unknown>>;
+    goBack(): boolean;
+    canGoBack(): boolean;
+    reset(): void;
+    getGeneratedSkill(): GeneratedSkillPreview | null;
+    setTargetAgents(agentIds: string[]): void;
+    setMemoryPersonalization(enabled: boolean): void;
+    updateSkillContent(content: string): void;
+    private emitStepChange;
+    private emitProgress;
+    private emitError;
+    private emitComplete;
 }
 
 type AuditEventType = 'skill.install' | 'skill.uninstall' | 'skill.sync' | 'skill.translate' | 'skill.execute' | 'team.create' | 'team.share' | 'team.import' | 'team.sync' | 'bundle.create' | 'bundle.export' | 'bundle.import' | 'plugin.install' | 'plugin.uninstall' | 'plugin.enable' | 'plugin.disable' | 'workflow.execute' | 'ai.search' | 'ai.generate';
@@ -10437,7 +11825,7 @@ interface HybridSearchOptions {
     rrfK?: number;
     positionAwareBlending?: boolean;
 }
-interface HybridSearchResult extends SearchResult {
+interface HybridSearchResult extends SearchResult$1 {
     hybridScore: number;
     vectorSimilarity?: number;
     keywordScore?: number;
@@ -10868,4 +12256,4 @@ declare class SkillInjector {
     cacheStats(): CacheStats;
 }
 
-export { AGENT_CLI_CONFIGS, AGENT_CONFIG, AGENT_DISCOVERY_PATHS, AGENT_FORMAT_MAP, AGENT_INSTRUCTION_TEMPLATES, AGENT_SKILL_FORMATS, type AIConfig, type AIGenerateOptions, AIManager, type AIProvider, AISearch, type AISearchOptions, type AISearchResult, AISkillGenerator, ALL_AGENT_DISCOVERY_PATHS, APIBasedCompressor, type APICompressionConfig, type ActivatedSkill, type AdvancedScore, type AgentAdapterInfo, type AgentCLIConfig, type AgentCommandFormat, AgentConfig, type AgentDirectoryConfig, type AgentExecutionResult, type AgentFormatCategory, AgentFrontmatter, AgentHook, type AgentHookFormat, type AgentInstance, type AgentInstructionTemplate, AgentLocation, AgentMetadata, AgentPermissionMode, type AgentPipeline, type AgentSkillFormat, type AgentStatus, type AgentTranslationOptions, type AgentTranslationResult, AgentType, type AssertionResult, type AuditEvent, type AuditEventType, type AuditExportOptions, AuditLogger, type AuditQuery, type AuditStats, BUILTIN_PIPELINES, BaseAIProvider, type BenchmarkResult, BitbucketProvider, type BundleManifest, CATEGORY_RELEVANCE_PROMPT, CATEGORY_TAXONOMY, CIConfig, CIRCLECI_CONFIG_TEMPLATE, CONTEXT_DIR, CONTEXT_FILE, CUSTOM_AGENT_FORMAT_MAP, type CacheBackend, type CacheOptions, type CacheStats, type CanonicalAgent, type CanonicalSkill, type CategoryMapping, type CategoryScore, type CategoryStats, type CheckpointHandler, type CheckpointResponse, type ClarityScore, type CloneOptions, type CloneResult, CodeConvention, type CommandArg, type CommandBundle, type CommandContext, type CommandEvent, type CommandEventListener, CommandGenerator, type CommandGeneratorOptions, type CommandHandler, type CommandPlugin, CommandRegistry, type CommandRegistryOptions, type CommandResult, type CommandSearchOptions, type CommandValidationResult, CommunityRegistry, type CompletenessResult, type CompressedLearning, type CompressionEngine, type CompressionOptions, type CompressionResult, type ConnectorAnalysis, type ConnectorCategory, ConnectorCategorySchema, type ConnectorConfig, ConnectorConfigSchema, type ConnectorMapping, ConnectorMappingSchema, type ConnectorPlaceholder, ConnectorPlaceholderSchema, type ContextCategory, type ContextExportOptions, type ContextImportOptions, type ContextLoadOptions, ContextLoader, ContextManager, ContextSync, type ContextSyncOptions, CopilotTranslator, type CrossAgentSkill, type CurrentExecution, CursorTranslator, type CustomAgent, DEFAULT_CACHE_TTL, DEFAULT_CHUNKING_CONFIG, DEFAULT_CONTEXT_CATEGORIES, DEFAULT_GUIDELINE_CONFIG, DEFAULT_HYBRID_CONFIG, DEFAULT_LEARNING_CONFIG, DEFAULT_MEMORY_CONFIG, DEFAULT_PROFILE_CONFIG, DEFAULT_REASONING_CONFIG, DEFAULT_SCORING_WEIGHTS, DEFAULT_SKILL_SOURCES, DependencyInfo, Detection, type DetectionSource, type DiscoveredSkill, DockerConfig, EXPLANATION_PROMPT, EmbeddingService, type EmbeddingServiceStats, EnvConfig, type EvolvingPattern, type ExecutableSkill, type ExecutableTask, type ExecutableTaskType, type ExecutionContext, type ExecutionFlow, type ExecutionFlowConfig, ExecutionFlowSchema, type ExecutionHistory, ExecutionManager, type ExecutionMode, type ExecutionModeConfig, type ExecutionOptions, type ExecutionProgressCallback, type ExecutionProgressEvent, type ExecutionStep, ExecutionStepSchema, type ExecutionStepStatus, ExecutionStepStatusSchema, type ExecutionStrategy, type ExecutionTaskStatus, type ExpandedQuery, type ExplainedMatch, type ExplainedMatchDetails, type ExplainedRecommendation, type ExplainedScoredSkill, type ExternalRegistry, type ExternalSkill, type FederatedResult, FederatedSearch, type FeedbackResult, type FetchedSkill, type FlowMetrics, type FlowSummary, type FormatCategory, type FormatTranslator, type FreshnessResult, GITHUB_ACTION_TEMPLATE, GITLAB_CI_TEMPLATE, type GenerateOptions, type GeneratedInstruction, type GeneratedSkill, type GitAnalysisOptions, type GitAnalysisResult, type GitAnalysisSummary, type GitCommit, type GitFileChange, GitHubProvider, GitHubSkillRegistry, GitLabProvider, GitProvider, type GitProviderAdapter, type Guideline, type GuidelineCategory, type GuidelineConfig, type HookConfig, type HookContext, type HookError, type HookEvent, type HookEventListener, HookManager, type HookManagerOptions, type HookTriggerResult, type HybridSearchOptions, HybridSearchPipeline, type HybridSearchResponse, type HybridSearchResult, INDEX_CACHE_HOURS, INDEX_PATH, type ImportOptions, type IndexBuildCallback, type IndexBuildProgress, type IndexSource, type InjectedMemory, type InjectionMode, type InjectionOptions, type InjectionResult, type InstallOptions, type InstallResult, type InstalledPackInfo, type InstalledSkillInfo, type IssueSeverity, KNOWN_SKILL_REPOS, type LLMResponse, type LearnedPattern, type LearnedSkillOutput, type Learning, type LearningConfig, LearningConsolidator, LearningStore, type LearningStoreData, type LoadedContext, type LocalModelConfig, LocalModelConfigSchema, LocalModelManager, LocalProvider, MARKETPLACE_CACHE_FILE, MODEL_REGISTRY, MarketplaceAggregator, type MarketplaceConfig, type MarketplaceIndex, type MarketplaceSearchOptions, type MarketplaceSearchResult, type MarketplaceSkill, type MatchCategory, type MatchReason, type MatcherFunction, MemoryCache, MemoryCompressor, type MemoryConfig, MemoryEnabledEngine, type MemoryEnabledEngineOptions, type MemoryFull, type MemoryIndex, MemoryIndexStore, MemoryInjector, MemoryObserver, type MemoryObserverConfig, type MemoryPaths, type MemoryPreview, type MemorySearchOptions, type MemorySearchResult, type MemoryStatus, type MemorySummary, type MessageHandler, type MessageType, MethodologyLoader, MethodologyManager, type MethodologyManagerOptions, type MethodologyPack, type MethodologySearchQuery, type MethodologySearchResult, type MethodologySkill, type MethodologySkillMetadata, type MethodologyState, type MethodologySyncResult, MockAIProvider, type ModeCapabilities, type ModeDetectionResult, type ObservableEvent, type ObservableEventType, type Observation, type ObservationContent, ObservationStore, type ObservationStoreData, type ObservationType, type OperationalProfile, type OrchestratorOptions, type OrchestratorTaskStatus, type OrchestratorTeamConfig, PRE_COMMIT_CONFIG_TEMPLATE, PRE_COMMIT_HOOK_TEMPLATE, PROJECT_TYPE_HINTS, PackageManager, type ParseOptions, type ParsedSkillContent, type PatternCategory, type PatternDomain, type PatternExtractionResult, type PatternGenerateOptions, type PatternStore, type PipelineStage, type PlaceholderMatch, type PlaceholderReplacement, type PlanEvent, type PlanEventListener, type PlanExecutionOptions, type PlanExecutionResult, PlanExecutor, PlanGenerator, PlanParser, type PlanResult, type PlanStatus, type PlanStep, type PlanTask, type PlanTaskFiles, type PlanTaskResult, type PlanValidationResult, PlanValidator, type Plugin, type PluginConfig, type PluginContext, type PluginHooks, PluginLoader, PluginManager, type PluginMetadata, PrimerAnalysis, PrimerAnalyzer, PrimerGenerator, PrimerLanguage, type PrimerOptions, type PrimerResult, type ProfileConfig, type ProfileName, ProjectContext, ProjectDetector, ProjectPatterns, type ProjectProfile, ProjectStack, ProjectStructure, type ProviderPlugin, type QualityScore, QueryExpander, type RRFInput, type RRFRanking, type RankableSkill, type RankedSkill, type RankerResult, RateLimitError, type ReasoningCacheEntry, type ReasoningConfig, ReasoningEngine, type ReasoningEngineStats, type ReasoningPrompt, type ReasoningProvider, ReasoningProviderSchema, type ReasoningRecommendOptions, ReasoningRecommendationEngine, type ReasoningRecommendationResult, type RecommendHybridSearchOptions, type RecommendHybridSearchResult, type RecommendOptions, RecommendationEngine, type RecommendationResult, type RegisteredCommand, type RegistrySkill, type RelatedSkillResult, type RelationType, RelevanceRanker, type RerankerInput, type RerankerOutput, type ReviewIssue, type ReviewResult, type ReviewStage, type ReviewStageName, RuleBasedCompressor, type RuntimeSkillSource, SEARCH_PLANNING_PROMPT, SESSION_FILE, SKILL_DISCOVERY_PATHS, SKILL_MATCH_PROMPT, STANDARD_PLACEHOLDERS, type ScoreBreakdown, type ScoredSkill, type ScoringWeights, type SearchOptions, type SearchPlan, type SearchResult, type SearchableSkill, type SessionContext, type SessionDecision, type SessionFile, SessionManager, type SessionMessage, type SessionState, type SessionSummary, type SessionTask, type ShareOptions, type SharedSkill, Skill, SkillBundle, type SkillChunk, SkillChunkSchema, type SkillEmbedding, type SkillEntry, type SkillExample, SkillExecutionEngine, type SkillExecutionEvent, type SkillExecutionResult, type SkillExecutor, type SkillExecutorOptions, SkillFrontmatter, type SkillGraph, type SkillHook, type SkillIndex, SkillInjector, SkillLocation, SkillMdTranslator, SkillMetadata, type SkillNode, SkillPreferences, type SkillReference, type SkillRelation, type SkillSource, SkillSummary, type SkillTestCase, type SkillTestSuite, type SkillToSubagentOptions, type SkillTranslationOptions, type SkillTranslationResult, type SkillTree, SkillTreeSchema, SkillTriggerEngine, SkillkitConfig, type SkillsManifest, type SlashCommand, type SlashCommandResult, type SpecificityScore, type StepDefinition, type StepExecutor, type StepType, type StructureScore, type StructuredPlan, type SyncOptions, type SyncReport, type SyncResult, TAG_TO_CATEGORY, TAG_TO_TECH, TASK_TEMPLATES, TREE_FILE_NAME, type Task, type TaskEvent, type TaskEventListener, type TaskExecutionResult, type TaskFiles, type TaskFilter, TaskManager, type TaskPlan, type TaskResult, type TaskStatus, type TaskStep, type TaskTemplate, type Team, type TeamConfig, type TeamEvent, type TeamEventListener, TeamManager, type TeamMember, type TeamMessage, TeamMessageBus, TeamOrchestrator, type TeamRegistry, type TeamStatus, type TestAssertion, type TestAssertionType, type TestCaseResult, type TestProgressEvent, type TestResult, type TestRunnerOptions, type TestSuiteResult, TranslatableSkillFrontmatter, type TranslationOptions, type TranslationPath, type TranslationResult, type TranslatorPlugin, TranslatorRegistry, TreeGenerator, type TreeGeneratorOptions, type TreeNode, TreeNodeSchema, type TreePath, type TreeReasoningResult, type TreeSearchQuery, type TreeSearchResult, type TreeTraversalStep, type TriggerEngineOptions, type UpdateOptions, type ValidationError, type ValidationIssue, type ValidationResult, type ValidationWarning, type ValidatorOptions, type VectorSearchResult, VectorStore, type VectorStoreConfig, type VerificationRule, WORKFLOWS_DIR, WORKFLOW_EXTENSION, type WaveExecutionStatus, type WellKnownIndex, WellKnownProvider, type WellKnownSkill, WindsurfTranslator, type Workflow, type WorkflowExecution, type WorkflowExecutionStatus, WorkflowOrchestrator, type WorkflowProgressCallback, type WorkflowSkill, type WorkflowWave, addCustomGuideline, addCustomProfile, addPattern, addToManifest, agentExists, analyzeForPrimer, analyzeGitHistory, analyzePlaceholders, analyzePrimer, analyzeProject, applyConnectorConfig, applyPositionAwareBlending, approvePattern, benchmarkSkill, buildCategoryRelevancePrompt, buildExplanationPrompt, buildSearchPlanPrompt, buildSkillGraph, buildSkillIndex, buildSkillMatchPrompt, calculateBaseSkillsUrl, calculatePercentile, canTranslate, clusterPatterns, compareTreeVersions, computeRRFScore, copilotTranslator, createAPIBasedCompressor, createCommandGenerator, createCommandRegistry, createConnectorConfig, createContextLoader, createContextManager, createContextSync, createEmbeddingService, createExecutionEngine, createExecutionManager, createHookManager, createHybridSearchPipeline, createMarketplaceAggregator, createMemoryCompressor, createMemoryEnabledEngine, createMemoryInjector, createMemoryObserver, createMessageBus, createMethodologyLoader, createMethodologyManager, createModeAwareExecutor, createPlanExecutor, createPlanGenerator, createPlanParser, createPlanValidator, createPluginManager, createQueryExpander, createReasoningEngine, createReasoningRecommendationEngine, createRecommendationEngine, createRuleBasedCompressor, createSessionFile, createSessionManager, createSimulatedSkillExecutor, createSkillBundle, createSkillExecutor, createTaskManager, createTeamManager, createTeamOrchestrator, createTestSuiteFromFrontmatter, createTriggerEngine, createVectorStore, createWorkflowOrchestrator, createWorkflowTemplate, cursorTranslator, deserializeGraph, deserializeTree, detectCategory, detectExecutionMode, detectPlaceholders, detectProvider, detectSkillFormat, disableGuideline, discoverAgents, discoverAgentsForAgent, discoverAgentsFromPath, discoverAgentsRecursive, discoverGlobalAgents, discoverReferences, discoverSkills, dryRunExecutor, enableGuideline, estimateTokens, evaluateSkillContent, evaluateSkillDirectory, evaluateSkillFile, executeWithAgent, expandQuerySimple, exportBundle, exportPatternsAsJson, extractAgentContent, extractAgentFrontmatter, extractField, extractFrontmatter, extractJsonFromResponse, extractPatternsFromSession, extractSkillMetadata, fetchSkillsFromRepo, findAgent, findAllAgents, findAllSkills, findManifestPath, findSkill, findSkillsByRelationType, findSkillsInCategory, formatBytes, formatSkillAsPrompt, fromCanonicalAgent, fuseWithRRF, generateComparisonNotes, generateConnectorsMarkdown, generateManifestFromInstalled, generatePatternReport, generatePrimer, generatePrimerForAgent, generateRecommendations, generateSkillFromPatterns, generateSkillTree, generateSkillsConfig, generateSubagentFromSkill, generateWellKnownIndex, generateWellKnownStructure, getActiveProfile, getAgentCLIConfig, getAgentConfigFile, getAgentConfigPath, getAgentDirectoryConfig, getAgentFilename, getAgentFormat, getAgentSkillsDir, getAgentStats, getAgentTargetDirectory, getAgentsDirectory, getAllCategories, getAllGuidelines, getAllPatterns, getAllProfiles, getAllProviders, getAllSkillsDirs, getApprovedPatterns, getAvailableCLIAgents, getBuiltinGuidelines, getBuiltinPacksDir, getBuiltinPipeline, getBuiltinPipelines, getBuiltinProfiles, getCICDTemplate, getCategoryStats, getConfigFile, getConfigFormat, getDefaultConfigPath, getDefaultModelDir, getDefaultStorePath, getEnabledGuidelineContent, getEnabledGuidelines, getEvolvingPattern, getEvolvingPatternsByDomain, getExecutionStrategy, getGitCommits, getGlobalConfigPath, getGlobalSkillsDir, getGrade, getGuideline, getGuidelineContent, getGuidelinesByCategory, getHighConfidencePatterns, getIndexStatus, getInstallDir, getLowConfidencePatterns, getManualExecutionInstructions, getMemoryPaths, getMemoryStatus, getModeDescription, getMostRecentSession, getMostUsedPatterns, getPattern, getPatternStats, getPatternsByCategory, getPlaceholderInfo, getProfile, getProfileContext, getProfileNames, getProjectConfigPath, getProvider, getQualityGrade, getRankFromScore, getRecentBugFixes, getRecentRefactors, getRelatedSkills, getSearchDirs, getSkillPath, getSkillsDir, getStackTags, getStandaloneAlternative, getSupportedTranslationAgents, getTechTags, globalMemoryDirectoryExists, hybridSearch, importBundle, importPatternsFromJson, initContext, initManifest, initProject, initializeMemoryDirectory, isAgentCLIAvailable, isAgentCompatible, isBuiltinGuideline, isBuiltinProfile, isGitUrl, isGuidelineEnabled, isHighQuality, isIndexStale, isLocalPath, isPathInside, listCICDTemplates, listSessions, listWorkflows, loadAgentMetadata, loadAndConvertSkill, loadConfig, loadContext, loadGuidelineConfig, loadIndex, loadLearningConfig, loadManifest, loadMetadata, loadPatternStore, loadPlugin, loadPluginsFromDirectory, loadProfileConfig, loadSessionFile, loadSkillMetadata, loadTree, loadWorkflow, loadWorkflowByName, memoryDirectoryExists, mergePatterns, mergeRankings, normalizeScores, parseAgentDir, parseAgentFile, parseShorthand, parseSkill, parseSkillContent, parseSkillContentToCanonical, parseSkillMd, parseSkillToCanonical, parseSource, parseWorkflow, readAgentContent, readSkillContent, recordFailure, recordSuccess, rejectPattern, removeCustomGuideline, removeCustomProfile, removeFromManifest, removePattern, replacePlaceholders, requireCapability, requireEnhancedMode, runTestSuite, saveConfig, saveGeneratedSkill, saveGuidelineConfig, saveIndex, saveLearningConfig, saveManifest, savePatternStore, saveProfileConfig, saveSessionFile, saveSkillMetadata, saveTree, saveWorkflow, serializeGraph, serializeTree, serializeWorkflow, setActiveProfile, setSkillEnabled, shellExecutor, skillMdTranslator, skillToSubagent, stripFrontmatter, suggestMappingsFromMcp, supportsAutoDiscovery, supportsSlashCommands, syncToAgent, syncToAllAgents, toCanonicalAgent, translateAgent, translateAgentContent, translateAgents, translateCanonicalAgent, translateSkill, translateSkillFile, translateSkillToAgent, translateSkillToAll, translatorRegistry, treeToMarkdown, treeToText, updateSessionFile, validateAgent, validateBuiltinPacks, validateCategoryScore, validateConnectorConfig, validatePackDirectory, validatePackManifest, validatePlan, validateSearchPlan, validateSkill, validateSkillContent, validateWorkflow, weightedCombine, windsurfTranslator, wrapProgressCallbackWithMemory, writeTranslatedSkill };
+export { AGENT_CLI_CONFIGS, AGENT_CONFIG, AGENT_DISCOVERY_PATHS, AGENT_FORMAT_MAP, AGENT_INSTRUCTION_TEMPLATES, AGENT_SKILL_FORMATS, type AIConfig, type AIGenerateOptions, AIManager, type AIProvider, AISearch, type AISearchOptions, type AISearchResult, AISkillGenerator, ALL_AGENT_DISCOVERY_PATHS, APIBasedCompressor, type APICompressionConfig, type ActivatedSkill, type ActivityPoint, type AdvancedScore, type AgentAdapterInfo, type AgentCLIConfig, type AgentCommandFormat, AgentConfig, type AgentConstraints, type AgentDirectoryConfig, type AgentExecutionResult, type AgentFormatCategory, AgentFrontmatter, AgentHook, type AgentHookFormat, type AgentInstance, type AgentInstructionTemplate, AgentLocation, AgentMetadata, AgentOptimizer, AgentPermissionMode, type AgentPipeline, type AgentSkillFormat, type AgentStatus, type AgentTranslationOptions, type AgentTranslationResult, AgentType, type AggregatedContext, AnthropicProvider, type AssertionResult, type AuditEvent, type AuditEventType, type AuditExportOptions, AuditLogger, type AuditQuery, type AuditStats, type AutoCompressCallback, BUILTIN_PIPELINES, BaseAIProvider, type BenchmarkResult, BitbucketProvider, type BundleManifest, CATEGORY_RELEVANCE_PROMPT, CATEGORY_TAXONOMY, CIConfig, CIRCLECI_CONFIG_TEMPLATE, CONTEXT_DIR, CONTEXT_FILE, CUSTOM_AGENT_FORMAT_MAP, type CacheBackend, type CacheOptions, type CacheStats, type CanonicalAgent, type CanonicalSkill, type CategoryMapping, type CategoryScore, type CategoryStats, type ChatMessage, type CheckpointHandler, type CheckpointResponse, type ClarificationAnswer, ClarificationGenerator, type ClarificationQuestion, type ClarityScore, type ClaudeCodeHookEvent, type ClaudeCodeHookOutput, type ClaudeMdUpdateOptions, type ClaudeMdUpdateResult, ClaudeMdUpdater, type CloneOptions, type CloneResult, CodeConvention, CodebaseSource, type CommandArg, type CommandBundle, type CommandContext, type CommandEvent, type CommandEventListener, CommandGenerator, type CommandGeneratorOptions, type CommandHandler, type CommandPlugin, CommandRegistry, type CommandRegistryOptions, type CommandResult, type CommandSearchOptions, type CommandValidationResult, CommunityRegistry, type CompatibilityMatrix, type CompatibilityScore, CompatibilityScorer, type CompletenessResult, type ComposableSkill, type ComposeOptions, type ComposedSkill, type CompositionResult, type CompressedLearning, type CompressionEngine, type CompressionOptions, type CompressionResult, type ConnectorAnalysis, type ConnectorCategory, ConnectorCategorySchema, type ConnectorConfig, ConnectorConfigSchema, type ConnectorMapping, ConnectorMappingSchema, type ConnectorPlaceholder, ConnectorPlaceholderSchema, type ContextCategory, type ContextChunk, ContextEngine, type ContextEngineOptions, type ContextExportOptions, type ContextFetchOptions, type ContextImportOptions, type ContextLoadOptions, ContextLoader, ContextManager, type ContextSource, type ContextSourceConfig, ContextSync, type ContextSyncOptions, CopilotTranslator, type CrossAgentSkill, type CurrentExecution, CursorTranslator, type CustomAgent, DEFAULT_CACHE_TTL, DEFAULT_CHUNKING_CONFIG, DEFAULT_CONTEXT_CATEGORIES, DEFAULT_GUIDELINE_CONFIG, DEFAULT_HYBRID_CONFIG, DEFAULT_LEARNING_CONFIG, DEFAULT_MEMORY_CONFIG, DEFAULT_MEMORY_HOOK_CONFIG, DEFAULT_PROFILE_CONFIG, DEFAULT_REASONING_CONFIG, DEFAULT_SCORING_WEIGHTS, DEFAULT_SKILL_SOURCES, DependencyInfo, type DetailsEntry, Detection, type DetectionSource, type DiscoveredSkill, DockerConfig, DocsSource, EXPLANATION_PROMPT, EmbeddingService, type EmbeddingServiceStats, EnvConfig, type EvolvingPattern, type ExecutableSkill, type ExecutableTask, type ExecutableTaskType, type ExecutionContext, type ExecutionFlow, type ExecutionFlowConfig, ExecutionFlowSchema, type ExecutionHistory, ExecutionManager, type ExecutionMode, type ExecutionModeConfig, type ExecutionOptions, type ExecutionProgressCallback, type ExecutionProgressEvent, type ExecutionStep, ExecutionStepSchema, type ExecutionStepStatus, ExecutionStepStatusSchema, type ExecutionStrategy, type ExecutionTaskStatus, type ExpandedQuery, type ExplainedMatch, type ExplainedMatchDetails, type ExplainedRecommendation, type ExplainedScoredSkill, type ExternalRegistry, type ExternalSkill, type FederatedResult, FederatedSearch, type FeedbackResult, type FetchedSkill, type FlowMetrics, type FlowSummary, type FormatCategory, type FormatTranslator, type FreshnessResult, GITHUB_ACTION_TEMPLATE, GITLAB_CI_TEMPLATE, type GenerateOptions, type GeneratedInstruction, type GeneratedSkill, type GeneratedSkillPreview, type GeneratedSkillResult, type GenerationContext, type GitAnalysisOptions, type GitAnalysisResult, type GitAnalysisSummary, type GitCommit, type GitFileChange, GitHubProvider, GitHubSkillRegistry, GitLabProvider, GitProvider, type GitProviderAdapter, GoogleProvider, type Guideline, type GuidelineCategory, type GuidelineConfig, type HookConfig, type HookContext, type HookError, type HookEvent, type HookEventListener, HookManager, type HookManagerOptions, type HookTriggerResult, type HybridSearchOptions, HybridSearchPipeline, type HybridSearchResponse, type HybridSearchResult, INDEX_CACHE_HOURS, INDEX_PATH, type ImportOptions, type IndexBuildCallback, type IndexBuildProgress, type IndexEntry, type IndexSource, type InjectedMemory, type InjectionDetectionResult, InjectionDetector, type InjectionMode, type InjectionOptions, type InjectionResult, type InjectionThreat, type InjectionType, type InstallOptions, type InstallResult$1 as InstallResult, type InstalledPackInfo, type InstalledSkillInfo, type IssueSeverity, KNOWN_SKILL_REPOS, type LLMProvider, type LLMResponse, type SearchResult as LLMSearchResult, type LearnedPattern, type LearnedSkillOutput, type Learning, type LearningConfig, LearningConsolidator, LearningStore, type LearningStoreData, type LoadedContext, type LocalModelConfig, LocalModelConfigSchema, LocalModelManager, LocalProvider, MARKETPLACE_CACHE_FILE, MODEL_REGISTRY, MarketplaceAggregator, type MarketplaceConfig, type MarketplaceIndex, type MarketplaceSearchOptions, type MarketplaceSearchResult, type MarketplaceSkill, type MatchCategory, type MatchReason, type MatcherFunction, MemoryCache, MemoryCompressor, type MemoryConfig, MemoryEnabledEngine, type MemoryEnabledEngineOptions, type MemoryFull, type MemoryHookConfig, MemoryHookManager, type MemoryHookStats, type MemoryIndex, MemoryIndexStore, MemoryInjector, MemoryObserver, type MemoryObserverConfig, type MemoryPaths, type MemoryPattern, type MemoryPreview, type MemorySearchOptions, type MemorySearchResult, MemorySource, type MemoryStatus, type MemorySummary, type MergeReport, type MessageHandler, type MessageType, MethodologyLoader, MethodologyManager, type MethodologyManagerOptions, type MethodologyPack, type MethodologySearchQuery, type MethodologySearchResult, type MethodologySkill, type MethodologySkillMetadata, type MethodologyState, type MethodologySyncResult, MockAIProvider, type ModeCapabilities, type ModeDetectionResult, type ObservableEvent, type ObservableEventType, type Observation, type ObservationContent, ObservationStore, type ObservationStoreData, type ObservationStoreOptions, type ObservationType, OllamaProvider, OpenAIProvider, OpenRouterProvider, type OperationalProfile, type OptimizationResult, type OrchestratorOptions, type OrchestratorTaskStatus, type OrchestratorTeamConfig, PRE_COMMIT_CONFIG_TEMPLATE, PRE_COMMIT_HOOK_TEMPLATE, PROJECT_TYPE_HINTS, PackageManager, type ParseOptions, type ParsedClaudeMd, type ParsedSkillContent, type PatternCategory, type PatternDomain, type PatternExtractionResult, type PatternGenerateOptions, type PatternStore, type PipelineStage, type PlaceholderMatch, type PlaceholderReplacement, type PlanEvent, type PlanEventListener, type PlanExecutionOptions, type PlanExecutionResult, PlanExecutor, PlanGenerator, PlanParser, type PlanResult, type PlanStatus, type PlanStep, type PlanTask, type PlanTaskFiles, type PlanTaskResult, type PlanValidationResult, PlanValidator, type Plugin, type PluginConfig, type PluginContext, type PluginHooks, PluginLoader, PluginManager, type PluginMetadata, PostToolUseHook, PrimerAnalysis, PrimerAnalyzer, PrimerGenerator, PrimerLanguage, type PrimerOptions, type PrimerResult, type ProfileConfig, type ProfileName, ProgressiveDisclosureManager, type ProgressiveDisclosureOptions, ProjectContext, ProjectDetector, ProjectPatterns, type ProjectProfile, ProjectStack, ProjectStructure, type ProviderCapabilities, type ProviderConfig, type ProviderDetectionResult, ProviderFactory, type ProviderName, type ProviderPlugin, type QualityScore, QueryExpander, type RRFInput, type RRFRanking, type RankableSkill, type RankedSkill, type RankerResult, RateLimitError, type ReasoningCacheEntry, type ReasoningConfig, ReasoningEngine, type ReasoningEngineStats, type ReasoningPrompt, type ReasoningProvider, ReasoningProviderSchema, type ReasoningRecommendOptions, ReasoningRecommendationEngine, type ReasoningRecommendationResult, type RecommendHybridSearchOptions, type RecommendHybridSearchResult, type RecommendOptions, RecommendationEngine, type RecommendationResult, type RegisteredCommand, type RegistrySkill, type RelatedSkillResult, type RelationType, RelevanceRanker, type RerankerInput, type RerankerOutput, type ReviewIssue, type ReviewResult, type ReviewStage, type ReviewStageName, RuleBasedCompressor, type RuntimeSkillSource, SEARCH_PLANNING_PROMPT, SESSION_FILE, SKILL_DISCOVERY_PATHS, SKILL_MATCH_PROMPT, STANDARD_PLACEHOLDERS, STEP_HANDLERS, type ScoreBreakdown, type ScoredSkill, type ScoringWeights, type SearchOptions, type SearchPlan, type SearchResult$1 as SearchResult, type SearchableSkill, type SessionContext, type SessionDecision, type SessionEndContext, SessionEndHook, type SessionEndResult, type SessionFile, SessionManager, type SessionMessage, type SessionStartContext, SessionStartHook, type SessionStartResult, type SessionState, type SessionSummary, type SessionTask, type ShareOptions, type SharedSkill, Skill, SkillAnalyzer, SkillBundle, type SkillChunk, SkillChunkSchema, SkillComposer, type SkillEmbedding, type SkillEntry, type SkillExample, SkillExecutionEngine, type SkillExecutionEvent, type SkillExecutionResult, type SkillExecutor, type SkillExecutorOptions, SkillFrontmatter, type SkillGraph, type SkillHook, type SkillIndex, SkillInjector, SkillLocation, SkillMdTranslator, SkillMerger, SkillMetadata, type SkillNode, SkillPreferences, type SkillReference, type SkillRelation, type SkillRequirements, type SkillSource, SkillSummary, type SkillTestCase, type SkillTestSuite, type SkillToSubagentOptions, type SkillTranslationOptions, type SkillTranslationResult, type SkillTree, SkillTreeSchema, SkillTriggerEngine, SkillWizard, SkillkitConfig, type SkillsManifest, SkillsSource, type SlashCommand, type SlashCommandResult, type SourceSummary, type SpecificityScore, type StepDefinition, type StepExecutor, type StepResult, type StepType, type StructureScore, type StructuredPlan, type SyncOptions, type SyncReport, type SyncResult, TAG_TO_CATEGORY, TAG_TO_TECH, TASK_TEMPLATES, TREE_FILE_NAME, type Task, type TaskEvent, type TaskEventListener, type TaskExecutionResult, type TaskFiles, type TaskFilter, TaskManager, type TaskPlan, type TaskResult, type TaskStatus, type TaskStep, type TaskTemplate, type Team, type TeamConfig, type TeamEvent, type TeamEventListener, TeamManager, type TeamMember, type TeamMessage, TeamMessageBus, TeamOrchestrator, type TeamRegistry, type TeamStatus, type TestAssertion, type TestAssertionType, type TestCaseResult, type TestProgressEvent, type TestResult, type TestRunnerOptions, type TestSuiteResult, type TimelineEntry, type ToolUseCaptureResult, type ToolUseEvent, TranslatableSkillFrontmatter, type TranslationOptions, type TranslationPath, type TranslationResult, type TranslatorPlugin, TranslatorRegistry, TreeGenerator, type TreeGeneratorOptions, type TreeNode, TreeNodeSchema, type TreePath, type TreeReasoningResult, type TreeSearchQuery, type TreeSearchResult, type TreeTraversalStep, type TriggerEngineOptions, type TrustBreakdown, type TrustScore, type TrustScoreOptions, TrustScorer, type UpdateOptions, type ValidationError, type ValidationIssue, type ValidationResult, type ValidationWarning, type ValidatorOptions, type VectorSearchResult, VectorStore, type VectorStoreConfig, type VerificationRule, WORKFLOWS_DIR, WORKFLOW_EXTENSION, type WaveExecutionStatus, type WellKnownIndex, WellKnownProvider, type WellKnownSkill, WindsurfTranslator, type WizardContext, type WizardError, type WizardEvents, type InstallResult as WizardInstallResult, type WizardOptions, type WizardState, type WizardStep, type Workflow, type WorkflowExecution, type WorkflowExecutionStatus, WorkflowOrchestrator, type WorkflowProgressCallback, type WorkflowSkill, type WorkflowWave, addCustomGuideline, addCustomProfile, addPattern, addToManifest, agentExists, analyzeForPrimer, analyzeGitHistory, analyzePlaceholders, analyzePrimer, analyzeProject, applyConnectorConfig, applyPositionAwareBlending, approvePattern, benchmarkSkill, buildCategoryRelevancePrompt, buildExplanationPrompt, buildSearchPlanPrompt, buildSkillGraph, buildSkillIndex, buildSkillMatchPrompt, calculateBaseSkillsUrl, calculatePercentile, canTranslate, clusterPatterns, compareTreeVersions, computeRRFScore, copilotTranslator, createAPIBasedCompressor, createClaudeMdUpdater, createCommandGenerator, createCommandRegistry, createConnectorConfig, createContextLoader, createContextManager, createContextSync, createEmbeddingService, createExecutionEngine, createExecutionManager, createHookManager, createHybridSearchPipeline, createInitialState, createMarketplaceAggregator, createMemoryCompressor, createMemoryEnabledEngine, createMemoryHookManager, createMemoryInjector, createMemoryObserver, createMessageBus, createMethodologyLoader, createMethodologyManager, createModeAwareExecutor, createPlanExecutor, createPlanGenerator, createPlanParser, createPlanValidator, createPluginManager, createPostToolUseHook, createProgressiveDisclosureManager, createProvider, createQueryExpander, createQuestionFromPattern, createReasoningEngine, createReasoningRecommendationEngine, createRecommendationEngine, createRuleBasedCompressor, createSessionEndHook, createSessionFile, createSessionManager, createSessionStartHook, createSimulatedSkillExecutor, createSkillBundle, createSkillExecutor, createTaskManager, createTeamManager, createTeamOrchestrator, createTestSuiteFromFrontmatter, createTriggerEngine, createVectorStore, createWorkflowOrchestrator, createWorkflowTemplate, cursorTranslator, deserializeGraph, deserializeTree, detectCategory, detectExecutionMode, detectPlaceholders, detectProvider, detectProviders, detectSkillFormat, disableGuideline, discoverAgents, discoverAgentsForAgent, discoverAgentsFromPath, discoverAgentsRecursive, discoverGlobalAgents, discoverReferences, discoverSkills, dryRunExecutor, enableGuideline, estimateTokens, evaluateSkillContent, evaluateSkillDirectory, evaluateSkillFile, executePostToolUseHook, executeSessionEndHook, executeSessionStartHook, executeWithAgent, expandQuerySimple, exportBundle, exportPatternsAsJson, extractAgentContent, extractAgentFrontmatter, extractField, extractFrontmatter, extractJsonFromResponse, extractPatternsFromSession, extractSkillMetadata, fetchSkillsFromRepo, findAgent, findAllAgents, findAllSkills, findManifestPath, findSkill, findSkillsByRelationType, findSkillsInCategory, formatBytes, formatSkillAsPrompt, fromCanonicalAgent, fuseWithRRF, generateComparisonNotes, generateConnectorsMarkdown, generateManifestFromInstalled, generatePatternReport, generatePrimer, generatePrimerForAgent, generateRecommendations, generateSkillFromPatterns, generateSkillTree, generateSkillsConfig, generateSubagentFromSkill, generateWellKnownIndex, generateWellKnownStructure, getActiveProfile, getAgentCLIConfig, getAgentConfigFile, getAgentConfigPath, getAgentDirectoryConfig, getAgentFilename, getAgentFormat, getAgentSkillsDir, getAgentStats, getAgentTargetDirectory, getAgentsDirectory, getAllCategories, getAllGuidelines, getAllPatterns, getAllProfiles, getAllProviders, getAllSkillsDirs, getApprovedPatterns, getAvailableCLIAgents, getBuiltinGuidelines, getBuiltinPacksDir, getBuiltinPipeline, getBuiltinPipelines, getBuiltinProfiles, getCICDTemplate, getCategoryStats, getConfigFile, getConfigFormat, getDefaultConfigPath, getDefaultModelDir, getDefaultProvider, getDefaultStorePath, getEnabledGuidelineContent, getEnabledGuidelines, getEvolvingPattern, getEvolvingPatternsByDomain, getExecutionStrategy, getGitCommits, getGlobalConfigPath, getGlobalSkillsDir, getGrade, getGuideline, getGuidelineContent, getGuidelinesByCategory, getHighConfidencePatterns, getIndexStatus, getInstallDir, getLowConfidencePatterns, getManualExecutionInstructions, getMemoryPaths, getMemoryStatus, getModeDescription, getMostRecentSession, getMostUsedPatterns, getNextStep, getPattern, getPatternStats, getPatternsByCategory, getPlaceholderInfo, getPreviousStep, getProfile, getProfileContext, getProfileNames, getProjectConfigPath, getProvider, getProviderEnvVars, getProviderModels, getQualityGrade, getRankFromScore, getRecentBugFixes, getRecentRefactors, getRelatedSkills, getSearchDirs, getSkillPath, getSkillsDir, getStackTags, getStandaloneAlternative, getStepNumber, getStepOrder, getSupportedTranslationAgents, getTechTags, getTotalSteps, globalMemoryDirectoryExists, hybridSearch, importBundle, importPatternsFromJson, initContext, initManifest, initProject, initializeMemoryDirectory, isAgentCLIAvailable, isAgentCompatible, isBuiltinGuideline, isBuiltinProfile, isGitUrl, isGuidelineEnabled, isHighQuality, isIndexStale, isLocalPath, isPathInside, isProviderConfigured, listCICDTemplates, listSessions, listWorkflows, loadAgentMetadata, loadAndConvertSkill, loadConfig, loadContext, loadGuidelineConfig, loadIndex, loadLearningConfig, loadManifest, loadMetadata, loadPatternStore, loadPlugin, loadPluginsFromDirectory, loadProfileConfig, loadSessionFile, loadSkillMetadata, loadTree, loadWorkflow, loadWorkflowByName, memoryDirectoryExists, mergePatterns, mergeRankings, normalizeScores, parseAgentDir, parseAgentFile, parseShorthand, parseSkill, parseSkillContent, parseSkillContentToCanonical, parseSkillMd, parseSkillToCanonical, parseSource, parseWorkflow, quickInjectionCheck, quickTrustScore, readAgentContent, readSkillContent, recordFailure, recordSuccess, rejectPattern, removeCustomGuideline, removeCustomProfile, removeFromManifest, removePattern, replacePlaceholders, requireCapability, requireEnhancedMode, runTestSuite, sanitizeSkillContent, saveConfig, saveGeneratedSkill, saveGuidelineConfig, saveIndex, saveLearningConfig, saveManifest, savePatternStore, saveProfileConfig, saveSessionFile, saveSkillMetadata, saveTree, saveWorkflow, serializeGraph, serializeTree, serializeWorkflow, setActiveProfile, setSkillEnabled, shellExecutor, skillMdTranslator, skillToSubagent, stripFrontmatter, suggestMappingsFromMcp, supportsAutoDiscovery, supportsSlashCommands, syncGlobalClaudeMd, syncToAgent, syncToAllAgents, toCanonicalAgent, translateAgent, translateAgentContent, translateAgents, translateCanonicalAgent, translateSkill, translateSkillFile, translateSkillToAgent, translateSkillToAll, translatorRegistry, treeToMarkdown, treeToText, updateClaudeMd, updateSessionFile, validateAgent, validateBuiltinPacks, validateCategoryScore, validateConnectorConfig, validatePackDirectory, validatePackManifest, validatePlan, validateSearchPlan, validateSkill, validateSkillContent, validateWorkflow, weightedCombine, windsurfTranslator, wrapProgressCallbackWithMemory, writeTranslatedSkill };