cognitive-core 0.2.5 → 0.3.1

package/src/learning/instant-loop.ts

@@ -1,357 +0,0 @@
-/**
- * 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);
-}