@jeffober/thatch 0.1.39 → 0.1.41

package/src/db.ts

@@ -4,11 +4,13 @@ import {
   PredictionEngine,
 } from "./prediction";
 import { BehaviorEngine } from "./behavior";
+import { ChatStore, type ChatHostKind } from "./chat";
 import { PREDICTION_K, PREDICTION_P0, PREDICTION_W_SOFT } from "./scoring-engine";
 
 export { cosineSimilarity } from "./vector-math";
 export type { PredictionNudgeItem, MatcherRow, PredictionRow, ScoredPrediction } from "./prediction";
 export type { BehaviorNudgeItem, BehaviorRow, ScoredBehavior } from "./behavior";
+export type { ChatSessionRow, ChatInboxItem, ChatNotificationRow, ChatResult } from "./chat";
 
 export interface MemoryRow {
   slug: string;
@@ -53,6 +55,7 @@ export class ThatchDB {
   #db: Database;
   #predictions: PredictionEngine;
   #behaviors: BehaviorEngine;
+  #chat: ChatStore;
 
   constructor(path: string) {
     this.#db = new Database(path, { create: true });
@@ -66,6 +69,7 @@ export class ThatchDB {
     this.#db.run("PRAGMA foreign_keys = ON");
     this.#predictions = new PredictionEngine(this.#db);
     this.#behaviors = new BehaviorEngine(this.#db);
+    this.#chat = new ChatStore(this.#db);
     this.#initSchema();
   }
 
@@ -218,9 +222,80 @@ export class ThatchDB {
       )
     `);
 
+    // Cross-session chat: the machine-wide session directory and message
+    // inbox, shared by every opencode process (delivery itself stays local
+    // to each host process - see src/chat.ts). Display-name uniqueness is
+    // case-insensitive ("Landru" and "landru" are one name), so two visually
+    // identical identities cannot coexist. Message endpoints are plain
+    // columns, not foreign keys, on purpose: unregistering a session must
+    // not be blocked by message history, and a departed sender degrades to
+    // an unknown name in the reader's view rather than vanishing rows.
+    this.#db.run(`
+      CREATE TABLE IF NOT EXISTS chat_sessions (
+        session_id    TEXT PRIMARY KEY,
+        name          TEXT NOT NULL UNIQUE COLLATE NOCASE,
+        topic         TEXT,
+        project       TEXT,
+        host_kind     TEXT NOT NULL DEFAULT ('opencode'),
+        registered_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now')),
+        last_seen     TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
+      )
+    `);
+
+    // delivered_at is the last wake-prompt stamp: set when the recipient's
+    // host accepts a nudge, restamped on re-nudges (which resets the
+    // re-nudge timer). read_at is set when the recipient drains its inbox.
+    // via_broadcast marks rows a chat_broadcast fan-out created, so the
+    // tail feed can render one broadcast line instead of N direct sends.
+    this.#db.run(`
+      CREATE TABLE IF NOT EXISTS chat_messages (
+        id            INTEGER PRIMARY KEY AUTOINCREMENT,
+        from_session  TEXT NOT NULL,
+        to_session    TEXT NOT NULL,
+        body          TEXT NOT NULL,
+        created_at    TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now')),
+        delivered_at  TEXT,
+        read_at       TEXT,
+        via_broadcast INTEGER NOT NULL DEFAULT 0
+      )
+    `);
+
     this.#db.run("INSERT OR IGNORE INTO stores (name) VALUES ('global')");
 
     this.#migrateColumns();
+    this.#migrateChatNameCollation();
+    this.#migrateChatTopic();
+    this.#migrateChatHostKind();
+    this.#migrateChatBroadcastFlag();
+  }
+
+  // chat_sessions tables created before the host_kind column lack it; the
+  // ALTER adds it, and existing rows read as opencode (which they were).
+  #migrateChatHostKind(): void {
+    const cols = (this.#db.query("PRAGMA table_info(chat_sessions)").all() as any[]).map((r) => r.name);
+    if (cols.length > 0 && !cols.includes("host_kind")) {
+      this.#db.run("ALTER TABLE chat_sessions ADD COLUMN host_kind TEXT NOT NULL DEFAULT 'opencode'");
+    }
+  }
+
+  // chat_messages tables created before the via_broadcast column lack it;
+  // the ALTER adds it, and existing rows read as direct sends (which they
+  // were).
+  #migrateChatBroadcastFlag(): void {
+    const cols = (this.#db.query("PRAGMA table_info(chat_messages)").all() as any[]).map((r) => r.name);
+    if (cols.length > 0 && !cols.includes("via_broadcast")) {
+      this.#db.run("ALTER TABLE chat_messages ADD COLUMN via_broadcast INTEGER NOT NULL DEFAULT 0");
+    }
+  }
+
+  // chat_sessions tables created before the topic column lack it; the
+  // ALTER adds it, and rows degrade to a NULL topic (rendered as no topic
+  // in chat_list).
+  #migrateChatTopic(): void {
+    const cols = (this.#db.query("PRAGMA table_info(chat_sessions)").all() as any[]).map((r) => r.name);
+    if (cols.length > 0 && !cols.includes("topic")) {
+      this.#db.run("ALTER TABLE chat_sessions ADD COLUMN topic TEXT");
+    }
   }
 
   // Databases created before recall telemetry lack these columns; the CREATE
@@ -241,6 +316,43 @@ export class ThatchDB {
     }
   }
 
+  // A chat_sessions table created before the NOCASE uniqueness change has a
+  // case-SENSITIVE unique constraint, which let "Landru" and "landru"
+  // coexist as distinct identities. SQLite cannot ALTER a column
+  // constraint, so the repair is a table rebuild. Detection reads the
+  // stored CREATE statement from sqlite_master: the NOCASE schema text
+  // contains COLLATE NOCASE, the older one does not. Colliding rows
+  // collapse via INSERT OR IGNORE (one row wins per case group; scan order
+  // decides which). chat_messages has no foreign key into this table, so
+  // message history survives untouched.
+  //
+  // ORDERING TRAP: the rebuild's CREATE and SELECT are pinned to the
+  // columns the OLDEST chat_sessions schema had, because a legacy table
+  // only has those columns - a SELECT naming a newer column would throw.
+  // This migration must run BEFORE any ALTER-based chat_sessions migration
+  // (which add newer columns afterward); when adding a column to
+  // chat_sessions, extend the ALTER-based migrations, not this SELECT.
+  #migrateChatNameCollation(): void {
+    const row = this.#db
+      .query("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'chat_sessions'")
+      .get() as any;
+    if (!row?.sql || /COLLATE\s+NOCASE/i.test(row.sql)) return;
+    this.transaction(() => {
+      this.#db.run(`
+        CREATE TABLE chat_sessions_migrated (
+          session_id    TEXT PRIMARY KEY,
+          name          TEXT NOT NULL UNIQUE COLLATE NOCASE,
+          project       TEXT,
+          registered_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now')),
+          last_seen     TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
+        )
+      `);
+      this.#db.run("INSERT OR IGNORE INTO chat_sessions_migrated SELECT session_id, name, project, registered_at, last_seen FROM chat_sessions");
+      this.#db.run("DROP TABLE chat_sessions");
+      this.#db.run("ALTER TABLE chat_sessions_migrated RENAME TO chat_sessions");
+    });
+  }
+
   // ---------------------------------------------------------------------------
   // Stores
   // ---------------------------------------------------------------------------
@@ -612,7 +724,7 @@ export class ThatchDB {
     return this.#predictions.createMatcher(store, description, embedding, model);
   }
 
-  findNearestPrediction(store: string, embedding: Float32Array, threshold: number) {
+  findNearestPrediction(store: string | string[], embedding: Float32Array, threshold: number) {
     return this.#predictions.findNearestPrediction(store, embedding, threshold);
   }
 
@@ -672,7 +784,7 @@ export class ThatchDB {
     return this.#behaviors.createBehaviorMatcher(store, description, embedding, model);
   }
 
-  findNearestBehavior(store: string, embedding: Float32Array, threshold: number) {
+  findNearestBehavior(store: string | string[], embedding: Float32Array, threshold: number) {
     return this.#behaviors.findNearestBehavior(store, embedding, threshold);
   }
 
@@ -708,6 +820,73 @@ export class ThatchDB {
     return this.#behaviors.listBehaviors(store);
   }
 
+  // ---------------------------------------------------------------------------
+  // Cross-session chat: delegates to ChatStore
+  // ---------------------------------------------------------------------------
+
+  registerChatSession(sessionID: string, name: string, project: string | null, topic: string | null, kind: ChatHostKind) {
+    return this.#chat.register(sessionID, name, project, topic, kind);
+  }
+
+  assignChatName(sessionID: string, project: string | null, topic: string | null, kind: ChatHostKind) {
+    return this.#chat.assign(sessionID, project, topic, kind);
+  }
+
+  broadcastChatMessage(fromSession: string, body: string) {
+    return this.#chat.broadcast(fromSession, body);
+  }
+
+  chatMessageStatus(sessionID: string) {
+    return this.#chat.status(sessionID);
+  }
+
+  chatPendingByProject(project: string) {
+    return this.#chat.pendingByProject(project);
+  }
+
+  chatMessageFeed() {
+    return this.#chat.messageFeed();
+  }
+
+  unregisterChatSession(sessionID: string) {
+    return this.#chat.unregister(sessionID);
+  }
+
+  listChatSessions() {
+    return this.#chat.list();
+  }
+
+  findChatSession(nameOrID: string) {
+    // Facade surface: production resolves recipients inside send()/find();
+    // this delegation exists so callers (and tests) can resolve a session
+    // by name or ID without reaching past the ThatchDB API.
+    return this.#chat.find(nameOrID);
+  }
+
+  sendChatMessage(fromSession: string, toNameOrID: string, body: string) {
+    return this.#chat.send(fromSession, toNameOrID, body);
+  }
+
+  readChatMessages(sessionID: string) {
+    return this.#chat.read(sessionID);
+  }
+
+  unreadChatCount(sessionID: string) {
+    return this.#chat.unreadCount(sessionID);
+  }
+
+  heartbeatChatSessions(sessionIDs: string[]) {
+    return this.#chat.heartbeat(sessionIDs);
+  }
+
+  pendingChatNotifications(sessionIDs: string[], renudgeCutoff: string) {
+    return this.#chat.pendingNotifications(sessionIDs, renudgeCutoff);
+  }
+
+  markChatDelivered(ids: number[]) {
+    return this.#chat.markDelivered(ids);
+  }
+
   // ---------------------------------------------------------------------------
   // Hygiene - signals for the session-start heartbeat. Staleness means
   // neither written nor recalled since the cutoff; recall telemetry keeps

package/src/embeddings.ts

@@ -25,11 +25,99 @@ export interface EmbeddingModel {
  */
 export type PipelineFactory = (modelName: string) => Promise<any>;
 
+/**
+ * Embedding backend mode. "wasm" runs the ONNX model on onnxruntime-web's
+ * pure-JS/wasm runtime; "native" runs it on onnxruntime-node's NAPI addon.
+ */
+export type EmbeddingBackendMode = "wasm" | "native";
+
+/**
+ * Reads the backend override. Only "native" opts out; any other value,
+ * including unset, selects the wasm default. Exported for tests.
+ */
+export function backendMode(): EmbeddingBackendMode {
+  return process.env.THATCH_EMBEDDING_BACKEND === "native" ? "native" : "wasm";
+}
+
+const ORT_SYMBOL = Symbol.for("onnxruntime");
+
+let backendConfigured: Promise<EmbeddingBackendMode> | null = null;
+
+/**
+ * Chooses the ONNX backend before transformers initializes. Memoized: the
+ * choice is made once at transformers' module init and cannot be changed
+ * afterwards. Exported for tests.
+ *
+ * "wasm" mode pins globalThis[Symbol.for("onnxruntime")] to onnxruntime-web
+ * so transformers' node build creates sessions on its pure-JS/wasm runtime
+ * instead of the onnxruntime-node NAPI addon. The NAPI addon leaves wrap
+ * finalizers that panic Bun at process teardown (oven-sh/bun#34664); the wasm
+ * runtime creates none. A backend already chosen by the host (symbol present)
+ * is respected, never clobbered. A failed onnxruntime-web import falls back
+ * to native rather than blocking embedding.
+ */
+export async function configureBackend(): Promise<EmbeddingBackendMode> {
+  backendConfigured ??= (async () => {
+    const mode = backendMode();
+    if (mode === "native" || ORT_SYMBOL in globalThis) return mode;
+    try {
+      const ort = await import("onnxruntime-web");
+      (globalThis as Record<symbol, unknown>)[ORT_SYMBOL] = ort;
+      // Single-threaded wasm: deterministic, and avoids worker_threads,
+      // where Bun has known shutdown crashes. Latency at one thread is fine
+      // for background embedding.
+      ort.env.wasm.numThreads = 1;
+    } catch {
+      // onnxruntime-web unavailable - native sessions still work.
+    }
+    return mode;
+  })();
+  return backendConfigured;
+}
+
+/**
+ * Test hook: clears the configureBackend memo and unpins the onnxruntime
+ * global, so a test can exercise the pinning path itself. Needed because the
+ * test process is shared across files: initializing the plugin server seeds
+ * behaviors, which embeds, which runs configureBackend and pins the symbol
+ * as a side effect. Whether that happened before a given test file runs
+ * depends on bun's file order, which differs between machines.
+ */
+export function resetBackendForTests(): void {
+  backendConfigured = null;
+  delete (globalThis as Record<symbol, unknown>)[ORT_SYMBOL];
+}
+
 const defaultPipelineFactory: PipelineFactory = async (modelName) => {
+  const mode = await configureBackend();
   const { pipeline } = await import("@huggingface/transformers");
-  return pipeline("feature-extraction", modelName);
+  if (mode === "native") {
+    return pipeline("feature-extraction", modelName);
+  }
+  // The ORT_SYMBOL override branch leaves transformers' device allowlist
+  // empty, so any named device throws; "auto" bypasses the check and the
+  // explicit execution provider does the real work.
+  return pipeline("feature-extraction", modelName, {
+    device: "auto",
+    session_options: { executionProviders: ["wasm"] },
+  });
 };
 
+/**
+ * How long a loaded pipeline may sit unused before its native ONNX sessions
+ * are released while the runtime is still healthy. Long enough to span the
+ * gap between extraction bursts, short enough to matter before process exit.
+ */
+const DEFAULT_IDLE_TTL_MS = 10 * 60 * 1000;
+
+export interface BgeEmbeddingModelOptions {
+  /**
+   * Idle milliseconds before the pipeline's native sessions are released.
+   * A later embed lazily re-loads. 0 disables idle release.
+   */
+  idleTtlMs?: number;
+}
+
 /**
  * Lazy-loads an embedding model via @huggingface/transformers.
  * Model files (~34 MB for the default) are downloaded once and cached by HF Hub.
@@ -37,12 +125,19 @@ const defaultPipelineFactory: PipelineFactory = async (modelName) => {
 export class BgeEmbeddingModel implements EmbeddingModel {
   #modelName: string;
   #pipelineFactory: PipelineFactory;
+  #idleTtlMs: number;
   #pipe: any = null;
   #loading: Promise<void> | null = null;
+  #idleTimer: ReturnType<typeof setTimeout> | null = null;
 
-  constructor(modelName = "Xenova/bge-small-en-v1.5", pipelineFactory?: PipelineFactory) {
+  constructor(
+    modelName = "Xenova/bge-small-en-v1.5",
+    pipelineFactory?: PipelineFactory,
+    options: BgeEmbeddingModelOptions = {},
+  ) {
     this.#modelName = modelName;
     this.#pipelineFactory = pipelineFactory ?? defaultPipelineFactory;
+    this.#idleTtlMs = options.idleTtlMs ?? DEFAULT_IDLE_TTL_MS;
   }
 
   get loaded(): boolean {
@@ -75,12 +170,31 @@ export class BgeEmbeddingModel implements EmbeddingModel {
   }
 
   async #embed(text: string): Promise<Float32Array> {
-    await this.load();
-    const output = await this.#pipe(text, {
-      pooling: "mean",
-      normalize: true,
-    });
-    return output.data as Float32Array;
+    // Clear any pending idle timer before touching the pipeline. The timer
+    // must never fire while an embed is in flight - its callback releases
+    // the pipeline this call is about to use.
+    this.#clearIdleTimer();
+    try {
+      await this.load();
+      const pipe = this.#pipe;
+      const output = await pipe(text, {
+        pooling: "mean",
+        normalize: true,
+      });
+      // Copy the vector before releasing the tensor: the real Tensor's data
+      // getter exposes memory the disposer frees.
+      const data = new Float32Array(output.data);
+      if (typeof output?.dispose === "function") {
+        try {
+          await output.dispose();
+        } catch {
+          // Tensor release is best-effort; the copied data is already valid.
+        }
+      }
+      return data;
+    } finally {
+      this.#armIdleTimer();
+    }
   }
 
   /**
@@ -89,11 +203,16 @@ export class BgeEmbeddingModel implements EmbeddingModel {
    * the runtime is still alive. If instead they survive to Bun's worker
    * teardown, Bun panics creating their errors (oven-sh/bun#34664).
    *
+   * The idle timer releases on the same principle during normal operation:
+   * the plugin's dispose hook is best-effort because opencode can exit
+   * without running it, so sessions are also freed after a quiet period.
+   *
    * Best-effort by design: dispose never throws, and a failed release is
    * indistinguishable from never loading. An embed call after dispose just
    * lazily re-loads the model.
    */
   async dispose(): Promise<void> {
+    this.#clearIdleTimer();
     // An in-flight load memoizes a rejecting promise on failure. Await it
     // defensively so its error neither escapes dispose nor kills the teardown.
     if (this.#loading) {
@@ -103,6 +222,10 @@ export class BgeEmbeddingModel implements EmbeddingModel {
         // Load failed - nothing was loaded, so nothing to release.
       }
     }
+    await this.#release();
+  }
+
+  async #release(): Promise<void> {
     const pipe = this.#pipe;
     this.#pipe = null;
     this.#loading = null;
@@ -110,7 +233,27 @@ export class BgeEmbeddingModel implements EmbeddingModel {
     try {
       await pipe.dispose();
     } catch {
-      // Best-effort - see doc comment above.
+      // Best-effort - see dispose's doc comment.
+    }
+  }
+
+  #armIdleTimer(): void {
+    if (this.#idleTtlMs <= 0) return;
+    this.#clearIdleTimer();
+    this.#idleTimer = setTimeout(() => {
+      this.#idleTimer = null;
+      this.#release().catch(() => {
+        // Idle release is best-effort; a failed release retries on dispose.
+      });
+    }, this.#idleTtlMs);
+    // Never hold the host process open for an idle timer.
+    this.#idleTimer.unref?.();
+  }
+
+  #clearIdleTimer(): void {
+    if (this.#idleTimer) {
+      clearTimeout(this.#idleTimer);
+      this.#idleTimer = null;
     }
   }
 }

package/src/index.ts

@@ -22,7 +22,8 @@ import { hygieneReport } from "./hygiene";
 import { seedDefaultBehaviors } from "./seed-behaviors";
 import { startVersionChecker, stopVersionChecker, getVersionChecker, readOnDiskVersion, compareSemver } from "./version-check";
 import { WatcherRegistry, ghApiRun, ghAvailable } from "./watchers";
-import { watcherNotificationNudge } from "./prompts";
+import { watcherNotificationNudge, chatNotificationNudge, chatEchoText, isChatEchoParts } from "./prompts";
+import { ChatPoller } from "./chat";
 import pkg from "../package.json";
 
 // ---------------------------------------------------------------------------
@@ -86,9 +87,12 @@ export const server: Plugin = async ({ client, worktree }) => {
   const runningVersion = pkg.version;
 
   // Latest observed opencode session status per session ("busy" | "idle" |
-  // "retry"). The event hook records these; the watcher registry's
-  // canDeliver gate reads them so proactive notification prompts only fire
-  // into idle sessions - never into a turn that is already running.
+  // "retry"). Keys enter from session.status events and leave only in
+  // session.deleted (which shrinks the chat poller's hosted set). Readers:
+  // the watcher registry's and the chat poller's canDeliver gates
+  // (proactive prompts only fire into idle sessions, never into a running
+  // turn), and the chat poller's hostedSessions set (the sessions this
+  // process may deliver chat mail to - the map's keys).
   const sessionStatus = new Map<string, string>();
 
   // In-memory watcher registry for proactive event notifications (GitHub PR
@@ -140,6 +144,50 @@ export const server: Plugin = async ({ client, worktree }) => {
   });
   watchers.start();
 
+  // Cross-session chat delivery. The inbox is shared SQLite state (any
+  // process reads/writes it), but this poller only ever delivers to sessions
+  // hosted by THIS process - the recipient's host is the single deliverer,
+  // so there is no cross-process double-delivery race. Wake prompts use the
+  // same synthetic-part mechanism as watcher notifications; the toast
+  // covers the TUI-hidden part so the user sees why the model woke up.
+  // canDeliver closes over `compacting` (declared below): the closure reads
+  // it at call time, after full initialization, same as the watcher gate.
+  const chatPoller = new ChatPoller({
+    store: db,
+    hostedSessions: () => {
+      // Sub-agent children share this process's sessionStatus (their
+      // status events land here), but they are never legitimate chat
+      // participants - a registered child would be heartbeat-ed
+      // fresh-forever and burn nudge budget on undeliverable wake
+      // prompts. Keep them out of the hosted set even when guidance
+      // against registering them is ignored.
+      const hosted = [...sessionStatus.keys()].filter((id) => !childToParent.has(id));
+      return hosted;
+    },
+    deliver: async (sessionID, senders, count) => {
+      await client.session.promptAsync({
+        path: { id: sessionID },
+        body: {
+          parts: [{ type: "text", text: chatNotificationNudge(senders, count), synthetic: true }],
+        },
+      });
+      try {
+        await client.tui.showToast({
+          body: {
+            message: `\u{1F4AC} chat: ${count} unread from ${senders.join(", ")}`,
+            variant: "info",
+            duration: 5000,
+          },
+        });
+      } catch {
+        // TUI may not be connected. Best-effort.
+      }
+    },
+    canDeliver: (sessionID) =>
+      !compacting.has(sessionID) && sessionStatus.get(sessionID) === "idle",
+  });
+  chatPoller.start();
+
   // 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
@@ -407,6 +455,40 @@ export const server: Plugin = async ({ client, worktree }) => {
         childMetrics.set(input.sessionID, metrics);
         return;
       }
+      // Chat conversational events echo back into the transcript as visible
+      // message parts. Plugin tools render as muted one-line entries with
+      // the output hidden behind a default-off TUI toggle, so without this
+      // the human watching a session never sees the conversation happen.
+      // Delivery is a non-synthetic noReply promptAsync: the part renders
+      // as a visible bubble and starts no model turn (the server's prompt
+      // path returns before the completion loop). Non-synthetic also means
+      // later turns see the echo in context - a small duplication of the
+      // tool call it mirrors, accepted for visibility. Fire-and-forget: an
+      // echo failure must never fail the tool call it follows.
+      if (input.tool.startsWith("thatch_chat_")) {
+        const echo = chatEchoText(
+          input.tool,
+          (input.args ?? {}) as Record<string, unknown>,
+          typeof output.output === "string" ? output.output : "",
+        );
+        if (echo) {
+          void client.session
+            .promptAsync({
+              path: { id: input.sessionID },
+              body: {
+                noReply: true,
+                parts: [{ type: "text", text: echo }],
+              },
+            })
+            .catch((err) => {
+              // The echo must never fail the tool call, but a silent catch
+              // would hide a systemic promptAsync failure (bubbles would
+              // stop appearing everywhere with no diagnostics).
+              console.error(`[thatch] chat echo delivery failed: ${err}`);
+            });
+        }
+        return;
+      }
       if (input.tool.startsWith("thatch_") || input.tool === "skill" || input.tool === "task") return;
       extraction.push({
         tool: input.tool,
@@ -434,6 +516,12 @@ export const server: Plugin = async ({ client, worktree }) => {
     // a summary, so a nudge that says "use thatch_memory_recall" triggers a
     // blocked-tool error.
     "chat.message": async (input, output) => {
+      // Chat transcript echoes are non-synthetic noReply parts, so they
+      // arrive here like any user message - but no model turn ever reads
+      // them, and the nudge machinery would embed and scan their text for
+      // nothing (and fire spurious toasts when thresholds cross). Skip
+      // them entirely.
+      if (isChatEchoParts(output.parts)) return;
       if (compacting.has(input.sessionID)) {
         // The session is marked as compacting. If this message is the
         // compaction summary generation itself (has a compaction-type part),
@@ -757,10 +845,22 @@ export const server: Plugin = async ({ client, worktree }) => {
         } catch (err) {
           console.error(`[thatch] watcher delivery on idle failed: ${err}`);
         }
+        // Same for chat messages: mail that arrived mid-turn lands now
+        // instead of waiting for the next poll cycle.
+        try {
+          await chatPoller.deliverPending();
+        } catch (err) {
+          console.error(`[thatch] chat delivery on idle failed: ${err}`);
+        }
         return;
       }
       if (event.type === "session.deleted") {
         const id = event.properties.info.id;
+        // Shrink the chat poller's hosted set FIRST: the rest of this
+        // branch runs extraction calls that could throw on a transient DB
+        // error, and a leaked status key would keep heartbeat-ing a dead
+        // session as permanently fresh.
+        sessionStatus.delete(id);
         // A child deleted before completing never processed its payload.
         const parentID = childToParent.get(id);
         if (parentID) {
@@ -776,8 +876,15 @@ export const server: Plugin = async ({ client, worktree }) => {
         // notifications no longer exists.
         extraction.completeAccepted(id);
         extracting.delete(id);
-        sessionStatus.delete(id);
         watchers.cancelSession(id);
+        // Leaving the chat directory is the graceful-exit fast path; a
+        // crashed process never fires session.deleted, so the heartbeat
+        // staleness in chat_list is the covering signal for that case.
+        try {
+          db.unregisterChatSession(id);
+        } catch (err) {
+          console.error(`[thatch] chat unregister on delete failed: ${err}`);
+        }
         return;
       }
 
@@ -816,6 +923,7 @@ export const server: Plugin = async ({ client, worktree }) => {
     dispose: async () => {
       stopVersionChecker();
       watchers.dispose();
+      chatPoller.dispose();
       // Release native ONNX sessions while the worker is still healthy. Left
       // to Bun's teardown, their NAPI finalizers panic the process (see
       // BgeEmbeddingModel.dispose).

package/src/prediction.ts

@@ -89,7 +89,7 @@ export class PredictionEngine {
     return this.#engine.createMatcher(store, description, embedding, model);
   }
 
-  findNearestPrediction(store: string, embedding: Float32Array, threshold: number): PredictionRow | null {
+  findNearestPrediction(store: string | string[], embedding: Float32Array, threshold: number): PredictionRow | null {
     return this.#engine.findNearestItem(store, embedding, threshold) as PredictionRow | null;
   }