cognitive-core 0.1.0 → 0.1.2

package/dist/types/config.d.ts

@@ -29,7 +29,7 @@ export declare const LearningConfigSchema: z.ZodObject<{
     maxExperiences: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     creditStrategy: "llm" | "simple" | "counterfactual";
-    patternExtractor: "llm" | "text" | "both";
+    patternExtractor: "llm" | "both" | "text";
     minTrajectories: number;
     deduplicationThreshold: number;
     maxExperiences: number;
@@ -37,7 +37,7 @@ export declare const LearningConfigSchema: z.ZodObject<{
     minSuccessRate?: number | undefined;
 }, {
     creditStrategy?: "llm" | "simple" | "counterfactual" | undefined;
-    patternExtractor?: "llm" | "text" | "both" | undefined;
+    patternExtractor?: "llm" | "both" | "text" | undefined;
     minTrajectories?: number | undefined;
     minHoursSinceLast?: number | undefined;
     minSuccessRate?: number | undefined;
@@ -226,15 +226,15 @@ export declare const EmbeddingConfigSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     provider: "openai" | "voyage" | "local" | "none";
     vectorDbPath: string;
-    apiKey?: string | undefined;
     model?: string | undefined;
+    apiKey?: string | undefined;
     modelPath?: string | undefined;
     dimension?: number | undefined;
     baseUrl?: string | undefined;
 }, {
+    model?: string | undefined;
     provider?: "openai" | "voyage" | "local" | "none" | undefined;
     apiKey?: string | undefined;
-    model?: string | undefined;
     modelPath?: string | undefined;
     dimension?: number | undefined;
     vectorDbPath?: string | undefined;
@@ -270,6 +270,26 @@ export declare const ExecutionConfigSchema: z.ZodObject<{
     defaultAgentType?: string | undefined;
 }>;
 export type ExecutionConfig = z.infer<typeof ExecutionConfigSchema>;
+/**
+ * Compute provider configuration
+ */
+export declare const ComputeProviderConfigSchema: z.ZodObject<{
+    /** Default cost tier preference */
+    defaultCostTier: z.ZodDefault<z.ZodEnum<["free", "low", "medium", "high"]>>;
+    /** Default location preference */
+    defaultLocation: z.ZodDefault<z.ZodEnum<["local", "remote", "any"]>>;
+    /** Fallback to any available source if preferred not available */
+    allowFallback: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    defaultCostTier: "free" | "low" | "medium" | "high";
+    defaultLocation: "local" | "remote" | "any";
+    allowFallback: boolean;
+}, {
+    defaultCostTier?: "free" | "low" | "medium" | "high" | undefined;
+    defaultLocation?: "local" | "remote" | "any" | undefined;
+    allowFallback?: boolean | undefined;
+}>;
+export type ComputeProviderConfig = z.infer<typeof ComputeProviderConfigSchema>;
 /**
  * Refinement configuration
  */
@@ -498,6 +518,34 @@ export declare const SkillLibraryConfigSchema: z.ZodObject<{
     } | undefined;
 }>;
 export type SkillLibraryConfig = z.infer<typeof SkillLibraryConfigSchema>;
+/**
+ * Agentic Task Runner configuration
+ */
+export declare const AgenticTaskRunnerConfigSchema: z.ZodObject<{
+    /** Cleanup workspaces after completion */
+    cleanupWorkspaces: z.ZodDefault<z.ZodBoolean>;
+    /** Keep workspaces for failed tasks (for debugging) */
+    keepFailedWorkspaces: z.ZodDefault<z.ZodBoolean>;
+    /** Maximum concurrent analysis agents */
+    maxConcurrentAgents: z.ZodDefault<z.ZodNumber>;
+    /** Stale workspace cleanup threshold in milliseconds */
+    staleWorkspaceMaxAgeMs: z.ZodDefault<z.ZodNumber>;
+    /** Base directory for workspaces (defaults to os.tmpdir()) */
+    workspaceBaseDir: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    cleanupWorkspaces: boolean;
+    keepFailedWorkspaces: boolean;
+    maxConcurrentAgents: number;
+    staleWorkspaceMaxAgeMs: number;
+    workspaceBaseDir?: string | undefined;
+}, {
+    cleanupWorkspaces?: boolean | undefined;
+    keepFailedWorkspaces?: boolean | undefined;
+    maxConcurrentAgents?: number | undefined;
+    staleWorkspaceMaxAgeMs?: number | undefined;
+    workspaceBaseDir?: string | undefined;
+}>;
+export type AgenticTaskRunnerConfig = z.infer<typeof AgenticTaskRunnerConfigSchema>;
 /**
  * MCP Server configuration
  */
@@ -519,18 +567,18 @@ export declare const MCPServerConfigSchema: z.ZodObject<{
     /** Enable filtering by domain */
     enableDomainFiltering: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
+    enabled: boolean;
     minConfidence: number;
     includeRefinements: boolean;
-    enabled: boolean;
     exposeResources: boolean;
     exposeTools: boolean;
     maxResults: number;
     enableDomainFiltering: boolean;
     port?: number | undefined;
 }, {
+    enabled?: boolean | undefined;
     minConfidence?: number | undefined;
     includeRefinements?: boolean | undefined;
-    enabled?: boolean | undefined;
     port?: number | undefined;
     exposeResources?: boolean | undefined;
     exposeTools?: boolean | undefined;
@@ -538,6 +586,560 @@ export declare const MCPServerConfigSchema: z.ZodObject<{
     enableDomainFiltering?: boolean | undefined;
 }>;
 export type MCPServerConfig = z.infer<typeof MCPServerConfigSchema>;
+/**
+ * Compression configuration for team trajectory ingestion
+ */
+export declare const CompressionConfigSchema: z.ZodObject<{
+    /** Maximum tokens per agent after compression */
+    maxTokensPerAgent: z.ZodDefault<z.ZodNumber>;
+    /** Preserve interaction boundary steps at full fidelity */
+    preserveInteractionBoundaries: z.ZodDefault<z.ZodBoolean>;
+    /** Minimum consecutive non-key steps before folding */
+    foldThreshold: z.ZodDefault<z.ZodNumber>;
+    /** Maximum ratio of steps to mark as critical */
+    maxCriticalRatio: z.ZodDefault<z.ZodNumber>;
+    /** Score threshold for critical steps */
+    criticalStepThreshold: z.ZodDefault<z.ZodNumber>;
+    /** Score threshold for critical interactions */
+    criticalInteractionThreshold: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    maxTokensPerAgent: number;
+    preserveInteractionBoundaries: boolean;
+    foldThreshold: number;
+    maxCriticalRatio: number;
+    criticalStepThreshold: number;
+    criticalInteractionThreshold: number;
+}, {
+    maxTokensPerAgent?: number | undefined;
+    preserveInteractionBoundaries?: boolean | undefined;
+    foldThreshold?: number | undefined;
+    maxCriticalRatio?: number | undefined;
+    criticalStepThreshold?: number | undefined;
+    criticalInteractionThreshold?: number | undefined;
+}>;
+export type CompressionConfig = z.infer<typeof CompressionConfigSchema>;
+/**
+ * Team-aware learning configuration
+ */
+export declare const TeamLearningConfigSchema: z.ZodObject<{
+    /** Enable team-aware learning */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /** Minimum team trajectories before batch learning */
+    minTeamTrajectories: z.ZodDefault<z.ZodNumber>;
+    /** Similarity threshold for team playbook deduplication */
+    deduplicationThreshold: z.ZodDefault<z.ZodNumber>;
+    /** Weight of structural metrics in analysis (0 = ignore, 1 = metrics only) */
+    metricsWeight: z.ZodDefault<z.ZodNumber>;
+    /** Maximum team experiences to store */
+    maxTeamExperiences: z.ZodDefault<z.ZodNumber>;
+    /** Maximum team playbooks to store */
+    maxTeamPlaybooks: z.ZodDefault<z.ZodNumber>;
+    /** Maximum role playbooks to store */
+    maxRolePlaybooks: z.ZodDefault<z.ZodNumber>;
+    /** Analysis agent timeout in milliseconds */
+    analysisTimeout: z.ZodDefault<z.ZodNumber>;
+    /** Extraction agent timeout in milliseconds */
+    extractionTimeout: z.ZodDefault<z.ZodNumber>;
+    /** Compression settings for trajectory ingestion */
+    compression: z.ZodDefault<z.ZodObject<{
+        /** Maximum tokens per agent after compression */
+        maxTokensPerAgent: z.ZodDefault<z.ZodNumber>;
+        /** Preserve interaction boundary steps at full fidelity */
+        preserveInteractionBoundaries: z.ZodDefault<z.ZodBoolean>;
+        /** Minimum consecutive non-key steps before folding */
+        foldThreshold: z.ZodDefault<z.ZodNumber>;
+        /** Maximum ratio of steps to mark as critical */
+        maxCriticalRatio: z.ZodDefault<z.ZodNumber>;
+        /** Score threshold for critical steps */
+        criticalStepThreshold: z.ZodDefault<z.ZodNumber>;
+        /** Score threshold for critical interactions */
+        criticalInteractionThreshold: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxTokensPerAgent: number;
+        preserveInteractionBoundaries: boolean;
+        foldThreshold: number;
+        maxCriticalRatio: number;
+        criticalStepThreshold: number;
+        criticalInteractionThreshold: number;
+    }, {
+        maxTokensPerAgent?: number | undefined;
+        preserveInteractionBoundaries?: boolean | undefined;
+        foldThreshold?: number | undefined;
+        maxCriticalRatio?: number | undefined;
+        criticalStepThreshold?: number | undefined;
+        criticalInteractionThreshold?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    deduplicationThreshold: number;
+    minTeamTrajectories: number;
+    metricsWeight: number;
+    maxTeamExperiences: number;
+    maxTeamPlaybooks: number;
+    maxRolePlaybooks: number;
+    analysisTimeout: number;
+    extractionTimeout: number;
+    compression: {
+        maxTokensPerAgent: number;
+        preserveInteractionBoundaries: boolean;
+        foldThreshold: number;
+        maxCriticalRatio: number;
+        criticalStepThreshold: number;
+        criticalInteractionThreshold: number;
+    };
+}, {
+    enabled?: boolean | undefined;
+    deduplicationThreshold?: number | undefined;
+    minTeamTrajectories?: number | undefined;
+    metricsWeight?: number | undefined;
+    maxTeamExperiences?: number | undefined;
+    maxTeamPlaybooks?: number | undefined;
+    maxRolePlaybooks?: number | undefined;
+    analysisTimeout?: number | undefined;
+    extractionTimeout?: number | undefined;
+    compression?: {
+        maxTokensPerAgent?: number | undefined;
+        preserveInteractionBoundaries?: boolean | undefined;
+        foldThreshold?: number | undefined;
+        maxCriticalRatio?: number | undefined;
+        criticalStepThreshold?: number | undefined;
+        criticalInteractionThreshold?: number | undefined;
+    } | undefined;
+}>;
+export type TeamLearningConfig = z.infer<typeof TeamLearningConfigSchema>;
+/**
+ * Knowledge Bank confidence model configuration
+ */
+export declare const ConfidenceConfigSchema: z.ZodObject<{
+    /** Initial confidence for extracted observations */
+    extractedInitial: z.ZodDefault<z.ZodNumber>;
+    /** Initial confidence for agent-authored notes */
+    agentAuthoredInitial: z.ZodDefault<z.ZodNumber>;
+    /** EMA alpha for reinforcement */
+    reinforcementAlpha: z.ZodDefault<z.ZodNumber>;
+    /** Confidence reduction on contradiction */
+    contradictionPenalty: z.ZodDefault<z.ZodNumber>;
+    /** Daily confidence decay rate for unvalidated knowledge */
+    dailyDecayRate: z.ZodDefault<z.ZodNumber>;
+    /** Confidence below which to mark as stale */
+    staleThreshold: z.ZodDefault<z.ZodNumber>;
+    /** Days without validation before decay begins */
+    decayGracePeriodDays: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    extractedInitial: number;
+    agentAuthoredInitial: number;
+    reinforcementAlpha: number;
+    contradictionPenalty: number;
+    dailyDecayRate: number;
+    staleThreshold: number;
+    decayGracePeriodDays: number;
+}, {
+    extractedInitial?: number | undefined;
+    agentAuthoredInitial?: number | undefined;
+    reinforcementAlpha?: number | undefined;
+    contradictionPenalty?: number | undefined;
+    dailyDecayRate?: number | undefined;
+    staleThreshold?: number | undefined;
+    decayGracePeriodDays?: number | undefined;
+}>;
+export type ConfidenceConfig = z.infer<typeof ConfidenceConfigSchema>;
+/**
+ * Knowledge Bank graph overlay configuration
+ */
+export declare const GraphConfigSchema: z.ZodObject<{
+    /** Which graph layers to enable */
+    enabledLayers: z.ZodDefault<z.ZodArray<z.ZodEnum<["semantic", "temporal", "causal", "entity"]>, "many">>;
+    /** Whether to auto-infer temporal edges from timestamps */
+    inferTemporalEdges: z.ZodDefault<z.ZodBoolean>;
+    /** Whether to auto-infer causal edges from failure-recovery patterns */
+    inferCausalEdges: z.ZodDefault<z.ZodBoolean>;
+    /** Whether to auto-infer entity edges from shared entity tags */
+    inferEntityEdges: z.ZodDefault<z.ZodBoolean>;
+    /** Split layer files by domain when node count exceeds this */
+    domainSplitThreshold: z.ZodDefault<z.ZodNumber>;
+    /** Promote to SQLite when total edge count exceeds this */
+    sqlitePromotionThreshold: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    enabledLayers: ("semantic" | "temporal" | "causal" | "entity")[];
+    inferTemporalEdges: boolean;
+    inferCausalEdges: boolean;
+    inferEntityEdges: boolean;
+    domainSplitThreshold: number;
+    sqlitePromotionThreshold: number;
+}, {
+    enabledLayers?: ("semantic" | "temporal" | "causal" | "entity")[] | undefined;
+    inferTemporalEdges?: boolean | undefined;
+    inferCausalEdges?: boolean | undefined;
+    inferEntityEdges?: boolean | undefined;
+    domainSplitThreshold?: number | undefined;
+    sqlitePromotionThreshold?: number | undefined;
+}>;
+export type GraphConfigType = z.infer<typeof GraphConfigSchema>;
+/**
+ * Knowledge Bank defragmentation configuration
+ */
+export declare const DefragConfigSchema: z.ZodObject<{
+    /** Minimum inbox items before triggering defrag */
+    minInboxItems: z.ZodDefault<z.ZodNumber>;
+    /** Whether to auto-consolidate observations into entities */
+    autoConsolidate: z.ZodDefault<z.ZodBoolean>;
+    /** Minimum observations about an entity before consolidation */
+    consolidationThreshold: z.ZodDefault<z.ZodNumber>;
+    /** Whether to auto-regenerate domain summaries */
+    autoRegenerateSummaries: z.ZodDefault<z.ZodBoolean>;
+    /** Use LLM for summary generation (vs heuristic concatenation) */
+    llmSummaryGeneration: z.ZodDefault<z.ZodBoolean>;
+    /** Whether to auto-resolve simple contradictions */
+    autoResolveContradictions: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    minInboxItems: number;
+    autoConsolidate: boolean;
+    consolidationThreshold: number;
+    autoRegenerateSummaries: boolean;
+    llmSummaryGeneration: boolean;
+    autoResolveContradictions: boolean;
+}, {
+    minInboxItems?: number | undefined;
+    autoConsolidate?: boolean | undefined;
+    consolidationThreshold?: number | undefined;
+    autoRegenerateSummaries?: boolean | undefined;
+    llmSummaryGeneration?: boolean | undefined;
+    autoResolveContradictions?: boolean | undefined;
+}>;
+export type DefragConfig = z.infer<typeof DefragConfigSchema>;
+/**
+ * Knowledge Bank extraction configuration
+ */
+export declare const KnowledgeExtractionConfigSchema: z.ZodObject<{
+    /** Enable automatic knowledge extraction from trajectories */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /** Use LLM-assisted extraction (vs heuristic only) */
+    useLlmExtraction: z.ZodDefault<z.ZodBoolean>;
+    /** Minimum trajectory attribution score for extraction */
+    minAttributionScore: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    useLlmExtraction: boolean;
+    minAttributionScore: number;
+}, {
+    enabled?: boolean | undefined;
+    useLlmExtraction?: boolean | undefined;
+    minAttributionScore?: number | undefined;
+}>;
+export type KnowledgeExtractionConfig = z.infer<typeof KnowledgeExtractionConfigSchema>;
+/**
+ * Knowledge Bank surfacing configuration
+ */
+export declare const KnowledgeSurfacingConfigSchema: z.ZodObject<{
+    /** Include domain summaries in task context */
+    includeDomainSummaries: z.ZodDefault<z.ZodBoolean>;
+    /** Include entity notes in task context */
+    includeEntityNotes: z.ZodDefault<z.ZodBoolean>;
+    /** Maximum knowledge notes to surface per task */
+    maxNotesPerTask: z.ZodDefault<z.ZodNumber>;
+    /** Maximum tokens for knowledge context */
+    maxTokensForKnowledge: z.ZodDefault<z.ZodNumber>;
+    /** Include evidence citations in surfaced notes */
+    includeEvidence: z.ZodDefault<z.ZodBoolean>;
+    /** Include graph links in surfaced notes */
+    includeLinks: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    includeDomainSummaries: boolean;
+    includeEntityNotes: boolean;
+    maxNotesPerTask: number;
+    maxTokensForKnowledge: number;
+    includeEvidence: boolean;
+    includeLinks: boolean;
+}, {
+    includeDomainSummaries?: boolean | undefined;
+    includeEntityNotes?: boolean | undefined;
+    maxNotesPerTask?: number | undefined;
+    maxTokensForKnowledge?: number | undefined;
+    includeEvidence?: boolean | undefined;
+    includeLinks?: boolean | undefined;
+}>;
+export type KnowledgeSurfacingConfig = z.infer<typeof KnowledgeSurfacingConfigSchema>;
+/**
+ * Knowledge Bank configuration
+ */
+export declare const KnowledgeBankConfigSchema: z.ZodObject<{
+    /** Enable knowledge bank */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /** Root directory for knowledge files (relative to storage.baseDir) */
+    memoryDir: z.ZodDefault<z.ZodString>;
+    /** Extraction config */
+    extraction: z.ZodDefault<z.ZodObject<{
+        /** Enable automatic knowledge extraction from trajectories */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Use LLM-assisted extraction (vs heuristic only) */
+        useLlmExtraction: z.ZodDefault<z.ZodBoolean>;
+        /** Minimum trajectory attribution score for extraction */
+        minAttributionScore: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        useLlmExtraction: boolean;
+        minAttributionScore: number;
+    }, {
+        enabled?: boolean | undefined;
+        useLlmExtraction?: boolean | undefined;
+        minAttributionScore?: number | undefined;
+    }>>;
+    /** Defragmentation config */
+    defrag: z.ZodDefault<z.ZodObject<{
+        /** Minimum inbox items before triggering defrag */
+        minInboxItems: z.ZodDefault<z.ZodNumber>;
+        /** Whether to auto-consolidate observations into entities */
+        autoConsolidate: z.ZodDefault<z.ZodBoolean>;
+        /** Minimum observations about an entity before consolidation */
+        consolidationThreshold: z.ZodDefault<z.ZodNumber>;
+        /** Whether to auto-regenerate domain summaries */
+        autoRegenerateSummaries: z.ZodDefault<z.ZodBoolean>;
+        /** Use LLM for summary generation (vs heuristic concatenation) */
+        llmSummaryGeneration: z.ZodDefault<z.ZodBoolean>;
+        /** Whether to auto-resolve simple contradictions */
+        autoResolveContradictions: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        minInboxItems: number;
+        autoConsolidate: boolean;
+        consolidationThreshold: number;
+        autoRegenerateSummaries: boolean;
+        llmSummaryGeneration: boolean;
+        autoResolveContradictions: boolean;
+    }, {
+        minInboxItems?: number | undefined;
+        autoConsolidate?: boolean | undefined;
+        consolidationThreshold?: number | undefined;
+        autoRegenerateSummaries?: boolean | undefined;
+        llmSummaryGeneration?: boolean | undefined;
+        autoResolveContradictions?: boolean | undefined;
+    }>>;
+    /** Confidence model config */
+    confidence: z.ZodDefault<z.ZodObject<{
+        /** Initial confidence for extracted observations */
+        extractedInitial: z.ZodDefault<z.ZodNumber>;
+        /** Initial confidence for agent-authored notes */
+        agentAuthoredInitial: z.ZodDefault<z.ZodNumber>;
+        /** EMA alpha for reinforcement */
+        reinforcementAlpha: z.ZodDefault<z.ZodNumber>;
+        /** Confidence reduction on contradiction */
+        contradictionPenalty: z.ZodDefault<z.ZodNumber>;
+        /** Daily confidence decay rate for unvalidated knowledge */
+        dailyDecayRate: z.ZodDefault<z.ZodNumber>;
+        /** Confidence below which to mark as stale */
+        staleThreshold: z.ZodDefault<z.ZodNumber>;
+        /** Days without validation before decay begins */
+        decayGracePeriodDays: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        extractedInitial: number;
+        agentAuthoredInitial: number;
+        reinforcementAlpha: number;
+        contradictionPenalty: number;
+        dailyDecayRate: number;
+        staleThreshold: number;
+        decayGracePeriodDays: number;
+    }, {
+        extractedInitial?: number | undefined;
+        agentAuthoredInitial?: number | undefined;
+        reinforcementAlpha?: number | undefined;
+        contradictionPenalty?: number | undefined;
+        dailyDecayRate?: number | undefined;
+        staleThreshold?: number | undefined;
+        decayGracePeriodDays?: number | undefined;
+    }>>;
+    /** Graph overlay config */
+    graph: z.ZodDefault<z.ZodObject<{
+        /** Which graph layers to enable */
+        enabledLayers: z.ZodDefault<z.ZodArray<z.ZodEnum<["semantic", "temporal", "causal", "entity"]>, "many">>;
+        /** Whether to auto-infer temporal edges from timestamps */
+        inferTemporalEdges: z.ZodDefault<z.ZodBoolean>;
+        /** Whether to auto-infer causal edges from failure-recovery patterns */
+        inferCausalEdges: z.ZodDefault<z.ZodBoolean>;
+        /** Whether to auto-infer entity edges from shared entity tags */
+        inferEntityEdges: z.ZodDefault<z.ZodBoolean>;
+        /** Split layer files by domain when node count exceeds this */
+        domainSplitThreshold: z.ZodDefault<z.ZodNumber>;
+        /** Promote to SQLite when total edge count exceeds this */
+        sqlitePromotionThreshold: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabledLayers: ("semantic" | "temporal" | "causal" | "entity")[];
+        inferTemporalEdges: boolean;
+        inferCausalEdges: boolean;
+        inferEntityEdges: boolean;
+        domainSplitThreshold: number;
+        sqlitePromotionThreshold: number;
+    }, {
+        enabledLayers?: ("semantic" | "temporal" | "causal" | "entity")[] | undefined;
+        inferTemporalEdges?: boolean | undefined;
+        inferCausalEdges?: boolean | undefined;
+        inferEntityEdges?: boolean | undefined;
+        domainSplitThreshold?: number | undefined;
+        sqlitePromotionThreshold?: number | undefined;
+    }>>;
+    /** Surfacing config (independent from SkillLibrary) */
+    surfacing: z.ZodDefault<z.ZodObject<{
+        /** Include domain summaries in task context */
+        includeDomainSummaries: z.ZodDefault<z.ZodBoolean>;
+        /** Include entity notes in task context */
+        includeEntityNotes: z.ZodDefault<z.ZodBoolean>;
+        /** Maximum knowledge notes to surface per task */
+        maxNotesPerTask: z.ZodDefault<z.ZodNumber>;
+        /** Maximum tokens for knowledge context */
+        maxTokensForKnowledge: z.ZodDefault<z.ZodNumber>;
+        /** Include evidence citations in surfaced notes */
+        includeEvidence: z.ZodDefault<z.ZodBoolean>;
+        /** Include graph links in surfaced notes */
+        includeLinks: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        includeDomainSummaries: boolean;
+        includeEntityNotes: boolean;
+        maxNotesPerTask: number;
+        maxTokensForKnowledge: number;
+        includeEvidence: boolean;
+        includeLinks: boolean;
+    }, {
+        includeDomainSummaries?: boolean | undefined;
+        includeEntityNotes?: boolean | undefined;
+        maxNotesPerTask?: number | undefined;
+        maxTokensForKnowledge?: number | undefined;
+        includeEvidence?: boolean | undefined;
+        includeLinks?: boolean | undefined;
+    }>>;
+    /** Whether to manage minimem-specific features (sync, versioning) */
+    minimemAware: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    confidence: {
+        extractedInitial: number;
+        agentAuthoredInitial: number;
+        reinforcementAlpha: number;
+        contradictionPenalty: number;
+        dailyDecayRate: number;
+        staleThreshold: number;
+        decayGracePeriodDays: number;
+    };
+    enabled: boolean;
+    graph: {
+        enabledLayers: ("semantic" | "temporal" | "causal" | "entity")[];
+        inferTemporalEdges: boolean;
+        inferCausalEdges: boolean;
+        inferEntityEdges: boolean;
+        domainSplitThreshold: number;
+        sqlitePromotionThreshold: number;
+    };
+    memoryDir: string;
+    extraction: {
+        enabled: boolean;
+        useLlmExtraction: boolean;
+        minAttributionScore: number;
+    };
+    defrag: {
+        minInboxItems: number;
+        autoConsolidate: boolean;
+        consolidationThreshold: number;
+        autoRegenerateSummaries: boolean;
+        llmSummaryGeneration: boolean;
+        autoResolveContradictions: boolean;
+    };
+    surfacing: {
+        includeDomainSummaries: boolean;
+        includeEntityNotes: boolean;
+        maxNotesPerTask: number;
+        maxTokensForKnowledge: number;
+        includeEvidence: boolean;
+        includeLinks: boolean;
+    };
+    minimemAware: boolean;
+}, {
+    confidence?: {
+        extractedInitial?: number | undefined;
+        agentAuthoredInitial?: number | undefined;
+        reinforcementAlpha?: number | undefined;
+        contradictionPenalty?: number | undefined;
+        dailyDecayRate?: number | undefined;
+        staleThreshold?: number | undefined;
+        decayGracePeriodDays?: number | undefined;
+    } | undefined;
+    enabled?: boolean | undefined;
+    graph?: {
+        enabledLayers?: ("semantic" | "temporal" | "causal" | "entity")[] | undefined;
+        inferTemporalEdges?: boolean | undefined;
+        inferCausalEdges?: boolean | undefined;
+        inferEntityEdges?: boolean | undefined;
+        domainSplitThreshold?: number | undefined;
+        sqlitePromotionThreshold?: number | undefined;
+    } | undefined;
+    memoryDir?: string | undefined;
+    extraction?: {
+        enabled?: boolean | undefined;
+        useLlmExtraction?: boolean | undefined;
+        minAttributionScore?: number | undefined;
+    } | undefined;
+    defrag?: {
+        minInboxItems?: number | undefined;
+        autoConsolidate?: boolean | undefined;
+        consolidationThreshold?: number | undefined;
+        autoRegenerateSummaries?: boolean | undefined;
+        llmSummaryGeneration?: boolean | undefined;
+        autoResolveContradictions?: boolean | undefined;
+    } | undefined;
+    surfacing?: {
+        includeDomainSummaries?: boolean | undefined;
+        includeEntityNotes?: boolean | undefined;
+        maxNotesPerTask?: number | undefined;
+        maxTokensForKnowledge?: number | undefined;
+        includeEvidence?: boolean | undefined;
+        includeLinks?: boolean | undefined;
+    } | undefined;
+    minimemAware?: boolean | undefined;
+}>;
+export type KnowledgeBankConfig = z.infer<typeof KnowledgeBankConfigSchema>;
+/**
+ * Session Bank configuration (Entire CLI integration)
+ */
+export declare const SessionBankConfigSchema: z.ZodObject<{
+    /** Enable session bank integration */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /** Orphan branch name */
+    branch: z.ZodDefault<z.ZodString>;
+    /** State directory (relative to storage.baseDir) */
+    stateDir: z.ZodDefault<z.ZodString>;
+    /** Default outcome strategy for synthesis */
+    outcomeStrategy: z.ZodDefault<z.ZodEnum<["summary", "heuristic"]>>;
+    /** Auto-ingest unprocessed sessions on init */
+    autoIngest: z.ZodDefault<z.ZodBoolean>;
+    /** Maximum sessions per auto-ingest batch */
+    maxIngestBatch: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    branch: string;
+    stateDir: string;
+    outcomeStrategy: "summary" | "heuristic";
+    autoIngest: boolean;
+    maxIngestBatch: number;
+}, {
+    enabled?: boolean | undefined;
+    branch?: string | undefined;
+    stateDir?: string | undefined;
+    outcomeStrategy?: "summary" | "heuristic" | undefined;
+    autoIngest?: boolean | undefined;
+    maxIngestBatch?: number | undefined;
+}>;
+export type SessionBankConfig = z.infer<typeof SessionBankConfigSchema>;
+/**
+ * Skill-tree storage configuration
+ */
+export declare const SkillTreeConfigSchema: z.ZodObject<{
+    /** Enable automatic skill-tree publishing via SqliteStorageAdapter */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /** Path to the SQLite database for skill storage (relative to storage.baseDir) */
+    dbPath: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    dbPath: string;
+}, {
+    enabled?: boolean | undefined;
+    dbPath?: string | undefined;
+}>;
+export type SkillTreeConfig = z.infer<typeof SkillTreeConfigSchema>;
 /**
  * Main Atlas configuration
  */
@@ -560,7 +1162,7 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         maxExperiences: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         creditStrategy: "llm" | "simple" | "counterfactual";
-        patternExtractor: "llm" | "text" | "both";
+        patternExtractor: "llm" | "both" | "text";
         minTrajectories: number;
         deduplicationThreshold: number;
         maxExperiences: number;
@@ -568,7 +1170,7 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         minSuccessRate?: number | undefined;
     }, {
         creditStrategy?: "llm" | "simple" | "counterfactual" | undefined;
-        patternExtractor?: "llm" | "text" | "both" | undefined;
+        patternExtractor?: "llm" | "both" | "text" | undefined;
         minTrajectories?: number | undefined;
         minHoursSinceLast?: number | undefined;
         minSuccessRate?: number | undefined;
@@ -704,15 +1306,15 @@ export declare const AtlasConfigSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         provider: "openai" | "voyage" | "local" | "none";
         vectorDbPath: string;
-        apiKey?: string | undefined;
         model?: string | undefined;
+        apiKey?: string | undefined;
         modelPath?: string | undefined;
         dimension?: number | undefined;
         baseUrl?: string | undefined;
     }, {
+        model?: string | undefined;
         provider?: "openai" | "voyage" | "local" | "none" | undefined;
         apiKey?: string | undefined;
-        model?: string | undefined;
         modelPath?: string | undefined;
         dimension?: number | undefined;
         vectorDbPath?: string | undefined;
@@ -900,24 +1502,424 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         /** Enable filtering by domain */
         enableDomainFiltering: z.ZodDefault<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
         minConfidence: number;
         includeRefinements: boolean;
-        enabled: boolean;
         exposeResources: boolean;
         exposeTools: boolean;
         maxResults: number;
         enableDomainFiltering: boolean;
         port?: number | undefined;
     }, {
+        enabled?: boolean | 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;
     }>>;
+    /** Agentic Task Runner configuration */
+    agenticTasks: z.ZodDefault<z.ZodObject<{
+        /** Cleanup workspaces after completion */
+        cleanupWorkspaces: z.ZodDefault<z.ZodBoolean>;
+        /** Keep workspaces for failed tasks (for debugging) */
+        keepFailedWorkspaces: z.ZodDefault<z.ZodBoolean>;
+        /** Maximum concurrent analysis agents */
+        maxConcurrentAgents: z.ZodDefault<z.ZodNumber>;
+        /** Stale workspace cleanup threshold in milliseconds */
+        staleWorkspaceMaxAgeMs: z.ZodDefault<z.ZodNumber>;
+        /** Base directory for workspaces (defaults to os.tmpdir()) */
+        workspaceBaseDir: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        cleanupWorkspaces: boolean;
+        keepFailedWorkspaces: boolean;
+        maxConcurrentAgents: number;
+        staleWorkspaceMaxAgeMs: number;
+        workspaceBaseDir?: string | undefined;
+    }, {
+        cleanupWorkspaces?: boolean | undefined;
+        keepFailedWorkspaces?: boolean | undefined;
+        maxConcurrentAgents?: number | undefined;
+        staleWorkspaceMaxAgeMs?: number | undefined;
+        workspaceBaseDir?: string | undefined;
+    }>>;
+    /** Compute provider configuration */
+    compute: z.ZodDefault<z.ZodObject<{
+        /** Default cost tier preference */
+        defaultCostTier: z.ZodDefault<z.ZodEnum<["free", "low", "medium", "high"]>>;
+        /** Default location preference */
+        defaultLocation: z.ZodDefault<z.ZodEnum<["local", "remote", "any"]>>;
+        /** Fallback to any available source if preferred not available */
+        allowFallback: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        defaultCostTier: "free" | "low" | "medium" | "high";
+        defaultLocation: "local" | "remote" | "any";
+        allowFallback: boolean;
+    }, {
+        defaultCostTier?: "free" | "low" | "medium" | "high" | undefined;
+        defaultLocation?: "local" | "remote" | "any" | undefined;
+        allowFallback?: boolean | undefined;
+    }>>;
+    /** Team-aware learning configuration */
+    teamLearning: z.ZodDefault<z.ZodObject<{
+        /** Enable team-aware learning */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Minimum team trajectories before batch learning */
+        minTeamTrajectories: z.ZodDefault<z.ZodNumber>;
+        /** Similarity threshold for team playbook deduplication */
+        deduplicationThreshold: z.ZodDefault<z.ZodNumber>;
+        /** Weight of structural metrics in analysis (0 = ignore, 1 = metrics only) */
+        metricsWeight: z.ZodDefault<z.ZodNumber>;
+        /** Maximum team experiences to store */
+        maxTeamExperiences: z.ZodDefault<z.ZodNumber>;
+        /** Maximum team playbooks to store */
+        maxTeamPlaybooks: z.ZodDefault<z.ZodNumber>;
+        /** Maximum role playbooks to store */
+        maxRolePlaybooks: z.ZodDefault<z.ZodNumber>;
+        /** Analysis agent timeout in milliseconds */
+        analysisTimeout: z.ZodDefault<z.ZodNumber>;
+        /** Extraction agent timeout in milliseconds */
+        extractionTimeout: z.ZodDefault<z.ZodNumber>;
+        /** Compression settings for trajectory ingestion */
+        compression: z.ZodDefault<z.ZodObject<{
+            /** Maximum tokens per agent after compression */
+            maxTokensPerAgent: z.ZodDefault<z.ZodNumber>;
+            /** Preserve interaction boundary steps at full fidelity */
+            preserveInteractionBoundaries: z.ZodDefault<z.ZodBoolean>;
+            /** Minimum consecutive non-key steps before folding */
+            foldThreshold: z.ZodDefault<z.ZodNumber>;
+            /** Maximum ratio of steps to mark as critical */
+            maxCriticalRatio: z.ZodDefault<z.ZodNumber>;
+            /** Score threshold for critical steps */
+            criticalStepThreshold: z.ZodDefault<z.ZodNumber>;
+            /** Score threshold for critical interactions */
+            criticalInteractionThreshold: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            maxTokensPerAgent: number;
+            preserveInteractionBoundaries: boolean;
+            foldThreshold: number;
+            maxCriticalRatio: number;
+            criticalStepThreshold: number;
+            criticalInteractionThreshold: number;
+        }, {
+            maxTokensPerAgent?: number | undefined;
+            preserveInteractionBoundaries?: boolean | undefined;
+            foldThreshold?: number | undefined;
+            maxCriticalRatio?: number | undefined;
+            criticalStepThreshold?: number | undefined;
+            criticalInteractionThreshold?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        deduplicationThreshold: number;
+        minTeamTrajectories: number;
+        metricsWeight: number;
+        maxTeamExperiences: number;
+        maxTeamPlaybooks: number;
+        maxRolePlaybooks: number;
+        analysisTimeout: number;
+        extractionTimeout: number;
+        compression: {
+            maxTokensPerAgent: number;
+            preserveInteractionBoundaries: boolean;
+            foldThreshold: number;
+            maxCriticalRatio: number;
+            criticalStepThreshold: number;
+            criticalInteractionThreshold: number;
+        };
+    }, {
+        enabled?: boolean | undefined;
+        deduplicationThreshold?: number | undefined;
+        minTeamTrajectories?: number | undefined;
+        metricsWeight?: number | undefined;
+        maxTeamExperiences?: number | undefined;
+        maxTeamPlaybooks?: number | undefined;
+        maxRolePlaybooks?: number | undefined;
+        analysisTimeout?: number | undefined;
+        extractionTimeout?: number | undefined;
+        compression?: {
+            maxTokensPerAgent?: number | undefined;
+            preserveInteractionBoundaries?: boolean | undefined;
+            foldThreshold?: number | undefined;
+            maxCriticalRatio?: number | undefined;
+            criticalStepThreshold?: number | undefined;
+            criticalInteractionThreshold?: number | undefined;
+        } | undefined;
+    }>>;
+    /** Knowledge bank configuration */
+    knowledgeBank: z.ZodDefault<z.ZodObject<{
+        /** Enable knowledge bank */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Root directory for knowledge files (relative to storage.baseDir) */
+        memoryDir: z.ZodDefault<z.ZodString>;
+        /** Extraction config */
+        extraction: z.ZodDefault<z.ZodObject<{
+            /** Enable automatic knowledge extraction from trajectories */
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            /** Use LLM-assisted extraction (vs heuristic only) */
+            useLlmExtraction: z.ZodDefault<z.ZodBoolean>;
+            /** Minimum trajectory attribution score for extraction */
+            minAttributionScore: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            useLlmExtraction: boolean;
+            minAttributionScore: number;
+        }, {
+            enabled?: boolean | undefined;
+            useLlmExtraction?: boolean | undefined;
+            minAttributionScore?: number | undefined;
+        }>>;
+        /** Defragmentation config */
+        defrag: z.ZodDefault<z.ZodObject<{
+            /** Minimum inbox items before triggering defrag */
+            minInboxItems: z.ZodDefault<z.ZodNumber>;
+            /** Whether to auto-consolidate observations into entities */
+            autoConsolidate: z.ZodDefault<z.ZodBoolean>;
+            /** Minimum observations about an entity before consolidation */
+            consolidationThreshold: z.ZodDefault<z.ZodNumber>;
+            /** Whether to auto-regenerate domain summaries */
+            autoRegenerateSummaries: z.ZodDefault<z.ZodBoolean>;
+            /** Use LLM for summary generation (vs heuristic concatenation) */
+            llmSummaryGeneration: z.ZodDefault<z.ZodBoolean>;
+            /** Whether to auto-resolve simple contradictions */
+            autoResolveContradictions: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            minInboxItems: number;
+            autoConsolidate: boolean;
+            consolidationThreshold: number;
+            autoRegenerateSummaries: boolean;
+            llmSummaryGeneration: boolean;
+            autoResolveContradictions: boolean;
+        }, {
+            minInboxItems?: number | undefined;
+            autoConsolidate?: boolean | undefined;
+            consolidationThreshold?: number | undefined;
+            autoRegenerateSummaries?: boolean | undefined;
+            llmSummaryGeneration?: boolean | undefined;
+            autoResolveContradictions?: boolean | undefined;
+        }>>;
+        /** Confidence model config */
+        confidence: z.ZodDefault<z.ZodObject<{
+            /** Initial confidence for extracted observations */
+            extractedInitial: z.ZodDefault<z.ZodNumber>;
+            /** Initial confidence for agent-authored notes */
+            agentAuthoredInitial: z.ZodDefault<z.ZodNumber>;
+            /** EMA alpha for reinforcement */
+            reinforcementAlpha: z.ZodDefault<z.ZodNumber>;
+            /** Confidence reduction on contradiction */
+            contradictionPenalty: z.ZodDefault<z.ZodNumber>;
+            /** Daily confidence decay rate for unvalidated knowledge */
+            dailyDecayRate: z.ZodDefault<z.ZodNumber>;
+            /** Confidence below which to mark as stale */
+            staleThreshold: z.ZodDefault<z.ZodNumber>;
+            /** Days without validation before decay begins */
+            decayGracePeriodDays: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            extractedInitial: number;
+            agentAuthoredInitial: number;
+            reinforcementAlpha: number;
+            contradictionPenalty: number;
+            dailyDecayRate: number;
+            staleThreshold: number;
+            decayGracePeriodDays: number;
+        }, {
+            extractedInitial?: number | undefined;
+            agentAuthoredInitial?: number | undefined;
+            reinforcementAlpha?: number | undefined;
+            contradictionPenalty?: number | undefined;
+            dailyDecayRate?: number | undefined;
+            staleThreshold?: number | undefined;
+            decayGracePeriodDays?: number | undefined;
+        }>>;
+        /** Graph overlay config */
+        graph: z.ZodDefault<z.ZodObject<{
+            /** Which graph layers to enable */
+            enabledLayers: z.ZodDefault<z.ZodArray<z.ZodEnum<["semantic", "temporal", "causal", "entity"]>, "many">>;
+            /** Whether to auto-infer temporal edges from timestamps */
+            inferTemporalEdges: z.ZodDefault<z.ZodBoolean>;
+            /** Whether to auto-infer causal edges from failure-recovery patterns */
+            inferCausalEdges: z.ZodDefault<z.ZodBoolean>;
+            /** Whether to auto-infer entity edges from shared entity tags */
+            inferEntityEdges: z.ZodDefault<z.ZodBoolean>;
+            /** Split layer files by domain when node count exceeds this */
+            domainSplitThreshold: z.ZodDefault<z.ZodNumber>;
+            /** Promote to SQLite when total edge count exceeds this */
+            sqlitePromotionThreshold: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabledLayers: ("semantic" | "temporal" | "causal" | "entity")[];
+            inferTemporalEdges: boolean;
+            inferCausalEdges: boolean;
+            inferEntityEdges: boolean;
+            domainSplitThreshold: number;
+            sqlitePromotionThreshold: number;
+        }, {
+            enabledLayers?: ("semantic" | "temporal" | "causal" | "entity")[] | undefined;
+            inferTemporalEdges?: boolean | undefined;
+            inferCausalEdges?: boolean | undefined;
+            inferEntityEdges?: boolean | undefined;
+            domainSplitThreshold?: number | undefined;
+            sqlitePromotionThreshold?: number | undefined;
+        }>>;
+        /** Surfacing config (independent from SkillLibrary) */
+        surfacing: z.ZodDefault<z.ZodObject<{
+            /** Include domain summaries in task context */
+            includeDomainSummaries: z.ZodDefault<z.ZodBoolean>;
+            /** Include entity notes in task context */
+            includeEntityNotes: z.ZodDefault<z.ZodBoolean>;
+            /** Maximum knowledge notes to surface per task */
+            maxNotesPerTask: z.ZodDefault<z.ZodNumber>;
+            /** Maximum tokens for knowledge context */
+            maxTokensForKnowledge: z.ZodDefault<z.ZodNumber>;
+            /** Include evidence citations in surfaced notes */
+            includeEvidence: z.ZodDefault<z.ZodBoolean>;
+            /** Include graph links in surfaced notes */
+            includeLinks: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            includeDomainSummaries: boolean;
+            includeEntityNotes: boolean;
+            maxNotesPerTask: number;
+            maxTokensForKnowledge: number;
+            includeEvidence: boolean;
+            includeLinks: boolean;
+        }, {
+            includeDomainSummaries?: boolean | undefined;
+            includeEntityNotes?: boolean | undefined;
+            maxNotesPerTask?: number | undefined;
+            maxTokensForKnowledge?: number | undefined;
+            includeEvidence?: boolean | undefined;
+            includeLinks?: boolean | undefined;
+        }>>;
+        /** Whether to manage minimem-specific features (sync, versioning) */
+        minimemAware: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        confidence: {
+            extractedInitial: number;
+            agentAuthoredInitial: number;
+            reinforcementAlpha: number;
+            contradictionPenalty: number;
+            dailyDecayRate: number;
+            staleThreshold: number;
+            decayGracePeriodDays: number;
+        };
+        enabled: boolean;
+        graph: {
+            enabledLayers: ("semantic" | "temporal" | "causal" | "entity")[];
+            inferTemporalEdges: boolean;
+            inferCausalEdges: boolean;
+            inferEntityEdges: boolean;
+            domainSplitThreshold: number;
+            sqlitePromotionThreshold: number;
+        };
+        memoryDir: string;
+        extraction: {
+            enabled: boolean;
+            useLlmExtraction: boolean;
+            minAttributionScore: number;
+        };
+        defrag: {
+            minInboxItems: number;
+            autoConsolidate: boolean;
+            consolidationThreshold: number;
+            autoRegenerateSummaries: boolean;
+            llmSummaryGeneration: boolean;
+            autoResolveContradictions: boolean;
+        };
+        surfacing: {
+            includeDomainSummaries: boolean;
+            includeEntityNotes: boolean;
+            maxNotesPerTask: number;
+            maxTokensForKnowledge: number;
+            includeEvidence: boolean;
+            includeLinks: boolean;
+        };
+        minimemAware: boolean;
+    }, {
+        confidence?: {
+            extractedInitial?: number | undefined;
+            agentAuthoredInitial?: number | undefined;
+            reinforcementAlpha?: number | undefined;
+            contradictionPenalty?: number | undefined;
+            dailyDecayRate?: number | undefined;
+            staleThreshold?: number | undefined;
+            decayGracePeriodDays?: number | undefined;
+        } | undefined;
+        enabled?: boolean | undefined;
+        graph?: {
+            enabledLayers?: ("semantic" | "temporal" | "causal" | "entity")[] | undefined;
+            inferTemporalEdges?: boolean | undefined;
+            inferCausalEdges?: boolean | undefined;
+            inferEntityEdges?: boolean | undefined;
+            domainSplitThreshold?: number | undefined;
+            sqlitePromotionThreshold?: number | undefined;
+        } | undefined;
+        memoryDir?: string | undefined;
+        extraction?: {
+            enabled?: boolean | undefined;
+            useLlmExtraction?: boolean | undefined;
+            minAttributionScore?: number | undefined;
+        } | undefined;
+        defrag?: {
+            minInboxItems?: number | undefined;
+            autoConsolidate?: boolean | undefined;
+            consolidationThreshold?: number | undefined;
+            autoRegenerateSummaries?: boolean | undefined;
+            llmSummaryGeneration?: boolean | undefined;
+            autoResolveContradictions?: boolean | undefined;
+        } | undefined;
+        surfacing?: {
+            includeDomainSummaries?: boolean | undefined;
+            includeEntityNotes?: boolean | undefined;
+            maxNotesPerTask?: number | undefined;
+            maxTokensForKnowledge?: number | undefined;
+            includeEvidence?: boolean | undefined;
+            includeLinks?: boolean | undefined;
+        } | undefined;
+        minimemAware?: boolean | undefined;
+    }>>;
+    /** Skill-tree storage configuration */
+    skillTree: z.ZodDefault<z.ZodObject<{
+        /** Enable automatic skill-tree publishing via SqliteStorageAdapter */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Path to the SQLite database for skill storage (relative to storage.baseDir) */
+        dbPath: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        dbPath: string;
+    }, {
+        enabled?: boolean | undefined;
+        dbPath?: string | undefined;
+    }>>;
+    /** Session bank configuration (Entire CLI integration) */
+    sessionBank: z.ZodDefault<z.ZodObject<{
+        /** Enable session bank integration */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Orphan branch name */
+        branch: z.ZodDefault<z.ZodString>;
+        /** State directory (relative to storage.baseDir) */
+        stateDir: z.ZodDefault<z.ZodString>;
+        /** Default outcome strategy for synthesis */
+        outcomeStrategy: z.ZodDefault<z.ZodEnum<["summary", "heuristic"]>>;
+        /** Auto-ingest unprocessed sessions on init */
+        autoIngest: z.ZodDefault<z.ZodBoolean>;
+        /** Maximum sessions per auto-ingest batch */
+        maxIngestBatch: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        branch: string;
+        stateDir: string;
+        outcomeStrategy: "summary" | "heuristic";
+        autoIngest: boolean;
+        maxIngestBatch: number;
+    }, {
+        enabled?: boolean | undefined;
+        branch?: string | undefined;
+        stateDir?: string | undefined;
+        outcomeStrategy?: "summary" | "heuristic" | undefined;
+        autoIngest?: boolean | undefined;
+        maxIngestBatch?: number | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     refinement: {
         maxIterations: number;
@@ -930,8 +1932,8 @@ export declare const AtlasConfigSchema: z.ZodObject<{
     embedding: {
         provider: "openai" | "voyage" | "local" | "none";
         vectorDbPath: string;
-        apiKey?: string | undefined;
         model?: string | undefined;
+        apiKey?: string | undefined;
         modelPath?: string | undefined;
         dimension?: number | undefined;
         baseUrl?: string | undefined;
@@ -942,20 +1944,6 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         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;
@@ -972,6 +1960,20 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             preserveDomainCoverage: boolean;
         };
     };
+    learning: {
+        creditStrategy: "llm" | "simple" | "counterfactual";
+        patternExtractor: "llm" | "both" | "text";
+        minTrajectories: number;
+        deduplicationThreshold: number;
+        maxExperiences: number;
+        minHoursSinceLast?: number | undefined;
+        minSuccessRate?: number | undefined;
+    };
+    router: {
+        similarityThreshold: number;
+        useDomainRouting: boolean;
+        defaultStrategy: string;
+    };
     storage: {
         baseDir: string;
         persistenceEnabled: boolean;
@@ -1000,15 +2002,101 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         };
     };
     mcp: {
+        enabled: boolean;
         minConfidence: number;
         includeRefinements: boolean;
-        enabled: boolean;
         exposeResources: boolean;
         exposeTools: boolean;
         maxResults: number;
         enableDomainFiltering: boolean;
         port?: number | undefined;
     };
+    agenticTasks: {
+        cleanupWorkspaces: boolean;
+        keepFailedWorkspaces: boolean;
+        maxConcurrentAgents: number;
+        staleWorkspaceMaxAgeMs: number;
+        workspaceBaseDir?: string | undefined;
+    };
+    compute: {
+        defaultCostTier: "free" | "low" | "medium" | "high";
+        defaultLocation: "local" | "remote" | "any";
+        allowFallback: boolean;
+    };
+    teamLearning: {
+        enabled: boolean;
+        deduplicationThreshold: number;
+        minTeamTrajectories: number;
+        metricsWeight: number;
+        maxTeamExperiences: number;
+        maxTeamPlaybooks: number;
+        maxRolePlaybooks: number;
+        analysisTimeout: number;
+        extractionTimeout: number;
+        compression: {
+            maxTokensPerAgent: number;
+            preserveInteractionBoundaries: boolean;
+            foldThreshold: number;
+            maxCriticalRatio: number;
+            criticalStepThreshold: number;
+            criticalInteractionThreshold: number;
+        };
+    };
+    knowledgeBank: {
+        confidence: {
+            extractedInitial: number;
+            agentAuthoredInitial: number;
+            reinforcementAlpha: number;
+            contradictionPenalty: number;
+            dailyDecayRate: number;
+            staleThreshold: number;
+            decayGracePeriodDays: number;
+        };
+        enabled: boolean;
+        graph: {
+            enabledLayers: ("semantic" | "temporal" | "causal" | "entity")[];
+            inferTemporalEdges: boolean;
+            inferCausalEdges: boolean;
+            inferEntityEdges: boolean;
+            domainSplitThreshold: number;
+            sqlitePromotionThreshold: number;
+        };
+        memoryDir: string;
+        extraction: {
+            enabled: boolean;
+            useLlmExtraction: boolean;
+            minAttributionScore: number;
+        };
+        defrag: {
+            minInboxItems: number;
+            autoConsolidate: boolean;
+            consolidationThreshold: number;
+            autoRegenerateSummaries: boolean;
+            llmSummaryGeneration: boolean;
+            autoResolveContradictions: boolean;
+        };
+        surfacing: {
+            includeDomainSummaries: boolean;
+            includeEntityNotes: boolean;
+            maxNotesPerTask: number;
+            maxTokensForKnowledge: number;
+            includeEvidence: boolean;
+            includeLinks: boolean;
+        };
+        minimemAware: boolean;
+    };
+    skillTree: {
+        enabled: boolean;
+        dbPath: string;
+    };
+    sessionBank: {
+        enabled: boolean;
+        branch: string;
+        stateDir: string;
+        outcomeStrategy: "summary" | "heuristic";
+        autoIngest: boolean;
+        maxIngestBatch: number;
+    };
 }, {
     refinement?: {
         maxIterations?: number | undefined;
@@ -1019,9 +2107,9 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         triggerOnStrategies?: ("adapt" | "direct" | "explore" | "fallback")[] | undefined;
     } | undefined;
     embedding?: {
+        model?: string | undefined;
         provider?: "openai" | "voyage" | "local" | "none" | undefined;
         apiKey?: string | undefined;
-        model?: string | undefined;
         modelPath?: string | undefined;
         dimension?: number | undefined;
         vectorDbPath?: string | undefined;
@@ -1033,20 +2121,6 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         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;
@@ -1063,6 +2137,20 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             preserveDomainCoverage?: boolean | undefined;
         } | undefined;
     } | undefined;
+    learning?: {
+        creditStrategy?: "llm" | "simple" | "counterfactual" | undefined;
+        patternExtractor?: "llm" | "both" | "text" | 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;
     storage?: {
         baseDir?: string | undefined;
         persistenceEnabled?: boolean | undefined;
@@ -1091,15 +2179,101 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         } | undefined;
     } | undefined;
     mcp?: {
+        enabled?: boolean | 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;
     } | undefined;
+    agenticTasks?: {
+        cleanupWorkspaces?: boolean | undefined;
+        keepFailedWorkspaces?: boolean | undefined;
+        maxConcurrentAgents?: number | undefined;
+        staleWorkspaceMaxAgeMs?: number | undefined;
+        workspaceBaseDir?: string | undefined;
+    } | undefined;
+    compute?: {
+        defaultCostTier?: "free" | "low" | "medium" | "high" | undefined;
+        defaultLocation?: "local" | "remote" | "any" | undefined;
+        allowFallback?: boolean | undefined;
+    } | undefined;
+    teamLearning?: {
+        enabled?: boolean | undefined;
+        deduplicationThreshold?: number | undefined;
+        minTeamTrajectories?: number | undefined;
+        metricsWeight?: number | undefined;
+        maxTeamExperiences?: number | undefined;
+        maxTeamPlaybooks?: number | undefined;
+        maxRolePlaybooks?: number | undefined;
+        analysisTimeout?: number | undefined;
+        extractionTimeout?: number | undefined;
+        compression?: {
+            maxTokensPerAgent?: number | undefined;
+            preserveInteractionBoundaries?: boolean | undefined;
+            foldThreshold?: number | undefined;
+            maxCriticalRatio?: number | undefined;
+            criticalStepThreshold?: number | undefined;
+            criticalInteractionThreshold?: number | undefined;
+        } | undefined;
+    } | undefined;
+    knowledgeBank?: {
+        confidence?: {
+            extractedInitial?: number | undefined;
+            agentAuthoredInitial?: number | undefined;
+            reinforcementAlpha?: number | undefined;
+            contradictionPenalty?: number | undefined;
+            dailyDecayRate?: number | undefined;
+            staleThreshold?: number | undefined;
+            decayGracePeriodDays?: number | undefined;
+        } | undefined;
+        enabled?: boolean | undefined;
+        graph?: {
+            enabledLayers?: ("semantic" | "temporal" | "causal" | "entity")[] | undefined;
+            inferTemporalEdges?: boolean | undefined;
+            inferCausalEdges?: boolean | undefined;
+            inferEntityEdges?: boolean | undefined;
+            domainSplitThreshold?: number | undefined;
+            sqlitePromotionThreshold?: number | undefined;
+        } | undefined;
+        memoryDir?: string | undefined;
+        extraction?: {
+            enabled?: boolean | undefined;
+            useLlmExtraction?: boolean | undefined;
+            minAttributionScore?: number | undefined;
+        } | undefined;
+        defrag?: {
+            minInboxItems?: number | undefined;
+            autoConsolidate?: boolean | undefined;
+            consolidationThreshold?: number | undefined;
+            autoRegenerateSummaries?: boolean | undefined;
+            llmSummaryGeneration?: boolean | undefined;
+            autoResolveContradictions?: boolean | undefined;
+        } | undefined;
+        surfacing?: {
+            includeDomainSummaries?: boolean | undefined;
+            includeEntityNotes?: boolean | undefined;
+            maxNotesPerTask?: number | undefined;
+            maxTokensForKnowledge?: number | undefined;
+            includeEvidence?: boolean | undefined;
+            includeLinks?: boolean | undefined;
+        } | undefined;
+        minimemAware?: boolean | undefined;
+    } | undefined;
+    skillTree?: {
+        enabled?: boolean | undefined;
+        dbPath?: string | undefined;
+    } | undefined;
+    sessionBank?: {
+        enabled?: boolean | undefined;
+        branch?: string | undefined;
+        stateDir?: string | undefined;
+        outcomeStrategy?: "summary" | "heuristic" | undefined;
+        autoIngest?: boolean | undefined;
+        maxIngestBatch?: number | undefined;
+    } | undefined;
 }>;
 export type AtlasConfig = z.infer<typeof AtlasConfigSchema>;
 /**