@jeffober/thatch 0.1.18 → 0.1.19

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}`);
       }
     },
 

package/src/prompts.ts

@@ -1,3 +1,5 @@
+import type { PredictionNudgeItem } from "./db";
+
 export function systemPrompt(repo: string): string {
   return `# Persistence
 
@@ -7,7 +9,9 @@ knowledge so future sessions can build on what you've already learned.
 Tools: thatch_memory_remember, thatch_memory_recall, thatch_memory_list,
        thatch_memory_show, thatch_memory_forget, thatch_store_list,
        thatch_find_duplicates, thatch_dedup_mark_checked,
-       thatch_extraction_done
+       thatch_extraction_done,
+       thatch_prediction_query, thatch_prediction_update, thatch_prediction_list,
+       thatch_prediction_delete
 
 ## Stores
 
@@ -60,6 +64,27 @@ whether you've discovered knowledge worth persisting. Use thatch_memory_recall
 to check for duplicates, then thatch_memory_remember for new findings. Then
 deliver your response.
 
+## User Decision Model
+
+A statistical model of the user's decision-making preferences is maintained by
+the prediction engine. Scored predictions may appear above as "User decision
+model" context; these are learned patterns about what the user tends to
+prefer in specific situations.
+
+When facing a judgment call about scope, appropriateness, or methodology:
+- If a prediction is strong (high confidence, sufficient evidence), follow it
+- If predictions conflict or confidence is thin, surface the uncertainty
+  naturally: "I think you usually prefer X here, but I'm not sure; what do
+  you want?"
+- When the user responds to a surfaced prediction, use thatch_prediction_update
+  to reinforce or weaken the model
+
+When the user corrects you, answers your question, or provides a clear signal
+about their preferences:
+1. Use thatch_prediction_query to check for existing matchers and predictions
+2. Use thatch_prediction_update to create, reinforce, or weaken a prediction
+3. Use thatch_prediction_delete to remove a prediction created in error
+
 ## What to Store
 
 - **Global store**: user observations, agent personality, system environment
@@ -150,8 +175,9 @@ Tools are prefixed in Claude Code: \`mcp__thatch__memory_remember\`,
 \`mcp__thatch__memory_recall\`, \`mcp__thatch__memory_list\`,
 \`mcp__thatch__memory_show\`, \`mcp__thatch__memory_forget\`,
 \`mcp__thatch__store_list\`, \`mcp__thatch__find_duplicates\`,
-\`mcp__thatch__dedup_mark_checked\`, \`mcp__thatch__extraction_done\`.
-Bare names used below for readability.
+\`mcp__thatch__dedup_mark_checked\`, \`mcp__thatch__extraction_done\`,
+\`mcp__thatch__prediction_query\`, \`mcp__thatch__prediction_update\`,
+\`mcp__thatch__prediction_list\`, \`mcp__thatch__prediction_delete\`. Bare names used below for readability.
 
 ## Stores
 
@@ -204,6 +230,27 @@ whether you've discovered knowledge worth persisting. Use memory_recall to
 check for duplicates, then memory_remember for new findings. Then deliver
 your response.
 
+## User Decision Model
+
+A statistical model of the user's decision-making preferences is maintained by
+the prediction engine. Scored predictions may appear above as "User decision
+model" context; these are learned patterns about what the user tends to
+prefer in specific situations.
+
+When facing a judgment call about scope, appropriateness, or methodology:
+- If a prediction is strong (high confidence, sufficient evidence), follow it
+- If predictions conflict or confidence is thin, surface the uncertainty
+  naturally: "I think you usually prefer X here, but I'm not sure; what do
+  you want?"
+- When the user responds to a surfaced prediction, use prediction_update
+  to reinforce or weaken the model
+
+When the user corrects you, answers your question, or provides a clear signal
+about their preferences:
+1. Use prediction_query to check for existing matchers and predictions
+2. Use prediction_update to create, reinforce, or weaken a prediction
+3. Use prediction_delete to remove a prediction created in error
+
 ## What to Store
 
 - **Global store**: user observations, agent personality, system environment
@@ -356,8 +403,9 @@ Tools are prefixed in Cursor: \`mcp__thatch__memory_remember\`,
 \`mcp__thatch__memory_recall\`, \`mcp__thatch__memory_list\`,
 \`mcp__thatch__memory_show\`, \`mcp__thatch__memory_forget\`,
 \`mcp__thatch__store_list\`, \`mcp__thatch__find_duplicates\`,
-\`mcp__thatch__dedup_mark_checked\`, \`mcp__thatch__extraction_done\`.
-Bare names used below for readability.
+\`mcp__thatch__dedup_mark_checked\`, \`mcp__thatch__extraction_done\`,
+\`mcp__thatch__prediction_query\`, \`mcp__thatch__prediction_update\`,
+\`mcp__thatch__prediction_list\`, \`mcp__thatch__prediction_delete\`. Bare names used below for readability.
 
 ## Stores
 
@@ -410,6 +458,27 @@ whether you've discovered knowledge worth persisting. Use memory_recall to
 check for duplicates, then memory_remember for new findings. Then deliver
 your response.
 
+## User Decision Model
+
+A statistical model of the user's decision-making preferences is maintained by
+the prediction engine. Scored predictions may appear above as "User decision
+model" context; these are learned patterns about what the user tends to
+prefer in specific situations.
+
+When facing a judgment call about scope, appropriateness, or methodology:
+- If a prediction is strong (high confidence, sufficient evidence), follow it
+- If predictions conflict or confidence is thin, surface the uncertainty
+  naturally: "I think you usually prefer X here, but I'm not sure; what do
+  you want?"
+- When the user responds to a surfaced prediction, use prediction_update
+  to reinforce or weaken the model
+
+When the user corrects you, answers your question, or provides a clear signal
+about their preferences:
+1. Use prediction_query to check for existing matchers and predictions
+2. Use prediction_update to create, reinforce, or weaken a prediction
+3. Use prediction_delete to remove a prediction created in error
+
 ## What to Store
 
 - **Global store**: user observations, agent personality, system environment
@@ -495,3 +564,18 @@ function formatRecallNudge(matches: NudgeMatch[], toolName: string): string {
   const etc = n > 2 ? ", etc." : "";
   return `[thatch] ${n} ${word} ${verb} to this prompt (${labels}${etc}). Use ${toolName} before responding.`;
 }
+
+// ---------------------------------------------------------------------------
+// Prediction nudge: auto-injected when matchers fire for the user's prompt.
+// Descriptive, not directive: the system prompt instructions govern how to
+// act on the scored predictions (follow strong, surface weak/competing,
+// update on user response).
+// ---------------------------------------------------------------------------
+
+export function predictionNudge(items: PredictionNudgeItem[]): string {
+  const lines = items.map((p) => {
+    const verb = p.evidence_count === 0 ? "you may prefer" : "you tend to";
+    return `- [${p.confidence.toFixed(2)} conf, ${p.evidence_count} tests] When ${p.matcher_description}: ${verb} ${p.statement}`;
+  });
+  return `[thatch] User decision model\n${lines.join("\n")}`;
+}

package/src/sideband.ts

@@ -3,7 +3,7 @@ import { unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createServer, connect, type Server, type Socket } from "node:net";
-import type { ThatchDB } from "./db";
+import type { ThatchDB, PredictionNudgeItem } from "./db";
 import type { EmbeddingModel } from "./embeddings";
 
 /**
@@ -24,7 +24,7 @@ export interface SidebandMatch {
 }
 
 interface MatchRequest {
-  method: "match";
+  method: "match" | "predictions";
   text: string;
   stores: string[];
   threshold: number;
@@ -34,6 +34,7 @@ interface MatchRequest {
 interface MatchResponse {
   ok: boolean;
   matches?: SidebandMatch[];
+  predictions?: PredictionNudgeItem[];
   error?: string;
 }
 
@@ -115,13 +116,22 @@ export class SidebandServer {
       return;
     }
 
-    if (req.method !== "match") {
+    if (req.method !== "match" && req.method !== "predictions") {
       this.#respond(socket, { ok: false, error: `Unknown method: ${req.method}` });
       return;
     }
 
     try {
       const embedding = await this.#model.queryEmbed(req.text);
+
+      if (req.method === "predictions") {
+        const predictions = this.#db.scorePredictionNudge(
+          req.stores, embedding, req.threshold, 5,
+        );
+        this.#respond(socket, { ok: true, predictions });
+        return;
+      }
+
       const results = this.#db.search(req.stores, embedding, { limit: req.limit });
       const matches: SidebandMatch[] = results
         .filter((r) => r._score >= req.threshold)
@@ -156,16 +166,45 @@ export function sidebandMatch(
   limit: number,
   timeoutMs = 2000,
 ): Promise<SidebandMatch[] | null> {
+  return sidebandRequest("match", socketPath, text, stores, threshold, limit, timeoutMs)
+    .then((res) => res?.matches ?? null);
+}
+
+/**
+ * Connect to the sideband server and request scored predictions for a prompt.
+ * Returns null on any failure; callers treat null as "skip the prediction nudge."
+ */
+export function sidebandPredictions(
+  socketPath: string,
+  text: string,
+  stores: string[],
+  threshold: number,
+  limit: number,
+  timeoutMs = 2000,
+): Promise<PredictionNudgeItem[] | null> {
+  return sidebandRequest("predictions", socketPath, text, stores, threshold, limit, timeoutMs)
+    .then((res) => res?.predictions ?? null);
+}
+
+function sidebandRequest(
+  method: "match" | "predictions",
+  socketPath: string,
+  text: string,
+  stores: string[],
+  threshold: number,
+  limit: number,
+  timeoutMs: number,
+): Promise<MatchResponse | null> {
   return new Promise((resolve) => {
     let settled = false;
-    const done = (val: SidebandMatch[] | null) => {
+    const done = (val: MatchResponse | null) => {
       if (settled) return;
       settled = true;
       resolve(val);
     };
 
     const socket = connect(socketPath);
-    const req = JSON.stringify({ method: "match", text, stores, threshold, limit }) + "\n";
+    const req = JSON.stringify({ method, text, stores, threshold, limit }) + "\n";
     let buf = "";
 
     const timer = setTimeout(() => {
@@ -173,14 +212,13 @@ export function sidebandMatch(
       done(null);
     }, timeoutMs);
 
-    socket.on("error", () => {
+    socket.on("error", (err: NodeJS.ErrnoException) => {
       clearTimeout(timer);
-      // Stale socket file left by a crashed server — clean it up so the next
-      // connection attempt doesn't hit ECONNREFUSED again.
-      try {
-        unlinkSync(socketPath);
-      } catch {
-        // Already gone or never existed.
+      // Only remove the socket file if it's a stale-file situation
+      // (ECONNREFUSED). Other errors (timeout, server error) should
+      // not delete a live server's socket.
+      if (err.code === "ECONNREFUSED" || err.code === "ENOENT") {
+        try { unlinkSync(socketPath); } catch { /* already gone */ }
       }
       done(null);
     });
@@ -197,7 +235,7 @@ export function sidebandMatch(
       clearTimeout(timer);
       try {
         const res = JSON.parse(buf.slice(0, nl)) as MatchResponse;
-        done(res.ok ? (res.matches ?? []) : null);
+        done(res);
       } catch {
         done(null);
       }

package/src/tool-defs.ts

@@ -2,6 +2,17 @@ import { z } from "zod";
 import type { ThatchDB, DedupCandidate } from "./db";
 import type { EmbeddingModel } from "./embeddings";
 
+// Near-duplicate thresholds for matcher/prediction dedup at creation time.
+// Matches the thatch_find_duplicates threshold (0.85).
+const MATCHER_DEDUP_COSINE = 0.85;
+const PREDICTION_DEDUP_COSINE = 0.85;
+
+// Minimum matcher cosine to consider a prediction relevant. Matches the
+// auto-fire threshold in index.ts (PREDICTION_THRESHOLD). The query tool
+// should not return predictions from near-zero-similarity matchers that
+// would never fire in the auto-fire.
+const PREDICTION_QUERY_THRESHOLD = 0.45;
+
 /**
  * Shared context passed to every tool's execute function. Framework-agnostic —
  * neither opencode nor MCP specific. The plugin wires real defaults; tests and
@@ -367,6 +378,194 @@ const extractionDoneDef: ToolDef = {
   },
 };
 
+// ---------------------------------------------------------------------------
+// Prediction engine: user decision model
+// ---------------------------------------------------------------------------
+
+const predictionQueryDef: ToolDef = {
+  name: "prediction_query",
+  description:
+    "Query the user decision model for scored predictions matching a " +
+    "context. Returns predictions with confidence and evidence count. " +
+    "Use when facing a judgment call about scope, appropriateness, or " +
+    "methodology and the auto-injected prediction block did not already " +
+    "cover the situation.",
+  args: {
+    context: z.string().describe(
+      "The situation or context to match against. Describe the decision being faced.",
+    ),
+    store: z.string().optional().describe(
+      "Store to search. Defaults to the project store and global together.",
+    ),
+  },
+  async execute(args, ctx) {
+    const stores = args.store
+      ? [args.store as string]
+      : [ctx.defaultStore, "global"];
+    const embedding = await ctx.model.queryEmbed(args.context as string);
+    const matchers = ctx.db.findMatchers(stores, embedding, { limit: 5 })
+      .filter((m) => m.score >= PREDICTION_QUERY_THRESHOLD);
+    if (matchers.length === 0) return "No matching predictions found.";
+    const scored = ctx.db.scorePredictions(matchers);
+    if (scored.length === 0) return "No matching predictions found.";
+    return scored.map((s) => {
+      const verb = s.evidence_count === 0 ? "you may prefer" : "you tend to";
+      return `[${s.confidence.toFixed(2)} conf, ${s.evidence_count} tests] ` +
+        `When ${s.matcher_description}: ${verb} ${s.statement}`;
+    }).join("\n");
+  },
+};
+
+const predictionUpdateDef: ToolDef = {
+  name: "prediction_update",
+  description:
+    "Create, reinforce, or weaken a prediction in the user decision " +
+    "model. Use when the user corrects you, answers a question, or " +
+    "provides a clear signal about their preferences or decision-making " +
+    "strategy. The tool handles matcher and prediction lookup, dedup, " +
+    "and confidence adjustment automatically.",
+  args: {
+    matcher: z.string().describe(
+      "Description of the situation. What decision was being made?",
+    ),
+    prediction: z.string().describe(
+      "The user's preference or tendency in this situation.",
+    ),
+    signal: z.enum(["confirm", "disconfirm", "soft", "create"]).describe(
+      "What happened: confirm (user confirmed the prediction), " +
+      "disconfirm (user pushed back), soft (weak disconfirm, user " +
+      "partially disagreed), create (new observation).",
+    ),
+    rationale: z.string().describe(
+      "Why this prediction was formed or updated. What did the user say or do?",
+    ),
+    store: z.string().optional().describe(
+      "Store to write to. Defaults to the project store.",
+    ),
+  },
+  async execute(args, ctx) {
+    const store = (args.store as string) || ctx.defaultStore;
+    const matcherText = args.matcher as string;
+    const predictionText = args.prediction as string;
+    const signal = args.signal as "confirm" | "disconfirm" | "soft" | "create";
+    const rationale = args.rationale as string;
+
+    const matcherEmbed = await ctx.model.passageEmbed(matcherText);
+    const predEmbed = await ctx.model.passageEmbed(predictionText);
+
+    // All read-modify-write mutations run inside a transaction so a
+    // failure mid-sequence (FK violation, I/O error) rolls back the
+    // entire operation rather than leaving orphans (matcher without
+    // prediction, prediction without edge, edge without confidence).
+    return ctx.db.transaction(() => {
+      // Dedup matchers: find an existing matcher above the cosine threshold
+      // rather than always creating a new one.
+      let matcherId = ctx.db.findNearestMatcher(store, matcherEmbed, MATCHER_DEDUP_COSINE)?.id;
+      if (!matcherId) matcherId = ctx.db.createMatcher(store, matcherText, matcherEmbed, ctx.model.name);
+
+      // Store-wide dedup: search the entire store for a near-identical
+      // prediction, not just this matcher's edges. If found, link this
+      // matcher to the existing prediction via an edge rather than
+      // creating a second row with the same statement.
+      let predictionId = ctx.db.findNearestPrediction(store, predEmbed, PREDICTION_DEDUP_COSINE)?.id;
+
+      if (!predictionId) {
+        // No near-identical prediction exists; create one and link it.
+        predictionId = ctx.db.createPrediction(store, predictionText, rationale, predEmbed, ctx.model.name);
+        ctx.db.createEdge(matcherId, predictionId, 1.0);
+
+        // When the signal is confirm/disconfirm/soft (not create), apply
+        // it immediately so the first signal isn't lost. The prediction
+        // starts at p0 with 0 evidence; without this, the agent's
+        // "confirm" would be discarded and the prediction would have
+        // 0 confirms.
+        if (signal !== "create") {
+          ctx.db.adjustConfidence(predictionId, signal === "soft" ? "soft" : signal === "confirm" ? "confirm" : "disconfirm");
+          ctx.db.addProvenance(predictionId, signal, rationale);
+          const updated = ctx.db.getPrediction(predictionId);
+          return `[created + ${signal}] "${updated?.statement ?? predictionText}" confidence=${(updated?.confidence ?? 0).toFixed(2)} (${updated?.confirm_count ?? 0}/${updated?.disconfirm_count ?? 0})`;
+        }
+        ctx.db.addProvenance(predictionId, "create", rationale);
+        return `[created] ${store} :: "${predictionText}" for "${matcherText}"`;
+      }
+
+      // Ensure an edge links this matcher to the existing prediction.
+      // createEdge uses ON CONFLICT DO NOTHING, so existing edge weights
+      // are preserved.
+      ctx.db.createEdge(matcherId, predictionId, 1.0);
+
+      // "create" on an existing prediction means the agent re-observed
+      // the same preference in a new context. Link the edge and record
+      // provenance, but do NOT adjust confidence — "create" is
+      // confidence-neutral, not a disconfirm.
+      if (signal === "create") {
+        ctx.db.addProvenance(predictionId, "create", rationale);
+        const existing = ctx.db.getPrediction(predictionId);
+        return `[linked] "${existing?.statement ?? predictionText}" for "${matcherText}" confidence=${(existing?.confidence ?? 0).toFixed(2)} (${existing?.confirm_count ?? 0}/${existing?.disconfirm_count ?? 0})`;
+      }
+
+      // Signal is confirm, disconfirm, or soft. Map the tool's 4-value
+      // enum to adjustConfidence's 3-value enum.
+      ctx.db.adjustConfidence(predictionId, signal === "soft" ? "soft" : signal === "confirm" ? "confirm" : "disconfirm");
+      ctx.db.addProvenance(predictionId, signal, rationale);
+      const updated = ctx.db.getPrediction(predictionId);
+      return `[${signal}] "${updated?.statement ?? predictionText}" confidence=${(updated?.confidence ?? 0).toFixed(2)} (${updated?.confirm_count ?? 0}/${updated?.disconfirm_count ?? 0})`;
+    });
+  },
+};
+
+const predictionListDef: ToolDef = {
+  name: "prediction_list",
+  description:
+    "List all predictions in the user decision model with their matchers, " +
+    "confidence, and evidence count. For inspection and debugging.",
+  args: {
+    store: z.string().optional().describe(
+      "Which store to list. Defaults to the project store.",
+    ),
+  },
+  async execute(args, ctx) {
+    const store = (args.store as string) || ctx.defaultStore;
+    const predictions = ctx.db.listPredictions(store);
+    if (predictions.length === 0) return `No predictions in "${store}".`;
+    return predictions.map((p) => {
+      const matchers = p.matchers.map((m) => `    - "${m.description}" (w:${m.weight})`).join("\n");
+      const provenance = ctx.db.getProvenance(p.id);
+      const provLines = provenance.map((pr) => `    - [${pr.created_at.slice(0, 10)}] ${pr.signal}: ${pr.detail ?? ""}`).join("\n");
+      return `[${p.confidence.toFixed(2)} conf, ${p.evidence_count} tests] ${p.statement}` +
+        (p.rationale ? `\n  rationale: ${p.rationale}` : "") +
+        (matchers ? `\n  matchers:\n${matchers}` : "") +
+        (provLines ? `\n  provenance:\n${provLines}` : "");
+    }).join("\n\n");
+  },
+};
+
+const predictionDeleteDef: ToolDef = {
+  name: "prediction_delete",
+  description:
+    "Delete a prediction from the user decision model. Useful when a " +
+    "prediction was created in error or is no longer relevant. Edges " +
+    "and provenance are deleted automatically (cascade).",
+  args: {
+    statement: z.string().describe(
+      "The prediction statement to delete. Use prediction_list to find the exact text; matching is semantic (cosine >= 0.85).",
+    ),
+    store: z.string().optional().describe(
+      "Store to delete from. Defaults to the project store.",
+    ),
+  },
+  async execute(args, ctx) {
+    const store = (args.store as string) || ctx.defaultStore;
+    const statementText = args.statement as string;
+    const predEmbed = await ctx.model.passageEmbed(statementText);
+    const prediction = ctx.db.findNearestPrediction(store, predEmbed, PREDICTION_DEDUP_COSINE);
+    if (!prediction) return `No prediction matching "${statementText}" found in "${store}".`;
+    const deleted = ctx.db.deletePrediction(prediction.id);
+    if (!deleted) return `Failed to delete prediction "${prediction.statement}".`;
+    return `[deleted] "${prediction.statement}" from "${store}"`;
+  },
+};
+
 /**
  * All tool definitions, in the order they should be presented to the agent.
  * The opencode plugin wraps each in `tool()`; the MCP server exposes them
@@ -382,4 +581,8 @@ export const TOOL_DEFS: ToolDef[] = [
   findDuplicatesDef,
   markCheckedDef,
   extractionDoneDef,
+  predictionQueryDef,
+  predictionUpdateDef,
+  predictionListDef,
+  predictionDeleteDef,
 ];