@jeffober/thatch 0.1.28 → 0.1.29

package/src/embeddings.ts

@@ -82,44 +82,3 @@ export class BgeEmbeddingModel implements EmbeddingModel {
     return output.data as Float32Array;
   }
 }
-
-/**
- * Mock embedding model for tests. Returns deterministic vectors derived from
- * a hash of the input text via xorshift, so identical texts embed identically
- * and distinct texts land near-orthogonal - mirroring how unrelated content
- * behaves in a real embedding space. Never loads a model or touches the network.
- */
-export class MockEmbeddingModel implements EmbeddingModel {
-  readonly dims = 384;
-  readonly name = "mock";
-  loaded = true;
-
-  async load(): Promise<void> {}
-
-  async queryEmbed(text: string): Promise<Float32Array> {
-    return this.#embed(text);
-  }
-
-  async passageEmbed(text: string): Promise<Float32Array> {
-    return this.#embed(text);
-  }
-
-  #embed(text: string): Float32Array {
-    let h = 0;
-    for (let i = 0; i < text.length; i++) {
-      h = ((h << 5) - h) + text.charCodeAt(i);
-      h |= 0;
-    }
-    h ^= 0x9e3779b9; // avoid the degenerate all-zero state for empty input
-
-    const vec = new Float32Array(this.dims);
-    for (let i = 0; i < this.dims; i++) {
-      h ^= h << 13;
-      h ^= h >>> 17;
-      h ^= h << 5;
-      h |= 0;
-      vec[i] = h / 0x80000000;
-    }
-    return vec;
-  }
-}

package/src/extraction.ts

@@ -11,7 +11,7 @@ export interface ToolInteraction {
  * opencode plugin (in-process) and the Claude Code CLI (file-backed queue) so
  * the payload the agent ultimately receives has the same shape from either path.
  */
-export function summarizeArgs(tool: string, args: Record<string, unknown>): string {
+function summarizeArgs(tool: string, args: Record<string, unknown>): string {
   const file = args.filePath ?? args.file_path;
   switch (tool.toLowerCase()) {
     case "read":
@@ -54,7 +54,7 @@ export function deriveTitle(tool: string, args: Record<string, unknown>): string
   }
 }
 
-export function truncate(text: string, maxLen: number): string {
+function truncate(text: string, maxLen: number): string {
   if (text.length <= maxLen) return text;
   return text.slice(0, maxLen) + "...";
 }

package/src/git.ts

@@ -69,8 +69,10 @@ export async function detectRepo(cwd?: string): Promise<string> {
   try {
     const gitDir = await $`git rev-parse --git-common-dir`.cwd(dir).quiet();
     if (gitDir.exitCode === 0) {
+      // Handle both "/path/to/.git" (absolute) and ".git" (relative,
+      // when cwd is the repo root itself).
       const d = gitDir.stdout.toString().trim();
-      const parent = d.endsWith("/.git") ? d.slice(0, -5) : d;
+      const parent = d.endsWith("/.git") ? d.slice(0, -5) : (d === ".git" ? "" : d);
       const name = parent.split("/").pop() || "unknown";
       if (name !== "unknown") return name;
     }

package/src/index.ts

@@ -12,11 +12,13 @@ import {
   extractionNudge,
   extractionDirectPrompt,
   predictionNudge,
+  behaviorNudge,
   type NudgeMatch,
 } from "./prompts";
 import { ExtractionPipeline, type ToolInteraction } from "./extraction";
 import { installSkills, SHARED_SKILLS, OPENCODE_ONLY_SKILLS } from "./skills";
 import { hygieneReport } from "./hygiene";
+import { seedDefaultBehaviors } from "./seed-behaviors";
 
 // ---------------------------------------------------------------------------
 // V1 server export - tools, prompt injection, session hooks
@@ -31,10 +33,17 @@ 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");
+// Minimum cosine score for the prediction auto-fire. Higher than the
+// recall nudge (0.55) because surfacing a user-preference nudge is more
+// disruptive than surfacing a memory -- the agent may act on it or
+// surface it to the user. 0.60 cuts noise in dense embedding spaces
+// while still catching genuinely related contexts.
+const PREDICTION_THRESHOLD = parseFloat(process.env.THATCH_PREDICTION_THRESHOLD ?? "0.60");
+
+// Same threshold for behavior auto-fire. Same rationale: surfacing a
+// self-discipline rule is disruptive and should only fire when the
+// situation genuinely matches.
+const BEHAVIOR_THRESHOLD = parseFloat(process.env.THATCH_BEHAVIOR_THRESHOLD ?? "0.60");
 
 export const server: Plugin = async ({ client, worktree }) => {
   // The opencode server's cwd is wherever the server happened to start;
@@ -49,6 +58,13 @@ export const server: Plugin = async ({ client, worktree }) => {
   const model = new BgeEmbeddingModel(modelName);
   const extraction = new ExtractionPipeline();
 
+  // Seed default behaviors into the global store on first run, and
+  // update them when their content changes across releases. Idempotent:
+  // behaviors are matched by key stamp, not by cosine similarity, so
+  // user-codified behaviors are never overwritten. See seed-behaviors.ts
+  // for the full mechanism.
+  await seedDefaultBehaviors(db, model);
+
   // Sessions currently being compacted. chat.message nudges are skipped while
   // a session is in this set - the agent can't call tools during summary
   // generation, so a recall or extraction nudge would cause a blocked-tool
@@ -328,13 +344,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 + prediction nudge: when no extraction is pending, embed
-    //      the user's prompt (shared embedding for both) and:
+    //   b. Recall + prediction + behavior nudge: when no extraction is pending, embed
+    //      the user's prompt (shared embedding for all three) 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.
+    //        - search behavior matchers by cosine, score behaviors (behavior fire)
+    //      All three fire independently; any subset may inject.
+    //      The auto-fires reuse the embedding already computed for recall,
+    //      adding only cosine scans against the matchers tables.
     //      No extra model calls.
     //
     // Skipped during compaction: the agent can't call tools while generating
@@ -448,6 +465,35 @@ export const server: Plugin = async ({ client, worktree }) => {
         } catch (err) {
           console.error(`[thatch] prediction nudge failed: ${err}`);
         }
+
+        // Behavior fire: independent of recall and prediction. Same
+        // embedding, one more cosine scan against behavior_matchers.
+        try {
+          const behaviorItems = db.scoreBehaviorNudge([repo, "global"], embedding, BEHAVIOR_THRESHOLD);
+          if (behaviorItems.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: behaviorNudge(behaviorItems),
+              synthetic: true,
+            });
+            try {
+              await client.tui.showToast({
+                body: {
+                  message: `\u{1F4AD} ${behaviorItems.length} behavior${behaviorItems.length === 1 ? "" : "s"} surfaced`,
+                  variant: "info",
+                  duration: 3000,
+                },
+              });
+            } catch {
+              // TUI may not be connected. Best-effort.
+            }
+          }
+        } catch (err) {
+          console.error(`[thatch] behavior nudge failed: ${err}`);
+        }
       } catch (err) {
         console.error(`[thatch] nudge hook failed: ${err}`);
       }

package/src/mcp.ts

@@ -1,12 +1,14 @@
+import { resolve } from "node:path";
 import { z } from "zod";
 import { ThatchDB } from "./db";
 import { BgeEmbeddingModel } from "./embeddings";
 import { detectRepo } from "./git";
-import { checkSetup } from "./setup";
+import { checkSetup, setupClaudeCode, setupCursor } from "./setup";
 import { TOOL_DEFS, type CoreContext, type ToolDef } from "./tool-defs";
 import { SidebandServer, sidebandSocketPath } from "./sideband";
 import { peekQueue, consumeQueue, resetMissedCount } from "./extract-queue";
 import { buildExtractionPayload } from "./extraction";
+import { seedDefaultBehaviors } from "./seed-behaviors";
 import pkg from "../package.json";
 
 // ---------------------------------------------------------------------------
@@ -101,6 +103,8 @@ export async function runMcpServer(): Promise<void> {
   const db = new ThatchDB(dbPath);
   const model = new BgeEmbeddingModel(modelName);
 
+  await seedDefaultBehaviors(db, model);
+
   // Extraction payload provider: peeks the file-backed queue and returns the
   // serialized JSON payload. Called by the get_extraction_payload tool when a
   // sub-agent needs to fetch the parent's queued interactions. Returns null
@@ -140,6 +144,31 @@ export async function runMcpServer(): Promise<void> {
     console.error(`[thatch] ${setupWarning}`);
   }
 
+  // Auto-refresh: if setup was previously run (markers exist), re-run the
+  // install functions to update skills, instructions, and hooks that may have
+  // drifted since the last `thatch setup`. All operations are idempotent --
+  // they only write when content differs. This keeps MCP-host installations
+  // up to date without requiring the user to manually re-run setup after
+  // upgrading thatch. The MCP config itself is also re-written, but it
+  // writes the same command that's already running, so it's a no-op in
+  // practice.
+  if (setupStatus && setupStatus.status === "installed") {
+    const thatchBin = resolve(process.argv[1] ?? process.execPath);
+    const isGlobal = setupStatus.scope === "global";
+    try {
+      if (setupStatus.host === "claude") {
+        setupClaudeCode(thatchBin, isGlobal, projectDir);
+      } else if (setupStatus.host === "cursor") {
+        setupCursor(thatchBin, isGlobal, projectDir);
+      }
+    } catch (err) {
+      // Auto-refresh is best-effort. A failure here does not affect the
+      // MCP server's ability to serve tool calls -- it just means skills
+      // or instructions may be stale until the user re-runs setup.
+      console.error(`[thatch] auto-refresh of skills/instructions failed: ${err}`);
+    }
+  }
+
   // The sideband socket lets one-shot hook processes (flush-tools) ask the
   // warm MCP server to embed a prompt and search for matches - without
   // loading the ~34 MB model themselves. If the socket can't be opened

package/src/prediction.ts

@@ -0,0 +1,127 @@
+import { Database } from "bun:sqlite";
+import { ScoringEngine, type NudgeItem, PREDICTION_K, PREDICTION_P0, PREDICTION_W_SOFT } from "./scoring-engine";
+
+export { PREDICTION_K, PREDICTION_P0, PREDICTION_W_SOFT };
+
+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 extends NudgeItem {}
+
+export interface ScoredPrediction {
+  matcher_id: string;
+  matcher_description: string;
+  prediction_id: string;
+  statement: string;
+  confidence: number;
+  evidence_count: number;
+  score: number;
+  rationale: string | null;
+}
+
+const config = {
+  matchersTable: "prediction_matchers",
+  itemsTable: "predictions",
+  edgesTable: "prediction_edges",
+  provenanceTable: "prediction_provenance",
+  itemForeignKey: "prediction_id",
+};
+
+/**
+ * Prediction engine: matchers (context patterns), predictions (graded
+ * confidence statements), edges (weighted matcher-to-prediction links),
+ * and provenance (audit trail). Delegates to ScoringEngine for all
+ * SQL and scoring logic. Wraps the generic return types with
+ * prediction-specific type names for caller clarity.
+ */
+export class PredictionEngine {
+  #engine: ScoringEngine;
+
+  constructor(db: Database) {
+    this.#engine = new ScoringEngine(db, config);
+  }
+
+  findMatchers(stores: string[], queryEmbedding: Float32Array, opts?: { limit?: number }) {
+    return this.#engine.findMatchers(stores, queryEmbedding, opts);
+  }
+
+  scorePredictions(matchers: { id: string; description: string; score: number }[]): ScoredPrediction[] {
+    return this.#engine.scoreItems(matchers).map((s) => ({
+      matcher_id: s.matcher_id,
+      matcher_description: s.matcher_description,
+      prediction_id: s.item_id,
+      statement: s.statement,
+      confidence: s.confidence,
+      evidence_count: s.evidence_count,
+      score: s.score,
+      rationale: s.rationale,
+    }));
+  }
+
+  scorePredictionNudge(stores: string[], embedding: Float32Array, threshold: number, limit = 5): PredictionNudgeItem[] {
+    return this.#engine.scoreNudge(stores, embedding, threshold, limit);
+  }
+
+  findNearestMatcher(store: string, embedding: Float32Array, threshold: number): { id: string; description: string } | null {
+    return this.#engine.findNearestMatcher(store, embedding, threshold);
+  }
+
+  createMatcher(store: string, description: string, embedding: Float32Array, model: string): string {
+    return this.#engine.createMatcher(store, description, embedding, model);
+  }
+
+  findNearestPrediction(store: string, embedding: Float32Array, threshold: number): PredictionRow | null {
+    return this.#engine.findNearestItem(store, embedding, threshold) as PredictionRow | null;
+  }
+
+  createPrediction(store: string, statement: string, rationale: string, embedding: Float32Array, model: string): string {
+    return this.#engine.createItem(store, statement, rationale, embedding, model);
+  }
+
+  createEdge(matcherId: string, predictionId: string, weight: number): void {
+    return this.#engine.createEdge(matcherId, predictionId, weight);
+  }
+
+  adjustConfidence(predictionId: string, signal: "confirm" | "disconfirm" | "soft"): void {
+    return this.#engine.adjustConfidence(predictionId, signal);
+  }
+
+  getPrediction(predictionId: string): PredictionRow | null {
+    return this.#engine.getItem(predictionId) as PredictionRow | null;
+  }
+
+  addProvenance(predictionId: string, signal: string, detail: string): void {
+    return this.#engine.addProvenance(predictionId, signal, detail);
+  }
+
+  getProvenance(predictionId: string): { signal: string; detail: string | null; created_at: string }[] {
+    return this.#engine.getProvenance(predictionId);
+  }
+
+  deletePrediction(predictionId: string): boolean {
+    return this.#engine.deleteItem(predictionId);
+  }
+
+  listPredictions(store: string) {
+    return this.#engine.listItems(store);
+  }
+}