@jeffober/thatch 0.1.28 → 0.1.29

package/src/db.ts

@@ -1,4 +1,14 @@
 import { Database } from "bun:sqlite";
+import { blobToVector, cosineSimilarity } from "./vector-math";
+import {
+  PredictionEngine,
+} from "./prediction";
+import { BehaviorEngine } from "./behavior";
+import { PREDICTION_K, PREDICTION_P0, PREDICTION_W_SOFT } from "./scoring-engine";
+
+export { cosineSimilarity } from "./vector-math";
+export type { PredictionNudgeItem, MatcherRow, PredictionRow, ScoredPrediction } from "./prediction";
+export type { BehaviorNudgeItem, BehaviorRow, ScoredBehavior } from "./behavior";
 
 export interface MemoryRow {
   slug: string;
@@ -34,46 +44,6 @@ export interface DedupCandidate {
   score: number;
 }
 
-export interface MatcherRow {
-  id: string;
-  store: string;
-  description: string;
-  embedding: Uint8Array | null;
-  model: string | null;
-  created_at: string;
-  updated_at: string;
-}
-
-export interface PredictionRow {
-  id: string;
-  store: string;
-  statement: string;
-  rationale: string | null;
-  confidence: number;
-  confirm_count: number;
-  disconfirm_count: number;
-  created_at: string;
-  updated_at: string;
-}
-
-export interface PredictionNudgeItem {
-  confidence: number;
-  evidence_count: number;
-  matcher_description: string;
-  statement: string;
-}
-
-export interface ScoredPrediction {
-  matcher_id: string;
-  matcher_description: string;
-  prediction_id: string;
-  statement: string;
-  confidence: number;
-  evidence_count: number;
-  score: number;
-  rationale: string | null;
-}
-
 /**
  * SQLite-backed store for thatch. All stores live in a single database
  * partitioned by a `store` column. Embeddings are raw Float32Array bytes
@@ -81,6 +51,8 @@ export interface ScoredPrediction {
  */
 export class ThatchDB {
   #db: Database;
+  #predictions: PredictionEngine;
+  #behaviors: BehaviorEngine;
 
   constructor(path: string) {
     this.#db = new Database(path, { create: true });
@@ -92,6 +64,8 @@ export class ThatchDB {
     // existing FK to stores(name), which was declarative but unenforced
     // before this branch.
     this.#db.run("PRAGMA foreign_keys = ON");
+    this.#predictions = new PredictionEngine(this.#db);
+    this.#behaviors = new BehaviorEngine(this.#db);
     this.#initSchema();
   }
 
@@ -187,6 +161,63 @@ export class ThatchDB {
       )
     `);
 
+    // Behavior engine: the LLM's codified self-discipline rules. Same
+    // shape as the prediction engine (matchers, behaviors, edges,
+    // provenance) but separate tables because the semantics differ.
+    // Predictions model what the USER wants; behaviors model what the
+    // LLM should do. The LLM grades its own behaviors (ham/spam), while
+    // the user is the ground truth for predictions.
+    this.#db.run(`
+      CREATE TABLE IF NOT EXISTS behavior_matchers (
+        id          TEXT PRIMARY KEY,
+        store       TEXT NOT NULL REFERENCES stores(name),
+        description TEXT NOT NULL,
+        embedding   BLOB,
+        model       TEXT,
+        created_at  TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now')),
+        updated_at  TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
+      )
+    `);
+
+    this.#db.run(`
+      CREATE TABLE IF NOT EXISTS behaviors (
+        id              TEXT PRIMARY KEY,
+        store           TEXT NOT NULL REFERENCES stores(name),
+        statement       TEXT NOT NULL,
+        rationale       TEXT,
+        embedding       BLOB,
+        model           TEXT,
+        confidence      REAL NOT NULL DEFAULT 0.5,
+        confirm_count   REAL NOT NULL DEFAULT 0,
+        disconfirm_count REAL NOT NULL DEFAULT 0,
+        created_at      TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now')),
+        updated_at      TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
+      )
+    `);
+
+    this.#db.run(`
+      CREATE TABLE IF NOT EXISTS behavior_edges (
+        matcher_id   TEXT NOT NULL,
+        behavior_id  TEXT NOT NULL,
+        weight       REAL NOT NULL DEFAULT 1.0,
+        created_at   TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now')),
+        PRIMARY KEY (matcher_id, behavior_id),
+        FOREIGN KEY (matcher_id) REFERENCES behavior_matchers(id) ON DELETE CASCADE,
+        FOREIGN KEY (behavior_id) REFERENCES behaviors(id) ON DELETE CASCADE
+      )
+    `);
+
+    this.#db.run(`
+      CREATE TABLE IF NOT EXISTS behavior_provenance (
+        id           TEXT PRIMARY KEY,
+        behavior_id  TEXT NOT NULL,
+        signal       TEXT NOT NULL,
+        detail       TEXT,
+        created_at   TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now')),
+        FOREIGN KEY (behavior_id) REFERENCES behaviors(id) ON DELETE CASCADE
+      )
+    `);
+
     this.#db.run("INSERT OR IGNORE INTO stores (name) VALUES ('global')");
 
     this.#migrateColumns();
@@ -554,380 +585,127 @@ export class ThatchDB {
   }
 
   // ---------------------------------------------------------------------------
-  // Prediction engine: matchers, predictions, edges, provenance
+  // Prediction engine: delegates to PredictionEngine
   // ---------------------------------------------------------------------------
 
-  // Bayesian confidence model constants. The posterior is:
-  //   p = (confirm_count + K * P0) / (confirm_count + disconfirm_count + K)
-  // K is the prior strength (pseudo-evidence count): K=5 means 5
-  // pseudo-evidence "anchors" the prior. P0 is the prior probability
-  // (p=0.5 = "no preference either way"). W_SOFT is the fractional
-  // weight for a soft (weak) signal: 0.25 means a soft disconfirm counts
-  // as 1/4 of a full disconfirm.
-  static readonly PREDICTION_K = 5;
-  static readonly PREDICTION_P0 = 0.5;
-  static readonly PREDICTION_W_SOFT = 0.25;
+  static readonly PREDICTION_K = PREDICTION_K;
+  static readonly PREDICTION_P0 = PREDICTION_P0;
+  static readonly PREDICTION_W_SOFT = PREDICTION_W_SOFT;
 
-  /**
-   * Brute-force cosine search over the matchers table for auto-fire.
-   * Returns matchers ranked by similarity to the query embedding,
-   * filtered by a noise floor (cosine >= 0.01) to exclude near-zero
-   * and negative scores, and by model-space compatibility (dimension
-   * match). Callers apply the actual relevance threshold (0.45 for
-   * auto-fire in index.ts, caller-specified for sideband).
-   */
-  findMatchers(
-    stores: string[],
-    queryEmbedding: Float32Array,
-    opts?: { limit?: number },
-  ): { id: string; description: string; score: number }[] {
-    if (stores.length === 0) return [];
-    const limit = opts?.limit ?? 5;
-    const placeholders = stores.map(() => "?").join(", ");
-    const rows = this.#db
-      .query(
-        `SELECT id, description, embedding FROM prediction_matchers
-         WHERE store IN (${placeholders}) AND embedding IS NOT NULL`,
-      )
-      .all(...(stores as [string, ...string[]])) as any[];
+  findMatchers(stores: string[], queryEmbedding: Float32Array, opts?: { limit?: number }) {
+    return this.#predictions.findMatchers(stores, queryEmbedding, opts);
+  }
 
-    const scored: { id: string; description: string; score: number }[] = [];
-    for (const r of rows) {
-      const emb = blobToVector(r.embedding);
-      if (emb.length !== queryEmbedding.length) continue;
-      const score = cosineSimilarity(queryEmbedding, emb);
-      if (score >= 0.01) {
-        scored.push({ id: r.id, description: r.description, score: Math.round(score * 1000) / 1000 });
-      }
-    }
-    scored.sort((a, b) => b.score - a.score);
-    return scored.slice(0, limit);
+  scorePredictions(matchers: { id: string; description: string; score: number }[]) {
+    return this.#predictions.scorePredictions(matchers);
   }
 
-  /**
-   * Follows edges from matchers to scored predictions. Returns all
-   * predictions reachable from any matching matcher, ranked by
-   * cosine * weight * confidence.
-   */
-  scorePredictions(
-    matchers: { id: string; description: string; score: number }[],
-  ): ScoredPrediction[] {
-    if (matchers.length === 0) return [];
-    const matcherIds = matchers.map((m) => m.id);
-    const placeholders = matcherIds.map(() => "?").join(", ");
-    const rows = this.#db
-      .query(
-        `SELECT p.id, p.statement, p.rationale, p.confidence, p.confirm_count, p.disconfirm_count,
-                e.matcher_id, e.weight
-         FROM prediction_edges e
-         JOIN predictions p ON e.prediction_id = p.id
-         WHERE e.matcher_id IN (${placeholders})
-         ORDER BY p.statement`,
-      )
-      .all(...(matcherIds as [string, ...string[]])) as any[];
+  scorePredictionNudge(stores: string[], embedding: Float32Array, threshold: number, limit = 5) {
+    return this.#predictions.scorePredictionNudge(stores, embedding, threshold, limit);
+  }
 
-    const matcherMap = new Map(matchers.map((m) => [m.id, m]));
-    const scored: ScoredPrediction[] = [];
-    for (const r of rows) {
-      const matcher = matcherMap.get(r.matcher_id);
-      if (!matcher) continue;
-
-      const confidence = r.confidence as number;
-      const evidence = Math.round(r.confirm_count + r.disconfirm_count);
-      const score = matcher.score * (r.weight as number) * confidence;
-      scored.push({
-        matcher_id: r.matcher_id,
-        matcher_description: matcher.description,
-        prediction_id: r.id,
-        statement: r.statement,
-        confidence: Math.round(confidence * 1000) / 1000,
-        evidence_count: evidence,
-        score: Math.round(score * 1000) / 1000,
-        rationale: r.rationale,
-      });
-    }
-    scored.sort((a, b) => b.score - a.score);
-
-    // Dedup by prediction_id: multiple matchers may link to the same
-    // prediction via separate edges. Keep only the highest-scoring
-    // entry per prediction so the nudge doesn't repeat the same
-    // prediction with different matcher contexts.
-    const seen = new Set<string>();
-    return scored.filter((s) => {
-      if (seen.has(s.prediction_id)) return false;
-      seen.add(s.prediction_id);
-      return true;
-    });
+  findNearestMatcher(store: string, embedding: Float32Array, threshold: number) {
+    return this.#predictions.findNearestMatcher(store, embedding, threshold);
   }
 
-  /**
-   * Full scoring pipeline for auto-fire and sideband: findMatchers,
-   * filter by threshold, scorePredictions (which includes dedup by
-   * prediction_id), slice, and map to PredictionNudgeItem. Shared by
-   * index.ts (auto-fire) and sideband.ts (MCP path) to prevent
-   * scoring-logic drift between the two host paths.
-   */
-  scorePredictionNudge(
-    stores: string[],
-    embedding: Float32Array,
-    threshold: number,
-    limit = 5,
-  ): PredictionNudgeItem[] {
-    const matchers = this.findMatchers(stores, embedding, { limit })
-      .filter((m) => m.score >= threshold);
-    if (matchers.length === 0) return [];
-    return this.scorePredictions(matchers)
-      .slice(0, limit)
-      .map((s) => ({
-        confidence: s.confidence,
-        evidence_count: s.evidence_count,
-        matcher_description: s.matcher_description,
-        statement: s.statement,
-      }));
+  createMatcher(store: string, description: string, embedding: Float32Array, model: string) {
+    return this.#predictions.createMatcher(store, description, embedding, model);
   }
 
-  /**
-   * Finds the nearest matcher by cosine similarity above a caller-
-   * specified threshold. Used for dedup at prediction_update time
-   * (threshold 0.85), not auto-fire (use findMatchers for that).
-   */
-  findNearestMatcher(
-    store: string,
-    embedding: Float32Array,
-    threshold: number,
-  ): MatcherRow | null {
-    const rows = this.#db
-      .query("SELECT id, store, description, embedding, model, created_at, updated_at FROM prediction_matchers WHERE store = ? AND embedding IS NOT NULL")
-      .all(store) as any[];
+  findNearestPrediction(store: string, embedding: Float32Array, threshold: number) {
+    return this.#predictions.findNearestPrediction(store, embedding, threshold);
+  }
 
-    let best: { row: any; score: number } | null = null;
-    for (const r of rows) {
-      const emb = blobToVector(r.embedding);
-      if (emb.length !== embedding.length) continue;
-      const score = cosineSimilarity(embedding, emb);
-      if (score >= threshold && (!best || score > best.score)) {
-        best = { row: r, score };
-      }
-    }
-    if (!best) return null;
-    return best.row as MatcherRow;
+  createPrediction(store: string, statement: string, rationale: string, embedding: Float32Array, model: string) {
+    return this.#predictions.createPrediction(store, statement, rationale, embedding, model);
   }
 
-  /** Creates a new matcher (context pattern) in the store, returning its id. */
-  createMatcher(
-    store: string,
-    description: string,
-    embedding: Float32Array,
-    model: string,
-  ): string {
-    this.ensureStore(store);
-    const id = crypto.randomUUID();
-    const blob = new Uint8Array(embedding.buffer, embedding.byteOffset, embedding.byteLength);
-    const now = new Date().toISOString();
-    this.#db.run(
-      "INSERT INTO prediction_matchers (id, store, description, embedding, model, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
-      [id, store, description, blob, model, now, now] as any,
-    );
-    return id;
+  createEdge(matcherId: string, predictionId: string, weight: number) {
+    return this.#predictions.createEdge(matcherId, predictionId, weight);
   }
 
-  /**
-   * Finds the nearest prediction by cosine similarity across the
-   * entire store (not scoped to a single matcher's edges). This
-   * prevents duplicate predictions: when a new matcher is created,
-   * it can link to an existing prediction via a new edge rather
-   * than creating a second row with the same statement.
-   */
-  findNearestPrediction(
-    store: string,
-    embedding: Float32Array,
-    threshold: number,
-  ): PredictionRow | null {
-    const rows = this.#db
-      .query(
-        `SELECT id, store, statement, rationale, confidence, confirm_count, disconfirm_count, created_at, updated_at, embedding
-         FROM predictions
-         WHERE store = ? AND embedding IS NOT NULL`,
-      )
-      .all(store) as any[];
+  adjustConfidence(predictionId: string, signal: "confirm" | "disconfirm" | "soft") {
+    return this.#predictions.adjustConfidence(predictionId, signal);
+  }
 
-    let best: { row: any; score: number } | null = null;
-    for (const r of rows) {
-      const emb = blobToVector(r.embedding);
-      if (emb.length !== embedding.length) continue;
-      const score = cosineSimilarity(embedding, emb);
-      if (score >= threshold && (!best || score > best.score)) {
-        best = { row: r, score };
-      }
-    }
-    if (!best) return null;
-    const { embedding: _, ...rest } = best.row;
-    return rest as PredictionRow;
+  getPrediction(predictionId: string) {
+    return this.#predictions.getPrediction(predictionId);
   }
 
-  /**
-   * Creates a new prediction, returning its id. Confidence is seeded
-   * at p0 (the population prior).
-   */
-  createPrediction(
-    store: string,
-    statement: string,
-    rationale: string,
-    embedding: Float32Array,
-    model: string,
-  ): string {
-    this.ensureStore(store);
-    const id = crypto.randomUUID();
-    const blob = new Uint8Array(embedding.buffer, embedding.byteOffset, embedding.byteLength);
-    const now = new Date().toISOString();
-    this.#db.run(
-      `INSERT INTO predictions (id, store, statement, rationale, embedding, model, confidence, confirm_count, disconfirm_count, created_at, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, 0, 0, ?, ?)`,
-      [id, store, statement, rationale, blob, model, ThatchDB.PREDICTION_P0, now, now] as any,
-    );
-    return id;
+  addProvenance(predictionId: string, signal: string, detail: string) {
+    return this.#predictions.addProvenance(predictionId, signal, detail);
   }
 
-  /** Ensures an edge links a matcher to a prediction. Does not overwrite existing edge weight. */
-  createEdge(matcherId: string, predictionId: string, weight: number): void {
-    const now = new Date().toISOString();
-    this.#db.run(
-      `INSERT INTO prediction_edges (matcher_id, prediction_id, weight, created_at)
-       VALUES (?, ?, ?, ?)
-       ON CONFLICT(matcher_id, prediction_id) DO NOTHING`,
-      [matcherId, predictionId, weight, now] as any,
-    );
+  getProvenance(predictionId: string) {
+    return this.#predictions.getProvenance(predictionId);
   }
 
-/**
-   * Adjusts a prediction's confidence by applying a signal, then
-   * recomputing the Bayesian posterior. Mirrors samskara's
-   * samskara_apply_evaluation: discount prior evidence is NOT applied
-   * in v1 (no wall-clock decay), so counts accumulate monotonically.
-   *
-   * Signal mapping: "confirm" adds 1 to confirm_count; "disconfirm"
-   * adds 1 to disconfirm_count; "soft" adds W_SOFT (0.25) to
-   * disconfirm_count. The asymmetry (soft is a weak disconfirm, not
-   * a weak confirm) is intentional: a soft signal means the user
-   * partially disagreed, not partially agreed. There is no soft
-   * confirm; use "confirm" for weak agreement.
-   */
-  adjustConfidence(predictionId: string, signal: "confirm" | "disconfirm" | "soft"): void {
-    const deltaConfirm = signal === "confirm" ? 1 : 0;
-    const deltaDisconfirm = signal === "disconfirm" ? 1 : (signal === "soft" ? ThatchDB.PREDICTION_W_SOFT : 0);
-    const k = ThatchDB.PREDICTION_K;
-    const p0 = ThatchDB.PREDICTION_P0;
-    const now = new Date().toISOString();
-    // Atomic UPDATE: uses the OLD column values in the confidence
-    // expression, so (confirm_count + deltaConfirm) equals the new
-    // confirm_count. No read-modify-write race between connections.
-    this.#db.run(
-      `UPDATE predictions
-       SET confirm_count = confirm_count + ?,
-           disconfirm_count = disconfirm_count + ?,
-           confidence = (confirm_count + ? + ? * ?) / (confirm_count + ? + disconfirm_count + ? + ?),
-           updated_at = ?
-       WHERE id = ?`,
-      [deltaConfirm, deltaDisconfirm, deltaConfirm, k, p0, deltaConfirm, deltaDisconfirm, k, now, predictionId] as any,
-    );
+  deletePrediction(predictionId: string) {
+    return this.#predictions.deletePrediction(predictionId);
   }
 
-  /**
-   * Returns the population prior p0 for a store. Falls back to
-   * PREDICTION_P0 (0.5) when total evidence < 20; otherwise returns
-   * confirm_count / total_evidence. v2 feature: not yet wired into
-   * createPrediction, which uses flat PREDICTION_P0. v1 uses the
-   * flat prior until enough evidence exists to derive a population rate.
-   */
-  populationP0(store: string): number {
-    const row = this.#db
-      .query(
-        `SELECT SUM(confirm_count) AS c, SUM(disconfirm_count) AS d FROM predictions WHERE store = ?`,
-      )
-      .get(store) as { c: number | null; d: number | null } | null;
-    const total = (row?.c ?? 0) + (row?.d ?? 0);
-    if (total < 20) return ThatchDB.PREDICTION_P0;
-    return row!.c! / total;
+  listPredictions(store: string) {
+    return this.#predictions.listPredictions(store);
   }
 
-  /**
-   * Returns a prediction's metadata by id. Does not return the
-   * embedding/model columns (creation-only, used by findNearestPrediction
-   * for dedup at write time, not needed for display or scoring).
-   */
-  getPrediction(predictionId: string): PredictionRow | null {
-    const row = this.#db
-      .query(
-        "SELECT id, store, statement, rationale, confidence, confirm_count, disconfirm_count, created_at, updated_at FROM predictions WHERE id = ?",
-      )
-      .get(predictionId) as any;
-    if (!row) return null;
-    return row as PredictionRow;
+  // ---------------------------------------------------------------------------
+  // Behavior engine: delegates to BehaviorEngine
+  // ---------------------------------------------------------------------------
+
+  findBehaviorMatchers(stores: string[], queryEmbedding: Float32Array, opts?: { limit?: number }) {
+    return this.#behaviors.findBehaviorMatchers(stores, queryEmbedding, opts);
   }
 
-  /**
-   * Records a provenance entry (signal type + detail) for a prediction.
-   * Provenance is an audit trail for the inspector and agent.
-   */
-  addProvenance(predictionId: string, signal: string, detail: string): void {
-    const id = crypto.randomUUID();
-    this.#db.run(
-      "INSERT INTO prediction_provenance (id, prediction_id, signal, detail) VALUES (?, ?, ?, ?)",
-      [id, predictionId, signal, detail] as any,
-    );
+  scoreBehaviors(matchers: { id: string; description: string; score: number }[]) {
+    return this.#behaviors.scoreBehaviors(matchers);
   }
 
-  /** Returns recent provenance entries for a prediction (newest first). */
-  getProvenance(predictionId: string): { signal: string; detail: string | null; created_at: string }[] {
-    return this.#db
-      .query("SELECT signal, detail, created_at FROM prediction_provenance WHERE prediction_id = ? ORDER BY rowid DESC LIMIT 10")
-      .all(predictionId) as any[];
-  }
-
-  /** Deletes a prediction. Edges and provenance cascade via FK ON DELETE CASCADE. */
-  deletePrediction(predictionId: string): boolean {
-    const result = this.#db.run("DELETE FROM predictions WHERE id = ?", [predictionId]);
-    return result.changes > 0;
-  }
-
-  /** Lists all predictions with their matchers, for the inspector. */
-  listPredictions(store: string): {
-    id: string;
-    statement: string;
-    rationale: string | null;
-    confidence: number;
-    evidence_count: number;
-    matchers: { id: string; description: string; weight: number }[];
-  }[] {
-    const predRows = this.#db
-      .query(
-        `SELECT id, statement, rationale, confidence, confirm_count, disconfirm_count
-         FROM predictions WHERE store = ? ORDER BY confidence DESC`,
-      )
-      .all(store) as any[];
+  scoreBehaviorNudge(stores: string[], embedding: Float32Array, threshold: number, limit = 5) {
+    return this.#behaviors.scoreBehaviorNudge(stores, embedding, threshold, limit);
+  }
 
-    return predRows.map((p) => {
-      const edgeRows = this.#db
-        .query(
-          `SELECT e.matcher_id, e.weight, m.description
-           FROM prediction_edges e
-           JOIN prediction_matchers m ON e.matcher_id = m.id
-           WHERE e.prediction_id = ?`,
-        )
-        .all(p.id) as any[];
-      return {
-        id: p.id,
-        statement: p.statement,
-        rationale: p.rationale,
-        confidence: Math.round(p.confidence * 1000) / 1000,
-        evidence_count: Math.round(p.confirm_count + p.disconfirm_count),
-        matchers: edgeRows.map((e) => ({
-          id: e.matcher_id,
-          description: e.description,
-          weight: e.weight,
-        })),
-      };
-    });
+  findNearestBehaviorMatcher(store: string, embedding: Float32Array, threshold: number) {
+    return this.#behaviors.findNearestBehaviorMatcher(store, embedding, threshold);
+  }
+
+  createBehaviorMatcher(store: string, description: string, embedding: Float32Array, model: string) {
+    return this.#behaviors.createBehaviorMatcher(store, description, embedding, model);
+  }
+
+  findNearestBehavior(store: string, embedding: Float32Array, threshold: number) {
+    return this.#behaviors.findNearestBehavior(store, embedding, threshold);
+  }
+
+  createBehavior(store: string, statement: string, rationale: string, embedding: Float32Array, model: string) {
+    return this.#behaviors.createBehavior(store, statement, rationale, embedding, model);
+  }
+
+  createBehaviorEdge(matcherId: string, behaviorId: string, weight: number) {
+    return this.#behaviors.createBehaviorEdge(matcherId, behaviorId, weight);
+  }
+
+  adjustBehaviorConfidence(behaviorId: string, signal: "confirm" | "disconfirm" | "soft") {
+    return this.#behaviors.adjustBehaviorConfidence(behaviorId, signal);
+  }
+
+  getBehavior(behaviorId: string) {
+    return this.#behaviors.getBehavior(behaviorId);
+  }
+
+  addBehaviorProvenance(behaviorId: string, signal: string, detail: string) {
+    return this.#behaviors.addBehaviorProvenance(behaviorId, signal, detail);
+  }
+
+  getBehaviorProvenance(behaviorId: string) {
+    return this.#behaviors.getBehaviorProvenance(behaviorId);
+  }
+
+  deleteBehavior(behaviorId: string) {
+    return this.#behaviors.deleteBehavior(behaviorId);
+  }
+
+  listBehaviors(store: string) {
+    return this.#behaviors.listBehaviors(store);
   }
 
   // ---------------------------------------------------------------------------
@@ -985,38 +763,3 @@ export class ThatchDB {
     this.#db.close();
   }
 }
-
-// ---------------------------------------------------------------------------
-// Vector math
-// ---------------------------------------------------------------------------
-
-/**
- * Reconstructs a Float32Array from a stored BLOB. The Uint8Array bun:sqlite
- * hands back may itself be a view, so honor its offset and length rather than
- * reading the whole backing buffer.
- */
-function blobToVector(blob: Uint8Array): Float32Array {
-  return new Float32Array(blob.buffer, blob.byteOffset, blob.byteLength / 4);
-}
-
-/**
- * Cosine similarity between two Float32Array vectors of equal dimension.
- * Returns a value in [-1, 1]. Normalized embeddings will be close to [0, 1].
- * Throws on dimension mismatch - comparing vectors from different embedding
- * spaces is always a caller bug; callers filter by length first.
- */
-export function cosineSimilarity(a: Float32Array, b: Float32Array): number {
-  if (a.length !== b.length) {
-    throw new Error(`cosineSimilarity: dimension mismatch (${a.length} vs ${b.length})`);
-  }
-  let dot = 0;
-  let magA = 0;
-  let magB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dot += a[i] * b[i];
-    magA += a[i] * a[i];
-    magB += b[i] * b[i];
-  }
-  const denominator = Math.sqrt(magA) * Math.sqrt(magB);
-  return denominator === 0 ? 0 : dot / denominator;
-}