@symerian/symi 3.0.18 → 3.0.19

package/extensions/learning-loop/src/hooks.ts

@@ -1,244 +0,0 @@
-/**
- * Hook registration for the learning loop plugin.
- *
- * | Priority | Hook                | Role                                    |
- * |----------|---------------------|-----------------------------------------|
- * | 200      | before_prompt_build | Inject learnings (runs first)           |
- * | 100      | llm_input           | Capture run start metadata              |
- * | 100      | llm_output          | Capture usage + response data           |
- * | 100      | after_tool_call     | Capture tool call traces                |
- * | 100      | subagent_ended      | Capture subagent outcomes               |
- * | 50       | agent_end           | Score run, extract learnings, persist    |
- * | 50       | message_received    | Detect implicit feedback                |
- */
-
-import { hashText } from "../../../src/memory/internal.js";
-import type { SymiPluginApi, PluginLogger } from "../../../src/plugins/types.js";
-import type { MetricsAggregator } from "./analytics/metrics-aggregator.js";
-import type { RunTracker } from "./capture/run-tracker.js";
-import { normalizeCompletedRun, reconstructCompletedRun } from "./capture/serializer.js";
-import type { DatabaseManager } from "./db.js";
-import type { ImplicitSignals } from "./feedback/implicit-signals.js";
-import type { EdgeInference } from "./graph/edge-inference.js";
-import type { ContextInjector } from "./injection/context-injector.js";
-import type { LearningExtractor } from "./learning/learning-extractor.js";
-import type { LearningStore } from "./learning/learning-store.js";
-import type { QualityEngine } from "./scoring/quality-engine.js";
-import type { LearningLoopConfig } from "./types.js";
-
-export function registerHooks(
-  api: SymiPluginApi,
-  deps: {
-    config: LearningLoopConfig;
-    logger: PluginLogger;
-    db: DatabaseManager;
-    tracker: RunTracker;
-    qualityEngine: QualityEngine;
-    learningStore: LearningStore;
-    extractor: LearningExtractor;
-    injector: ContextInjector;
-    metrics: MetricsAggregator;
-    implicit: ImplicitSignals;
-    edgeInference?: EdgeInference;
-  },
-) {
-  const {
-    config,
-    logger,
-    db,
-    tracker,
-    qualityEngine,
-    learningStore,
-    extractor,
-    injector,
-    metrics,
-    implicit,
-    edgeInference,
-  } = deps;
-
-  // -----------------------------------------------------------------------
-  // before_prompt_build (priority 200) -- Inject learnings
-  // -----------------------------------------------------------------------
-  api.on(
-    "before_prompt_build",
-    async (event, ctx) => {
-      try {
-        const context = await injector.getContext(event.prompt);
-        if (context) {
-          return { prependContext: context };
-        }
-      } catch (err) {
-        logger.warn(`[learning-loop] before_prompt_build failed: ${String(err)}`);
-      }
-      return undefined;
-    },
-    { priority: 200 },
-  );
-
-  // -----------------------------------------------------------------------
-  // llm_input (priority 100) -- Capture run start metadata
-  // -----------------------------------------------------------------------
-  api.on(
-    "llm_input",
-    (event, ctx) => {
-      try {
-        tracker.onLlmInput({
-          runId: event.runId,
-          sessionId: event.sessionId,
-          provider: event.provider,
-          model: event.model,
-          prompt: event.prompt,
-          sessionKey: ctx.sessionKey,
-          agentId: ctx.agentId,
-        });
-
-        // Record prompt for implicit feedback analysis
-        implicit.recordPrompt(event.runId, event.prompt);
-      } catch (err) {
-        logger.warn(`[learning-loop] llm_input handler failed: ${String(err)}`);
-      }
-    },
-    { priority: 100 },
-  );
-
-  // -----------------------------------------------------------------------
-  // llm_output (priority 100) -- Capture usage + response data
-  // -----------------------------------------------------------------------
-  api.on(
-    "llm_output",
-    (event, ctx) => {
-      try {
-        tracker.onLlmOutput({
-          runId: event.runId,
-          sessionId: event.sessionId,
-          assistantTexts: event.assistantTexts,
-          usage: event.usage,
-        });
-      } catch (err) {
-        logger.warn(`[learning-loop] llm_output handler failed: ${String(err)}`);
-      }
-    },
-    { priority: 100 },
-  );
-
-  // -----------------------------------------------------------------------
-  // after_tool_call (priority 100) -- Capture tool call traces
-  // -----------------------------------------------------------------------
-  api.on(
-    "after_tool_call",
-    (event, ctx) => {
-      try {
-        tracker.onToolCall({
-          toolName: event.toolName,
-          durationMs: event.durationMs,
-          success: !event.error,
-          error: event.error,
-          paramHash: hashText(JSON.stringify(event.params)),
-          sessionKey: ctx.sessionKey,
-        });
-      } catch (err) {
-        logger.warn(`[learning-loop] after_tool_call handler failed: ${String(err)}`);
-      }
-    },
-    { priority: 100 },
-  );
-
-  // -----------------------------------------------------------------------
-  // subagent_ended (priority 100) -- Capture subagent outcomes
-  // -----------------------------------------------------------------------
-  api.on(
-    "subagent_ended",
-    (event, ctx) => {
-      // Subagent outcomes are tracked as metadata; no separate storage needed.
-      // The parent agent's agent_end will finalize the run.
-    },
-    { priority: 100 },
-  );
-
-  // -----------------------------------------------------------------------
-  // agent_end (priority 50) -- Score run, extract learnings, persist
-  // -----------------------------------------------------------------------
-  api.on(
-    "agent_end",
-    async (event, ctx) => {
-      try {
-        const completedRaw = tracker.finalize({
-          sessionKey: ctx.sessionKey,
-          agentId: ctx.agentId,
-          sessionId: ctx.sessionId,
-          success: event.success,
-          error: event.error,
-          durationMs: event.durationMs,
-        });
-
-        if (!completedRaw) return;
-
-        const completed = normalizeCompletedRun(completedRaw);
-
-        // Score the run
-        const score = qualityEngine.scoreRun(completed);
-
-        // Persist run with score
-        db.insertRun(completed, score);
-
-        // Update metrics bucket
-        metrics.recordRun(completed, score);
-
-        // Track which learnings were injected into this run
-        injector.trackRunAppliedIds(completed.runId);
-        const appliedIds = injector.getAppliedIds(completed.runId);
-
-        // Extract learnings (async: embeds content if bridge is available)
-        const extractedIds = await extractor.extract(completed, score);
-
-        // Infer graph edges from run scoring
-        if (edgeInference) {
-          edgeInference.onRunScored(completed.runId, appliedIds, extractedIds);
-        }
-
-        // Prune old runs if needed (learnings are preserved with run_id='__pruned__')
-        db.pruneOldRuns(config.capture.maxRuns);
-
-        // Prune genuinely stale learnings (unapplied, low-confidence, >90 days old)
-        db.pruneStaleLearnings(90 * 24 * 60 * 60 * 1000);
-
-        logger.debug?.(
-          `[learning-loop] run ${completed.runId}: score=${score.score.toFixed(3)} ` +
-            `(${completed.provider}/${completed.model}, ${completed.toolCalls.length} tool calls)`,
-        );
-      } catch (err) {
-        logger.warn(`[learning-loop] agent_end handler failed: ${String(err)}`);
-      }
-    },
-    { priority: 50 },
-  );
-
-  // -----------------------------------------------------------------------
-  // message_received (priority 50) -- Detect implicit feedback
-  // -----------------------------------------------------------------------
-  api.on(
-    "message_received",
-    (event, ctx) => {
-      try {
-        const feedback = implicit.analyzeMessage(event.content, event.timestamp ?? Date.now());
-
-        // Close the feedback loop: rescore the associated run
-        if (feedback) {
-          const runRow = db.getRun(feedback.runId);
-          if (runRow) {
-            const toolCalls = db.getToolCalls(feedback.runId);
-            const completedRun = reconstructCompletedRun(runRow, toolCalls);
-            const newScore = qualityEngine.rescoreWithFeedback(completedRun, {
-              source: feedback.source as "explicit" | "implicit",
-              score: feedback.score,
-            });
-            db.updateRunScore(feedback.runId, newScore.score);
-          }
-        }
-      } catch (err) {
-        logger.warn(`[learning-loop] message_received handler failed: ${String(err)}`);
-      }
-    },
-    { priority: 50 },
-  );
-}

package/extensions/learning-loop/src/injection/cache.ts

@@ -1,73 +0,0 @@
-/**
- * LRU cache for context injection results.
- * Target: >85% hit rate, O(1) lookup.
- */
-
-export type CacheEntry<T> = {
-  value: T;
-  expiresAt: number;
-};
-
-export type LRUCache<T> = ReturnType<typeof createLRUCache<T>>;
-
-export function createLRUCache<T>(maxSize: number = 128, ttlMs: number = 60_000) {
-  const cache = new Map<string, CacheEntry<T>>();
-  let hits = 0;
-  let misses = 0;
-
-  function get(key: string): T | undefined {
-    const entry = cache.get(key);
-    if (!entry) {
-      misses++;
-      return undefined;
-    }
-
-    if (Date.now() > entry.expiresAt) {
-      cache.delete(key);
-      misses++;
-      return undefined;
-    }
-
-    // Move to end (most recently used) by re-inserting
-    cache.delete(key);
-    cache.set(key, entry);
-    hits++;
-    return entry.value;
-  }
-
-  function set(key: string, value: T): void {
-    // Evict oldest if at capacity
-    if (cache.size >= maxSize) {
-      const oldest = cache.keys().next().value;
-      if (oldest !== undefined) {
-        cache.delete(oldest);
-      }
-    }
-
-    cache.set(key, {
-      value,
-      expiresAt: Date.now() + ttlMs,
-    });
-  }
-
-  function invalidate(key: string): void {
-    cache.delete(key);
-  }
-
-  function clear(): void {
-    cache.clear();
-    hits = 0;
-    misses = 0;
-  }
-
-  function getHitRate(): number {
-    const total = hits + misses;
-    return total === 0 ? 0 : hits / total;
-  }
-
-  function getStats(): { size: number; hits: number; misses: number; hitRate: number } {
-    return { size: cache.size, hits, misses, hitRate: getHitRate() };
-  }
-
-  return { get, set, invalidate, clear, getHitRate, getStats };
-}

package/extensions/learning-loop/src/injection/context-injector.ts

@@ -1,104 +0,0 @@
-/**
- * Context injection for before_prompt_build hook.
- *
- * On each prompt build:
- * 1. Hash prompt -> check LRU cache (target >85% hit rate, O(1))
- * 2. Cache miss: query learnings via cosine similarity or FTS5 fallback
- * 3. Apply temporal decay and MMR rerank for diversity
- * 4. Format top N as <learnings> context block
- * 5. Return { prependContext }
- */
-
-import { hashText } from "../../../../src/memory/internal.js";
-import type { DatabaseManager } from "../db.js";
-import type { GraphRetrieval } from "../graph/graph-retrieval.js";
-import type { EmbeddingBridge } from "../learning/embedding-bridge.js";
-import type { LearningStore } from "../learning/learning-store.js";
-import { retrieveLearnings, type RetrievalResult } from "../learning/retrieval.js";
-import type { LearningLoopConfig, RunId } from "../types.js";
-import { createLRUCache } from "./cache.js";
-import { formatLearningsContext } from "./prompt-builder.js";
-
-export type ContextInjector = ReturnType<typeof createContextInjector>;
-
-export function createContextInjector(params: {
-  db: DatabaseManager;
-  learningStore: LearningStore;
-  config: LearningLoopConfig;
-  embeddingBridge?: EmbeddingBridge;
-  graphRetrieval?: GraphRetrieval;
-}) {
-  const { db, learningStore, config, embeddingBridge, graphRetrieval } = params;
-  const cache = createLRUCache<string>(128, config.injection.cacheTtlMs);
-  const appliedIdsMap = new Map<RunId, string[]>();
-  let lastAppliedIds: string[] = [];
-
-  /**
-   * Generate context to prepend to the agent prompt.
-   * Returns empty string if no relevant learnings exist.
-   */
-  async function getContext(prompt: string): Promise<string> {
-    const promptKey = hashText(prompt);
-
-    // Check cache first
-    const cached = cache.get(promptKey);
-    if (cached !== undefined) return cached;
-
-    // Get query embedding if bridge is available
-    let queryEmbedding: number[] | null = null;
-    if (embeddingBridge?.available()) {
-      queryEmbedding = await embeddingBridge.embed(prompt);
-    }
-
-    // Retrieve relevant learnings
-    const results = retrieveLearnings({
-      learningStore,
-      config,
-      queryEmbedding,
-      queryText: prompt,
-      graphRetrieval,
-    });
-
-    // Record applications and track applied IDs
-    const appliedIds: string[] = [];
-    for (const result of results) {
-      learningStore.recordApplication(result.learning.id);
-      appliedIds.push(result.learning.id);
-    }
-    lastAppliedIds = appliedIds;
-
-    // Format context
-    const context = formatLearningsContext(results, config);
-
-    // Cache result
-    cache.set(promptKey, context);
-
-    return context;
-  }
-
-  /**
-   * Associate the most recently injected learning IDs with a run ID.
-   */
-  function trackRunAppliedIds(runId: RunId): void {
-    if (lastAppliedIds.length > 0) {
-      appliedIdsMap.set(runId, [...lastAppliedIds]);
-    }
-  }
-
-  /**
-   * Get the learning IDs that were injected into a specific run.
-   */
-  function getAppliedIds(runId: RunId): string[] {
-    return appliedIdsMap.get(runId) ?? [];
-  }
-
-  function getCacheStats() {
-    return cache.getStats();
-  }
-
-  function clearCache(): void {
-    cache.clear();
-  }
-
-  return { getContext, trackRunAppliedIds, getAppliedIds, getCacheStats, clearCache };
-}

package/extensions/learning-loop/src/injection/prompt-builder.ts

@@ -1,43 +0,0 @@
-/**
- * Format retrieved learnings into context text for prompt injection.
- */
-
-import type { RetrievalResult } from "../learning/retrieval.js";
-import type { LearningLoopConfig } from "../types.js";
-
-/**
- * Format learnings into a context block that will be prepended to the agent prompt.
- *
- * Respects maxTokens by estimating token count (chars / 4) and truncating.
- * Returns empty string if no learnings pass the threshold.
- */
-export function formatLearningsContext(
-  results: RetrievalResult[],
-  config: LearningLoopConfig,
-): string {
-  if (results.length === 0) return "";
-
-  const maxTokens = config.injection.maxTokens;
-  const lines: string[] = [];
-  let estimatedTokens = 0;
-
-  // Header
-  const header = "<learnings>";
-  const footer = "</learnings>";
-  estimatedTokens += (header.length + footer.length) / 4;
-
-  for (const result of results) {
-    const contested = result.contested ? " [CONTESTED]" : "";
-    const line = `- [${result.learning.category}] ${result.learning.content}${contested}`;
-    const lineTokens = line.length / 4;
-
-    if (estimatedTokens + lineTokens > maxTokens) break;
-
-    lines.push(line);
-    estimatedTokens += lineTokens;
-  }
-
-  if (lines.length === 0) return "";
-
-  return `${header}\n${lines.join("\n")}\n${footer}`;
-}

package/extensions/learning-loop/src/learning/embedding-bridge.ts

@@ -1,54 +0,0 @@
-/**
- * Bridge to the existing embedding provider system.
- * Uses the same multi-provider system (OpenAI, Gemini, Voyage, local ONNX)
- * that the memory system uses.
- */
-
-import type { EmbeddingProvider } from "../../../../src/memory/embeddings.js";
-import type { PluginLogger } from "../../../../src/plugins/types.js";
-
-export type EmbeddingBridge = {
-  embed: (text: string) => Promise<number[] | null>;
-  embedBatch: (texts: string[]) => Promise<Array<number[] | null>>;
-  available: () => boolean;
-};
-
-/**
- * Create an embedding bridge that wraps an existing EmbeddingProvider.
- * If no provider is available, embed() returns null gracefully.
- */
-export function createEmbeddingBridge(params: {
-  provider: EmbeddingProvider | null;
-  logger: PluginLogger;
-}): EmbeddingBridge {
-  const { provider, logger } = params;
-
-  async function embed(text: string): Promise<number[] | null> {
-    if (!provider) return null;
-
-    try {
-      return await provider.embedQuery(text);
-    } catch (err) {
-      logger.warn(`[learning-loop] embedding failed: ${String(err)}`);
-      return null;
-    }
-  }
-
-  async function embedBatch(texts: string[]): Promise<Array<number[] | null>> {
-    if (!provider) return texts.map(() => null);
-
-    try {
-      const results = await provider.embedBatch(texts);
-      return results;
-    } catch (err) {
-      logger.warn(`[learning-loop] batch embedding failed: ${String(err)}`);
-      return texts.map(() => null);
-    }
-  }
-
-  function available(): boolean {
-    return provider !== null;
-  }
-
-  return { embed, embedBatch, available };
-}