@skillkit/core 1.8.1 → 1.10.0

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 
 declare const AgentType: z.ZodEnum<["claude-code", "codex", "cursor", "antigravity", "opencode", "gemini-cli", "amp", "clawdbot", "droid", "github-copilot", "goose", "kilo", "kiro-cli", "roo", "trae", "windsurf", "universal", "cline", "codebuddy", "commandcode", "continue", "crush", "factory", "mcpjam", "mux", "neovate", "openhands", "pi", "qoder", "qwen", "vercel", "zencoder"]>;
 type AgentType = z.infer<typeof AgentType>;
-declare const GitProvider: z.ZodEnum<["github", "gitlab", "bitbucket", "local"]>;
+declare const GitProvider: z.ZodEnum<["github", "gitlab", "bitbucket", "local", "wellknown"]>;
 type GitProvider = z.infer<typeof GitProvider>;
 declare const SkillFrontmatter: z.ZodObject<{
     name: z.ZodString;
@@ -43,7 +43,7 @@ declare const SkillMetadata: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodString;
     source: z.ZodString;
-    sourceType: z.ZodEnum<["github", "gitlab", "bitbucket", "local"]>;
+    sourceType: z.ZodEnum<["github", "gitlab", "bitbucket", "local", "wellknown"]>;
     subpath: z.ZodOptional<z.ZodString>;
     installedAt: z.ZodString;
     updatedAt: z.ZodOptional<z.ZodString>;
@@ -54,7 +54,7 @@ declare const SkillMetadata: z.ZodObject<{
     name: string;
     description: string;
     source: string;
-    sourceType: "github" | "gitlab" | "bitbucket" | "local";
+    sourceType: "github" | "gitlab" | "bitbucket" | "local" | "wellknown";
     installedAt: string;
     enabled: boolean;
     version?: string | undefined;
@@ -65,7 +65,7 @@ declare const SkillMetadata: z.ZodObject<{
     name: string;
     description: string;
     source: string;
-    sourceType: "github" | "gitlab" | "bitbucket" | "local";
+    sourceType: "github" | "gitlab" | "bitbucket" | "local" | "wellknown";
     installedAt: string;
     version?: string | undefined;
     subpath?: string | undefined;
@@ -85,7 +85,7 @@ declare const Skill: z.ZodObject<{
         name: z.ZodString;
         description: z.ZodString;
         source: z.ZodString;
-        sourceType: z.ZodEnum<["github", "gitlab", "bitbucket", "local"]>;
+        sourceType: z.ZodEnum<["github", "gitlab", "bitbucket", "local", "wellknown"]>;
         subpath: z.ZodOptional<z.ZodString>;
         installedAt: z.ZodString;
         updatedAt: z.ZodOptional<z.ZodString>;
@@ -96,7 +96,7 @@ declare const Skill: z.ZodObject<{
         name: string;
         description: string;
         source: string;
-        sourceType: "github" | "gitlab" | "bitbucket" | "local";
+        sourceType: "github" | "gitlab" | "bitbucket" | "local" | "wellknown";
         installedAt: string;
         enabled: boolean;
         version?: string | undefined;
@@ -107,7 +107,7 @@ declare const Skill: z.ZodObject<{
         name: string;
         description: string;
         source: string;
-        sourceType: "github" | "gitlab" | "bitbucket" | "local";
+        sourceType: "github" | "gitlab" | "bitbucket" | "local" | "wellknown";
         installedAt: string;
         version?: string | undefined;
         subpath?: string | undefined;
@@ -126,7 +126,7 @@ declare const Skill: z.ZodObject<{
         name: string;
         description: string;
         source: string;
-        sourceType: "github" | "gitlab" | "bitbucket" | "local";
+        sourceType: "github" | "gitlab" | "bitbucket" | "local" | "wellknown";
         installedAt: string;
         enabled: boolean;
         version?: string | undefined;
@@ -143,7 +143,7 @@ declare const Skill: z.ZodObject<{
         name: string;
         description: string;
         source: string;
-        sourceType: "github" | "gitlab" | "bitbucket" | "local";
+        sourceType: "github" | "gitlab" | "bitbucket" | "local" | "wellknown";
         installedAt: string;
         version?: string | undefined;
         subpath?: string | undefined;
@@ -417,6 +417,45 @@ declare class LocalProvider implements GitProviderAdapter {
     clone(source: string, _targetDir: string, _options?: CloneOptions): Promise<CloneResult>;
 }
 
+interface WellKnownSkill {
+    name: string;
+    description?: string;
+    files: string[];
+}
+interface WellKnownIndex {
+    version?: string;
+    skills: WellKnownSkill[];
+}
+declare class WellKnownProvider implements GitProviderAdapter {
+    readonly type: GitProvider;
+    readonly name = "Well-Known";
+    readonly baseUrl = "";
+    parseSource(source: string): {
+        owner: string;
+        repo: string;
+        subpath?: string;
+    } | null;
+    matches(source: string): boolean;
+    getCloneUrl(_owner: string, _repo: string): string;
+    getSshUrl(_owner: string, _repo: string): string;
+    clone(source: string, _targetDir: string, _options?: CloneOptions): Promise<CloneResult>;
+}
+declare function calculateBaseSkillsUrl(foundUrl: string): string;
+declare function generateWellKnownIndex(skills: Array<{
+    name: string;
+    description?: string;
+    files: string[];
+}>): WellKnownIndex;
+declare function generateWellKnownStructure(outputDir: string, skills: Array<{
+    name: string;
+    description?: string;
+    content: string;
+    additionalFiles?: Record<string, string>;
+}>): {
+    indexPath: string;
+    skillPaths: string[];
+};
+
 declare function getProvider(type: GitProvider): GitProviderAdapter | undefined;
 declare function getAllProviders(): GitProviderAdapter[];
 declare function detectProvider(source: string): GitProviderAdapter | undefined;
@@ -2337,6 +2376,208 @@ declare const TAG_TO_TECH: Record<string, string[]>;
  * Reverse mapping: tech to tags
  */
 declare function getTechTags(techName: string): string[];
+/**
+ * Enhanced recommendation options with reasoning support
+ */
+interface ReasoningRecommendOptions extends RecommendOptions {
+    reasoning?: boolean;
+    explainResults?: boolean;
+    useTree?: boolean;
+}
+/**
+ * Explained match details
+ */
+interface ExplainedMatchDetails {
+    matchedBecause: string[];
+    relevantFor: string[];
+    differentFrom: string[];
+    confidence: 'high' | 'medium' | 'low';
+}
+/**
+ * Enhanced scored skill with reasoning
+ */
+interface ExplainedScoredSkill extends ScoredSkill {
+    explanation?: ExplainedMatchDetails;
+    treePath?: string[];
+    reasoningDetails?: string;
+}
+/**
+ * Enhanced recommendation result with reasoning
+ */
+interface ReasoningRecommendationResult extends RecommendationResult {
+    recommendations: ExplainedScoredSkill[];
+    reasoningSummary?: string;
+    searchPlan?: {
+        primaryCategories: string[];
+        secondaryCategories: string[];
+        keywords: string[];
+        strategy: string;
+    };
+}
+/**
+ * Hybrid search options for RecommendationEngine
+ */
+interface RecommendHybridSearchOptions extends SearchOptions {
+    hybrid?: boolean;
+    enableExpansion?: boolean;
+    enableReranking?: boolean;
+    semanticWeight?: number;
+    keywordWeight?: number;
+}
+/**
+ * Hybrid search result with additional metadata for RecommendationEngine
+ */
+interface RecommendHybridSearchResult extends SearchResult {
+    hybridScore?: number;
+    vectorSimilarity?: number;
+    keywordScore?: number;
+    rrfScore?: number;
+    expandedTerms?: string[];
+}
+
+interface TreeNode {
+    id: string;
+    name: string;
+    description?: string;
+    children: TreeNode[];
+    skills: string[];
+    skillCount: number;
+    depth: number;
+}
+declare const TreeNodeSchema: z.ZodType<TreeNode>;
+declare const SkillTreeSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodNumber>;
+    generatedAt: z.ZodString;
+    rootNode: z.ZodType<TreeNode, z.ZodTypeDef, TreeNode>;
+    totalSkills: z.ZodNumber;
+    totalCategories: z.ZodNumber;
+    maxDepth: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    version: number;
+    totalSkills: number;
+    generatedAt: string;
+    rootNode: TreeNode;
+    totalCategories: number;
+    maxDepth: number;
+}, {
+    totalSkills: number;
+    generatedAt: string;
+    rootNode: TreeNode;
+    totalCategories: number;
+    maxDepth: number;
+    version?: number | undefined;
+}>;
+type SkillTree = z.infer<typeof SkillTreeSchema>;
+interface TreePath {
+    segments: string[];
+    node: TreeNode;
+}
+interface CategoryMapping {
+    category: string;
+    subcategories: string[];
+    tags: string[];
+    keywords: string[];
+}
+declare const CATEGORY_TAXONOMY: CategoryMapping[];
+declare const TAG_TO_CATEGORY: Record<string, string[]>;
+interface TreeGeneratorOptions {
+    maxDepth?: number;
+    minSkillsPerNode?: number;
+    includeEmpty?: boolean;
+}
+
+declare const ReasoningProviderSchema: z.ZodEnum<["openai", "anthropic", "ollama", "mock"]>;
+type ReasoningProvider = z.infer<typeof ReasoningProviderSchema>;
+interface ReasoningConfig {
+    provider: ReasoningProvider;
+    apiKey?: string;
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+    baseUrl?: string;
+}
+interface TreeSearchQuery {
+    query: string;
+    context?: ProjectProfile;
+    maxResults?: number;
+    minConfidence?: number;
+    searchDepth?: number;
+}
+interface TreeTraversalStep {
+    node: TreeNode;
+    reasoning: string;
+    confidence: number;
+    action: 'explore' | 'skip' | 'select';
+    selectedSkills: string[];
+}
+interface TreeSearchResult {
+    skill: SkillSummary;
+    path: string[];
+    reasoning: string;
+    confidence: number;
+    relevantSections: string[];
+    matchedKeywords: string[];
+}
+interface TreeReasoningResult {
+    query: string;
+    results: TreeSearchResult[];
+    exploredPaths: string[][];
+    reasoning: string;
+    totalNodesVisited: number;
+    processingTimeMs: number;
+}
+interface ExplainedMatch {
+    matchedBecause: string[];
+    relevantFor: string[];
+    differentFrom: string[];
+    confidence: 'high' | 'medium' | 'low';
+}
+interface ExplainedRecommendation {
+    skill: SkillSummary;
+    score: number;
+    reasoning: ExplainedMatch;
+    treePath: string[];
+}
+interface ReasoningPrompt {
+    name: string;
+    template: string;
+    variables: string[];
+}
+interface LLMResponse {
+    content: string;
+    tokensUsed: number;
+    model: string;
+}
+interface ReasoningCacheEntry {
+    query: string;
+    results: TreeSearchResult[];
+    timestamp: number;
+    ttl: number;
+}
+declare const DEFAULT_REASONING_CONFIG: ReasoningConfig;
+interface CategoryScore {
+    category: string;
+    score: number;
+    reasoning: string;
+}
+interface SearchPlan {
+    primaryCategories: string[];
+    secondaryCategories: string[];
+    keywords: string[];
+    filters: {
+        tags?: string[];
+        frameworks?: string[];
+        languages?: string[];
+    };
+    strategy: 'breadth-first' | 'depth-first' | 'targeted';
+}
+interface ReasoningEngineStats {
+    totalQueries: number;
+    cacheHits: number;
+    cacheMisses: number;
+    averageProcessingTimeMs: number;
+    averageResultsPerQuery: number;
+}
 
 /**
  * Recommendation engine for matching skills to project profiles
@@ -2344,7 +2585,16 @@ declare function getTechTags(techName: string): string[];
 declare class RecommendationEngine {
     private weights;
     private index;
+    private hybridPipeline;
     constructor(weights?: Partial<ScoringWeights>);
+    /**
+     * Initialize hybrid search pipeline for vector + keyword search
+     */
+    initHybridSearch(): Promise<void>;
+    /**
+     * Check if hybrid search is available
+     */
+    isHybridSearchAvailable(): boolean;
     /**
      * Load skill index from cache or generate from local skills
      */
@@ -2409,6 +2659,19 @@ declare class RecommendationEngine {
      * Calculate search relevance for a skill
      */
     private calculateRelevance;
+    /**
+     * Hybrid search combining vector embeddings and keyword matching
+     */
+    hybridSearch(options: RecommendHybridSearchOptions): Promise<RecommendHybridSearchResult[]>;
+    /**
+     * Build hybrid search index from skills
+     */
+    buildHybridIndex(onProgress?: (progress: {
+        phase: string;
+        current: number;
+        total: number;
+        message?: string;
+    }) => void): Promise<void>;
     /**
      * Check freshness of installed skills against project dependencies
      *
@@ -2423,6 +2686,24 @@ declare class RecommendationEngine {
  * Create a recommendation engine with default settings
  */
 declare function createRecommendationEngine(weights?: Partial<ScoringWeights>): RecommendationEngine;
+/**
+ * Enhanced Recommendation Engine with reasoning support
+ */
+declare class ReasoningRecommendationEngine extends RecommendationEngine {
+    private reasoningEngine;
+    private reasoningConfig?;
+    constructor(weights?: Partial<ScoringWeights>, reasoningConfig?: Partial<ReasoningConfig>);
+    initReasoning(): Promise<void>;
+    recommendWithReasoning(profile: ProjectProfile, options?: ReasoningRecommendOptions): Promise<ReasoningRecommendationResult>;
+    private buildQueryFromProfile;
+    private extractKeywords;
+    getReasoningStats(): ReasoningEngineStats | null;
+    getSkillTree(): SkillTree | null;
+}
+/**
+ * Create an enhanced recommendation engine with reasoning support
+ */
+declare function createReasoningRecommendationEngine(weights?: Partial<ScoringWeights>): ReasoningRecommendationEngine;
 
 /**
  * Known skill repositories to index
@@ -7822,6 +8103,8 @@ declare const AgentFrontmatter: z.ZodObject<{
     disallowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     /** Allowed tools for this agent */
     allowedTools: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+    /** Tools (Claude Code native format alias for allowedTools) */
+    tools: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
     /** Agent-scoped hooks */
     hooks: z.ZodOptional<z.ZodArray<z.ZodObject<{
         /** Hook event type */
@@ -7872,6 +8155,7 @@ declare const AgentFrontmatter: z.ZodObject<{
     'user-invocable'?: boolean | undefined;
     'argument-hint'?: string | undefined;
     skills?: string[] | undefined;
+    tools?: string | string[] | undefined;
     hooks?: {
         type: "SessionStart" | "SessionEnd" | "PreToolUse" | "PostToolUse" | "Stop" | "SubagentStop";
         command: string;
@@ -7893,6 +8177,7 @@ declare const AgentFrontmatter: z.ZodObject<{
     'user-invocable'?: boolean | undefined;
     'argument-hint'?: string | undefined;
     skills?: string[] | undefined;
+    tools?: string | string[] | undefined;
     hooks?: {
         type: "SessionStart" | "SessionEnd" | "PreToolUse" | "PostToolUse" | "Stop" | "SubagentStop";
         command: string;
@@ -8195,6 +8480,46 @@ declare function isAgentCompatible(sourceFormat: AgentFormatCategory, targetForm
     warnings: string[];
 };
 
+/**
+ * Skill to Subagent Converter
+ *
+ * Converts SkillKit skills into Claude Code native subagent format (.md files).
+ * Supports both reference mode (skills: [skill-name]) and inline mode (embedded content).
+ */
+
+/**
+ * Options for skill-to-subagent conversion
+ */
+interface SkillToSubagentOptions {
+    /** Embed full skill content in system prompt (default: false - use skills reference) */
+    inline?: boolean;
+    /** Model to use (sonnet, opus, haiku, inherit) */
+    model?: 'sonnet' | 'opus' | 'haiku' | 'inherit';
+    /** Permission mode for the agent */
+    permissionMode?: AgentPermissionMode;
+    /** Tools the agent is allowed to use */
+    tools?: string[];
+    /** Tools the agent cannot use */
+    disallowedTools?: string[];
+}
+/**
+ * Convert a skill to a CanonicalAgent representation
+ */
+declare function skillToSubagent(skill: Skill, skillContent: string, options?: SkillToSubagentOptions): CanonicalAgent;
+/**
+ * Generate the markdown content for a Claude Code subagent from a skill
+ */
+declare function generateSubagentFromSkill(skill: Skill, skillContent: string, options?: SkillToSubagentOptions): string;
+/**
+ * Load a skill and generate subagent content
+ * Convenience function that reads skill content and generates subagent markdown
+ */
+declare function loadAndConvertSkill(skill: Skill, options?: SkillToSubagentOptions): {
+    success: boolean;
+    content?: string;
+    error?: string;
+};
+
 /**
  * Skill Translator
  *
@@ -8430,14 +8755,14 @@ declare const CodeConvention: z.ZodObject<{
     indentation?: "tabs" | "spaces-2" | "spaces-4" | undefined;
     quotes?: "single" | "double" | undefined;
     semicolons?: boolean | undefined;
-    trailingCommas?: "all" | "none" | "es5" | undefined;
+    trailingCommas?: "none" | "all" | "es5" | undefined;
     maxLineLength?: number | undefined;
 }, {
     namingStyle?: "camelCase" | "snake_case" | "PascalCase" | "kebab-case" | undefined;
     indentation?: "tabs" | "spaces-2" | "spaces-4" | undefined;
     quotes?: "single" | "double" | undefined;
     semicolons?: boolean | undefined;
-    trailingCommas?: "all" | "none" | "es5" | undefined;
+    trailingCommas?: "none" | "all" | "es5" | undefined;
     maxLineLength?: number | undefined;
 }>;
 type CodeConvention = z.infer<typeof CodeConvention>;
@@ -8842,14 +9167,14 @@ declare const PrimerAnalysis: z.ZodObject<{
         indentation?: "tabs" | "spaces-2" | "spaces-4" | undefined;
         quotes?: "single" | "double" | undefined;
         semicolons?: boolean | undefined;
-        trailingCommas?: "all" | "none" | "es5" | undefined;
+        trailingCommas?: "none" | "all" | "es5" | undefined;
         maxLineLength?: number | undefined;
     }, {
         namingStyle?: "camelCase" | "snake_case" | "PascalCase" | "kebab-case" | undefined;
         indentation?: "tabs" | "spaces-2" | "spaces-4" | undefined;
         quotes?: "single" | "double" | undefined;
         semicolons?: boolean | undefined;
-        trailingCommas?: "all" | "none" | "es5" | undefined;
+        trailingCommas?: "none" | "all" | "es5" | undefined;
         maxLineLength?: number | undefined;
     }>>;
     ci: z.ZodOptional<z.ZodObject<{
@@ -9014,17 +9339,17 @@ declare const PrimerAnalysis: z.ZodObject<{
         hasCompose: boolean;
         baseImage?: string | undefined;
     } | undefined;
-    env?: {
-        hasEnvFile: boolean;
-        hasEnvExample: boolean;
-        envVariables?: string[] | undefined;
-    } | undefined;
     ci?: {
         hasCI: boolean;
         hasCD: boolean;
         provider?: "github-actions" | "gitlab-ci" | "circleci" | "jenkins" | "travis" | "azure-pipelines" | undefined;
         configFile?: string | undefined;
     } | undefined;
+    env?: {
+        hasEnvFile: boolean;
+        hasEnvExample: boolean;
+        envVariables?: string[] | undefined;
+    } | undefined;
     structure?: {
         hasWorkspaces: boolean;
         type?: "flat" | "monorepo" | "src-based" | "packages" | undefined;
@@ -9039,7 +9364,7 @@ declare const PrimerAnalysis: z.ZodObject<{
         indentation?: "tabs" | "spaces-2" | "spaces-4" | undefined;
         quotes?: "single" | "double" | undefined;
         semicolons?: boolean | undefined;
-        trailingCommas?: "all" | "none" | "es5" | undefined;
+        trailingCommas?: "none" | "all" | "es5" | undefined;
         maxLineLength?: number | undefined;
     } | undefined;
     buildCommands?: {
@@ -9135,17 +9460,17 @@ declare const PrimerAnalysis: z.ZodObject<{
         hasCompose?: boolean | undefined;
         baseImage?: string | undefined;
     } | undefined;
-    env?: {
-        hasEnvFile?: boolean | undefined;
-        hasEnvExample?: boolean | undefined;
-        envVariables?: string[] | undefined;
-    } | undefined;
     ci?: {
         provider?: "github-actions" | "gitlab-ci" | "circleci" | "jenkins" | "travis" | "azure-pipelines" | undefined;
         hasCI?: boolean | undefined;
         hasCD?: boolean | undefined;
         configFile?: string | undefined;
     } | undefined;
+    env?: {
+        hasEnvFile?: boolean | undefined;
+        hasEnvExample?: boolean | undefined;
+        envVariables?: string[] | undefined;
+    } | undefined;
     packageManagers?: ("go" | "bun" | "npm" | "pnpm" | "yarn" | "pip" | "poetry" | "uv" | "cargo" | "maven" | "gradle" | "composer" | "bundler" | "cocoapods" | "swift-package-manager" | "nuget")[] | undefined;
     structure?: {
         type?: "flat" | "monorepo" | "src-based" | "packages" | undefined;
@@ -9161,7 +9486,7 @@ declare const PrimerAnalysis: z.ZodObject<{
         indentation?: "tabs" | "spaces-2" | "spaces-4" | undefined;
         quotes?: "single" | "double" | undefined;
         semicolons?: boolean | undefined;
-        trailingCommas?: "all" | "none" | "es5" | undefined;
+        trailingCommas?: "none" | "all" | "es5" | undefined;
         maxLineLength?: number | undefined;
     } | undefined;
     buildCommands?: {
@@ -9506,4 +9831,876 @@ declare function getGuidelineContent(id: string): string | null;
 declare function getEnabledGuidelineContent(): string;
 declare function isBuiltinGuideline(id: string): boolean;
 
-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, CIConfig, CIRCLECI_CONFIG_TEMPLATE, CONTEXT_DIR, CONTEXT_FILE, CUSTOM_AGENT_FORMAT_MAP, type CanonicalAgent, type CanonicalSkill, 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, type CompletenessResult, type CompressedLearning, type CompressionEngine, type CompressionOptions, type CompressionResult, 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_CONTEXT_CATEGORIES, DEFAULT_GUIDELINE_CONFIG, DEFAULT_LEARNING_CONFIG, DEFAULT_MEMORY_CONFIG, DEFAULT_PROFILE_CONFIG, DEFAULT_SCORING_WEIGHTS, DEFAULT_SKILL_SOURCES, DependencyInfo, Detection, type DetectionSource, type DiscoveredSkill, DockerConfig, EnvConfig, type EvolvingPattern, type ExecutableSkill, type ExecutableTask, type ExecutableTaskType, type ExecutionHistory, type ExecutionOptions, type ExecutionProgressCallback, type ExecutionProgressEvent, type ExecutionStrategy, type ExecutionTaskStatus, type FeedbackResult, 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, 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, INDEX_CACHE_HOURS, INDEX_PATH, type ImportOptions, type IndexSource, type InjectedMemory, type InjectionMode, type InjectionOptions, type InjectionResult, type InstallOptions, type InstallResult, type InstalledPackInfo, type InstalledSkillInfo, type IssueSeverity, KNOWN_SKILL_REPOS, type LearnedPattern, type LearnedSkillOutput, type Learning, type LearningConfig, LearningConsolidator, LearningStore, type LearningStoreData, type LoadedContext, LocalProvider, MARKETPLACE_CACHE_FILE, MarketplaceAggregator, type MarketplaceConfig, type MarketplaceIndex, type MarketplaceSearchOptions, type MarketplaceSearchResult, type MarketplaceSkill, type MatchCategory, type MatchReason, type MatcherFunction, 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 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 PatternCategory, type PatternDomain, type PatternExtractionResult, type PatternGenerateOptions, type PatternStore, type PipelineStage, 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, type RecommendOptions, RecommendationEngine, type RecommendationResult, type RegisteredCommand, type RegistrySkill, type ReviewIssue, type ReviewResult, type ReviewStage, type ReviewStageName, RuleBasedCompressor, SESSION_FILE, SKILL_DISCOVERY_PATHS, type ScoredSkill, type ScoringWeights, type SearchOptions, 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 SkillEntry, type SkillExample, SkillExecutionEngine, type SkillExecutionEvent, type SkillExecutionResult, type SkillExecutor, type SkillExecutorOptions, SkillFrontmatter, type SkillHook, type SkillIndex, SkillLocation, SkillMdTranslator, SkillMetadata, SkillPreferences, type SkillSource, SkillSummary, type SkillTestCase, type SkillTestSuite, type SkillTranslationOptions, type SkillTranslationResult, SkillTriggerEngine, SkillkitConfig, type SkillsManifest, type SlashCommand, type SlashCommandResult, type SpecificityScore, type StepExecutor, type StepType, type StructureScore, type StructuredPlan, type SyncOptions, type SyncReport, type SyncResult, TAG_TO_TECH, TASK_TEMPLATES, 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, type TriggerEngineOptions, type UpdateOptions, type ValidationError, type ValidationIssue, type ValidationResult, type ValidationWarning, type ValidatorOptions, type VerificationRule, WORKFLOWS_DIR, WORKFLOW_EXTENSION, type WaveExecutionStatus, WindsurfTranslator, type Workflow, type WorkflowExecution, type WorkflowExecutionStatus, WorkflowOrchestrator, type WorkflowProgressCallback, type WorkflowSkill, type WorkflowWave, addCustomGuideline, addCustomProfile, addPattern, addToManifest, agentExists, analyzeForPrimer, analyzeGitHistory, analyzePrimer, analyzeProject, approvePattern, benchmarkSkill, buildSkillIndex, calculatePercentile, canTranslate, clusterPatterns, copilotTranslator, createAPIBasedCompressor, createCommandGenerator, createCommandRegistry, createContextLoader, createContextManager, createContextSync, createExecutionEngine, createHookManager, createMarketplaceAggregator, createMemoryCompressor, createMemoryEnabledEngine, createMemoryInjector, createMemoryObserver, createMessageBus, createMethodologyLoader, createMethodologyManager, createPlanExecutor, createPlanGenerator, createPlanParser, createPlanValidator, createPluginManager, createRecommendationEngine, createRuleBasedCompressor, createSessionFile, createSessionManager, createSimulatedSkillExecutor, createSkillBundle, createSkillExecutor, createTaskManager, createTeamManager, createTeamOrchestrator, createTestSuiteFromFrontmatter, createTriggerEngine, createWorkflowOrchestrator, createWorkflowTemplate, cursorTranslator, detectCategory, detectProvider, detectSkillFormat, disableGuideline, discoverAgents, discoverAgentsForAgent, discoverAgentsFromPath, discoverAgentsRecursive, discoverGlobalAgents, discoverSkills, dryRunExecutor, enableGuideline, estimateTokens, evaluateSkillContent, evaluateSkillDirectory, evaluateSkillFile, executeWithAgent, exportBundle, exportPatternsAsJson, extractAgentContent, extractAgentFrontmatter, extractField, extractFrontmatter, extractPatternsFromSession, extractSkillMetadata, fetchSkillsFromRepo, findAgent, findAllAgents, findAllSkills, findManifestPath, findSkill, formatSkillAsPrompt, fromCanonicalAgent, generateComparisonNotes, generateManifestFromInstalled, generatePatternReport, generatePrimer, generatePrimerForAgent, generateRecommendations, generateSkillFromPatterns, generateSkillsConfig, 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, getDefaultStorePath, getEnabledGuidelineContent, getEnabledGuidelines, getEvolvingPattern, getEvolvingPatternsByDomain, getExecutionStrategy, getGitCommits, getGlobalConfigPath, getGlobalSkillsDir, getGrade, getGuideline, getGuidelineContent, getGuidelinesByCategory, getHighConfidencePatterns, getIndexStatus, getInstallDir, getLowConfidencePatterns, getManualExecutionInstructions, getMemoryPaths, getMemoryStatus, getMostRecentSession, getMostUsedPatterns, getPattern, getPatternStats, getPatternsByCategory, getProfile, getProfileContext, getProfileNames, getProjectConfigPath, getProvider, getQualityGrade, getRecentBugFixes, getRecentRefactors, getSearchDirs, getSkillsDir, getStackTags, getSupportedTranslationAgents, getTechTags, globalMemoryDirectoryExists, importBundle, importPatternsFromJson, initContext, initManifest, initProject, initializeMemoryDirectory, isAgentCLIAvailable, isAgentCompatible, isBuiltinGuideline, isBuiltinProfile, isGitUrl, isGuidelineEnabled, isHighQuality, isIndexStale, isLocalPath, isPathInside, listCICDTemplates, listSessions, listWorkflows, loadAgentMetadata, loadConfig, loadContext, loadGuidelineConfig, loadIndex, loadLearningConfig, loadManifest, loadMetadata, loadPatternStore, loadPlugin, loadPluginsFromDirectory, loadProfileConfig, loadSessionFile, loadSkillMetadata, loadWorkflow, loadWorkflowByName, memoryDirectoryExists, mergePatterns, parseAgentDir, parseAgentFile, parseShorthand, parseSkill, parseSkillContent, parseSkillContentToCanonical, parseSkillToCanonical, parseSource, parseWorkflow, readAgentContent, readSkillContent, recordFailure, recordSuccess, rejectPattern, removeCustomGuideline, removeCustomProfile, removeFromManifest, removePattern, runTestSuite, saveConfig, saveGeneratedSkill, saveGuidelineConfig, saveIndex, saveLearningConfig, saveManifest, savePatternStore, saveProfileConfig, saveSessionFile, saveSkillMetadata, saveWorkflow, serializeWorkflow, setActiveProfile, setSkillEnabled, shellExecutor, skillMdTranslator, supportsAutoDiscovery, supportsSlashCommands, syncToAgent, syncToAllAgents, toCanonicalAgent, translateAgent, translateAgentContent, translateAgents, translateCanonicalAgent, translateSkill, translateSkillFile, translateSkillToAgent, translateSkillToAll, translatorRegistry, updateSessionFile, validateAgent, validateBuiltinPacks, validatePackDirectory, validatePackManifest, validatePlan, validateSkill, validateSkillContent, validateWorkflow, windsurfTranslator, wrapProgressCallbackWithMemory, writeTranslatedSkill };
+declare class TreeGenerator {
+    private options;
+    constructor(options?: TreeGeneratorOptions);
+    generateTree(skills: SkillSummary[]): SkillTree;
+    private buildTreeFromTaxonomy;
+    private buildCategoryNode;
+    private filterSkillsByCategory;
+    private filterSkillsBySubcategory;
+    private isSkillCategorized;
+    private countTreeStats;
+    findNode(tree: SkillTree, path: string[]): TreeNode | null;
+    getPath(tree: SkillTree, skillName: string): string[] | null;
+    getAllPaths(tree: SkillTree): Map<string, string[]>;
+    getNodesAtDepth(tree: SkillTree, depth: number): TreeNode[];
+    flattenTree(tree: SkillTree): TreeNode[];
+    searchTree(tree: SkillTree, query: string): TreeNode[];
+}
+declare function generateSkillTree(skills: SkillSummary[], options?: TreeGeneratorOptions): SkillTree;
+
+declare const TREE_FILE_NAME = "skill-tree.json";
+declare function serializeTree(tree: SkillTree): string;
+declare function deserializeTree(json: string): SkillTree;
+declare function saveTree(tree: SkillTree, path: string): void;
+declare function loadTree(path: string): SkillTree | null;
+declare function treeToText(tree: SkillTree, options?: {
+    maxDepth?: number;
+}): string;
+declare function treeToMarkdown(tree: SkillTree): string;
+declare function compareTreeVersions(oldTree: SkillTree, newTree: SkillTree): {
+    added: string[];
+    removed: string[];
+    moved: {
+        skill: string;
+        from: string[];
+        to: string[];
+    }[];
+};
+
+type RelationType = 'similar' | 'complementary' | 'dependency' | 'alternative';
+interface SkillRelation {
+    skillName: string;
+    relationType: RelationType;
+    strength: number;
+    reason: string;
+}
+interface SkillNode {
+    name: string;
+    tags: string[];
+    source?: string;
+    relations: SkillRelation[];
+}
+interface SkillGraph {
+    version: number;
+    generatedAt: string;
+    nodes: Map<string, SkillNode>;
+    totalSkills: number;
+    totalRelations: number;
+}
+interface RelatedSkillResult {
+    skill: SkillSummary;
+    relationType: RelationType;
+    strength: number;
+    reason: string;
+    path?: string[];
+}
+declare function buildSkillGraph(skills: SkillSummary[]): SkillGraph;
+declare function getRelatedSkills(skillName: string, graph: SkillGraph, skills: SkillSummary[], options?: {
+    limit?: number;
+    types?: RelationType[];
+    minStrength?: number;
+}): RelatedSkillResult[];
+declare function findSkillsByRelationType(graph: SkillGraph, skills: SkillSummary[], relationType: RelationType, limit?: number): Array<{
+    skill: SkillSummary;
+    relatedCount: number;
+}>;
+declare function getSkillPath(fromSkillName: string, toSkillName: string, graph: SkillGraph, maxHops?: number): string[] | null;
+declare function findSkillsInCategory(tree: SkillTree, categoryPath: string[]): string[];
+declare function serializeGraph(graph: SkillGraph): string;
+declare function deserializeGraph(json: string): SkillGraph;
+
+declare class ReasoningEngine {
+    private config;
+    private skillMap;
+    private tree;
+    private cache;
+    private stats;
+    constructor(config?: Partial<ReasoningConfig>);
+    loadSkills(skills: SkillSummary[]): void;
+    loadTree(tree: SkillTree): void;
+    generateTree(skills: SkillSummary[]): void;
+    search(query: TreeSearchQuery): Promise<TreeReasoningResult>;
+    explain(skill: SkillSummary, score: number, profile: ProjectProfile): Promise<ExplainedRecommendation>;
+    explainBatch(skills: Array<{
+        skill: SkillSummary;
+        score: number;
+    }>, profile: ProjectProfile): Promise<ExplainedRecommendation[]>;
+    private createSearchPlan;
+    private mockSearchPlan;
+    private traverseTree;
+    private findRelevantNodes;
+    private evaluateSkillMatch;
+    private fallbackSearch;
+    private generateExplanation;
+    private mockExplanation;
+    private scoreToConfidence;
+    private getSkillPath;
+    private buildReasoningSummary;
+    private callLLM;
+    private getCacheKey;
+    private getFromCache;
+    private addToCache;
+    private updateStats;
+    getStats(): ReasoningEngineStats;
+    clearCache(): void;
+    getTree(): SkillTree | null;
+}
+declare function createReasoningEngine(config?: Partial<ReasoningConfig>): ReasoningEngine;
+
+declare const SEARCH_PLANNING_PROMPT = "You are a skill discovery assistant. Given a user query and optional project context, create a search plan.\n\nUser Query: {{query}}\n\n{{#if context}}\nProject Context:\n- Languages: {{context.languages}}\n- Frameworks: {{context.frameworks}}\n- Project Type: {{context.type}}\n{{/if}}\n\nAvailable Categories:\n{{categories}}\n\nRespond with a JSON search plan:\n{\n  \"primaryCategories\": [\"most relevant categories\"],\n  \"secondaryCategories\": [\"somewhat relevant categories\"],\n  \"keywords\": [\"extracted search terms\"],\n  \"filters\": {\n    \"tags\": [\"relevant tags\"],\n    \"frameworks\": [\"relevant frameworks\"],\n    \"languages\": [\"relevant languages\"]\n  },\n  \"strategy\": \"breadth-first\" | \"depth-first\" | \"targeted\"\n}";
+declare const CATEGORY_RELEVANCE_PROMPT = "Rate the relevance of this category for the user's query.\n\nQuery: {{query}}\n\nCategory: {{category.name}}\nSkills in category: {{category.skillCount}}\nSubcategories: {{category.subcategories}}\n\nRate from 0-100 and explain briefly.\nRespond as JSON: {\"score\": number, \"reasoning\": \"brief explanation\"}";
+declare const SKILL_MATCH_PROMPT = "Evaluate how well this skill matches the user's query.\n\nQuery: {{query}}\n\nSkill: {{skill.name}}\nDescription: {{skill.description}}\nTags: {{skill.tags}}\n\n{{#if context}}\nProject Stack:\n- Languages: {{context.languages}}\n- Frameworks: {{context.frameworks}}\n{{/if}}\n\nEvaluate match quality and explain why.\nRespond as JSON:\n{\n  \"confidence\": 0-100,\n  \"matchedKeywords\": [\"words from query that match\"],\n  \"relevantSections\": [\"which parts of skill are relevant\"],\n  \"reasoning\": \"explanation of match quality\"\n}";
+declare const EXPLANATION_PROMPT = "Explain why this skill was recommended for the user's project.\n\nSkill: {{skill.name}}\nDescription: {{skill.description}}\nTags: {{skill.tags}}\nScore: {{score}}\n\nProject:\n- Name: {{project.name}}\n- Type: {{project.type}}\n- Languages: {{project.languages}}\n- Frameworks: {{project.frameworks}}\n\nExplain the match clearly and concisely.\nRespond as JSON:\n{\n  \"matchedBecause\": [\"specific match reasons\"],\n  \"relevantFor\": [\"how it helps this project\"],\n  \"differentFrom\": [\"what distinguishes it from alternatives\"],\n  \"confidence\": \"high\" | \"medium\" | \"low\"\n}";
+declare function buildSearchPlanPrompt(query: string, categories: string[], context?: ProjectProfile): string;
+declare function buildCategoryRelevancePrompt(query: string, node: TreeNode): string;
+declare function buildSkillMatchPrompt(query: string, skill: {
+    name: string;
+    description?: string;
+    tags?: string[];
+}, context?: ProjectProfile): string;
+declare function buildExplanationPrompt(skill: {
+    name: string;
+    description?: string;
+    tags?: string[];
+}, score: number, project: ProjectProfile): string;
+declare function extractJsonFromResponse(response: string): unknown;
+declare function validateSearchPlan(data: unknown): SearchPlan;
+declare function validateCategoryScore(data: unknown, fallbackCategory?: string): CategoryScore;
+
+declare const ConnectorCategorySchema: z.ZodEnum<["crm", "chat", "email", "calendar", "docs", "data", "search", "enrichment", "analytics", "storage", "notifications", "ai", "custom"]>;
+type ConnectorCategory = z.infer<typeof ConnectorCategorySchema>;
+declare const ConnectorPlaceholderSchema: z.ZodObject<{
+    placeholder: z.ZodString;
+    category: z.ZodEnum<["crm", "chat", "email", "calendar", "docs", "data", "search", "enrichment", "analytics", "storage", "notifications", "ai", "custom"]>;
+    description: z.ZodString;
+    examples: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    category: "custom" | "search" | "ai" | "storage" | "data" | "chat" | "docs" | "crm" | "email" | "calendar" | "enrichment" | "analytics" | "notifications";
+    required: boolean;
+    examples: string[];
+    placeholder: string;
+}, {
+    description: string;
+    category: "custom" | "search" | "ai" | "storage" | "data" | "chat" | "docs" | "crm" | "email" | "calendar" | "enrichment" | "analytics" | "notifications";
+    placeholder: string;
+    required?: boolean | undefined;
+    examples?: string[] | undefined;
+}>;
+type ConnectorPlaceholder = z.infer<typeof ConnectorPlaceholderSchema>;
+declare const ConnectorMappingSchema: z.ZodObject<{
+    placeholder: z.ZodString;
+    tool: z.ZodString;
+    mcpServer: z.ZodOptional<z.ZodString>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    tool: string;
+    placeholder: string;
+    config?: Record<string, unknown> | undefined;
+    mcpServer?: string | undefined;
+}, {
+    tool: string;
+    placeholder: string;
+    config?: Record<string, unknown> | undefined;
+    mcpServer?: string | undefined;
+}>;
+type ConnectorMapping = z.infer<typeof ConnectorMappingSchema>;
+declare const ConnectorConfigSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodNumber>;
+    mappings: z.ZodArray<z.ZodObject<{
+        placeholder: z.ZodString;
+        tool: z.ZodString;
+        mcpServer: z.ZodOptional<z.ZodString>;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        tool: string;
+        placeholder: string;
+        config?: Record<string, unknown> | undefined;
+        mcpServer?: string | undefined;
+    }, {
+        tool: string;
+        placeholder: string;
+        config?: Record<string, unknown> | undefined;
+        mcpServer?: string | undefined;
+    }>, "many">;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    version: number;
+    mappings: {
+        tool: string;
+        placeholder: string;
+        config?: Record<string, unknown> | undefined;
+        mcpServer?: string | undefined;
+    }[];
+    description?: string | undefined;
+}, {
+    mappings: {
+        tool: string;
+        placeholder: string;
+        config?: Record<string, unknown> | undefined;
+        mcpServer?: string | undefined;
+    }[];
+    description?: string | undefined;
+    version?: number | undefined;
+}>;
+type ConnectorConfig = z.infer<typeof ConnectorConfigSchema>;
+declare const STANDARD_PLACEHOLDERS: Record<ConnectorCategory, ConnectorPlaceholder>;
+interface PlaceholderMatch {
+    placeholder: string;
+    category: ConnectorCategory | null;
+    line: number;
+    column: number;
+    context: string;
+}
+interface PlaceholderReplacement {
+    original: string;
+    replacement: string;
+    category: ConnectorCategory | null;
+}
+interface ConnectorAnalysis {
+    placeholders: PlaceholderMatch[];
+    categories: ConnectorCategory[];
+    requiredCount: number;
+    optionalCount: number;
+    hasUnknownPlaceholders: boolean;
+}
+
+declare function detectPlaceholders(content: string): PlaceholderMatch[];
+declare function analyzePlaceholders(content: string): ConnectorAnalysis;
+declare function replacePlaceholders(content: string, mappings: ConnectorMapping[]): {
+    result: string;
+    replacements: PlaceholderReplacement[];
+};
+declare function applyConnectorConfig(content: string, config: ConnectorConfig): {
+    result: string;
+    replacements: PlaceholderReplacement[];
+};
+declare function getPlaceholderInfo(placeholder: string): ConnectorPlaceholder | null;
+declare function generateConnectorsMarkdown(analysis: ConnectorAnalysis): string;
+declare function createConnectorConfig(mappings: Array<{
+    placeholder: string;
+    tool: string;
+    mcpServer?: string;
+}>): ConnectorConfig;
+declare function validateConnectorConfig(config: ConnectorConfig, content: string): {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+};
+declare function suggestMappingsFromMcp(mcpServers: string[]): ConnectorMapping[];
+
+declare const ExecutionStepStatusSchema: z.ZodEnum<["pending", "running", "completed", "failed", "skipped"]>;
+type ExecutionStepStatus = z.infer<typeof ExecutionStepStatusSchema>;
+declare const ExecutionStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    status: z.ZodDefault<z.ZodEnum<["pending", "running", "completed", "failed", "skipped"]>>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodNumber>;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    error: z.ZodOptional<z.ZodString>;
+    retryCount: z.ZodDefault<z.ZodNumber>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    status: "pending" | "completed" | "failed" | "running" | "skipped";
+    name: string;
+    id: string;
+    retryCount: number;
+    description?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    error?: string | undefined;
+    input?: Record<string, unknown> | undefined;
+    startedAt?: string | undefined;
+    completedAt?: string | undefined;
+    output?: Record<string, unknown> | undefined;
+    duration?: number | undefined;
+}, {
+    name: string;
+    id: string;
+    status?: "pending" | "completed" | "failed" | "running" | "skipped" | undefined;
+    description?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    error?: string | undefined;
+    input?: Record<string, unknown> | undefined;
+    startedAt?: string | undefined;
+    completedAt?: string | undefined;
+    output?: Record<string, unknown> | undefined;
+    duration?: number | undefined;
+    retryCount?: number | undefined;
+}>;
+type ExecutionStep = z.infer<typeof ExecutionStepSchema>;
+declare const ExecutionFlowSchema: z.ZodObject<{
+    id: z.ZodString;
+    skillName: z.ZodString;
+    version: z.ZodDefault<z.ZodNumber>;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        status: z.ZodDefault<z.ZodEnum<["pending", "running", "completed", "failed", "skipped"]>>;
+        startedAt: z.ZodOptional<z.ZodString>;
+        completedAt: z.ZodOptional<z.ZodString>;
+        duration: z.ZodOptional<z.ZodNumber>;
+        input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        error: z.ZodOptional<z.ZodString>;
+        retryCount: z.ZodDefault<z.ZodNumber>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "pending" | "completed" | "failed" | "running" | "skipped";
+        name: string;
+        id: string;
+        retryCount: number;
+        description?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        error?: string | undefined;
+        input?: Record<string, unknown> | undefined;
+        startedAt?: string | undefined;
+        completedAt?: string | undefined;
+        output?: Record<string, unknown> | undefined;
+        duration?: number | undefined;
+    }, {
+        name: string;
+        id: string;
+        status?: "pending" | "completed" | "failed" | "running" | "skipped" | undefined;
+        description?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        error?: string | undefined;
+        input?: Record<string, unknown> | undefined;
+        startedAt?: string | undefined;
+        completedAt?: string | undefined;
+        output?: Record<string, unknown> | undefined;
+        duration?: number | undefined;
+        retryCount?: number | undefined;
+    }>, "many">;
+    currentStepIndex: z.ZodDefault<z.ZodNumber>;
+    status: z.ZodDefault<z.ZodEnum<["pending", "running", "completed", "failed", "skipped"]>>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
+    totalDuration: z.ZodOptional<z.ZodNumber>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    mode: z.ZodDefault<z.ZodEnum<["standalone", "enhanced"]>>;
+    mcpServers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    status: "pending" | "completed" | "failed" | "running" | "skipped";
+    version: number;
+    skillName: string;
+    id: string;
+    steps: {
+        status: "pending" | "completed" | "failed" | "running" | "skipped";
+        name: string;
+        id: string;
+        retryCount: number;
+        description?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        error?: string | undefined;
+        input?: Record<string, unknown> | undefined;
+        startedAt?: string | undefined;
+        completedAt?: string | undefined;
+        output?: Record<string, unknown> | undefined;
+        duration?: number | undefined;
+    }[];
+    mode: "standalone" | "enhanced";
+    currentStepIndex: number;
+    context?: Record<string, unknown> | undefined;
+    startedAt?: string | undefined;
+    completedAt?: string | undefined;
+    totalDuration?: number | undefined;
+    mcpServers?: string[] | undefined;
+}, {
+    skillName: string;
+    id: string;
+    steps: {
+        name: string;
+        id: string;
+        status?: "pending" | "completed" | "failed" | "running" | "skipped" | undefined;
+        description?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        error?: string | undefined;
+        input?: Record<string, unknown> | undefined;
+        startedAt?: string | undefined;
+        completedAt?: string | undefined;
+        output?: Record<string, unknown> | undefined;
+        duration?: number | undefined;
+        retryCount?: number | undefined;
+    }[];
+    status?: "pending" | "completed" | "failed" | "running" | "skipped" | undefined;
+    version?: number | undefined;
+    context?: Record<string, unknown> | undefined;
+    startedAt?: string | undefined;
+    completedAt?: string | undefined;
+    mode?: "standalone" | "enhanced" | undefined;
+    currentStepIndex?: number | undefined;
+    totalDuration?: number | undefined;
+    mcpServers?: string[] | undefined;
+}>;
+type ExecutionFlow = z.infer<typeof ExecutionFlowSchema>;
+interface ExecutionFlowConfig {
+    maxRetries?: number;
+    retryDelay?: number;
+    timeout?: number;
+    onStepStart?: (step: ExecutionStep, flow: ExecutionFlow) => void;
+    onStepComplete?: (step: ExecutionStep, flow: ExecutionFlow) => void;
+    onStepError?: (step: ExecutionStep, error: Error, flow: ExecutionFlow) => void;
+    onFlowComplete?: (flow: ExecutionFlow) => void;
+}
+interface StepDefinition {
+    name: string;
+    description?: string;
+    execute: (input: Record<string, unknown>, context: ExecutionContext) => Promise<Record<string, unknown>>;
+    rollback?: (context: ExecutionContext) => Promise<void>;
+    condition?: (context: ExecutionContext) => boolean;
+    retryable?: boolean;
+    timeout?: number;
+}
+interface ExecutionContext {
+    flow: ExecutionFlow;
+    stepIndex: number;
+    previousOutput?: Record<string, unknown>;
+    mcpTools?: string[];
+    isEnhanced: boolean;
+}
+interface FlowSummary {
+    id: string;
+    skillName: string;
+    status: ExecutionStepStatus;
+    progress: number;
+    currentStep?: string;
+    startedAt?: string;
+    completedAt?: string;
+    totalDuration?: number;
+    stepsCompleted: number;
+    totalSteps: number;
+    mode: 'standalone' | 'enhanced';
+}
+interface FlowMetrics {
+    totalFlows: number;
+    completedFlows: number;
+    failedFlows: number;
+    averageDuration: number;
+    stepMetrics: Map<string, {
+        executionCount: number;
+        successCount: number;
+        failureCount: number;
+        averageDuration: number;
+    }>;
+}
+
+declare class ExecutionManager {
+    private flows;
+    private stepDefinitions;
+    private config;
+    private metrics;
+    constructor(config?: ExecutionFlowConfig);
+    createFlow(skillName: string, steps: Array<{
+        name: string;
+        description?: string;
+    }>, options?: {
+        mode?: 'standalone' | 'enhanced';
+        mcpServers?: string[];
+        context?: Record<string, unknown>;
+    }): ExecutionFlow;
+    registerStepDefinitions(skillName: string, definitions: StepDefinition[]): void;
+    executeFlow(flowId: string): Promise<ExecutionFlow>;
+    private executeStep;
+    getFlow(flowId: string): ExecutionFlow | undefined;
+    getFlowSummary(flowId: string): FlowSummary | null;
+    getAllFlowSummaries(): FlowSummary[];
+    getMetrics(): FlowMetrics;
+    cancelFlow(flowId: string): boolean;
+    clearCompletedFlows(): number;
+    private calculateDuration;
+    private updateAverageDuration;
+    private updateStepMetrics;
+    private delay;
+}
+declare function createExecutionManager(config?: ExecutionFlowConfig): ExecutionManager;
+
+type ExecutionMode = 'standalone' | 'enhanced';
+interface ModeDetectionResult {
+    mode: ExecutionMode;
+    availableServers: string[];
+    missingServers: string[];
+    capabilities: ModeCapabilities;
+    connectorMappings: ConnectorMapping[];
+}
+interface ModeCapabilities {
+    canAccessCRM: boolean;
+    canSendEmails: boolean;
+    canAccessCalendar: boolean;
+    canAccessDocs: boolean;
+    canQueryData: boolean;
+    canEnrichData: boolean;
+    canSendNotifications: boolean;
+    canUseAI: boolean;
+    hasChat: boolean;
+    hasStorage: boolean;
+    hasSearch: boolean;
+    hasAnalytics: boolean;
+}
+interface ExecutionModeConfig {
+    requiredServers?: string[];
+    optionalServers?: string[];
+    mcpConfigPaths?: string[];
+    fallbackToStandalone?: boolean;
+}
+declare function detectExecutionMode(config?: ExecutionModeConfig): ModeDetectionResult;
+declare function getModeDescription(result: ModeDetectionResult): string;
+declare function requireEnhancedMode(result: ModeDetectionResult): void;
+declare function requireCapability(result: ModeDetectionResult, capability: keyof ModeCapabilities): void;
+declare function getStandaloneAlternative(capability: keyof ModeCapabilities): string;
+declare function createModeAwareExecutor<T>(enhancedFn: () => Promise<T>, standaloneFn: () => Promise<T>, modeResult: ModeDetectionResult): () => Promise<T>;
+
+declare const LocalModelConfigSchema: z.ZodObject<{
+    embedModel: z.ZodDefault<z.ZodString>;
+    llmModel: z.ZodDefault<z.ZodString>;
+    modelDir: z.ZodOptional<z.ZodString>;
+    autoDownload: z.ZodDefault<z.ZodBoolean>;
+    gpuLayers: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    embedModel: string;
+    llmModel: string;
+    autoDownload: boolean;
+    gpuLayers: number;
+    modelDir?: string | undefined;
+}, {
+    embedModel?: string | undefined;
+    llmModel?: string | undefined;
+    modelDir?: string | undefined;
+    autoDownload?: boolean | undefined;
+    gpuLayers?: number | undefined;
+}>;
+type LocalModelConfig = z.infer<typeof LocalModelConfigSchema>;
+declare const SkillChunkSchema: z.ZodObject<{
+    content: z.ZodString;
+    startLine: z.ZodNumber;
+    endLine: z.ZodNumber;
+    tokenCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    startLine: number;
+    endLine: number;
+    tokenCount: number;
+}, {
+    content: string;
+    startLine: number;
+    endLine: number;
+    tokenCount: number;
+}>;
+type SkillChunk = z.infer<typeof SkillChunkSchema>;
+interface SkillEmbedding {
+    skillName: string;
+    vector: Float32Array;
+    textContent: string;
+    chunks?: {
+        content: string;
+        vector: Float32Array;
+        startLine: number;
+        endLine: number;
+    }[];
+    generatedAt: string;
+}
+interface VectorSearchResult {
+    skillName: string;
+    similarity: number;
+    matchedChunk?: {
+        content: string;
+        startLine: number;
+    };
+}
+interface ExpandedQuery {
+    original: string;
+    variations: string[];
+    weights: number[];
+}
+interface RRFRanking {
+    skillName: string;
+    rrfScore: number;
+    ranks: {
+        source: string;
+        rank: number;
+    }[];
+}
+interface HybridSearchOptions {
+    query: string;
+    limit?: number;
+    enableExpansion?: boolean;
+    enableReranking?: boolean;
+    semanticWeight?: number;
+    keywordWeight?: number;
+    rrfK?: number;
+    positionAwareBlending?: boolean;
+}
+interface HybridSearchResult extends SearchResult {
+    hybridScore: number;
+    vectorSimilarity?: number;
+    keywordScore?: number;
+    rrfScore?: number;
+    rerankerScore?: number;
+    expandedTerms?: string[];
+    blendingWeights?: {
+        retrieval: number;
+        reranker: number;
+    };
+}
+interface HybridSearchResponse {
+    results: HybridSearchResult[];
+    query: {
+        original: string;
+        expanded?: ExpandedQuery;
+    };
+    timing: {
+        totalMs: number;
+        embeddingMs?: number;
+        vectorSearchMs?: number;
+        keywordSearchMs?: number;
+        fusionMs?: number;
+        rerankingMs?: number;
+    };
+    stats: {
+        candidatesFromVector: number;
+        candidatesFromKeyword: number;
+        totalMerged: number;
+        reranked: number;
+    };
+}
+interface EmbeddingServiceStats {
+    totalSkillsIndexed: number;
+    totalChunks: number;
+    indexSizeBytes: number;
+    lastIndexedAt: string;
+    modelName: string;
+    embeddingDimensions: number;
+}
+interface VectorStoreConfig {
+    dbPath: string;
+    tableName?: string;
+    dimensions?: number;
+}
+interface IndexBuildProgress {
+    phase: 'downloading' | 'loading' | 'embedding' | 'storing' | 'complete';
+    current: number;
+    total: number;
+    skillName?: string;
+    message?: string;
+}
+type IndexBuildCallback = (progress: IndexBuildProgress) => void;
+declare const MODEL_REGISTRY: {
+    readonly embeddings: {
+        readonly 'nomic-embed-text-v1.5.Q4_K_M.gguf': {
+            readonly url: "https://huggingface.co/nomic-ai/nomic-embed-text-v1.5-GGUF/resolve/main/nomic-embed-text-v1.5.Q4_K_M.gguf";
+            readonly size: 547000000;
+            readonly dimensions: 768;
+            readonly description: "Nomic Embed Text v1.5 - High quality embeddings";
+        };
+    };
+    readonly llm: {
+        readonly 'gemma-2b-it-Q4_K_M.gguf': {
+            readonly url: "https://huggingface.co/bartowski/gemma-2-2b-it-GGUF/resolve/main/gemma-2-2b-it-Q4_K_M.gguf";
+            readonly size: 1500000000;
+            readonly description: "Gemma 2 2B Instruct - Fast query expansion and reranking";
+        };
+    };
+};
+declare const DEFAULT_CHUNKING_CONFIG: {
+    readonly maxTokens: 800;
+    readonly overlapPercent: 15;
+    readonly minChunkSize: 100;
+};
+declare const DEFAULT_HYBRID_CONFIG: {
+    readonly rrfK: 60;
+    readonly semanticWeight: 0.5;
+    readonly keywordWeight: 0.5;
+    readonly rerankTopN: 30;
+    readonly positionBlending: {
+        readonly top3: {
+            readonly retrieval: 0.75;
+            readonly reranker: 0.25;
+        };
+        readonly top10: {
+            readonly retrieval: 0.6;
+            readonly reranker: 0.4;
+        };
+        readonly rest: {
+            readonly retrieval: 0.4;
+            readonly reranker: 0.6;
+        };
+    };
+    readonly expansionCacheTtlMs: number;
+};
+interface RerankerInput {
+    query: string;
+    skillName: string;
+    skillDescription: string;
+    skillTags: string[];
+}
+interface RerankerOutput {
+    skillName: string;
+    score: number;
+    reasoning?: string;
+}
+
+declare class LocalModelManager {
+    private config;
+    private embedModelPath;
+    private llmModelPath;
+    constructor(config?: Partial<LocalModelConfig>);
+    ensureModelsDirectory(): Promise<void>;
+    getEmbedModelPath(): string;
+    getLlmModelPath(): string;
+    isEmbedModelAvailable(): boolean;
+    isLlmModelAvailable(): boolean;
+    private getModelInfo;
+    downloadModel(modelType: 'embed' | 'llm', onProgress?: IndexBuildCallback): Promise<string>;
+    ensureEmbedModel(onProgress?: IndexBuildCallback): Promise<string>;
+    ensureLlmModel(onProgress?: IndexBuildCallback): Promise<string>;
+    ensureAllModels(onProgress?: IndexBuildCallback): Promise<{
+        embedModel: string;
+        llmModel: string;
+    }>;
+    getPublicModelInfo(modelType: 'embed' | 'llm'): {
+        name: string;
+        path: string;
+        available: boolean;
+        size: number;
+        description: string;
+    };
+    clearModels(): Promise<void>;
+    getConfig(): Required<LocalModelConfig>;
+}
+declare function formatBytes(bytes: number): string;
+declare function getDefaultModelDir(): string;
+
+declare class EmbeddingService {
+    private modelManager;
+    private model;
+    private context;
+    private initialized;
+    private dimensions;
+    constructor(modelManager?: LocalModelManager);
+    initialize(onProgress?: IndexBuildCallback): Promise<void>;
+    embed(text: string): Promise<Float32Array>;
+    embedBatch(texts: string[]): Promise<Float32Array[]>;
+    embedSkill(skill: SkillSummary): Promise<SkillEmbedding>;
+    embedSkillWithChunks(skill: SkillSummary, fullContent?: string): Promise<SkillEmbedding>;
+    embedSkills(skills: SkillSummary[], onProgress?: IndexBuildCallback): Promise<SkillEmbedding[]>;
+    private buildSkillText;
+    private chunkText;
+    cosineSimilarity(a: Float32Array, b: Float32Array): number;
+    getDimensions(): number;
+    isInitialized(): boolean;
+    dispose(): Promise<void>;
+}
+declare function createEmbeddingService(modelManager?: LocalModelManager): EmbeddingService;
+
+declare class VectorStore {
+    private config;
+    private db;
+    private initialized;
+    private usingSqliteVec;
+    private embeddings;
+    private embeddingService;
+    constructor(config?: Partial<VectorStoreConfig>, embeddingService?: EmbeddingService);
+    initialize(): Promise<void>;
+    private initializeSqliteVecTables;
+    private initializeFallbackTables;
+    private loadEmbeddingsFromDb;
+    store(embedding: SkillEmbedding): Promise<void>;
+    storeBatch(embeddings: SkillEmbedding[], onProgress?: IndexBuildCallback): Promise<void>;
+    search(queryVector: Float32Array, limit?: number): Promise<VectorSearchResult[]>;
+    private searchWithSqliteVec;
+    private searchInMemory;
+    searchChunks(queryVector: Float32Array, limit?: number): Promise<VectorSearchResult[]>;
+    has(skillName: string): boolean;
+    get(skillName: string): SkillEmbedding | undefined;
+    delete(skillName: string): Promise<void>;
+    clear(): Promise<void>;
+    getStats(): EmbeddingServiceStats;
+    isInitialized(): boolean;
+    isUsingSqliteVec(): boolean;
+    getEmbeddingCount(): number;
+    close(): Promise<void>;
+}
+declare function createVectorStore(config?: Partial<VectorStoreConfig>, embeddingService?: EmbeddingService): VectorStore;
+
+interface RankerResult {
+    skillName: string;
+    score: number;
+}
+interface RRFInput {
+    source: string;
+    results: RankerResult[];
+}
+declare function computeRRFScore(ranks: number[], k?: number): number;
+declare function fuseWithRRF(rankerInputs: RRFInput[], k?: number): RRFRanking[];
+declare function normalizeScores(results: RankerResult[]): RankerResult[];
+declare function weightedCombine(results: RRFInput[], weights: Record<string, number>): RankerResult[];
+declare function applyPositionAwareBlending(retrievalScores: Map<string, number>, rerankerScores: Map<string, number>, sortedSkillNames: string[], config?: {
+    readonly top3: {
+        readonly retrieval: 0.75;
+        readonly reranker: 0.25;
+    };
+    readonly top10: {
+        readonly retrieval: 0.6;
+        readonly reranker: 0.4;
+    };
+    readonly rest: {
+        readonly retrieval: 0.4;
+        readonly reranker: 0.6;
+    };
+}): Map<string, number>;
+declare function getRankFromScore(skillName: string, rankedResults: RankerResult[]): number;
+declare function mergeRankings(primaryRankings: RRFRanking[], secondaryRankings: RRFRanking[], primaryWeight?: number): RRFRanking[];
+
+declare class QueryExpander {
+    private modelManager;
+    private model;
+    private context;
+    private initialized;
+    private cacheTtlMs;
+    constructor(modelManager?: LocalModelManager, cacheTtlMs?: number);
+    initialize(onProgress?: IndexBuildCallback): Promise<void>;
+    expand(query: string, maxVariations?: number): Promise<ExpandedQuery>;
+    private generateVariations;
+    private expandWithoutLLM;
+    private getFromCache;
+    private addToCache;
+    clearCache(): void;
+    isInitialized(): boolean;
+    dispose(): Promise<void>;
+}
+declare function createQueryExpander(modelManager?: LocalModelManager, cacheTtlMs?: number): QueryExpander;
+declare function expandQuerySimple(query: string): ExpandedQuery;
+
+declare class HybridSearchPipeline {
+    private embeddingService;
+    private vectorStore;
+    private queryExpander;
+    private modelManager;
+    private recommendationEngine;
+    private initialized;
+    private skillsMap;
+    constructor(config?: Partial<LocalModelConfig>);
+    initialize(onProgress?: IndexBuildCallback): Promise<void>;
+    buildIndex(skills: SkillSummary[], onProgress?: IndexBuildCallback): Promise<void>;
+    search(options: HybridSearchOptions): Promise<HybridSearchResponse>;
+    private rerank;
+    loadSkillsIndex(index: SkillIndex): void;
+    getStats(): {
+        vectorStore: ReturnType<VectorStore['getStats']>;
+        initialized: boolean;
+        skillCount: number;
+    };
+    isInitialized(): boolean;
+    dispose(): Promise<void>;
+}
+declare function createHybridSearchPipeline(config?: Partial<LocalModelConfig>): HybridSearchPipeline;
+declare function hybridSearch(skills: SkillSummary[], query: string, options?: Partial<HybridSearchOptions>): Promise<HybridSearchResponse>;
+
+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 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, 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 FeedbackResult, 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, 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, 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 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 RankerResult, 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, type RerankerInput, type RerankerOutput, type ReviewIssue, type ReviewResult, type ReviewStage, type ReviewStageName, RuleBasedCompressor, SEARCH_PLANNING_PROMPT, SESSION_FILE, SKILL_DISCOVERY_PATHS, SKILL_MATCH_PROMPT, STANDARD_PLACEHOLDERS, 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, SkillLocation, SkillMdTranslator, SkillMetadata, type SkillNode, SkillPreferences, 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, 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, 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, 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 };