cognitive-core 0.1.0 → 0.2.0

package/src/factory.ts

@@ -14,18 +14,22 @@
  * const memory = factory.createMemorySystem('./.memory');
  * await memory.init();
  *
- * const pipeline = factory.createLearningPipeline(memory, {
- *   minTrajectories: 5,
- * });
+ * const pipeline = factory.createLearningPipeline(memory);
+ * await pipeline.init();
  * ```
  */
 
-import type { Task, Trajectory, Step, Outcome, LearningConfig } from './types/index.js';
+import type { Task, Trajectory, Step, Outcome } from './types/index.js';
 import { createTask, createTrajectory, createStep, successOutcome, failureOutcome } from './types/index.js';
 import type { MemorySystem } from './memory/system.js';
 import { createMemorySystem } from './memory/system.js';
-import type { ProcessResult, BatchResult } from './learning/pipeline.js';
-import { createLearningPipeline } from './learning/pipeline.js';
+import { createSqlitePersistence } from './persistence/index.js';
+import type {
+  ImmediateResult,
+  UnifiedBatchResult,
+  UnifiedPipelineConfig,
+} from './learning/unified-pipeline.js';
+import { createUnifiedPipeline } from './learning/unified-pipeline.js';
 
 /**
  * Parameters for creating a Task
@@ -71,10 +75,10 @@ export interface OutcomeParams {
 }
 
 /**
- * Learning pipeline configuration
+ * Learning pipeline configuration (subset exposed to external consumers)
  */
 export interface LearningPipelineConfig {
-  creditStrategy?: 'simple' | 'contribution';
+  creditStrategy?: 'simple' | 'llm' | 'counterfactual';
   minTrajectories?: number;
   deduplicationThreshold?: number;
   minSuccessRate?: number;
@@ -84,11 +88,10 @@ export interface LearningPipelineConfig {
  * Interface for the LearningPipeline that external consumers need
  */
 export interface ILearningPipeline {
-  processTrajectory(trajectory: Trajectory): Promise<ProcessResult>;
-  shouldRunBatch(): boolean;
-  runBatchLearning(): Promise<BatchResult>;
+  init(): Promise<void>;
+  processTrajectory(trajectory: Trajectory): Promise<ImmediateResult>;
+  runBatch(): Promise<UnifiedBatchResult>;
   getAccumulatedCount(): number;
-  clearAccumulated(): void;
 }
 
 /**
@@ -159,16 +162,29 @@ export interface CognitiveCoreFactory {
  */
 class CognitiveCoreFactoryImpl implements CognitiveCoreFactory {
   createMemorySystem(storagePath: string): IMemorySystem {
-    return createMemorySystem(storagePath) as IMemorySystem;
+    const persistence = createSqlitePersistence({ baseDir: storagePath });
+    return createMemorySystem(persistence, storagePath) as IMemorySystem;
   }
 
   createLearningPipeline(
     memory: IMemorySystem,
     config?: LearningPipelineConfig
   ): ILearningPipeline {
-    return createLearningPipeline(
+    const pipelineConfig: Partial<UnifiedPipelineConfig> = config ? {
+      batch: {
+        learning: {
+          creditStrategy: config.creditStrategy,
+          minTrajectories: config.minTrajectories,
+          deduplicationThreshold: config.deduplicationThreshold,
+          minSuccessRate: config.minSuccessRate,
+        },
+        energy: {},
+      },
+    } : {};
+
+    return createUnifiedPipeline(
       memory as MemorySystem,
-      config as Partial<LearningConfig>
+      pipelineConfig,
     ) as ILearningPipeline;
   }
 
@@ -212,6 +228,7 @@ class CognitiveCoreFactoryImpl implements CognitiveCoreFactory {
  *   minTrajectories: 10,
  *   deduplicationThreshold: 0.85,
  * });
+ * await pipeline.init();
  *
  * // Create and process trajectory
  * const task = factory.createTask({
@@ -254,7 +271,7 @@ export const cognitiveCoreFactory = createCognitiveCoreFactory();
  */
 export {
   createMemorySystem,
-  createLearningPipeline,
+  createUnifiedPipeline as createLearningPipeline,
   createTask,
   createTrajectory,
   createStep,

package/src/index.ts

@@ -37,6 +37,7 @@ export {
   createAtlasWithAgents,
   type AtlasStats,
   type SolveResult,
+  type TeamProcessResult,
 } from './atlas.js';
 
 // Types
@@ -56,16 +57,54 @@ export {
   // Meta-learning memory
   MetaMemory,
   createMetaMemory,
+  // Team experience memory
+  TeamExperienceMemory,
+  createTeamExperienceMemory,
+  type TeamExperience,
+  type TeamAnalysisResult,
+  // Reflexion episodes
+  ReflexionMemory,
+  createReflexionMemory,
+  // Coherence checking
+  CoherenceChecker,
+  createCoherenceChecker,
+  type CoherenceResult,
+  type CoherenceCheckerConfig,
+  // Reasoning bank (clustered experience retrieval)
+  ReasoningBank,
+  createReasoningBank,
+  type ExperienceCluster,
+  type ClusterStats,
+  type ReasoningBankConfig,
+  // Causal edge store
+  CausalStore,
+  createCausalStore,
+  type CausalEdge,
+  // Temporal compression
+  TemporalCompressor,
+  createTemporalCompressor,
+  type TemporalCompressorConfig,
+  type CompressionResult,
+  // Knowledge bank (semantic memory)
+  KnowledgeBank,
+  KnowledgeGraphManager,
+  KnowledgeDefragmenter,
+  SemanticGraphLayer,
+  TemporalGraphLayer,
+  CausalGraphLayer,
+  EntityGraphLayer,
+  // Search providers (strategy pattern for knowledge search)
+  type SearchProvider,
+  type SearchProviderResult,
+  TextSimilaritySearchProvider,
+  MinimemSearchProvider,
+  type MinimemSearchClient,
 } from './memory/index.js';
 
 // Learning engine
 export {
-  LearningPipeline,
-  createLearningPipeline,
   TrajectoryAnalyzer,
   createAnalyzer,
-  type ProcessResult,
-  type BatchResult,
   type AnalysisResult,
   // Playbook-based learning
   PlaybookExtractor,
@@ -82,13 +121,108 @@ export {
   createUsageInference,
   type PlaybookUsageResult,
   type UsageInferenceConfig,
-  // LLM-based extraction
-  LLMPlaybookExtractor,
-  createLLMExtractor,
-  type LLMExtractorConfig,
-  type LLMExtractionResult,
+  // Team-aware learning
+  TeamTrajectoryIngester,
+  createTeamTrajectoryIngester,
+  TeamLearningPipeline,
+  createTeamLearningPipeline,
+  type IngestionResult,
+  type TeamLearningProcessResult,
+  type TeamBatchResult,
+  // Team meta-learning
+  TeamMetaLearner,
+  createTeamMetaLearner,
+  type TeamMetaLearnerConfig,
+  // Knowledge extraction
+  KnowledgeExtractor,
+  createKnowledgeExtractor,
+  type KnowledgeExtractorConfig,
+  type ExtractionContext,
+  // Trajectory sources
+  InMemoryTrajectorySource,
+  FileTrajectorySource,
+  PipelineTrajectorySource,
+  SessionTrajectorySource,
+  type SessionSynthesisOptions,
+  DataclawTrajectorySource,
+  type DataclawSourceOptions,
+  // Instant (hot-path) learning
+  InstantLoop,
+  createInstantLoop,
+  type InstantLoopResult,
+  type InstantLoopConfig,
+  // Reflexion generation
+  ReflexionGenerator,
+  createReflexionGenerator,
+  type ReflexionGeneratorConfig,
+  // Effectiveness tracking
+  LearningEffectivenessTracker,
+  createEffectivenessTracker,
+  type TaskAnnotation,
+  type EffectivenessMetrics,
+  type PlaybookEffectivenessEntry,
+  // Unified learning pipeline (three-speed: immediate + batch + maintenance)
+  UnifiedLearningPipeline,
+  createUnifiedPipeline,
+  type UnifiedPipelineConfig,
+  type UnifiedPipelineFeatures,
+  type ImmediateResult,
+  type UnifiedBatchResult,
+  type UnifiedPipelineStats,
+  // Energy evaluator
+  EnergyEvaluator,
+  createEnergyEvaluator,
+  type EnergyEvaluatorConfig,
+  type EnergyEvaluation,
+  type EnergySignal,
+  type EscalationReason,
+  type LaneTransition,
+  // Maintenance scheduler
+  MaintenanceScheduler,
+  createMaintenanceScheduler,
+  type MaintenanceSchedulerConfig,
+  type MaintenanceMode,
+  type MaintenanceCycleResult,
+  type MaintenanceTask,
+  type MaintenanceTaskResult,
+  // Healing orchestrator
+  HealingOrchestrator,
+  createHealingOrchestrator,
+  PlaybookDriftDetector,
+  MemoryBloatDetector,
+  MetricDriftDetector,
+  type HealingCycleResult,
+  type HealthContext,
+  type AnomalyDetector,
+  type RepairStrategy,
+  type Anomaly,
+  type RepairResult,
 } from './learning/index.js';
 
+// Session bank (SessionLog checkpoint reader, with Entire CLI fallback)
+export {
+  SessionBank,
+  CheckpointGitReader,
+  CheckpointParser,
+  detectFormat,
+  type CheckpointFormat,
+  type SessionRecord,
+  type SessionMetadata,
+  type TranscriptMessage,
+  type ContentBlock as SessionContentBlock,
+  type TextBlock as SessionTextBlock,
+  type ToolUseBlock as SessionToolUseBlock,
+  type ToolResultBlock as SessionToolResultBlock,
+  type SessionSummary,
+  type TokenUsage as SessionTokenUsage,
+  type Attribution as SessionAttribution,
+  type SessionSource,
+  type CheckpointRef,
+  type SessionQuery,
+  type SessionQueryResult,
+  type SessionBankOptions,
+} from './session-bank/index.js';
+
 // Search/solving
 export {
   TaskRouter,
@@ -97,6 +231,13 @@ export {
   createSolver,
   type RoutingDecision,
   type SolverResult,
+  // MoE-inspired routing gate
+  MoEGate,
+  createMoEGate,
+  extractTaskFeatures,
+  MOE_FEATURE_SIZE,
+  MOE_STRATEGIES,
+  type MoEGateState,
   // Refinement
   SolutionEvaluator,
   createSolutionEvaluator,
@@ -115,6 +256,12 @@ export {
   type VerificationFunction,
   type VerificationResult,
   type RefinementLoopConfig,
+  // Team routing
+  TeamRouter,
+  createTeamRouter,
+  type TeamRouterConfig,
+  type TeamRecommendation,
+  type TeamRecommendationInput,
   // Verification runner
   VerificationRunner,
   createVerificationRunner,
@@ -143,6 +290,9 @@ export {
   JsonStore,
   saveJson,
   loadJson,
+  // Domain-partitioned storage
+  PartitionedStore,
+  type PartitionedStoreOptions,
 } from './utils/index.js';
 
 // Embeddings - Vector search and similarity
@@ -162,6 +312,8 @@ export {
   SqliteVectorStore,
   createVectorStore,
   type VectorSearchResult,
+  // Inverted index (candidate narrowing)
+  InvertedIndex,
   // Embedding manager
   EmbeddingManager,
   createEmbeddingManager,
@@ -182,8 +334,10 @@ export {
   claudeCodeConfig,
   MockBackend,
   createMockBackend,
+  LocalACPBackend,
   ACPBackend,
   createACPBackend,
+  ACPProtocolHandler,
   claudeCodeACPConfig,
   claudeCodeDirectConfig,
   // Flows
@@ -205,11 +359,20 @@ export {
   type SubprocessAgentConfig,
   type MockAgentBehavior,
   type ACPAgentConfig,
+  type ACPSessionBase,
   type LearningFlowConfig,
   type LearningFlowResult,
   type ValidationFlowConfig,
   type ValidationFlowResult,
   type ValidationMetrics,
+  // Compute Provider
+  DefaultComputeProvider,
+  createComputeProvider,
+  type ComputeProvider,
+  type ComputeRequirements,
+  type ComputeTarget,
+  type ComputeSource,
+  type CostTier,
 } from './runtime/index.js';
 
 // Surfacing - Skill library for agent consumption
@@ -218,6 +381,22 @@ export {
   createSkillLibrary,
   type AgentSkills,
   type TierRefreshResult,
+  // Team skill library
+  TeamSkillLibrary,
+  createTeamSkillLibrary,
+  type TeamSkillLibraryConfig,
+  type RankedTeamPlaybook,
+  type RankedRolePlaybook,
+  type TeamOutcomeFeedback,
+  type RoleOutcomeFeedback,
+  type TeamAgentSkills,
+  // Skill publishing to skill-tree storage
+  SkillPublisher,
+  convertPlaybookToSkill,
+  type PublishResult,
+  type DeprecateResult,
+  // SQLite storage adapter for skill-tree persistence
+  SqliteStorageAdapter,
 } from './surfacing/index.js';
 
 // MCP Server - On-demand playbook access
@@ -231,6 +410,49 @@ export {
   type PlaybookSearchResult,
 } from './mcp/index.js';
 
+// Workspace - Agentic analysis workspace infrastructure
+// WorkspaceManager and WorkspaceHandle provided by agent-workspace package
+export {
+  // Manager (from agent-workspace)
+  WorkspaceManager,
+  WorkspaceHandle,
+  // Runner
+  AgenticTaskRunner,
+  createAgenticTaskRunner,
+  // Skill converter
+  convertPlaybooksToSkills,
+  generateSkillMd,
+  parseSkillMdToPlaybook,
+  // Types
+  type OutputSpec,
+  type OutputFileSpec,
+  type ValidationResult,
+  type AgentSkillSpec,
+  type ResourceSpec,
+  type AnalysisComplexity,
+  type ProcessingContext,
+  type AgenticTaskTemplate,
+  type AgenticTaskResult,
+  type AgenticTaskMetrics,
+  AgenticTaskOutputError,
+} from './workspace/index.js';
+
+// Persistence - Unified SQLite database for system-internal state
+export {
+  SqlitePersistence,
+  createSqlitePersistence,
+  type SqlitePersistenceConfig,
+  type ExperienceRow,
+  type PlaybookRow,
+  type ReflexionRow,
+  type CausalEdgeRow,
+  type MetaObservationRow,
+  type MetaStrategyRow,
+  JsonToSqliteMigrator,
+  runMigration,
+  type MigrationResult,
+} from './persistence/index.js';
+
 // Factory - Unified interface for external integration (e.g., skill-tree)
 export {
   createCognitiveCoreFactory,

package/src/learning/analyzer.ts

@@ -1,4 +1,6 @@
 import type { Trajectory, CreditStrategy } from '../types/index.js';
+import { classifyError } from '../utils/error-classifier.js';
+import { detectRepeatedActions } from '../utils/trajectory-helpers.js';
 
 /**
  * Analysis result from trajectory examination
@@ -189,48 +191,30 @@ export class TrajectoryAnalyzer {
     const patterns: ErrorPattern[] = [];
 
     if (!trajectory.outcome.success && trajectory.outcome.errorInfo) {
-      // Extract error type from error info
-      const errorInfo = trajectory.outcome.errorInfo;
-
-      // Common error patterns
-      const errorTypes: Array<[RegExp, string, string]> = [
-        [/timeout/i, 'timeout', 'Operation timed out'],
-        [/not found/i, 'not_found', 'Resource not found'],
-        [/permission denied/i, 'permission', 'Permission denied'],
-        [/syntax error/i, 'syntax', 'Syntax error in code'],
-        [/type error/i, 'type', 'Type mismatch error'],
-        [/assertion|assert/i, 'assertion', 'Assertion failed'],
-        [/exception|error/i, 'general', 'General error'],
-      ];
-
-      for (const [pattern, type, desc] of errorTypes) {
-        if (pattern.test(errorInfo)) {
-          patterns.push({
-            type,
-            signature: errorInfo.slice(0, 100),
-            description: desc,
-          });
-          break;
-        }
+      const classification = classifyError(trajectory.outcome.errorInfo);
+      if (classification) {
+        patterns.push({
+          type: classification.type,
+          signature: trajectory.outcome.errorInfo.slice(0, 100),
+          description: classification.description,
+        });
       }
     }
 
     // Check for repeated failed actions
-    const actionCounts = new Map<string, number>();
-    for (const step of trajectory.steps) {
-      const count = (actionCounts.get(step.action) ?? 0) + 1;
-      actionCounts.set(step.action, count);
-    }
+    const repeated = detectRepeatedActions(
+      trajectory.steps,
+      this.config.actionRepetitionThreshold,
+      (a) => a, // Use raw action strings for analyzer (preserves full action for signature)
+    );
 
-    for (const [action, count] of actionCounts) {
-      if (count >= this.config.actionRepetitionThreshold) {
-        patterns.push({
-          type: 'repetition',
-          signature: action,
-          description: `Action repeated ${count} times`,
-          suggestedFix: 'Try a different approach',
-        });
-      }
+    for (const { action, count } of repeated) {
+      patterns.push({
+        type: 'repetition',
+        signature: action,
+        description: `Action repeated ${count} times`,
+        suggestedFix: 'Try a different approach',
+      });
     }
 
     return patterns;