@jeffober/thatch 0.1.18 → 0.1.20

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
 
@@ -42,8 +46,8 @@ workflows. The host auto-discovers them, but reach for them proactively:
 - \`thatch-session-reflection\` — record what you learned at end of session.
 - \`thatch-fact-extractor\` — extract durable facts from recent tool interactions (auto-triggered by the extraction pipeline).
 - \`thatch-dedup-classifier\` — resolve duplicate memory pairs from \`thatch_find_duplicates\`.
-- \`pr-description\` — draft a PR description using instructional-design scaffolding with bold and italic emphasis on the phrases that carry the meaning, so a reviewer skimming only the emphasized fragments still gets the story.
-- \`ticket-description\` — draft a ticket, issue, or work item (Linear or Jira) using instructional-design scaffolding with bold and italic emphasis for scanning.
+- \`pr-description\` — draft a PR description with SYNOPSIS / PURPOSE / DESCRIPTION / WALK-THROUGH / NOTES, using bold and italic emphasis on the phrases that carry the meaning.
+- \`ticket-description\` — draft a ticket, issue, or work item (Linear or Jira) with clear sections and bold/italic emphasis for scanning.
 - \`split-overlarge-pr\` — split already-completed work from an overlarge PR into human-reviewable, release-safe PRs targeting main.
 
 ## When to Write
@@ -60,6 +64,35 @@ 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
+
+Code review discussions are high-signal prediction material. When working
+through potential review comments with the user, watch for preferences about
+review threshold, severity, tone, evidence, scope, false positives, or what is
+worth posting. This applies whether the user invoked a review skill, is
+reviewing your changes, or asked you to review their changes or another LLM's
+changes. Before creating a new prediction, query for an existing one and
+reinforce or adjust it when possible.
+
 ## What to Store
 
 - **Global store**: user observations, agent personality, system environment
@@ -150,8 +183,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
 
@@ -186,8 +220,8 @@ workflows. The host auto-discovers them, but reach for them proactively:
 - \`thatch-session-reflection\` — record what you learned at end of session.
 - \`thatch-fact-extractor\` — extract durable facts from recent tool interactions (auto-triggered by the extraction pipeline).
 - \`thatch-dedup-classifier\` — resolve duplicate memory pairs from \`find_duplicates\`.
-- \`pr-description\` — draft a PR description using instructional-design scaffolding with bold and italic emphasis on the phrases that carry the meaning, so a reviewer skimming only the emphasized fragments still gets the story.
-- \`ticket-description\` — draft a ticket, issue, or work item (Linear or Jira) using instructional-design scaffolding with bold and italic emphasis for scanning.
+- \`pr-description\` — draft a PR description with SYNOPSIS / PURPOSE / DESCRIPTION / WALK-THROUGH / NOTES, using bold and italic emphasis on the phrases that carry the meaning.
+- \`ticket-description\` — draft a ticket, issue, or work item (Linear or Jira) with clear sections and bold/italic emphasis for scanning.
 - \`split-overlarge-pr\` — split already-completed work from an overlarge PR into human-reviewable, release-safe PRs targeting main.
 
 ## When to Write
@@ -204,6 +238,35 @@ 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
+
+Code review discussions are high-signal prediction material. When working
+through potential review comments with the user, watch for preferences about
+review threshold, severity, tone, evidence, scope, false positives, or what is
+worth posting. This applies whether the user invoked a review skill, is
+reviewing your changes, or asked you to review their changes or another LLM's
+changes. Before creating a new prediction, query for an existing one and
+reinforce or adjust it when possible.
+
 ## What to Store
 
 - **Global store**: user observations, agent personality, system environment
@@ -356,8 +419,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
 
@@ -392,8 +456,8 @@ workflows. The host auto-discovers them, but reach for them proactively:
 - \`thatch-session-reflection\` — record what you learned at end of session.
 - \`thatch-fact-extractor\` — extract durable facts from recent tool interactions (auto-triggered by the extraction pipeline).
 - \`thatch-dedup-classifier\` — resolve duplicate memory pairs from \`find_duplicates\`.
-- \`pr-description\` — draft a PR description using instructional-design scaffolding with bold and italic emphasis on the phrases that carry the meaning, so a reviewer skimming only the emphasized fragments still gets the story.
-- \`ticket-description\` — draft a ticket, issue, or work item (Linear or Jira) using instructional-design scaffolding with bold and italic emphasis for scanning.
+- \`pr-description\` — draft a PR description with SYNOPSIS / PURPOSE / DESCRIPTION / WALK-THROUGH / NOTES, using bold and italic emphasis on the phrases that carry the meaning.
+- \`ticket-description\` — draft a ticket, issue, or work item (Linear or Jira) with clear sections and bold/italic emphasis for scanning.
 - \`split-overlarge-pr\` — split already-completed work from an overlarge PR into human-reviewable, release-safe PRs targeting main.
 
 ## When to Write
@@ -410,6 +474,35 @@ 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
+
+Code review discussions are high-signal prediction material. When working
+through potential review comments with the user, watch for preferences about
+review threshold, severity, tone, evidence, scope, false positives, or what is
+worth posting. This applies whether the user invoked a review skill, is
+reviewing your changes, or asked you to review their changes or another LLM's
+changes. Before creating a new prediction, query for an existing one and
+reinforce or adjust it when possible.
+
 ## What to Store
 
 - **Global store**: user observations, agent personality, system environment
@@ -495,3 +588,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,
 ];