cognitive-core 0.1.0 → 0.2.0

package/src/learning/index.ts

@@ -11,13 +11,6 @@ export {
   type AnalyzerConfig,
 } from './analyzer.js';
 
-export {
-  LearningPipeline,
-  createLearningPipeline,
-  type ProcessResult,
-  type BatchResult,
-} from './pipeline.js';
-
 // Playbook-based learning
 export {
   PlaybookExtractor,
@@ -40,13 +33,63 @@ export {
   type UsageInferenceConfig,
 } from './usage-inference.js';
 
-// LLM-based extraction
+// Team-aware learning
+export {
+  TeamTrajectoryIngester,
+  createTeamTrajectoryIngester,
+  type CompressionConfig,
+  type CriticalStep,
+  type CriticalInteraction,
+  type StructuralMetrics,
+  type IngestionResult,
+} from './team-ingester.js';
+
+export {
+  TeamLearningPipeline,
+  createTeamLearningPipeline,
+  type TeamProcessResult as TeamLearningProcessResult,
+  type TeamBatchResult,
+} from './team-pipeline.js';
+
+export {
+  TeamMetaLearner,
+  createTeamMetaLearner,
+  type TeamMetaLearnerConfig,
+} from './team-meta-learner.js';
+
+// Knowledge extraction
+export {
+  KnowledgeExtractor,
+  createKnowledgeExtractor,
+  type KnowledgeExtractorConfig,
+  type ExtractionContext,
+} from './knowledge-extractor.js';
+
+// Trajectory sources
+export {
+  InMemoryTrajectorySource,
+  FileTrajectorySource,
+  PipelineTrajectorySource,
+  SessionTrajectorySource,
+  type SessionSynthesisOptions,
+  DataclawTrajectorySource,
+  type DataclawSourceOptions,
+} from './trajectory-sources/index.js';
+
+// Instant (hot-path) learning
+export {
+  InstantLoop,
+  createInstantLoop,
+  type InstantLoopResult,
+  type InstantLoopConfig,
+} from './instant-loop.js';
+
+// Reflexion generation
 export {
-  LLMPlaybookExtractor,
-  createLLMExtractor,
-  type LLMExtractorConfig,
-  type LLMExtractionResult,
-} from './llm-extractor.js';
+  ReflexionGenerator,
+  createReflexionGenerator,
+  type ReflexionGeneratorConfig,
+} from './reflexion-generator.js';
 
 // Effectiveness tracking
 export {
@@ -56,3 +99,51 @@ export {
   type EffectivenessMetrics,
   type PlaybookEffectivenessEntry,
 } from './effectiveness.js';
+
+// Unified learning pipeline (three-speed: immediate + batch + maintenance)
+export {
+  UnifiedLearningPipeline,
+  createUnifiedPipeline,
+  type UnifiedPipelineConfig,
+  type UnifiedPipelineFeatures,
+  type ImmediateResult,
+  type UnifiedBatchResult,
+  type UnifiedPipelineStats,
+  type EnergyEvaluation,
+  type EnergySignal,
+  type EscalationReason,
+  type MaintenanceCycleResult,
+  type MaintenanceTask,
+  type HealingCycleResult,
+  type HealthContext,
+  type AnomalyDetector,
+  type RepairStrategy,
+} from './unified-pipeline.js';
+
+// Energy evaluator (ruvector-inspired batch trigger)
+export {
+  EnergyEvaluator,
+  createEnergyEvaluator,
+  type EnergyEvaluatorConfig,
+  type LaneTransition,
+} from './energy-evaluator.js';
+
+// Maintenance scheduler (circadian-style duty-gated)
+export {
+  MaintenanceScheduler,
+  createMaintenanceScheduler,
+  type MaintenanceSchedulerConfig,
+  type MaintenanceMode,
+  type MaintenanceTaskResult,
+} from './maintenance-scheduler.js';
+
+// Healing orchestrator (plug-in detector/repair)
+export {
+  HealingOrchestrator,
+  createHealingOrchestrator,
+  PlaybookDriftDetector,
+  MemoryBloatDetector,
+  MetricDriftDetector,
+  type Anomaly,
+  type RepairResult,
+} from './healing-orchestrator.js';

package/src/learning/instant-loop.ts

@@ -0,0 +1,357 @@
+/**
+ * InstantLoop — Hot-path, per-trajectory learning
+ *
+ * Runs synchronously after every trajectory completion (<200ms budget).
+ * No LLM calls. No batch thresholds. Pure in-memory updates:
+ *
+ *   1. Store experience via MemorySystem.storeTrajectory()
+ *   2. Bump matched playbooks (recordSuccess / recordFailure)
+ *   3. Extract lightweight knowledge notes (heuristic only)
+ *   4. Access scores are bumped automatically by the memory layer
+ */
+
+import type { Trajectory } from '../types/index.js';
+import { createObservation } from '../types/knowledge.js';
+import type { MemorySystem } from '../memory/system.js';
+import type { PlaybookMatch } from '../memory/playbook.js';
+import type { CausalEdge } from '../memory/causal-store.js';
+import { ReflexionGenerator, type ReflexionGeneratorConfig } from './reflexion-generator.js';
+
+/**
+ * Result of a single instant-loop pass
+ */
+export interface InstantLoopResult {
+  /** ID of the stored experience */
+  experienceId: string;
+  /** Playbooks whose confidence was updated */
+  matchedPlaybooks: Array<{ id: string; confidenceDelta: number }>;
+  /** Number of knowledge notes extracted (0 if knowledge bank disabled) */
+  knowledgeNotesExtracted: number;
+  /** Number of causal edges extracted */
+  causalEdgesExtracted: number;
+  /** ID of the generated reflexion episode (if reflexion is enabled) */
+  reflexionEpisodeId?: string;
+  /** Wall-clock duration of the instant loop in ms */
+  durationMs: number;
+}
+
+/**
+ * InstantLoop configuration
+ */
+export interface InstantLoopConfig {
+  /** Max knowledge notes to extract per trajectory (default: 3) */
+  maxInstantKnowledgeNotes?: number;
+  /** Max playbooks to match per trajectory (default: 3) */
+  maxPlaybookMatches?: number;
+  /** Enable reflexion episode generation (default: true) */
+  enableReflexion?: boolean;
+  /** Enable causal edge extraction (default: true) */
+  enableCausalExtraction?: boolean;
+  /** Configuration for the reflexion generator */
+  reflexionConfig?: ReflexionGeneratorConfig;
+}
+
+/**
+ * InstantLoop — lightweight, per-trajectory learning
+ */
+export class InstantLoop {
+  private memory: MemorySystem;
+  private config: Required<Pick<InstantLoopConfig, 'maxInstantKnowledgeNotes' | 'maxPlaybookMatches' | 'enableReflexion' | 'enableCausalExtraction'>>;
+  private reflexionGenerator: ReflexionGenerator;
+
+  constructor(memory: MemorySystem, config?: InstantLoopConfig) {
+    this.memory = memory;
+    this.config = {
+      maxInstantKnowledgeNotes: config?.maxInstantKnowledgeNotes ?? 3,
+      maxPlaybookMatches: config?.maxPlaybookMatches ?? 3,
+      enableReflexion: config?.enableReflexion ?? true,
+      enableCausalExtraction: config?.enableCausalExtraction ?? true,
+    };
+    this.reflexionGenerator = new ReflexionGenerator(config?.reflexionConfig);
+  }
+
+  /**
+   * Process a single trajectory immediately after completion.
+   * Target: <200ms for typical trajectories.
+   */
+  async process(trajectory: Trajectory): Promise<InstantLoopResult> {
+    const start = Date.now();
+
+    // 1. Store experience
+    const experience = await this.memory.storeTrajectory(trajectory);
+
+    // 2. Find matching playbooks and bump confidence
+    const matchResult = await this.bumpPlaybooks(trajectory);
+
+    // 3. Extract lightweight knowledge (heuristic, no LLM)
+    const knowledgeNotesExtracted = await this.extractKnowledge(trajectory);
+
+    // 4. Extract lightweight causal edges (if enabled)
+    const causalEdgesExtracted = this.config.enableCausalExtraction
+      ? await this.extractCausalEdges(trajectory)
+      : 0;
+
+    // 5. Generate and store reflexion episode
+    let reflexionEpisodeId: string | undefined;
+    if (this.config.enableReflexion) {
+      try {
+        const episode = await this.reflexionGenerator.generate(
+          trajectory,
+          matchResult.playbookMatches
+        );
+        await this.memory.reflexion.add(episode);
+        reflexionEpisodeId = episode.id;
+      } catch {
+        // Non-critical — don't fail the instant loop for reflexion errors
+      }
+    }
+
+    return {
+      experienceId: experience.id,
+      matchedPlaybooks: matchResult.deltas,
+      knowledgeNotesExtracted,
+      causalEdgesExtracted,
+      reflexionEpisodeId,
+      durationMs: Date.now() - start,
+    };
+  }
+
+  /**
+   * Find matching playbooks and update their confidence based on trajectory outcome.
+   * Returns both confidence deltas and the original PlaybookMatch objects for reflexion.
+   */
+  private async bumpPlaybooks(
+    trajectory: Trajectory
+  ): Promise<{
+    deltas: Array<{ id: string; confidenceDelta: number }>;
+    playbookMatches: PlaybookMatch[];
+  }> {
+    const deltas: Array<{ id: string; confidenceDelta: number }> = [];
+
+    // Find playbooks matching this trajectory's task description
+    let matches: PlaybookMatch[];
+    try {
+      matches = await this.memory.playbooks.findMatching(
+        trajectory.task.description,
+        {
+          k: this.config.maxPlaybookMatches,
+          domains: trajectory.task.domain ? [trajectory.task.domain] : undefined,
+          minScore: 0.3,
+        }
+      );
+    } catch {
+      return { deltas, playbookMatches: [] };
+    }
+
+    for (const match of matches) {
+      const before = match.playbook.confidence;
+
+      if (trajectory.outcome.success) {
+        await this.memory.playbooks.recordSuccess(
+          match.playbook.id,
+          trajectory.id,
+          trajectory.task.domain,
+        );
+      } else {
+        await this.memory.playbooks.recordFailure(
+          match.playbook.id,
+          trajectory.id,
+          trajectory.task.domain ?? 'unknown',
+          trajectory.outcome.errorInfo ?? 'Unknown failure',
+        );
+      }
+
+      // Read back the updated confidence
+      const updated = await this.memory.playbooks.get(match.playbook.id);
+      const after = updated?.confidence ?? before;
+
+      deltas.push({
+        id: match.playbook.id,
+        confidenceDelta: after - before,
+      });
+    }
+
+    return { deltas, playbookMatches: matches };
+  }
+
+  /**
+   * Extract lightweight knowledge from a trajectory (heuristic, no LLM).
+   *
+   * Parses error messages, tool names, and file paths from trajectory steps
+   * and stores them as KnowledgeNote observations.
+   */
+  private async extractKnowledge(trajectory: Trajectory): Promise<number> {
+    const kb = this.memory.knowledgeBank;
+    if (!kb) return 0;
+
+    const notes: Array<{ subject: string; content: string }> = [];
+
+    // Extract error patterns from failed steps
+    if (!trajectory.outcome.success && trajectory.outcome.errorInfo) {
+      notes.push({
+        subject: `error:${trajectory.task.domain ?? 'general'}`,
+        content: `Error encountered: ${trajectory.outcome.errorInfo.slice(0, 300)}`,
+      });
+    }
+
+    // Extract tool usage patterns from steps
+    const toolNames = new Set<string>();
+    const filePaths = new Set<string>();
+
+    for (const step of trajectory.steps) {
+      // Extract tool names from action strings
+      const toolMatch = step.action?.match(/^(\w+(?:[A-Z]\w*)*)\s/);
+      if (toolMatch) {
+        toolNames.add(toolMatch[1]);
+      }
+
+      // Extract file paths from observations
+      const pathMatches = step.observation?.match(
+        /(?:\/[\w.-]+)+(?:\.[\w]+)/g
+      );
+      if (pathMatches) {
+        for (const p of pathMatches.slice(0, 5)) {
+          filePaths.add(p);
+        }
+      }
+    }
+
+    // Create a tool-usage note if tools were used
+    if (toolNames.size > 0 && trajectory.outcome.success) {
+      notes.push({
+        subject: `tools:${trajectory.task.domain ?? 'general'}`,
+        content: `Successful approach used tools: ${[...toolNames].join(', ')}`,
+      });
+    }
+
+    // Create a file-paths note for context
+    if (filePaths.size > 0) {
+      notes.push({
+        subject: `files:${trajectory.task.domain ?? 'general'}`,
+        content: `Files involved: ${[...filePaths].slice(0, 10).join(', ')}`,
+      });
+    }
+
+    // Store up to maxInstantKnowledgeNotes
+    const domain = trajectory.task.domain ?? 'general';
+    let stored = 0;
+    for (const note of notes.slice(0, this.config.maxInstantKnowledgeNotes)) {
+      try {
+        const observation = createObservation({
+          title: note.subject,
+          body: note.content,
+          domain: [domain],
+          entities: [note.subject],
+          confidence: trajectory.outcome.success ? 0.7 : 0.4,
+          source: {
+            origin: 'extracted',
+            trajectories: [trajectory.id],
+          },
+        });
+        await kb.addObservation(observation);
+        stored++;
+      } catch {
+        // Non-critical — don't fail the instant loop for knowledge extraction errors
+      }
+    }
+
+    return stored;
+  }
+
+  /**
+   * Extract lightweight causal edges from a trajectory.
+   *
+   * From failed trajectories: error message → root cause (if identifiable)
+   * From successful trajectories: approach → outcome patterns
+   */
+  private async extractCausalEdges(trajectory: Trajectory): Promise<number> {
+    const causalStore = this.memory.causal;
+    let extracted = 0;
+    const domain = trajectory.task.domain ?? 'general';
+    const now = new Date();
+
+    try {
+      if (!trajectory.outcome.success && trajectory.outcome.errorInfo) {
+        // Failed trajectory: extract error → root cause pattern
+        const errorInfo = trajectory.outcome.errorInfo.slice(0, 300);
+        const taskDesc = trajectory.task.description.slice(0, 200);
+
+        const edge: CausalEdge = {
+          id: `ce-fail-${trajectory.id}`,
+          cause: `Task: ${taskDesc}`,
+          effect: `Error: ${errorInfo}`,
+          confidence: 0.4,
+          domain,
+          sourceTrajectoryIds: [trajectory.id],
+          observedCount: 1,
+          createdAt: now,
+          updatedAt: now,
+        };
+        await causalStore.add(edge);
+        extracted++;
+      }
+
+      if (trajectory.outcome.success) {
+        // Successful trajectory: approach → outcome
+        const taskDesc = trajectory.task.description.slice(0, 200);
+        const solutionSummary = trajectory.outcome.solution !== undefined
+          ? String(trajectory.outcome.solution).slice(0, 200)
+          : 'Task completed successfully';
+
+        const edge: CausalEdge = {
+          id: `ce-succ-${trajectory.id}`,
+          cause: `Approach: ${taskDesc}`,
+          effect: `Outcome: ${solutionSummary}`,
+          confidence: 0.7,
+          domain,
+          sourceTrajectoryIds: [trajectory.id],
+          observedCount: 1,
+          createdAt: now,
+          updatedAt: now,
+        };
+        await causalStore.add(edge);
+        extracted++;
+
+        // Extract tool → outcome edges from steps with high attribution
+        for (const step of trajectory.steps) {
+          if (
+            step.attributionScore !== undefined &&
+            step.attributionScore > 0.7 &&
+            step.action
+          ) {
+            const toolMatch = step.action.match(/^(\w+(?:[A-Z]\w*)*)\s/);
+            if (toolMatch) {
+              const toolEdge: CausalEdge = {
+                id: `ce-tool-${trajectory.id}-${toolMatch[1]}`,
+                cause: `Used tool ${toolMatch[1]} for ${domain} task`,
+                effect: `Contributed to successful outcome (attribution: ${step.attributionScore.toFixed(2)})`,
+                confidence: 0.5,
+                domain,
+                sourceTrajectoryIds: [trajectory.id],
+                observedCount: 1,
+                createdAt: now,
+                updatedAt: now,
+              };
+              await causalStore.add(toolEdge);
+              extracted++;
+            }
+          }
+        }
+      }
+    } catch {
+      // Non-critical — don't fail the instant loop for causal extraction errors
+    }
+
+    return extracted;
+  }
+}
+
+/**
+ * Create an InstantLoop
+ */
+export function createInstantLoop(
+  memory: MemorySystem,
+  config?: InstantLoopConfig
+): InstantLoop {
+  return new InstantLoop(memory, config);
+}