@jeffober/thatch 0.1.17 → 0.1.19

package/src/index.ts

@@ -10,9 +10,10 @@ import {
   sessionStartReminder,
   recallNudge,
   extractionNudge,
+  predictionNudge,
   type NudgeMatch,
 } from "./prompts";
-import { ExtractionPipeline } from "./extraction";
+import { ExtractionPipeline, type ToolInteraction } from "./extraction";
 import { installSkills, SHARED_SKILLS, OPENCODE_ONLY_SKILLS } from "./skills";
 import { hygieneReport } from "./hygiene";
 
@@ -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.
@@ -64,6 +70,14 @@ export const server: Plugin = async ({ client, worktree }) => {
   // Populated from session.created events that carry a parentID.
   const childToParent = new Map<string, string>();
 
+  // Snapshot of the parent's buffer at the moment each child was dispatched.
+  // When the child writes a memory, consumeSnapshot drains only these entries
+  // (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 concurrently with the sub-agent.
+  const parentSnapshots = new Map<string, ToolInteraction[]>();
+
   // Skills always install to the global opencode config — installing into the
   // worktree would mutate the user's repo (untracked files in git status).
   // A failed install degrades the nudge workflow but must not kill the plugin.
@@ -113,9 +127,11 @@ export const server: Plugin = async ({ client, worktree }) => {
     //    grows with each missed cycle.
     //
     //    A memory_remember call in a child session (sub-agent) also drains
-    //    the parent's buffer. Without this, dispatching the fact-extractor as
-    //    a background task writes memories in the child but never clears the
-    //    parent's queue — the nudge replays every turn.
+    //    the parent's buffer — but only the entries that existed at dispatch
+    //    time (the snapshot). Entries from interleaved turns survive so their
+    //    facts aren't silently dropped. Without this, dispatching the
+    //    fact-extractor as a background task writes memories in the child but
+    //    never clears the parent's queue — the nudge replays every turn.
     //
     //    thatch_extraction_done is an explicit acknowledgment tool the model
     //    calls in the parent session after dispatching. Covers the case where
@@ -125,12 +141,19 @@ export const server: Plugin = async ({ client, worktree }) => {
       if (input.tool === "thatch_memory_remember") {
         extraction.consume(input.sessionID);
         missedNudges.delete(input.sessionID);
-        // If this is a child session, also drain the parent so the parent's
-        // extraction nudge stops replaying after a sub-agent writes memories
-        // on its behalf.
+        // If this is a child session, drain only the parent's snapshot entries
+        // (those present at dispatch time). Interleaved-turn entries survive.
+        // If no snapshot was recorded (e.g. session.created event never
+        // arrived), fall back to draining the entire parent buffer.
         const parentID = childToParent.get(input.sessionID);
         if (parentID) {
-          extraction.consume(parentID);
+          const snapshot = parentSnapshots.get(input.sessionID);
+          if (snapshot) {
+            extraction.consumeSnapshot(parentID, snapshot);
+            parentSnapshots.delete(input.sessionID);
+          } else {
+            extraction.consume(parentID);
+          }
           missedNudges.delete(parentID);
         }
         return;
@@ -156,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
@@ -195,41 +223,71 @@ 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}`);
       }
     },
 
     // 5. Session-start reminder, carrying the hygiene heartbeat. Hygiene is
     // best-effort: a failure there must not cost the reminder itself.
     //
-    // Also tracks parent-child session relationships for fix A (cross-session
-    // buffer drain). session.created with a parentID records the mapping;
-    // session.deleted cleans it up to avoid unbounded growth.
+    // Also tracks parent-child session relationships for cross-session buffer
+    // drain. session.created with a parentID records the mapping AND
+    // snapshots the parent's current buffer — so the child's later
+    // memory_remember drains only those snapshot entries, not the parent's
+    // entire buffer (which may have grown from interleaved turns).
+    // session.deleted cleans both maps to avoid unbounded growth.
     event: async ({ event }) => {
       if (event.type === "session.created") {
         const info = event.properties.info;
         if (info.parentID) {
           childToParent.set(info.id, info.parentID);
+          parentSnapshots.set(info.id, [...extraction.peek(info.parentID)]);
         }
       }
       if (event.type === "session.deleted") {
         childToParent.delete(event.properties.info.id);
+        parentSnapshots.delete(event.properties.info.id);
         return;
       }
 

package/src/mcp.ts

@@ -5,6 +5,7 @@ import { detectRepo } from "./git";
 import { checkSetup } from "./setup";
 import { TOOL_DEFS, type CoreContext, type ToolDef } from "./tool-defs";
 import { SidebandServer, sidebandSocketPath } from "./sideband";
+import pkg from "../package.json";
 
 // ---------------------------------------------------------------------------
 // JSON-RPC 2.0 types
@@ -34,7 +35,7 @@ const INTERNAL_ERROR = -32603;
 // ---------------------------------------------------------------------------
 
 const SERVER_NAME = "thatch";
-const SERVER_VERSION = "0.1.16";
+const SERVER_VERSION = pkg.version;
 
 /**
  * MCP capabilities declared in the initialize response. Thatch is a tools-only

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