@jeffober/thatch 0.1.18 → 0.1.20

package/src/db.ts

@@ -34,6 +34,46 @@ 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
@@ -46,6 +86,12 @@ export class ThatchDB {
     this.#db = new Database(path, { create: true });
     this.#db.run("PRAGMA journal_mode = WAL");
     this.#db.run("PRAGMA busy_timeout = 5000");
+    // Enforce FK constraints per connection. The prediction tables use
+    // ON DELETE CASCADE for edges and provenance; enabling this pragma
+    // ensures those cascades fire. Also enforces the entries table's
+    // existing FK to stores(name), which was declarative but unenforced
+    // before this branch.
+    this.#db.run("PRAGMA foreign_keys = ON");
     this.#initSchema();
   }
 
@@ -90,6 +136,57 @@ export class ThatchDB {
       )
     `);
 
+    this.#db.run(`
+      CREATE TABLE IF NOT EXISTS prediction_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 predictions (
+        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 prediction_edges (
+        matcher_id    TEXT NOT NULL,
+        prediction_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, prediction_id),
+        FOREIGN KEY (matcher_id) REFERENCES prediction_matchers(id) ON DELETE CASCADE,
+        FOREIGN KEY (prediction_id) REFERENCES predictions(id) ON DELETE CASCADE
+      )
+    `);
+
+    this.#db.run(`
+      CREATE TABLE IF NOT EXISTS prediction_provenance (
+        id            TEXT PRIMARY KEY,
+        prediction_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 (prediction_id) REFERENCES predictions(id) ON DELETE CASCADE
+      )
+    `);
+
     this.#db.run("INSERT OR IGNORE INTO stores (name) VALUES ('global')");
 
     this.#migrateColumns();
@@ -456,6 +553,383 @@ export class ThatchDB {
     return new Set(rows.map((r: any) => [r.slug_a, r.slug_b].sort().join("|")));
   }
 
+  // ---------------------------------------------------------------------------
+  // Prediction engine: matchers, predictions, edges, provenance
+  // ---------------------------------------------------------------------------
+
+  // 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;
+
+  /**
+   * 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[];
+
+    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);
+  }
+
+  /**
+   * 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[];
+
+    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;
+    });
+  }
+
+  /**
+   * 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,
+      }));
+  }
+
+  /**
+   * 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[];
+
+    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;
+  }
+
+  /** 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;
+  }
+
+  /**
+   * 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[];
+
+    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;
+  }
+
+  /**
+   * 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;
+  }
+
+  /** 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,
+    );
+  }
+
+/**
+   * 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,
+    );
+  }
+
+  /**
+   * 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;
+  }
+
+  /**
+   * 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;
+  }
+
+  /**
+   * 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,
+    );
+  }
+
+  /** 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[];
+
+    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,
+        })),
+      };
+    });
+  }
+
   // ---------------------------------------------------------------------------
   // Hygiene — signals for the session-start heartbeat. Staleness means
   // neither written nor recalled since the cutoff; recall telemetry keeps
@@ -501,6 +975,12 @@ export class ThatchDB {
     );
   }
 
+  /** Runs fn inside a SQLite transaction (BEGIN/COMMIT/ROLLBACK). */
+  transaction<T>(fn: () => T): T {
+    const t = this.#db.transaction(fn);
+    return t();
+  }
+
   close(): void {
     this.#db.close();
   }

package/src/index.ts

@@ -10,6 +10,7 @@ import {
   sessionStartReminder,
   recallNudge,
   extractionNudge,
+  predictionNudge,
   type NudgeMatch,
 } from "./prompts";
 import { ExtractionPipeline, type ToolInteraction } from "./extraction";
@@ -29,6 +30,11 @@ const RECALL_THRESHOLD = parseFloat(process.env.THATCH_RECALL_THRESHOLD ?? "0.55
 // like "yes" or "ok" match too broadly to be useful.
 const MIN_PROMPT_LEN = 10;
 
+// Minimum cosine score for the prediction auto-fire. Lower than
+// RECALL_THRESHOLD because "this situation matches a known pattern" is
+// a weaker signal than "this prompt relates to a stored memory."
+const PREDICTION_THRESHOLD = parseFloat(process.env.THATCH_PREDICTION_THRESHOLD ?? "0.45");
+
 export const server: Plugin = async ({ client, worktree }) => {
   // The opencode server's cwd is wherever the server happened to start;
   // `worktree` is the project this plugin instance actually serves.
@@ -69,7 +75,7 @@ export const server: Plugin = async ({ client, worktree }) => {
   // (by reference identity), preserving interleaved-turn entries that arrived
   // while the sub-agent was running. Without this, the child's memory_remember
   // would drain the parent's ENTIRE buffer — silently dropping facts from
-  // any tool calls the parent made concurrenly with the sub-agent.
+  // any tool calls the parent made concurrently with the sub-agent.
   const parentSnapshots = new Map<string, ToolInteraction[]>();
 
   // Skills always install to the global opencode config — installing into the
@@ -173,9 +179,14 @@ export const server: Plugin = async ({ client, worktree }) => {
     // 4. Per-message nudge — two priority tiers:
     //   a. Extraction nudge: prior tool interactions are queued for fact
     //      extraction (carries the JSON payload for thatch-fact-extractor).
-    //   b. Recall nudge: the user's prompt semantically matches existing
-    //      memories — surface that prior knowledge exists before the agent
-    //      responds. Uses the in-process warm model (no sideband needed).
+    //   b. Recall + prediction nudge: when no extraction is pending, embed
+    //      the user's prompt (shared embedding for both) and:
+    //        - search memories by cosine (recall nudge)
+    //        - search matchers by cosine, score predictions (prediction fire)
+    //      Both fire independently; either, both, or neither may inject.
+    //      The auto-fire reuses the embedding already computed for recall,
+    //      adding only one more cosine scan against the matchers table.
+    //      No extra model calls.
     //
     // Skipped during compaction: the agent can't call tools while generating
     // a summary, so a nudge that says "use thatch_memory_recall" triggers a
@@ -212,23 +223,48 @@ export const server: Plugin = async ({ client, worktree }) => {
         if (promptText.length < MIN_PROMPT_LEN) return;
 
         const embedding = await model.queryEmbed(promptText);
-        const results = db.search([repo, "global"], embedding, { limit: 5 });
-        const matches: NudgeMatch[] = results
-          .filter((r) => r._score >= RECALL_THRESHOLD)
-          .map((r) => ({ label: r.label, score: Math.round(r._score * 1000) / 1000 }));
 
-        if (matches.length === 0) return;
+        // Recall nudge: separate try/catch so a memory-search failure
+        // does not block the prediction fire (they share only the embedding).
+        try {
+          const results = db.search([repo, "global"], embedding, { limit: 5 });
+          const matches: NudgeMatch[] = results
+            .filter((r) => r._score >= RECALL_THRESHOLD)
+            .map((r) => ({ label: r.label, score: Math.round(r._score * 1000) / 1000 }));
 
-        output.parts.push({
-          id: `prt_thatch_${Math.random().toString(36).slice(2)}`,
-          sessionID: input.sessionID,
-          messageID: input.messageID ?? output.message.id,
-          type: "text",
-          text: recallNudge(matches),
-          synthetic: true,
-        });
+          if (matches.length > 0) {
+            output.parts.push({
+              id: `prt_thatch_${Math.random().toString(36).slice(2)}`,
+              sessionID: input.sessionID,
+              messageID: input.messageID ?? output.message.id,
+              type: "text",
+              text: recallNudge(matches),
+              synthetic: true,
+            });
+          }
+        } catch (err) {
+          console.error(`[thatch] recall nudge failed: ${err}`);
+        }
+
+        // Prediction fire: independent of recall; a failure here does
+        // not affect the recall nudge that may have already been pushed.
+        try {
+          const predItems = db.scorePredictionNudge([repo, "global"], embedding, PREDICTION_THRESHOLD);
+          if (predItems.length > 0) {
+            output.parts.push({
+              id: `prt_thatch_${Math.random().toString(36).slice(2)}`,
+              sessionID: input.sessionID,
+              messageID: input.messageID ?? output.message.id,
+              type: "text",
+              text: predictionNudge(predItems),
+              synthetic: true,
+            });
+          }
+        } catch (err) {
+          console.error(`[thatch] prediction nudge failed: ${err}`);
+        }
       } catch (err) {
-        console.error(`[thatch] recall nudge failed: ${err}`);
+        console.error(`[thatch] nudge hook failed: ${err}`);
       }
     },