@symerian/symi 3.0.18 → 3.0.19

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

@@ -1,217 +0,0 @@
-/**
- * Deterministic pattern extraction from scored runs.
- * No LLM calls -- all patterns are derived from mathematical analysis
- * of run history and tool call traces.
- */
-
-import type { DatabaseManager } from "../db.js";
-import type { EdgeInference } from "../graph/edge-inference.js";
-import { getEWMAValue } from "../math/ewma.js";
-import type {
-  CompletedRun,
-  QualityScore,
-  LearningLoopConfig,
-  LearningCategory,
-  RunRow,
-} from "../types.js";
-import type { EmbeddingBridge } from "./embedding-bridge.js";
-import type { LearningStore } from "./learning-store.js";
-
-export type LearningExtractor = ReturnType<typeof createLearningExtractor>;
-
-type ExtractedLearning = {
-  category: LearningCategory;
-  content: string;
-  confidence: number;
-};
-
-export function createLearningExtractor(params: {
-  db: DatabaseManager;
-  learningStore: LearningStore;
-  config: LearningLoopConfig;
-  edgeInference?: EdgeInference;
-  embeddingBridge?: EmbeddingBridge;
-}) {
-  const { db, learningStore, config, edgeInference, embeddingBridge } = params;
-
-  /**
-   * Extract learnings from a completed, scored run.
-   * Returns the IDs of newly created learnings.
-   */
-  async function extract(run: CompletedRun, score: QualityScore): Promise<string[]> {
-    const learnings: ExtractedLearning[] = [];
-
-    learnings.push(...extractToolPatterns(run, score));
-    learnings.push(...extractErrorRecovery(run));
-    learnings.push(...extractModelAffinity(run, score));
-    learnings.push(...extractAntiPatterns(run));
-
-    // Batch-embed all learning contents if bridge is available
-    const contents = learnings.map((l) => l.content);
-    const embeddings =
-      embeddingBridge && contents.length > 0
-        ? await embeddingBridge.embedBatch(contents)
-        : contents.map(() => null);
-
-    const ids: string[] = [];
-    for (let i = 0; i < learnings.length; i++) {
-      const learning = learnings[i]!;
-      const id = learningStore.addLearning({
-        runId: run.runId,
-        category: learning.category,
-        content: learning.content,
-        embedding: embeddings[i] ?? null,
-        confidence: learning.confidence,
-      });
-      if (id) {
-        ids.push(id);
-        // Infer graph edges for the newly created learning
-        if (edgeInference) {
-          const record = learningStore.getLearning(id);
-          if (record) {
-            edgeInference.onLearningCreated(record, run.runId);
-          }
-        }
-      }
-    }
-
-    return ids;
-  }
-
-  /**
-   * Tool Pattern: Same tool set (order-independent) succeeds 3+ times with score >= 0.7.
-   * Uses Jaccard similarity >= 0.8 on tool sets instead of exact sequence matching.
-   */
-  function extractToolPatterns(run: CompletedRun, score: QualityScore): ExtractedLearning[] {
-    if (score.score < 0.7 || run.toolCalls.length < 2) return [];
-
-    const toolSet = new Set(run.toolCalls.map((tc) => tc.toolName));
-
-    const recentRuns = db.getRunsByModel(run.provider, run.model, 50);
-    let matchCount = 0;
-
-    for (const prevRow of recentRuns) {
-      if (prevRow.run_id === run.runId) continue;
-      if ((prevRow.quality_score ?? 0) < 0.7) continue;
-
-      const prevToolCalls = db.getToolCalls(prevRow.run_id);
-      const prevToolSet = new Set(prevToolCalls.map((tc) => tc.tool_name));
-
-      // Jaccard similarity on tool sets
-      const intersection = [...toolSet].filter((t) => prevToolSet.has(t)).length;
-      const union = new Set([...toolSet, ...prevToolSet]).size;
-      const jaccard = union > 0 ? intersection / union : 0;
-
-      if (jaccard >= 0.8) matchCount++;
-    }
-
-    if (matchCount < 2) return []; // Need 3+ total (including current)
-
-    const uniqueTools = [...toolSet].sort();
-    return [
-      {
-        category: "tool_pattern",
-        content: `Tool combination [${uniqueTools.join(", ")}] is effective for tasks handled by ${run.provider}/${run.model}. Used successfully ${matchCount + 1} times.`,
-        confidence: Math.min(1.0, 0.5 + matchCount * 0.1),
-      },
-    ];
-  }
-
-  /**
-   * Error Recovery: Tool error followed by successful retry with different params
-   */
-  function extractErrorRecovery(run: CompletedRun): ExtractedLearning[] {
-    const results: ExtractedLearning[] = [];
-
-    for (let i = 1; i < run.toolCalls.length; i++) {
-      const prev = run.toolCalls[i - 1]!;
-      const curr = run.toolCalls[i]!;
-
-      if (
-        !prev.success &&
-        curr.success &&
-        prev.toolName === curr.toolName &&
-        prev.paramHash !== curr.paramHash
-      ) {
-        results.push({
-          category: "error_recovery",
-          content: `Tool "${prev.toolName}" failed with "${prev.error ?? "unknown error"}", retry with different parameters succeeded.`,
-          confidence: 0.7,
-        });
-      }
-    }
-
-    return results;
-  }
-
-  /**
-   * Model Affinity: Model's EWMA quality > global mean + 1 std dev
-   */
-  function extractModelAffinity(run: CompletedRun, score: QualityScore): ExtractedLearning[] {
-    const leaderboard = db.getModelLeaderboard();
-    if (leaderboard.length < 2) return [];
-
-    const globalSum = leaderboard.reduce((s, m) => s + m.avgQuality, 0);
-    const globalMean = globalSum / leaderboard.length;
-    const variance =
-      leaderboard.reduce((s, m) => s + (m.avgQuality - globalMean) ** 2, 0) / leaderboard.length;
-    const stdDev = Math.sqrt(variance);
-
-    if (stdDev === 0) return [];
-
-    const modelEntry = leaderboard.find(
-      (m) => m.provider === run.provider && m.model === run.model,
-    );
-    if (!modelEntry || modelEntry.runCount < 5) return [];
-
-    if (modelEntry.avgQuality > globalMean + stdDev) {
-      return [
-        {
-          category: "model_affinity",
-          content: `Model ${run.provider}/${run.model} performs above average (quality: ${modelEntry.avgQuality.toFixed(3)} vs global mean: ${globalMean.toFixed(3)}).`,
-          confidence: Math.min(1.0, 0.5 + modelEntry.runCount * 0.02),
-        },
-      ];
-    }
-
-    return [];
-  }
-
-  /**
-   * Anti-Pattern: Tool error rate > 50% over 5+ runs
-   */
-  function extractAntiPatterns(run: CompletedRun): ExtractedLearning[] {
-    const results: ExtractedLearning[] = [];
-
-    // Aggregate tool error rates from recent runs
-    const recentRuns = db.getRecentRuns(50);
-    const toolStats = new Map<string, { total: number; errors: number; lastError: string }>();
-
-    for (const row of recentRuns) {
-      const toolCalls = db.getToolCalls(row.run_id);
-      for (const tc of toolCalls) {
-        const stat = toolStats.get(tc.tool_name) ?? { total: 0, errors: 0, lastError: "" };
-        stat.total++;
-        if (!tc.success) {
-          stat.errors++;
-          stat.lastError = tc.error ?? "unknown error";
-        }
-        toolStats.set(tc.tool_name, stat);
-      }
-    }
-
-    for (const [toolName, stat] of toolStats) {
-      if (stat.total >= 5 && stat.errors / stat.total > 0.5) {
-        results.push({
-          category: "anti_pattern",
-          content: `Tool "${toolName}" has a high error rate (${stat.errors}/${stat.total} = ${((stat.errors / stat.total) * 100).toFixed(0)}%). Common error: "${stat.lastError}".`,
-          confidence: Math.min(1.0, 0.5 + stat.total * 0.02),
-        });
-      }
-    }
-
-    return results;
-  }
-
-  return { extract };
-}

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

@@ -1,158 +0,0 @@
-/**
- * CRUD operations for learning records.
- * Handles storage, retrieval, deduplication, and embedding management.
- */
-
-import crypto from "node:crypto";
-import { buildFtsQuery } from "../../../../src/memory/hybrid.js";
-import { cosineSimilarity } from "../../../../src/memory/internal.js";
-import type { DatabaseManager } from "../db.js";
-import type { GraphStore } from "../graph/graph-store.js";
-import type { LearningRecord, LearningRow, LearningCategory } from "../types.js";
-
-export type LearningStore = ReturnType<typeof createLearningStore>;
-
-const DEDUP_THRESHOLD = 0.92;
-
-function rowToRecord(row: LearningRow): LearningRecord {
-  return {
-    id: row.id,
-    runId: row.run_id,
-    category: row.category as LearningCategory,
-    content: row.content,
-    embedding: row.embedding ? (JSON.parse(row.embedding) as number[]) : null,
-    confidence: row.confidence,
-    appliedCount: row.applied_count,
-    createdAt: row.created_at,
-    updatedAt: row.updated_at,
-  };
-}
-
-export function createLearningStore(params: { db: DatabaseManager; graphStore?: GraphStore }) {
-  const { db, graphStore } = params;
-
-  function generateId(): string {
-    return `lrn_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`;
-  }
-
-  /**
-   * Check if a learning with similar content already exists.
-   * Uses cosine similarity on embeddings if available, otherwise exact match.
-   */
-  function isDuplicate(content: string, embedding: number[] | null): boolean {
-    if (!embedding) {
-      // Fallback: check exact content match
-      const all = db.getAllLearnings(500);
-      return all.some((row) => row.content === content);
-    }
-
-    // Check cosine similarity against existing embeddings
-    const all = db.getAllLearnings(500);
-    for (const row of all) {
-      if (!row.embedding) continue;
-      const existing = JSON.parse(row.embedding) as number[];
-      if (cosineSimilarity(embedding, existing) >= DEDUP_THRESHOLD) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  /**
-   * Add a new learning record, with deduplication.
-   * Returns the learning ID if created, or null if deduplicated.
-   */
-  function addLearning(params: {
-    runId: string;
-    category: LearningCategory;
-    content: string;
-    embedding: number[] | null;
-    confidence: number;
-  }): string | null {
-    if (isDuplicate(params.content, params.embedding)) {
-      return null;
-    }
-
-    const now = Date.now();
-    const record: LearningRecord = {
-      id: generateId(),
-      runId: params.runId,
-      category: params.category,
-      content: params.content,
-      embedding: params.embedding,
-      confidence: params.confidence,
-      appliedCount: 0,
-      createdAt: now,
-      updatedAt: now,
-    };
-
-    db.insertLearning(record);
-    return record.id;
-  }
-
-  function getLearning(id: string): LearningRecord | null {
-    const row = db.getLearning(id);
-    return row ? rowToRecord(row) : null;
-  }
-
-  function listLearnings(opts?: { category?: LearningCategory; limit?: number }): LearningRecord[] {
-    const rows = opts?.category
-      ? db.getLearningsByCategory(opts.category, opts.limit ?? 100)
-      : db.getAllLearnings(opts?.limit ?? 100);
-    return rows.map(rowToRecord);
-  }
-
-  function searchByText(query: string, limit: number = 20): LearningRecord[] {
-    const ftsQuery = buildFtsQuery(query);
-    if (!ftsQuery) return [];
-
-    const rows = db.searchLearningsFts(ftsQuery, limit);
-    return rows.map(rowToRecord);
-  }
-
-  /**
-   * Retrieve learnings by vector similarity.
-   * Falls back to FTS if no embeddings are available.
-   */
-  function searchByVector(
-    queryEmbedding: number[],
-    limit: number = 10,
-    minScore: number = 0.3,
-  ): Array<LearningRecord & { score: number }> {
-    const all = db.getAllLearnings(1000);
-    const results: Array<LearningRecord & { score: number }> = [];
-
-    for (const row of all) {
-      if (!row.embedding) continue;
-      const embedding = JSON.parse(row.embedding) as number[];
-      const score = cosineSimilarity(queryEmbedding, embedding);
-      if (score >= minScore) {
-        results.push({ ...rowToRecord(row), score });
-      }
-    }
-
-    results.sort((a, b) => b.score - a.score);
-    return results.slice(0, limit);
-  }
-
-  function recordApplication(id: string): void {
-    db.incrementAppliedCount(id);
-  }
-
-  function removeLearning(id: string): void {
-    graphStore?.removeEdgesFor(id);
-    db.deleteLearning(id);
-  }
-
-  return {
-    addLearning,
-    getLearning,
-    listLearnings,
-    searchByText,
-    searchByVector,
-    recordApplication,
-    removeLearning,
-    isDuplicate,
-  };
-}

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

@@ -1,87 +0,0 @@
-/**
- * Learning retrieval for context injection.
- * Supports vector similarity search with FTS5 fallback.
- */
-
-import { mmrRerank, type MMRItem } from "../../../../src/memory/mmr.js";
-import { calculateTemporalDecayMultiplier } from "../../../../src/memory/temporal-decay.js";
-import type { GraphRetrieval } from "../graph/graph-retrieval.js";
-import type { LearningRecord, LearningLoopConfig } from "../types.js";
-import type { LearningStore } from "./learning-store.js";
-
-export type RetrievalResult = {
-  learning: LearningRecord;
-  score: number;
-  decayedScore: number;
-  contested?: boolean;
-};
-
-/**
- * Retrieve relevant learnings for a given query.
- *
- * 1. Vector search (if embedding available) or FTS fallback
- * 2. Apply temporal decay
- * 3. MMR rerank for diversity
- * 4. Return top N
- */
-export function retrieveLearnings(params: {
-  learningStore: LearningStore;
-  config: LearningLoopConfig;
-  queryEmbedding: number[] | null;
-  queryText: string;
-  limit?: number;
-  graphRetrieval?: GraphRetrieval;
-}): RetrievalResult[] {
-  const { learningStore, config, queryEmbedding, queryText, graphRetrieval } = params;
-  const limit = params.limit ?? config.injection.maxLearnings;
-  const minRelevance = config.injection.minRelevance;
-  const halfLifeDays = config.decay.halfLifeDays;
-  const nowMs = Date.now();
-
-  // Step 1: Retrieve candidates
-  let candidates: Array<LearningRecord & { score: number }>;
-
-  if (queryEmbedding) {
-    candidates = learningStore.searchByVector(queryEmbedding, limit * 3, minRelevance * 0.5);
-  } else {
-    // FTS fallback
-    const textResults = learningStore.searchByText(queryText, limit * 3);
-    candidates = textResults.map((r, i) => ({
-      ...r,
-      score: 1.0 - i * (0.8 / Math.max(1, textResults.length)),
-    }));
-  }
-
-  if (candidates.length === 0) return [];
-
-  // Step 2: Apply temporal decay
-  const DAY_MS = 24 * 60 * 60 * 1000;
-  const withDecay = candidates.map((c) => {
-    const ageInDays = (nowMs - c.updatedAt) / DAY_MS;
-    const decayMultiplier = calculateTemporalDecayMultiplier({ ageInDays, halfLifeDays });
-    const decayedScore = c.score * decayMultiplier;
-    return { learning: c, score: c.score, decayedScore };
-  });
-
-  // Filter by minimum relevance after decay
-  const filtered = withDecay.filter((r) => r.decayedScore >= minRelevance);
-  if (filtered.length === 0) return [];
-
-  // Step 3: Graph expansion (if available)
-  if (graphRetrieval) {
-    return graphRetrieval.expandWithGraph(filtered, limit);
-  }
-
-  // Step 4: MMR rerank for diversity
-  const mmrItems: (MMRItem & { original: RetrievalResult })[] = filtered.map((r) => ({
-    id: r.learning.id,
-    score: r.decayedScore,
-    content: r.learning.content,
-    original: r,
-  }));
-
-  const reranked = mmrRerank(mmrItems, { enabled: true, lambda: 0.7 });
-
-  // Step 5: Take top N
-  return reranked.slice(0, limit).map((item) => item.original);
-}

package/extensions/learning-loop/src/math/confidence-intervals.ts

@@ -1,62 +0,0 @@
-/**
- * Wilson Score Interval for binomial proportions.
- *
- * Provides a confidence interval for a proportion derived from a binomial
- * distribution. Used to rank learnings by confidence: items with more
- * observations and higher success rates rank higher.
- *
- * Formula (lower bound, 95% CI):
- *   (p + z^2/(2n) - z * sqrt(p*(1-p)/n + z^2/(4n^2))) / (1 + z^2/n)
- *
- * Complexity: O(1)
- */
-
-const Z_95 = 1.96;
-
-/**
- * Compute the lower bound of the Wilson score interval.
- *
- * @param successes - Number of positive outcomes
- * @param total - Total number of trials
- * @param z - Z-score for confidence level (default: 1.96 for 95%)
- * @returns Lower bound of the confidence interval in [0, 1]
- */
-export function wilsonScoreLowerBound(successes: number, total: number, z: number = Z_95): number {
-  if (total <= 0) return 0;
-
-  const p = successes / total;
-  const z2 = z * z;
-  const denominator = 1 + z2 / total;
-
-  const numerator =
-    p + z2 / (2 * total) - z * Math.sqrt((p * (1 - p)) / total + z2 / (4 * total * total));
-
-  return Math.max(0, Math.min(1, numerator / denominator));
-}
-
-/**
- * Compute both bounds of the Wilson score interval.
- *
- * @param successes - Number of positive outcomes
- * @param total - Total number of trials
- * @param z - Z-score for confidence level (default: 1.96 for 95%)
- * @returns [lowerBound, upperBound] each in [0, 1]
- */
-export function wilsonScoreInterval(
-  successes: number,
-  total: number,
-  z: number = Z_95,
-): [number, number] {
-  if (total <= 0) return [0, 0];
-
-  const p = successes / total;
-  const z2 = z * z;
-  const denominator = 1 + z2 / total;
-  const center = p + z2 / (2 * total);
-  const spread = z * Math.sqrt((p * (1 - p)) / total + z2 / (4 * total * total));
-
-  const lower = Math.max(0, (center - spread) / denominator);
-  const upper = Math.min(1, (center + spread) / denominator);
-
-  return [lower, upper];
-}

package/extensions/learning-loop/src/math/ewma.ts

@@ -1,51 +0,0 @@
-/**
- * Exponentially Weighted Moving Average (EWMA).
- *
- * Maintains a running weighted average where recent observations
- * contribute more than older ones. O(1) per update.
- *
- * Formula: S_t = alpha * x_t + (1 - alpha) * S_{t-1}
- */
-
-export type EWMAState = {
-  value: number;
-  count: number;
-};
-
-const DEFAULT_ALPHA = 0.1;
-
-export function createEWMA(alpha: number = DEFAULT_ALPHA): EWMAState {
-  return { value: 0, count: 0 };
-}
-
-/**
- * Update EWMA with a new observation. Returns a new state (immutable).
- * First observation initializes directly; subsequent observations use exponential weighting.
- *
- * Complexity: O(1)
- */
-export function updateEWMA(
-  state: EWMAState,
-  observation: number,
-  alpha: number = DEFAULT_ALPHA,
-): EWMAState {
-  if (!Number.isFinite(observation)) return state;
-
-  const clampedAlpha = Math.max(0, Math.min(1, alpha));
-
-  if (state.count === 0) {
-    return { value: observation, count: 1 };
-  }
-
-  return {
-    value: clampedAlpha * observation + (1 - clampedAlpha) * state.value,
-    count: state.count + 1,
-  };
-}
-
-/**
- * Get the current EWMA value, or a fallback if no observations exist.
- */
-export function getEWMAValue(state: EWMAState, fallback: number = 0): number {
-  return state.count === 0 ? fallback : state.value;
-}

package/extensions/learning-loop/src/math/weighted-scorer.ts

@@ -1,42 +0,0 @@
-/**
- * Confidence-weighted arithmetic mean combiner.
- *
- * Combines multiple independent signals into a single score, where each
- * signal contributes proportionally to its weight AND confidence.
- *
- * Formula: score = sum(w_i * c_i * s_i) / sum(w_i * c_i)
- *
- * Complexity: O(k) where k = number of signals
- */
-
-export type WeightedSignal = {
-  value: number;
-  weight: number;
-  confidence: number;
-};
-
-/**
- * Compute a confidence-weighted score from multiple signals.
- *
- * @param signals - Array of signals with value in [0,1], weight > 0, confidence in [0,1]
- * @returns Combined score in [0, 1], or 0 if no valid signals
- */
-export function computeWeightedScore(signals: WeightedSignal[]): number {
-  let numerator = 0;
-  let denominator = 0;
-
-  for (const signal of signals) {
-    if (signal.confidence <= 0 || signal.weight <= 0) continue;
-    if (!Number.isFinite(signal.value)) continue;
-
-    const clampedValue = Math.max(0, Math.min(1, signal.value));
-    const clampedConfidence = Math.max(0, Math.min(1, signal.confidence));
-    const effectiveWeight = signal.weight * clampedConfidence;
-
-    numerator += effectiveWeight * clampedValue;
-    denominator += effectiveWeight;
-  }
-
-  if (denominator === 0) return 0;
-  return numerator / denominator;
-}