cognitive-core 0.0.1 → 0.1.0

package/dist/types/config.d.ts

@@ -0,0 +1,1113 @@
+import { z } from 'zod';
+/**
+ * Credit assignment strategy for trajectory analysis
+ */
+export declare const CreditStrategySchema: z.ZodEnum<["simple", "llm", "counterfactual"]>;
+export type CreditStrategy = z.infer<typeof CreditStrategySchema>;
+/**
+ * Pattern extraction approach
+ */
+export declare const PatternExtractorSchema: z.ZodEnum<["llm", "text", "both"]>;
+export type PatternExtractor = z.infer<typeof PatternExtractorSchema>;
+/**
+ * Learning pipeline configuration
+ */
+export declare const LearningConfigSchema: z.ZodObject<{
+    /** How to assign credit to steps */
+    creditStrategy: z.ZodDefault<z.ZodEnum<["simple", "llm", "counterfactual"]>>;
+    /** How to extract patterns */
+    patternExtractor: z.ZodDefault<z.ZodEnum<["llm", "text", "both"]>>;
+    /** Minimum trajectories before batch learning */
+    minTrajectories: z.ZodDefault<z.ZodNumber>;
+    /** Minimum hours since last batch learning */
+    minHoursSinceLast: z.ZodOptional<z.ZodNumber>;
+    /** Minimum success rate for extraction */
+    minSuccessRate: z.ZodOptional<z.ZodNumber>;
+    /** Similarity threshold for deduplication */
+    deduplicationThreshold: z.ZodDefault<z.ZodNumber>;
+    /** Maximum experiences to keep during pruning (default: 1000) */
+    maxExperiences: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    creditStrategy: "llm" | "simple" | "counterfactual";
+    patternExtractor: "llm" | "text" | "both";
+    minTrajectories: number;
+    deduplicationThreshold: number;
+    maxExperiences: number;
+    minHoursSinceLast?: number | undefined;
+    minSuccessRate?: number | undefined;
+}, {
+    creditStrategy?: "llm" | "simple" | "counterfactual" | undefined;
+    patternExtractor?: "llm" | "text" | "both" | undefined;
+    minTrajectories?: number | undefined;
+    minHoursSinceLast?: number | undefined;
+    minSuccessRate?: number | undefined;
+    deduplicationThreshold?: number | undefined;
+    maxExperiences?: number | undefined;
+}>;
+export type LearningConfig = z.infer<typeof LearningConfigSchema>;
+/**
+ * Task routing configuration
+ */
+export declare const RouterConfigSchema: z.ZodObject<{
+    /** Threshold for considering tasks similar */
+    similarityThreshold: z.ZodDefault<z.ZodNumber>;
+    /** Enable domain-based routing */
+    useDomainRouting: z.ZodDefault<z.ZodBoolean>;
+    /** Default search strategy */
+    defaultStrategy: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    similarityThreshold: number;
+    useDomainRouting: boolean;
+    defaultStrategy: string;
+}, {
+    similarityThreshold?: number | undefined;
+    useDomainRouting?: boolean | undefined;
+    defaultStrategy?: string | undefined;
+}>;
+export type RouterConfig = z.infer<typeof RouterConfigSchema>;
+/**
+ * Memory capacity limits for automatic pruning
+ */
+export declare const MemoryCapacityConfigSchema: z.ZodObject<{
+    /** Maximum number of experiences to store (0 = unlimited) */
+    maxExperiences: z.ZodDefault<z.ZodNumber>;
+    /** Maximum number of playbooks to store (0 = unlimited) */
+    maxPlaybooks: z.ZodDefault<z.ZodNumber>;
+    /** Maximum age of experiences in days (0 = unlimited) */
+    maxExperienceAgeDays: z.ZodDefault<z.ZodNumber>;
+    /** Maximum age of failed experiences in days (shorter than successful) */
+    maxFailedExperienceAgeDays: z.ZodDefault<z.ZodNumber>;
+    /** Enable automatic pruning when limits are exceeded */
+    autoPrune: z.ZodDefault<z.ZodBoolean>;
+    /** Preserve domain coverage when pruning */
+    preserveDomainCoverage: z.ZodDefault<z.ZodBoolean>;
+    /** Similarity threshold for deduplication (0 = disabled) */
+    deduplicationThreshold: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    deduplicationThreshold: number;
+    maxExperiences: number;
+    maxPlaybooks: number;
+    maxExperienceAgeDays: number;
+    maxFailedExperienceAgeDays: number;
+    autoPrune: boolean;
+    preserveDomainCoverage: boolean;
+}, {
+    deduplicationThreshold?: number | undefined;
+    maxExperiences?: number | undefined;
+    maxPlaybooks?: number | undefined;
+    maxExperienceAgeDays?: number | undefined;
+    maxFailedExperienceAgeDays?: number | undefined;
+    autoPrune?: boolean | undefined;
+    preserveDomainCoverage?: boolean | undefined;
+}>;
+export type MemoryCapacityConfig = z.infer<typeof MemoryCapacityConfigSchema>;
+/**
+ * Memory retrieval configuration
+ */
+export declare const MemoryConfigSchema: z.ZodObject<{
+    /** Maximum experiences to retrieve */
+    maxExperiences: z.ZodDefault<z.ZodNumber>;
+    /** Maximum strategies to retrieve */
+    maxStrategies: z.ZodDefault<z.ZodNumber>;
+    /** Maximum concepts to retrieve */
+    maxConcepts: z.ZodDefault<z.ZodNumber>;
+    /** Maximum skills to retrieve */
+    maxSkills: z.ZodDefault<z.ZodNumber>;
+    /** Maximum tokens for memory context */
+    maxContextTokens: z.ZodDefault<z.ZodNumber>;
+    /** Capacity limits for storage */
+    capacity: z.ZodDefault<z.ZodObject<{
+        /** Maximum number of experiences to store (0 = unlimited) */
+        maxExperiences: z.ZodDefault<z.ZodNumber>;
+        /** Maximum number of playbooks to store (0 = unlimited) */
+        maxPlaybooks: z.ZodDefault<z.ZodNumber>;
+        /** Maximum age of experiences in days (0 = unlimited) */
+        maxExperienceAgeDays: z.ZodDefault<z.ZodNumber>;
+        /** Maximum age of failed experiences in days (shorter than successful) */
+        maxFailedExperienceAgeDays: z.ZodDefault<z.ZodNumber>;
+        /** Enable automatic pruning when limits are exceeded */
+        autoPrune: z.ZodDefault<z.ZodBoolean>;
+        /** Preserve domain coverage when pruning */
+        preserveDomainCoverage: z.ZodDefault<z.ZodBoolean>;
+        /** Similarity threshold for deduplication (0 = disabled) */
+        deduplicationThreshold: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        deduplicationThreshold: number;
+        maxExperiences: number;
+        maxPlaybooks: number;
+        maxExperienceAgeDays: number;
+        maxFailedExperienceAgeDays: number;
+        autoPrune: boolean;
+        preserveDomainCoverage: boolean;
+    }, {
+        deduplicationThreshold?: number | undefined;
+        maxExperiences?: number | undefined;
+        maxPlaybooks?: number | undefined;
+        maxExperienceAgeDays?: number | undefined;
+        maxFailedExperienceAgeDays?: number | undefined;
+        autoPrune?: boolean | undefined;
+        preserveDomainCoverage?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    maxExperiences: number;
+    maxStrategies: number;
+    maxConcepts: number;
+    maxSkills: number;
+    maxContextTokens: number;
+    capacity: {
+        deduplicationThreshold: number;
+        maxExperiences: number;
+        maxPlaybooks: number;
+        maxExperienceAgeDays: number;
+        maxFailedExperienceAgeDays: number;
+        autoPrune: boolean;
+        preserveDomainCoverage: boolean;
+    };
+}, {
+    maxExperiences?: number | undefined;
+    maxStrategies?: number | undefined;
+    maxConcepts?: number | undefined;
+    maxSkills?: number | undefined;
+    maxContextTokens?: number | undefined;
+    capacity?: {
+        deduplicationThreshold?: number | undefined;
+        maxExperiences?: number | undefined;
+        maxPlaybooks?: number | undefined;
+        maxExperienceAgeDays?: number | undefined;
+        maxFailedExperienceAgeDays?: number | undefined;
+        autoPrune?: boolean | undefined;
+        preserveDomainCoverage?: boolean | undefined;
+    } | undefined;
+}>;
+export type MemoryConfig = z.infer<typeof MemoryConfigSchema>;
+/**
+ * Storage configuration
+ */
+export declare const StorageConfigSchema: z.ZodObject<{
+    /** Base directory for file storage */
+    baseDir: z.ZodDefault<z.ZodString>;
+    /** Enable file-based persistence */
+    persistenceEnabled: z.ZodDefault<z.ZodBoolean>;
+    /** Auto-save interval in milliseconds */
+    autoSaveInterval: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    baseDir: string;
+    persistenceEnabled: boolean;
+    autoSaveInterval: number;
+}, {
+    baseDir?: string | undefined;
+    persistenceEnabled?: boolean | undefined;
+    autoSaveInterval?: number | undefined;
+}>;
+export type StorageConfig = z.infer<typeof StorageConfigSchema>;
+/**
+ * Embedding provider type
+ */
+export declare const EmbeddingProviderTypeSchema: z.ZodEnum<["openai", "voyage", "local", "none"]>;
+export type EmbeddingProviderType = z.infer<typeof EmbeddingProviderTypeSchema>;
+/**
+ * Embedding configuration
+ */
+export declare const EmbeddingConfigSchema: z.ZodObject<{
+    /** Embedding provider type */
+    provider: z.ZodDefault<z.ZodEnum<["openai", "voyage", "local", "none"]>>;
+    /** API key for hosted providers (OpenAI, Voyage) */
+    apiKey: z.ZodOptional<z.ZodString>;
+    /** Model name/identifier */
+    model: z.ZodOptional<z.ZodString>;
+    /** Path to local model (for 'local' provider) */
+    modelPath: z.ZodOptional<z.ZodString>;
+    /** Embedding dimension (defaults vary by provider) */
+    dimension: z.ZodOptional<z.ZodNumber>;
+    /** Path for sqlite-vec database file */
+    vectorDbPath: z.ZodDefault<z.ZodString>;
+    /** Base URL for API (for custom endpoints) */
+    baseUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    provider: "openai" | "voyage" | "local" | "none";
+    vectorDbPath: string;
+    apiKey?: string | undefined;
+    model?: string | undefined;
+    modelPath?: string | undefined;
+    dimension?: number | undefined;
+    baseUrl?: string | undefined;
+}, {
+    provider?: "openai" | "voyage" | "local" | "none" | undefined;
+    apiKey?: string | undefined;
+    model?: string | undefined;
+    modelPath?: string | undefined;
+    dimension?: number | undefined;
+    vectorDbPath?: string | undefined;
+    baseUrl?: string | undefined;
+}>;
+export type EmbeddingConfig = z.infer<typeof EmbeddingConfigSchema>;
+/**
+ * Execution backend type
+ */
+export declare const ExecutionBackendSchema: z.ZodEnum<["acp", "subprocess", "mock"]>;
+export type ExecutionBackend = z.infer<typeof ExecutionBackendSchema>;
+/**
+ * Execution configuration
+ */
+export declare const ExecutionConfigSchema: z.ZodObject<{
+    /** Backend to use for agent execution */
+    backend: z.ZodDefault<z.ZodEnum<["acp", "subprocess", "mock"]>>;
+    /** Maximum execution time in seconds */
+    maxExecutionTime: z.ZodDefault<z.ZodNumber>;
+    /** Capture tool calls for trajectory extraction */
+    captureToolCalls: z.ZodDefault<z.ZodBoolean>;
+    /** Default agent type */
+    defaultAgentType: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    backend: "acp" | "subprocess" | "mock";
+    maxExecutionTime: number;
+    captureToolCalls: boolean;
+    defaultAgentType: string;
+}, {
+    backend?: "acp" | "subprocess" | "mock" | undefined;
+    maxExecutionTime?: number | undefined;
+    captureToolCalls?: boolean | undefined;
+    defaultAgentType?: string | undefined;
+}>;
+export type ExecutionConfig = z.infer<typeof ExecutionConfigSchema>;
+/**
+ * Refinement configuration
+ */
+export declare const RefinementConfigSchema: z.ZodObject<{
+    /** Maximum refinement iterations */
+    maxIterations: z.ZodDefault<z.ZodNumber>;
+    /** Minimum quality score to accept without refinement */
+    acceptableScore: z.ZodDefault<z.ZodNumber>;
+    /** Whether to use ACP agent for evaluation */
+    useAgentEvaluation: z.ZodDefault<z.ZodBoolean>;
+    /** Agent type to use for evaluation */
+    evaluatorAgentType: z.ZodDefault<z.ZodString>;
+    /** Confidence threshold below which to trigger refinement */
+    confidenceThreshold: z.ZodDefault<z.ZodNumber>;
+    /** Routing strategies that should trigger refinement */
+    triggerOnStrategies: z.ZodDefault<z.ZodArray<z.ZodEnum<["explore", "fallback", "direct", "adapt"]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    maxIterations: number;
+    acceptableScore: number;
+    useAgentEvaluation: boolean;
+    evaluatorAgentType: string;
+    confidenceThreshold: number;
+    triggerOnStrategies: ("adapt" | "direct" | "explore" | "fallback")[];
+}, {
+    maxIterations?: number | undefined;
+    acceptableScore?: number | undefined;
+    useAgentEvaluation?: boolean | undefined;
+    evaluatorAgentType?: string | undefined;
+    confidenceThreshold?: number | undefined;
+    triggerOnStrategies?: ("adapt" | "direct" | "explore" | "fallback")[] | undefined;
+}>;
+export type RefinementConfig = z.infer<typeof RefinementConfigSchema>;
+/**
+ * Skill Library promotion criteria
+ */
+export declare const SkillPromotionConfigSchema: z.ZodObject<{
+    /** Minimum confidence to promote to core skill */
+    minConfidence: z.ZodDefault<z.ZodNumber>;
+    /** Minimum success count to promote */
+    minSuccessCount: z.ZodDefault<z.ZodNumber>;
+    /** Minimum success rate to promote */
+    minSuccessRate: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    minSuccessRate: number;
+    minConfidence: number;
+    minSuccessCount: number;
+}, {
+    minSuccessRate?: number | undefined;
+    minConfidence?: number | undefined;
+    minSuccessCount?: number | undefined;
+}>;
+export type SkillPromotionConfig = z.infer<typeof SkillPromotionConfigSchema>;
+/**
+ * Skill Library capacity limits
+ */
+export declare const SkillLimitsConfigSchema: z.ZodObject<{
+    /** Maximum core skills (always in system prompt) */
+    maxCoreSkills: z.ZodDefault<z.ZodNumber>;
+    /** Maximum domain skills per domain */
+    maxDomainSkills: z.ZodDefault<z.ZodNumber>;
+    /** Maximum contextual playbooks per task */
+    maxContextualPlaybooks: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    maxCoreSkills: number;
+    maxDomainSkills: number;
+    maxContextualPlaybooks: number;
+}, {
+    maxCoreSkills?: number | undefined;
+    maxDomainSkills?: number | undefined;
+    maxContextualPlaybooks?: number | undefined;
+}>;
+export type SkillLimitsConfig = z.infer<typeof SkillLimitsConfigSchema>;
+/**
+ * Skill Library context budget
+ */
+export declare const SkillContextConfigSchema: z.ZodObject<{
+    /** Maximum tokens for skills in system prompt */
+    maxTokensForSkills: z.ZodDefault<z.ZodNumber>;
+    /** Include refinements in skill context */
+    includeRefinements: z.ZodDefault<z.ZodBoolean>;
+    /** Include code examples in skill context */
+    includeExamples: z.ZodDefault<z.ZodBoolean>;
+    /** Cache refresh interval in milliseconds (default: 5 minutes) */
+    cacheRefreshInterval: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    maxTokensForSkills: number;
+    includeRefinements: boolean;
+    includeExamples: boolean;
+    cacheRefreshInterval: number;
+}, {
+    maxTokensForSkills?: number | undefined;
+    includeRefinements?: boolean | undefined;
+    includeExamples?: boolean | undefined;
+    cacheRefreshInterval?: number | undefined;
+}>;
+export type SkillContextConfig = z.infer<typeof SkillContextConfigSchema>;
+/**
+ * Skill Library demotion criteria
+ */
+export declare const SkillDemotionConfigSchema: z.ZodObject<{
+    /** Number of consecutive failures before demotion */
+    failureThreshold: z.ZodDefault<z.ZodNumber>;
+    /** Minimum confidence to retain core skill status */
+    minConfidenceToRetain: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    failureThreshold: number;
+    minConfidenceToRetain: number;
+}, {
+    failureThreshold?: number | undefined;
+    minConfidenceToRetain?: number | undefined;
+}>;
+export type SkillDemotionConfig = z.infer<typeof SkillDemotionConfigSchema>;
+/**
+ * Skill Library configuration - all thresholds configurable
+ */
+export declare const SkillLibraryConfigSchema: z.ZodObject<{
+    /** Promotion criteria */
+    promotion: z.ZodDefault<z.ZodObject<{
+        /** Minimum confidence to promote to core skill */
+        minConfidence: z.ZodDefault<z.ZodNumber>;
+        /** Minimum success count to promote */
+        minSuccessCount: z.ZodDefault<z.ZodNumber>;
+        /** Minimum success rate to promote */
+        minSuccessRate: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        minSuccessRate: number;
+        minConfidence: number;
+        minSuccessCount: number;
+    }, {
+        minSuccessRate?: number | undefined;
+        minConfidence?: number | undefined;
+        minSuccessCount?: number | undefined;
+    }>>;
+    /** Capacity limits */
+    limits: z.ZodDefault<z.ZodObject<{
+        /** Maximum core skills (always in system prompt) */
+        maxCoreSkills: z.ZodDefault<z.ZodNumber>;
+        /** Maximum domain skills per domain */
+        maxDomainSkills: z.ZodDefault<z.ZodNumber>;
+        /** Maximum contextual playbooks per task */
+        maxContextualPlaybooks: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxCoreSkills: number;
+        maxDomainSkills: number;
+        maxContextualPlaybooks: number;
+    }, {
+        maxCoreSkills?: number | undefined;
+        maxDomainSkills?: number | undefined;
+        maxContextualPlaybooks?: number | undefined;
+    }>>;
+    /** Context budget */
+    context: z.ZodDefault<z.ZodObject<{
+        /** Maximum tokens for skills in system prompt */
+        maxTokensForSkills: z.ZodDefault<z.ZodNumber>;
+        /** Include refinements in skill context */
+        includeRefinements: z.ZodDefault<z.ZodBoolean>;
+        /** Include code examples in skill context */
+        includeExamples: z.ZodDefault<z.ZodBoolean>;
+        /** Cache refresh interval in milliseconds (default: 5 minutes) */
+        cacheRefreshInterval: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxTokensForSkills: number;
+        includeRefinements: boolean;
+        includeExamples: boolean;
+        cacheRefreshInterval: number;
+    }, {
+        maxTokensForSkills?: number | undefined;
+        includeRefinements?: boolean | undefined;
+        includeExamples?: boolean | undefined;
+        cacheRefreshInterval?: number | undefined;
+    }>>;
+    /** Demotion criteria */
+    demotion: z.ZodDefault<z.ZodObject<{
+        /** Number of consecutive failures before demotion */
+        failureThreshold: z.ZodDefault<z.ZodNumber>;
+        /** Minimum confidence to retain core skill status */
+        minConfidenceToRetain: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        failureThreshold: number;
+        minConfidenceToRetain: number;
+    }, {
+        failureThreshold?: number | undefined;
+        minConfidenceToRetain?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    context: {
+        maxTokensForSkills: number;
+        includeRefinements: boolean;
+        includeExamples: boolean;
+        cacheRefreshInterval: number;
+    };
+    promotion: {
+        minSuccessRate: number;
+        minConfidence: number;
+        minSuccessCount: number;
+    };
+    limits: {
+        maxCoreSkills: number;
+        maxDomainSkills: number;
+        maxContextualPlaybooks: number;
+    };
+    demotion: {
+        failureThreshold: number;
+        minConfidenceToRetain: number;
+    };
+}, {
+    context?: {
+        maxTokensForSkills?: number | undefined;
+        includeRefinements?: boolean | undefined;
+        includeExamples?: boolean | undefined;
+        cacheRefreshInterval?: number | undefined;
+    } | undefined;
+    promotion?: {
+        minSuccessRate?: number | undefined;
+        minConfidence?: number | undefined;
+        minSuccessCount?: number | undefined;
+    } | undefined;
+    limits?: {
+        maxCoreSkills?: number | undefined;
+        maxDomainSkills?: number | undefined;
+        maxContextualPlaybooks?: number | undefined;
+    } | undefined;
+    demotion?: {
+        failureThreshold?: number | undefined;
+        minConfidenceToRetain?: number | undefined;
+    } | undefined;
+}>;
+export type SkillLibraryConfig = z.infer<typeof SkillLibraryConfigSchema>;
+/**
+ * MCP Server configuration
+ */
+export declare const MCPServerConfigSchema: z.ZodObject<{
+    /** Enable MCP server */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /** Port for standalone server */
+    port: z.ZodOptional<z.ZodNumber>;
+    /** Expose playbooks as MCP resources */
+    exposeResources: z.ZodDefault<z.ZodBoolean>;
+    /** Expose playbook tools */
+    exposeTools: z.ZodDefault<z.ZodBoolean>;
+    /** Maximum results to return from searches */
+    maxResults: z.ZodDefault<z.ZodNumber>;
+    /** Minimum confidence threshold for search results */
+    minConfidence: z.ZodDefault<z.ZodNumber>;
+    /** Include refinements in playbook details */
+    includeRefinements: z.ZodDefault<z.ZodBoolean>;
+    /** Enable filtering by domain */
+    enableDomainFiltering: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    minConfidence: number;
+    includeRefinements: boolean;
+    enabled: boolean;
+    exposeResources: boolean;
+    exposeTools: boolean;
+    maxResults: number;
+    enableDomainFiltering: boolean;
+    port?: number | undefined;
+}, {
+    minConfidence?: number | undefined;
+    includeRefinements?: boolean | undefined;
+    enabled?: boolean | undefined;
+    port?: number | undefined;
+    exposeResources?: boolean | undefined;
+    exposeTools?: boolean | undefined;
+    maxResults?: number | undefined;
+    enableDomainFiltering?: boolean | undefined;
+}>;
+export type MCPServerConfig = z.infer<typeof MCPServerConfigSchema>;
+/**
+ * Main Atlas configuration
+ */
+export declare const AtlasConfigSchema: z.ZodObject<{
+    /** Learning configuration */
+    learning: z.ZodDefault<z.ZodObject<{
+        /** How to assign credit to steps */
+        creditStrategy: z.ZodDefault<z.ZodEnum<["simple", "llm", "counterfactual"]>>;
+        /** How to extract patterns */
+        patternExtractor: z.ZodDefault<z.ZodEnum<["llm", "text", "both"]>>;
+        /** Minimum trajectories before batch learning */
+        minTrajectories: z.ZodDefault<z.ZodNumber>;
+        /** Minimum hours since last batch learning */
+        minHoursSinceLast: z.ZodOptional<z.ZodNumber>;
+        /** Minimum success rate for extraction */
+        minSuccessRate: z.ZodOptional<z.ZodNumber>;
+        /** Similarity threshold for deduplication */
+        deduplicationThreshold: z.ZodDefault<z.ZodNumber>;
+        /** Maximum experiences to keep during pruning (default: 1000) */
+        maxExperiences: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        creditStrategy: "llm" | "simple" | "counterfactual";
+        patternExtractor: "llm" | "text" | "both";
+        minTrajectories: number;
+        deduplicationThreshold: number;
+        maxExperiences: number;
+        minHoursSinceLast?: number | undefined;
+        minSuccessRate?: number | undefined;
+    }, {
+        creditStrategy?: "llm" | "simple" | "counterfactual" | undefined;
+        patternExtractor?: "llm" | "text" | "both" | undefined;
+        minTrajectories?: number | undefined;
+        minHoursSinceLast?: number | undefined;
+        minSuccessRate?: number | undefined;
+        deduplicationThreshold?: number | undefined;
+        maxExperiences?: number | undefined;
+    }>>;
+    /** Router configuration */
+    router: z.ZodDefault<z.ZodObject<{
+        /** Threshold for considering tasks similar */
+        similarityThreshold: z.ZodDefault<z.ZodNumber>;
+        /** Enable domain-based routing */
+        useDomainRouting: z.ZodDefault<z.ZodBoolean>;
+        /** Default search strategy */
+        defaultStrategy: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        similarityThreshold: number;
+        useDomainRouting: boolean;
+        defaultStrategy: string;
+    }, {
+        similarityThreshold?: number | undefined;
+        useDomainRouting?: boolean | undefined;
+        defaultStrategy?: string | undefined;
+    }>>;
+    /** Memory configuration */
+    memory: z.ZodDefault<z.ZodObject<{
+        /** Maximum experiences to retrieve */
+        maxExperiences: z.ZodDefault<z.ZodNumber>;
+        /** Maximum strategies to retrieve */
+        maxStrategies: z.ZodDefault<z.ZodNumber>;
+        /** Maximum concepts to retrieve */
+        maxConcepts: z.ZodDefault<z.ZodNumber>;
+        /** Maximum skills to retrieve */
+        maxSkills: z.ZodDefault<z.ZodNumber>;
+        /** Maximum tokens for memory context */
+        maxContextTokens: z.ZodDefault<z.ZodNumber>;
+        /** Capacity limits for storage */
+        capacity: z.ZodDefault<z.ZodObject<{
+            /** Maximum number of experiences to store (0 = unlimited) */
+            maxExperiences: z.ZodDefault<z.ZodNumber>;
+            /** Maximum number of playbooks to store (0 = unlimited) */
+            maxPlaybooks: z.ZodDefault<z.ZodNumber>;
+            /** Maximum age of experiences in days (0 = unlimited) */
+            maxExperienceAgeDays: z.ZodDefault<z.ZodNumber>;
+            /** Maximum age of failed experiences in days (shorter than successful) */
+            maxFailedExperienceAgeDays: z.ZodDefault<z.ZodNumber>;
+            /** Enable automatic pruning when limits are exceeded */
+            autoPrune: z.ZodDefault<z.ZodBoolean>;
+            /** Preserve domain coverage when pruning */
+            preserveDomainCoverage: z.ZodDefault<z.ZodBoolean>;
+            /** Similarity threshold for deduplication (0 = disabled) */
+            deduplicationThreshold: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            deduplicationThreshold: number;
+            maxExperiences: number;
+            maxPlaybooks: number;
+            maxExperienceAgeDays: number;
+            maxFailedExperienceAgeDays: number;
+            autoPrune: boolean;
+            preserveDomainCoverage: boolean;
+        }, {
+            deduplicationThreshold?: number | undefined;
+            maxExperiences?: number | undefined;
+            maxPlaybooks?: number | undefined;
+            maxExperienceAgeDays?: number | undefined;
+            maxFailedExperienceAgeDays?: number | undefined;
+            autoPrune?: boolean | undefined;
+            preserveDomainCoverage?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        maxExperiences: number;
+        maxStrategies: number;
+        maxConcepts: number;
+        maxSkills: number;
+        maxContextTokens: number;
+        capacity: {
+            deduplicationThreshold: number;
+            maxExperiences: number;
+            maxPlaybooks: number;
+            maxExperienceAgeDays: number;
+            maxFailedExperienceAgeDays: number;
+            autoPrune: boolean;
+            preserveDomainCoverage: boolean;
+        };
+    }, {
+        maxExperiences?: number | undefined;
+        maxStrategies?: number | undefined;
+        maxConcepts?: number | undefined;
+        maxSkills?: number | undefined;
+        maxContextTokens?: number | undefined;
+        capacity?: {
+            deduplicationThreshold?: number | undefined;
+            maxExperiences?: number | undefined;
+            maxPlaybooks?: number | undefined;
+            maxExperienceAgeDays?: number | undefined;
+            maxFailedExperienceAgeDays?: number | undefined;
+            autoPrune?: boolean | undefined;
+            preserveDomainCoverage?: boolean | undefined;
+        } | undefined;
+    }>>;
+    /** Storage configuration */
+    storage: z.ZodDefault<z.ZodObject<{
+        /** Base directory for file storage */
+        baseDir: z.ZodDefault<z.ZodString>;
+        /** Enable file-based persistence */
+        persistenceEnabled: z.ZodDefault<z.ZodBoolean>;
+        /** Auto-save interval in milliseconds */
+        autoSaveInterval: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        baseDir: string;
+        persistenceEnabled: boolean;
+        autoSaveInterval: number;
+    }, {
+        baseDir?: string | undefined;
+        persistenceEnabled?: boolean | undefined;
+        autoSaveInterval?: number | undefined;
+    }>>;
+    /** Embedding configuration */
+    embedding: z.ZodDefault<z.ZodObject<{
+        /** Embedding provider type */
+        provider: z.ZodDefault<z.ZodEnum<["openai", "voyage", "local", "none"]>>;
+        /** API key for hosted providers (OpenAI, Voyage) */
+        apiKey: z.ZodOptional<z.ZodString>;
+        /** Model name/identifier */
+        model: z.ZodOptional<z.ZodString>;
+        /** Path to local model (for 'local' provider) */
+        modelPath: z.ZodOptional<z.ZodString>;
+        /** Embedding dimension (defaults vary by provider) */
+        dimension: z.ZodOptional<z.ZodNumber>;
+        /** Path for sqlite-vec database file */
+        vectorDbPath: z.ZodDefault<z.ZodString>;
+        /** Base URL for API (for custom endpoints) */
+        baseUrl: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        provider: "openai" | "voyage" | "local" | "none";
+        vectorDbPath: string;
+        apiKey?: string | undefined;
+        model?: string | undefined;
+        modelPath?: string | undefined;
+        dimension?: number | undefined;
+        baseUrl?: string | undefined;
+    }, {
+        provider?: "openai" | "voyage" | "local" | "none" | undefined;
+        apiKey?: string | undefined;
+        model?: string | undefined;
+        modelPath?: string | undefined;
+        dimension?: number | undefined;
+        vectorDbPath?: string | undefined;
+        baseUrl?: string | undefined;
+    }>>;
+    /** Execution configuration */
+    execution: z.ZodDefault<z.ZodObject<{
+        /** Backend to use for agent execution */
+        backend: z.ZodDefault<z.ZodEnum<["acp", "subprocess", "mock"]>>;
+        /** Maximum execution time in seconds */
+        maxExecutionTime: z.ZodDefault<z.ZodNumber>;
+        /** Capture tool calls for trajectory extraction */
+        captureToolCalls: z.ZodDefault<z.ZodBoolean>;
+        /** Default agent type */
+        defaultAgentType: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        backend: "acp" | "subprocess" | "mock";
+        maxExecutionTime: number;
+        captureToolCalls: boolean;
+        defaultAgentType: string;
+    }, {
+        backend?: "acp" | "subprocess" | "mock" | undefined;
+        maxExecutionTime?: number | undefined;
+        captureToolCalls?: boolean | undefined;
+        defaultAgentType?: string | undefined;
+    }>>;
+    /** Refinement configuration */
+    refinement: z.ZodDefault<z.ZodObject<{
+        /** Maximum refinement iterations */
+        maxIterations: z.ZodDefault<z.ZodNumber>;
+        /** Minimum quality score to accept without refinement */
+        acceptableScore: z.ZodDefault<z.ZodNumber>;
+        /** Whether to use ACP agent for evaluation */
+        useAgentEvaluation: z.ZodDefault<z.ZodBoolean>;
+        /** Agent type to use for evaluation */
+        evaluatorAgentType: z.ZodDefault<z.ZodString>;
+        /** Confidence threshold below which to trigger refinement */
+        confidenceThreshold: z.ZodDefault<z.ZodNumber>;
+        /** Routing strategies that should trigger refinement */
+        triggerOnStrategies: z.ZodDefault<z.ZodArray<z.ZodEnum<["explore", "fallback", "direct", "adapt"]>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        maxIterations: number;
+        acceptableScore: number;
+        useAgentEvaluation: boolean;
+        evaluatorAgentType: string;
+        confidenceThreshold: number;
+        triggerOnStrategies: ("adapt" | "direct" | "explore" | "fallback")[];
+    }, {
+        maxIterations?: number | undefined;
+        acceptableScore?: number | undefined;
+        useAgentEvaluation?: boolean | undefined;
+        evaluatorAgentType?: string | undefined;
+        confidenceThreshold?: number | undefined;
+        triggerOnStrategies?: ("adapt" | "direct" | "explore" | "fallback")[] | undefined;
+    }>>;
+    /** Skill Library configuration */
+    skillLibrary: z.ZodDefault<z.ZodObject<{
+        /** Promotion criteria */
+        promotion: z.ZodDefault<z.ZodObject<{
+            /** Minimum confidence to promote to core skill */
+            minConfidence: z.ZodDefault<z.ZodNumber>;
+            /** Minimum success count to promote */
+            minSuccessCount: z.ZodDefault<z.ZodNumber>;
+            /** Minimum success rate to promote */
+            minSuccessRate: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            minSuccessRate: number;
+            minConfidence: number;
+            minSuccessCount: number;
+        }, {
+            minSuccessRate?: number | undefined;
+            minConfidence?: number | undefined;
+            minSuccessCount?: number | undefined;
+        }>>;
+        /** Capacity limits */
+        limits: z.ZodDefault<z.ZodObject<{
+            /** Maximum core skills (always in system prompt) */
+            maxCoreSkills: z.ZodDefault<z.ZodNumber>;
+            /** Maximum domain skills per domain */
+            maxDomainSkills: z.ZodDefault<z.ZodNumber>;
+            /** Maximum contextual playbooks per task */
+            maxContextualPlaybooks: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            maxCoreSkills: number;
+            maxDomainSkills: number;
+            maxContextualPlaybooks: number;
+        }, {
+            maxCoreSkills?: number | undefined;
+            maxDomainSkills?: number | undefined;
+            maxContextualPlaybooks?: number | undefined;
+        }>>;
+        /** Context budget */
+        context: z.ZodDefault<z.ZodObject<{
+            /** Maximum tokens for skills in system prompt */
+            maxTokensForSkills: z.ZodDefault<z.ZodNumber>;
+            /** Include refinements in skill context */
+            includeRefinements: z.ZodDefault<z.ZodBoolean>;
+            /** Include code examples in skill context */
+            includeExamples: z.ZodDefault<z.ZodBoolean>;
+            /** Cache refresh interval in milliseconds (default: 5 minutes) */
+            cacheRefreshInterval: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            maxTokensForSkills: number;
+            includeRefinements: boolean;
+            includeExamples: boolean;
+            cacheRefreshInterval: number;
+        }, {
+            maxTokensForSkills?: number | undefined;
+            includeRefinements?: boolean | undefined;
+            includeExamples?: boolean | undefined;
+            cacheRefreshInterval?: number | undefined;
+        }>>;
+        /** Demotion criteria */
+        demotion: z.ZodDefault<z.ZodObject<{
+            /** Number of consecutive failures before demotion */
+            failureThreshold: z.ZodDefault<z.ZodNumber>;
+            /** Minimum confidence to retain core skill status */
+            minConfidenceToRetain: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            failureThreshold: number;
+            minConfidenceToRetain: number;
+        }, {
+            failureThreshold?: number | undefined;
+            minConfidenceToRetain?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        context: {
+            maxTokensForSkills: number;
+            includeRefinements: boolean;
+            includeExamples: boolean;
+            cacheRefreshInterval: number;
+        };
+        promotion: {
+            minSuccessRate: number;
+            minConfidence: number;
+            minSuccessCount: number;
+        };
+        limits: {
+            maxCoreSkills: number;
+            maxDomainSkills: number;
+            maxContextualPlaybooks: number;
+        };
+        demotion: {
+            failureThreshold: number;
+            minConfidenceToRetain: number;
+        };
+    }, {
+        context?: {
+            maxTokensForSkills?: number | undefined;
+            includeRefinements?: boolean | undefined;
+            includeExamples?: boolean | undefined;
+            cacheRefreshInterval?: number | undefined;
+        } | undefined;
+        promotion?: {
+            minSuccessRate?: number | undefined;
+            minConfidence?: number | undefined;
+            minSuccessCount?: number | undefined;
+        } | undefined;
+        limits?: {
+            maxCoreSkills?: number | undefined;
+            maxDomainSkills?: number | undefined;
+            maxContextualPlaybooks?: number | undefined;
+        } | undefined;
+        demotion?: {
+            failureThreshold?: number | undefined;
+            minConfidenceToRetain?: number | undefined;
+        } | undefined;
+    }>>;
+    /** MCP Server configuration */
+    mcp: z.ZodDefault<z.ZodObject<{
+        /** Enable MCP server */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Port for standalone server */
+        port: z.ZodOptional<z.ZodNumber>;
+        /** Expose playbooks as MCP resources */
+        exposeResources: z.ZodDefault<z.ZodBoolean>;
+        /** Expose playbook tools */
+        exposeTools: z.ZodDefault<z.ZodBoolean>;
+        /** Maximum results to return from searches */
+        maxResults: z.ZodDefault<z.ZodNumber>;
+        /** Minimum confidence threshold for search results */
+        minConfidence: z.ZodDefault<z.ZodNumber>;
+        /** Include refinements in playbook details */
+        includeRefinements: z.ZodDefault<z.ZodBoolean>;
+        /** Enable filtering by domain */
+        enableDomainFiltering: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        minConfidence: number;
+        includeRefinements: boolean;
+        enabled: boolean;
+        exposeResources: boolean;
+        exposeTools: boolean;
+        maxResults: number;
+        enableDomainFiltering: boolean;
+        port?: number | undefined;
+    }, {
+        minConfidence?: number | undefined;
+        includeRefinements?: boolean | undefined;
+        enabled?: boolean | undefined;
+        port?: number | undefined;
+        exposeResources?: boolean | undefined;
+        exposeTools?: boolean | undefined;
+        maxResults?: number | undefined;
+        enableDomainFiltering?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    refinement: {
+        maxIterations: number;
+        acceptableScore: number;
+        useAgentEvaluation: boolean;
+        evaluatorAgentType: string;
+        confidenceThreshold: number;
+        triggerOnStrategies: ("adapt" | "direct" | "explore" | "fallback")[];
+    };
+    embedding: {
+        provider: "openai" | "voyage" | "local" | "none";
+        vectorDbPath: string;
+        apiKey?: string | undefined;
+        model?: string | undefined;
+        modelPath?: string | undefined;
+        dimension?: number | undefined;
+        baseUrl?: string | undefined;
+    };
+    execution: {
+        backend: "acp" | "subprocess" | "mock";
+        maxExecutionTime: number;
+        captureToolCalls: boolean;
+        defaultAgentType: string;
+    };
+    learning: {
+        creditStrategy: "llm" | "simple" | "counterfactual";
+        patternExtractor: "llm" | "text" | "both";
+        minTrajectories: number;
+        deduplicationThreshold: number;
+        maxExperiences: number;
+        minHoursSinceLast?: number | undefined;
+        minSuccessRate?: number | undefined;
+    };
+    router: {
+        similarityThreshold: number;
+        useDomainRouting: boolean;
+        defaultStrategy: string;
+    };
+    memory: {
+        maxExperiences: number;
+        maxStrategies: number;
+        maxConcepts: number;
+        maxSkills: number;
+        maxContextTokens: number;
+        capacity: {
+            deduplicationThreshold: number;
+            maxExperiences: number;
+            maxPlaybooks: number;
+            maxExperienceAgeDays: number;
+            maxFailedExperienceAgeDays: number;
+            autoPrune: boolean;
+            preserveDomainCoverage: boolean;
+        };
+    };
+    storage: {
+        baseDir: string;
+        persistenceEnabled: boolean;
+        autoSaveInterval: number;
+    };
+    skillLibrary: {
+        context: {
+            maxTokensForSkills: number;
+            includeRefinements: boolean;
+            includeExamples: boolean;
+            cacheRefreshInterval: number;
+        };
+        promotion: {
+            minSuccessRate: number;
+            minConfidence: number;
+            minSuccessCount: number;
+        };
+        limits: {
+            maxCoreSkills: number;
+            maxDomainSkills: number;
+            maxContextualPlaybooks: number;
+        };
+        demotion: {
+            failureThreshold: number;
+            minConfidenceToRetain: number;
+        };
+    };
+    mcp: {
+        minConfidence: number;
+        includeRefinements: boolean;
+        enabled: boolean;
+        exposeResources: boolean;
+        exposeTools: boolean;
+        maxResults: number;
+        enableDomainFiltering: boolean;
+        port?: number | undefined;
+    };
+}, {
+    refinement?: {
+        maxIterations?: number | undefined;
+        acceptableScore?: number | undefined;
+        useAgentEvaluation?: boolean | undefined;
+        evaluatorAgentType?: string | undefined;
+        confidenceThreshold?: number | undefined;
+        triggerOnStrategies?: ("adapt" | "direct" | "explore" | "fallback")[] | undefined;
+    } | undefined;
+    embedding?: {
+        provider?: "openai" | "voyage" | "local" | "none" | undefined;
+        apiKey?: string | undefined;
+        model?: string | undefined;
+        modelPath?: string | undefined;
+        dimension?: number | undefined;
+        vectorDbPath?: string | undefined;
+        baseUrl?: string | undefined;
+    } | undefined;
+    execution?: {
+        backend?: "acp" | "subprocess" | "mock" | undefined;
+        maxExecutionTime?: number | undefined;
+        captureToolCalls?: boolean | undefined;
+        defaultAgentType?: string | undefined;
+    } | undefined;
+    learning?: {
+        creditStrategy?: "llm" | "simple" | "counterfactual" | undefined;
+        patternExtractor?: "llm" | "text" | "both" | undefined;
+        minTrajectories?: number | undefined;
+        minHoursSinceLast?: number | undefined;
+        minSuccessRate?: number | undefined;
+        deduplicationThreshold?: number | undefined;
+        maxExperiences?: number | undefined;
+    } | undefined;
+    router?: {
+        similarityThreshold?: number | undefined;
+        useDomainRouting?: boolean | undefined;
+        defaultStrategy?: string | undefined;
+    } | undefined;
+    memory?: {
+        maxExperiences?: number | undefined;
+        maxStrategies?: number | undefined;
+        maxConcepts?: number | undefined;
+        maxSkills?: number | undefined;
+        maxContextTokens?: number | undefined;
+        capacity?: {
+            deduplicationThreshold?: number | undefined;
+            maxExperiences?: number | undefined;
+            maxPlaybooks?: number | undefined;
+            maxExperienceAgeDays?: number | undefined;
+            maxFailedExperienceAgeDays?: number | undefined;
+            autoPrune?: boolean | undefined;
+            preserveDomainCoverage?: boolean | undefined;
+        } | undefined;
+    } | undefined;
+    storage?: {
+        baseDir?: string | undefined;
+        persistenceEnabled?: boolean | undefined;
+        autoSaveInterval?: number | undefined;
+    } | undefined;
+    skillLibrary?: {
+        context?: {
+            maxTokensForSkills?: number | undefined;
+            includeRefinements?: boolean | undefined;
+            includeExamples?: boolean | undefined;
+            cacheRefreshInterval?: number | undefined;
+        } | undefined;
+        promotion?: {
+            minSuccessRate?: number | undefined;
+            minConfidence?: number | undefined;
+            minSuccessCount?: number | undefined;
+        } | undefined;
+        limits?: {
+            maxCoreSkills?: number | undefined;
+            maxDomainSkills?: number | undefined;
+            maxContextualPlaybooks?: number | undefined;
+        } | undefined;
+        demotion?: {
+            failureThreshold?: number | undefined;
+            minConfidenceToRetain?: number | undefined;
+        } | undefined;
+    } | undefined;
+    mcp?: {
+        minConfidence?: number | undefined;
+        includeRefinements?: boolean | undefined;
+        enabled?: boolean | undefined;
+        port?: number | undefined;
+        exposeResources?: boolean | undefined;
+        exposeTools?: boolean | undefined;
+        maxResults?: number | undefined;
+        enableDomainFiltering?: boolean | undefined;
+    } | undefined;
+}>;
+export type AtlasConfig = z.infer<typeof AtlasConfigSchema>;
+/**
+ * Create default configuration
+ */
+export declare function createDefaultConfig(overrides?: Partial<AtlasConfig>): AtlasConfig;
+/**
+ * Merge configurations
+ */
+export declare function mergeConfig(base: AtlasConfig, overrides: Partial<AtlasConfig>): AtlasConfig;
+//# sourceMappingURL=config.d.ts.map