@symerian/symi 3.0.18 → 3.0.19

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

@@ -1,176 +0,0 @@
-/**
- * SQLite schema for the learning loop extension.
- * All tables use WAL mode for concurrent read/write performance.
- */
-
-import type { DatabaseSync } from "node:sqlite";
-
-export function initializeSchema(db: DatabaseSync): void {
-  db.exec("PRAGMA journal_mode = WAL");
-  db.exec("PRAGMA busy_timeout = 5000");
-  db.exec("PRAGMA synchronous = NORMAL");
-
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS runs (
-      run_id TEXT PRIMARY KEY,
-      session_id TEXT NOT NULL,
-      session_key TEXT NOT NULL,
-      agent_id TEXT NOT NULL,
-      provider TEXT NOT NULL,
-      model TEXT NOT NULL,
-      prompt_hash TEXT NOT NULL,
-      prompt_length INTEGER NOT NULL DEFAULT 0,
-      response_length INTEGER NOT NULL DEFAULT 0,
-      response_tool_call_count INTEGER NOT NULL DEFAULT 0,
-      usage_input INTEGER NOT NULL DEFAULT 0,
-      usage_output INTEGER NOT NULL DEFAULT 0,
-      usage_cache_read INTEGER NOT NULL DEFAULT 0,
-      usage_cache_write INTEGER NOT NULL DEFAULT 0,
-      usage_total INTEGER NOT NULL DEFAULT 0,
-      success INTEGER NOT NULL DEFAULT 0,
-      error TEXT,
-      duration_ms INTEGER NOT NULL DEFAULT 0,
-      quality_score REAL,
-      algorithm_version INTEGER,
-      started_at INTEGER NOT NULL,
-      completed_at INTEGER NOT NULL
-    )
-  `);
-
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS tool_calls (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
-      tool_name TEXT NOT NULL,
-      duration_ms INTEGER,
-      success INTEGER NOT NULL DEFAULT 1,
-      error TEXT,
-      param_hash TEXT NOT NULL
-    )
-  `);
-
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS quality_signals (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
-      signal_name TEXT NOT NULL,
-      value REAL NOT NULL,
-      confidence REAL NOT NULL,
-      weight REAL NOT NULL
-    )
-  `);
-
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS learnings (
-      id TEXT PRIMARY KEY,
-      run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
-      category TEXT NOT NULL,
-      content TEXT NOT NULL,
-      embedding TEXT,
-      confidence REAL NOT NULL DEFAULT 0.5,
-      applied_count INTEGER NOT NULL DEFAULT 0,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL
-    )
-  `);
-
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS feedback (
-      id TEXT PRIMARY KEY,
-      run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
-      source TEXT NOT NULL,
-      score REAL NOT NULL,
-      created_at INTEGER NOT NULL
-    )
-  `);
-
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS metrics_buckets (
-      provider TEXT NOT NULL,
-      model TEXT NOT NULL,
-      bucket_hour TEXT NOT NULL,
-      run_count INTEGER NOT NULL DEFAULT 0,
-      success_count INTEGER NOT NULL DEFAULT 0,
-      quality_sum REAL NOT NULL DEFAULT 0,
-      quality_sum_sq REAL NOT NULL DEFAULT 0,
-      latency_sum REAL NOT NULL DEFAULT 0,
-      latency_sum_sq REAL NOT NULL DEFAULT 0,
-      token_input_sum INTEGER NOT NULL DEFAULT 0,
-      token_output_sum INTEGER NOT NULL DEFAULT 0,
-      PRIMARY KEY (provider, model, bucket_hour)
-    )
-  `);
-
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS ewma_state (
-      provider TEXT NOT NULL,
-      model TEXT NOT NULL,
-      metric TEXT NOT NULL,
-      value REAL NOT NULL DEFAULT 0,
-      count INTEGER NOT NULL DEFAULT 0,
-      PRIMARY KEY (provider, model, metric)
-    )
-  `);
-
-  // --- Graph tables ---
-
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS learning_edges (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      source_id TEXT NOT NULL,
-      target_id TEXT NOT NULL,
-      edge_type TEXT NOT NULL CHECK(edge_type IN ('T','S','C','U','X','R')),
-      weight REAL NOT NULL DEFAULT 1.0,
-      created_at INTEGER NOT NULL,
-      UNIQUE(source_id, target_id, edge_type)
-    )
-  `);
-
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS centrality_scores (
-      learning_id TEXT PRIMARY KEY,
-      score REAL NOT NULL DEFAULT 0.0,
-      updated_at INTEGER NOT NULL
-    )
-  `);
-
-  // Indexes for efficient queries
-  db.exec(`CREATE INDEX IF NOT EXISTS idx_runs_provider_model ON runs(provider, model)`);
-  db.exec(`CREATE INDEX IF NOT EXISTS idx_runs_completed_at ON runs(completed_at)`);
-  db.exec(`CREATE INDEX IF NOT EXISTS idx_runs_quality_score ON runs(quality_score)`);
-  db.exec(`CREATE INDEX IF NOT EXISTS idx_tool_calls_run_id ON tool_calls(run_id)`);
-  db.exec(`CREATE INDEX IF NOT EXISTS idx_quality_signals_run_id ON quality_signals(run_id)`);
-  db.exec(`CREATE INDEX IF NOT EXISTS idx_learnings_run_id ON learnings(run_id)`);
-  db.exec(`CREATE INDEX IF NOT EXISTS idx_learnings_category ON learnings(category)`);
-  db.exec(`CREATE INDEX IF NOT EXISTS idx_feedback_run_id ON feedback(run_id)`);
-  db.exec(`CREATE INDEX IF NOT EXISTS idx_edges_source ON learning_edges(source_id)`);
-  db.exec(`CREATE INDEX IF NOT EXISTS idx_edges_target ON learning_edges(target_id)`);
-  db.exec(`CREATE INDEX IF NOT EXISTS idx_edges_type ON learning_edges(edge_type)`);
-
-  // FTS5 virtual table for text search over learnings
-  db.exec(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS learnings_fts USING fts5(
-      content,
-      content='learnings',
-      content_rowid='rowid'
-    )
-  `);
-
-  // Triggers to keep FTS in sync
-  db.exec(`
-    CREATE TRIGGER IF NOT EXISTS learnings_ai AFTER INSERT ON learnings BEGIN
-      INSERT INTO learnings_fts(rowid, content) VALUES (new.rowid, new.content);
-    END
-  `);
-  db.exec(`
-    CREATE TRIGGER IF NOT EXISTS learnings_ad AFTER DELETE ON learnings BEGIN
-      INSERT INTO learnings_fts(learnings_fts, rowid, content) VALUES('delete', old.rowid, old.content);
-    END
-  `);
-  db.exec(`
-    CREATE TRIGGER IF NOT EXISTS learnings_au AFTER UPDATE ON learnings BEGIN
-      INSERT INTO learnings_fts(learnings_fts, rowid, content) VALUES('delete', old.rowid, old.content);
-      INSERT INTO learnings_fts(rowid, content) VALUES (new.rowid, new.content);
-    END
-  `);
-}

package/extensions/learning-loop/src/scoring/normalization.ts

@@ -1,32 +0,0 @@
-/**
- * Signal normalization and combination.
- * Wraps the weighted scorer with signal-specific logic.
- */
-
-import { computeWeightedScore } from "../math/weighted-scorer.js";
-import type { QualitySignal, QualityScore } from "../types.js";
-import { ALGORITHM_VERSION } from "../types.js";
-
-/**
- * Combine quality signals into a single score using confidence-weighted
- * arithmetic mean.
- *
- * Formula: score = sum(w_i * c_i * s_i) / sum(w_i * c_i)
- *
- * Complexity: O(k) where k = number of signals (5)
- */
-export function combineSignals(signals: QualitySignal[]): QualityScore {
-  const score = computeWeightedScore(
-    signals.map((s) => ({
-      value: s.value,
-      weight: s.weight,
-      confidence: s.confidence,
-    })),
-  );
-
-  return {
-    score,
-    signals,
-    algorithmVersion: ALGORITHM_VERSION,
-  };
-}

package/extensions/learning-loop/src/scoring/quality-engine.ts

@@ -1,78 +0,0 @@
-/**
- * Quality scoring engine.
- * Orchestrates signal extraction, EWMA updates, and score combination.
- * Purely mathematical, deterministic, zero LLM calls.
- */
-
-import type { DatabaseManager } from "../db.js";
-import type { CompletedRun, LearningLoopConfig, QualityScore, FeedbackRecord } from "../types.js";
-import { combineSignals } from "./normalization.js";
-import {
-  extractTaskCompletion,
-  extractToolEfficiency,
-  extractResponseAppropriateness,
-  extractLatencyRelative,
-  extractUserFeedback,
-} from "./signal-extractors.js";
-
-export type QualityEngine = ReturnType<typeof createQualityEngine>;
-
-export function createQualityEngine(params: { config: LearningLoopConfig; db: DatabaseManager }) {
-  const { config, db } = params;
-  const weights = config.scoring.weights;
-
-  /**
-   * Score a completed run. Updates EWMA state for latency tracking.
-   *
-   * @param run - The completed run to score
-   * @param feedback - Optional feedback (explicit or implicit)
-   * @returns Quality score with all signal breakdowns
-   */
-  function scoreRun(
-    run: CompletedRun,
-    feedback?: { source: "explicit" | "implicit"; score: number },
-  ): QualityScore {
-    // Get EWMA state for latency comparison
-    const ewmaState = db.getEwmaState(run.provider, run.model, "latency");
-
-    // Extract all five signals
-    const signals = [
-      extractTaskCompletion(run, weights.taskCompletion),
-      extractToolEfficiency(run, weights.toolEfficiency),
-      extractResponseAppropriateness(run, weights.responseAppropriateLength),
-      extractLatencyRelative(run, weights.latencyRelative, ewmaState),
-      extractUserFeedback(weights.userFeedback, feedback),
-    ];
-
-    // Update EWMA for latency after scoring
-    db.updateEwmaState(run.provider, run.model, "latency", run.durationMs);
-
-    return combineSignals(signals);
-  }
-
-  /**
-   * Re-score a run with new feedback (e.g., when implicit or explicit feedback arrives later).
-   */
-  function rescoreWithFeedback(
-    run: CompletedRun,
-    feedback: { source: "explicit" | "implicit"; score: number },
-  ): QualityScore {
-    // Re-extract all signals with the feedback
-    const ewmaState = db.getEwmaState(run.provider, run.model, "latency");
-
-    const signals = [
-      extractTaskCompletion(run, weights.taskCompletion),
-      extractToolEfficiency(run, weights.toolEfficiency),
-      extractResponseAppropriateness(run, weights.responseAppropriateLength),
-      extractLatencyRelative(run, weights.latencyRelative, ewmaState),
-      extractUserFeedback(weights.userFeedback, feedback),
-    ];
-
-    return combineSignals(signals);
-  }
-
-  return {
-    scoreRun,
-    rescoreWithFeedback,
-  };
-}

package/extensions/learning-loop/src/scoring/signal-extractors.ts

@@ -1,155 +0,0 @@
-/**
- * Five independent signal extraction functions.
- * Each returns a value in [0, 1] and a confidence in [0, 1].
- * All are deterministic and require zero LLM calls.
- */
-
-import { type EWMAState, getEWMAValue } from "../math/ewma.js";
-import type { CompletedRun, QualitySignal, ScoringWeights } from "../types.js";
-
-/**
- * Signal 1: Task Completion
- *
- * success && !error => 1.0
- * success && error  => 0.5 (partial success with warnings)
- * fail              => 0.0
- *
- * Confidence: always 1.0 (deterministic from agent_end)
- * Complexity: O(1)
- */
-export function extractTaskCompletion(run: CompletedRun, weight: number): QualitySignal {
-  let value: number;
-  if (run.success && !run.error) {
-    value = 1.0;
-  } else if (run.success && run.error) {
-    value = 0.5;
-  } else {
-    value = 0.0;
-  }
-
-  return { name: "taskCompletion", value, confidence: 1.0, weight };
-}
-
-/**
- * Signal 2: Tool Efficiency
- *
- * Formula: 1.0 - 0.6*(errors/total) - 0.4*(redundant/total)
- * Redundant = consecutive calls with same tool+paramHash (likely retries of the same thing)
- *
- * Confidence: scales with tool call count (min 0.3 for 1 call, 1.0 for 5+)
- * Complexity: O(T) where T = number of tool calls
- */
-export function extractToolEfficiency(run: CompletedRun, weight: number): QualitySignal {
-  const total = run.toolCalls.length;
-  if (total === 0) {
-    return { name: "toolEfficiency", value: 1.0, confidence: 0.3, weight };
-  }
-
-  let errors = 0;
-  let redundant = 0;
-
-  for (let i = 0; i < total; i++) {
-    const tc = run.toolCalls[i]!;
-    if (!tc.success) errors++;
-
-    if (i > 0) {
-      const prev = run.toolCalls[i - 1]!;
-      if (tc.toolName === prev.toolName && tc.paramHash === prev.paramHash) {
-        redundant++;
-      }
-    }
-  }
-
-  const value = Math.max(0, 1.0 - 0.6 * (errors / total) - 0.4 * (redundant / total));
-  const confidence = Math.min(1.0, 0.3 + 0.7 * Math.min(1, (total - 1) / 4));
-
-  return { name: "toolEfficiency", value, confidence, weight };
-}
-
-/**
- * Signal 3: Response Appropriateness (length)
- *
- * Log-normal penalty around a target ratio of response/prompt.
- * Formula: exp(-0.5 * (ln(ratio) / sigma)^2)
- *
- * The target ratio is 1.0 (response length ~ prompt length).
- * sigma = 1.5 allows wide variance before heavy penalty.
- *
- * Confidence: 0.5 (weak signal, length is a rough proxy)
- * Complexity: O(1)
- */
-export function extractResponseAppropriateness(run: CompletedRun, weight: number): QualitySignal {
-  if (run.promptLength === 0 || run.responseLength === 0) {
-    return { name: "responseAppropriateLength", value: 0.5, confidence: 0.3, weight };
-  }
-
-  const ratio = run.responseLength / run.promptLength;
-  const sigma = 1.5;
-  const lnRatio = Math.log(ratio);
-  const value = Math.exp(-0.5 * (lnRatio / sigma) ** 2);
-
-  return { name: "responseAppropriateLength", value, confidence: 0.5, weight };
-}
-
-/**
- * Signal 4: Latency Relative
- *
- * Compares this run's duration against the per-model EWMA.
- * Formula: min(1.0, ewma / duration)
- *
- * If the run is faster than average, score = 1.0.
- * If slower, score degrades linearly.
- *
- * Confidence: scales with EWMA observation count (0.3 for <3, 0.7 for 3-10, 1.0 for 10+)
- * Complexity: O(1)
- */
-export function extractLatencyRelative(
-  run: CompletedRun,
-  weight: number,
-  ewmaState: EWMAState,
-): QualitySignal {
-  if (run.durationMs <= 0) {
-    return { name: "latencyRelative", value: 1.0, confidence: 0.3, weight };
-  }
-
-  const ewmaValue = getEWMAValue(ewmaState, run.durationMs);
-  const value = Math.min(1.0, ewmaValue / run.durationMs);
-
-  let confidence: number;
-  if (ewmaState.count < 3) confidence = 0.3;
-  else if (ewmaState.count < 10) confidence = 0.7;
-  else confidence = 1.0;
-
-  return { name: "latencyRelative", value, confidence, weight };
-}
-
-/**
- * Signal 5: User Feedback
- *
- * Explicit: 1-5 rating mapped to [0, 1] via (score - 1) / 4
- * Implicit: re-ask = 0.0, topic change = 1.0, continuation = 0.5
- * No feedback: returns confidence 0 (signal is excluded from combination)
- *
- * Complexity: O(1)
- */
-export function extractUserFeedback(
-  weight: number,
-  feedback?: { source: "explicit" | "implicit"; score: number },
-): QualitySignal {
-  if (!feedback) {
-    return { name: "userFeedback", value: 0.5, confidence: 0.0, weight };
-  }
-
-  let value: number;
-  let confidence: number;
-
-  if (feedback.source === "explicit") {
-    value = Math.max(0, Math.min(1, (feedback.score - 1) / 4));
-    confidence = 1.0;
-  } else {
-    value = Math.max(0, Math.min(1, feedback.score));
-    confidence = 0.6;
-  }
-
-  return { name: "userFeedback", value, confidence, weight };
-}

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

@@ -1,142 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createLRUCache } from "../injection/cache.js";
-import { formatLearningsContext } from "../injection/prompt-builder.js";
-import type { RetrievalResult } from "../learning/retrieval.js";
-import type { LearningLoopConfig } from "../types.js";
-
-describe("LRU Cache", () => {
-  it("should return undefined for missing keys", () => {
-    const cache = createLRUCache<string>();
-    expect(cache.get("nonexistent")).toBeUndefined();
-  });
-
-  it("should store and retrieve values", () => {
-    const cache = createLRUCache<string>();
-    cache.set("key1", "value1");
-    expect(cache.get("key1")).toBe("value1");
-  });
-
-  it("should evict oldest entries when at capacity", () => {
-    const cache = createLRUCache<string>(2);
-    cache.set("a", "1");
-    cache.set("b", "2");
-    cache.set("c", "3"); // evicts "a"
-    expect(cache.get("a")).toBeUndefined();
-    expect(cache.get("b")).toBe("2");
-    expect(cache.get("c")).toBe("3");
-  });
-
-  it("should expire entries after TTL", () => {
-    const cache = createLRUCache<string>(10, 1); // 1ms TTL
-    cache.set("key", "value");
-    // Wait for TTL (synchronous, but Date.now() should advance)
-    const start = Date.now();
-    while (Date.now() - start < 5) {
-      // busy wait
-    }
-    expect(cache.get("key")).toBeUndefined();
-  });
-
-  it("should track hit rate", () => {
-    const cache = createLRUCache<string>();
-    cache.set("a", "1");
-    cache.get("a"); // hit
-    cache.get("b"); // miss
-    const stats = cache.getStats();
-    expect(stats.hits).toBe(1);
-    expect(stats.misses).toBe(1);
-    expect(stats.hitRate).toBeCloseTo(0.5, 5);
-  });
-
-  it("should refresh LRU order on access", () => {
-    const cache = createLRUCache<string>(2);
-    cache.set("a", "1");
-    cache.set("b", "2");
-    cache.get("a"); // refresh "a"
-    cache.set("c", "3"); // evicts "b" (oldest)
-    expect(cache.get("a")).toBe("1");
-    expect(cache.get("b")).toBeUndefined();
-  });
-
-  it("should clear all entries and reset stats", () => {
-    const cache = createLRUCache<string>();
-    cache.set("a", "1");
-    cache.get("a");
-    cache.clear();
-    expect(cache.get("a")).toBeUndefined();
-    expect(cache.getStats().hits).toBe(0);
-  });
-});
-
-describe("Prompt Builder", () => {
-  const config: LearningLoopConfig = {
-    capture: { embedPrompts: false, maxRuns: 10000 },
-    scoring: {
-      weights: {
-        taskCompletion: 0.35,
-        toolEfficiency: 0.25,
-        responseAppropriateLength: 0.1,
-        latencyRelative: 0.1,
-        userFeedback: 0.2,
-      },
-    },
-    injection: { maxLearnings: 5, minRelevance: 0.3, maxTokens: 500, cacheTtlMs: 60000 },
-    decay: { halfLifeDays: 30 },
-  };
-
-  it("should return empty string for no results", () => {
-    expect(formatLearningsContext([], config)).toBe("");
-  });
-
-  it("should format learnings with category tags", () => {
-    const results: RetrievalResult[] = [
-      {
-        learning: {
-          id: "lrn-1",
-          runId: "run-1",
-          category: "tool_pattern",
-          content: "Use search before read",
-          embedding: null,
-          confidence: 0.8,
-          appliedCount: 3,
-          createdAt: Date.now(),
-          updatedAt: Date.now(),
-        },
-        score: 0.9,
-        decayedScore: 0.85,
-      },
-    ];
-
-    const context = formatLearningsContext(results, config);
-    expect(context).toContain("<learnings>");
-    expect(context).toContain("</learnings>");
-    expect(context).toContain("[tool_pattern]");
-    expect(context).toContain("Use search before read");
-  });
-
-  it("should respect maxTokens limit", () => {
-    const longContent = "A".repeat(5000);
-    const results: RetrievalResult[] = [
-      {
-        learning: {
-          id: "lrn-1",
-          runId: "run-1",
-          category: "tool_pattern",
-          content: longContent,
-          embedding: null,
-          confidence: 0.8,
-          appliedCount: 0,
-          createdAt: Date.now(),
-          updatedAt: Date.now(),
-        },
-        score: 0.9,
-        decayedScore: 0.85,
-      },
-    ];
-
-    const smallConfig = { ...config, injection: { ...config.injection, maxTokens: 50 } };
-    const context = formatLearningsContext(results, smallConfig);
-    // Should be empty because the single learning exceeds maxTokens
-    expect(context).toBe("");
-  });
-});