@jeffober/thatch 0.1.40 → 0.1.42

package/src/config.ts

@@ -16,15 +16,22 @@ export const notificationPrefsSchema = z.strictObject({
   sound: z.string().optional(),
 });
 
+export const chatPrefsSchema = z.strictObject({
+  enabled: z.boolean().optional(),
+  autoRegister: z.boolean().optional(),
+});
+
 export const configSchema = z.strictObject({
   notifications: notificationPrefsSchema.optional(),
+  chat: chatPrefsSchema.optional(),
 });
 
 export type NotificationPrefs = z.infer<typeof notificationPrefsSchema>;
+export type ChatPrefs = z.infer<typeof chatPrefsSchema>;
 export type Config = z.infer<typeof configSchema>;
 
 /** Sections in presentation order. config_get / config_set iterate this. */
-export const CONFIG_SECTIONS = ["notifications"] as const;
+export const CONFIG_SECTIONS = ["notifications", "chat"] as const;
 export type ConfigSection = (typeof CONFIG_SECTIONS)[number];
 
 /**
@@ -90,6 +97,32 @@ export function mergeNotificationPrefs(
   return { ...current, ...patch };
 }
 
+/** Field-level merge for one section: omitted fields keep their values. */
+export function mergeChatPrefs(current: ChatPrefs | undefined, patch: ChatPrefs): ChatPrefs {
+  return { ...current, ...patch };
+}
+
+/**
+ * Whether cross-session chat is on. Unset means on - chat is the default,
+ * and the toggle exists for users who want the feature entirely dark: every
+ * chat tool refuses, wake delivery never starts, and the system prompt
+ * omits the chat section.
+ */
+export function chatEnabled(config: Config): boolean {
+  return config.chat?.enabled !== false;
+}
+
+/**
+ * Whether opencode sessions join the chat directory automatically (first
+ * idle event, name assigned by thatch). Unset means on - the directory is
+ * only useful when peers are in it, and a session that must be told to
+ * register never is. Turning it off restores opt-in behavior: sessions
+ * stay out of the directory until they call chat_register.
+ */
+export function chatAutoRegister(config: Config): boolean {
+  return config.chat?.autoRegister !== false;
+}
+
 /**
  * Platform fallbacks shown by config_get and applied by notify_user when the
  * user has not set a preference. Only darwin has opinionated defaults; other

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 } 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,112 @@ 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')),
+        auto          INTEGER NOT NULL DEFAULT 0
+      )
+    `);
+
+    // 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')");
 
+    // Per-base name counters for assigned chat names. A row only ever
+    // increments (never on prune), so a name is minted exactly once.
+    this.#db.run(`
+      CREATE TABLE IF NOT EXISTS chat_name_counters (
+        base TEXT PRIMARY KEY,
+        next INTEGER NOT NULL DEFAULT 1
+      )
+    `);
+
+    // Explicit leaves (chat_unregister). Suppresses auto-registration so
+    // the next idle event cannot silently re-register the session; cleared
+    // when the session explicitly rejoins via chat_register. Survives the
+    // directory-row delete, which is the point.
+    this.#db.run(`
+      CREATE TABLE IF NOT EXISTS chat_leave_tombstones (
+        session_id TEXT PRIMARY KEY,
+        left_at    TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
+      )
+    `);
+
     this.#migrateColumns();
+    this.#migrateChatNameCollation();
+    this.#migrateChatTopic();
+    this.#migrateChatHostKind();
+    this.#migrateChatBroadcastFlag();
+    this.#migrateChatAuto();
+  }
+
+  // chat_sessions tables created before the auto column lack it; the ALTER
+  // adds it, and existing rows read as manual (which they were - auto is
+  // only set by the assigned-name registration path).
+  #migrateChatAuto(): void {
+    const cols = (this.#db.query("PRAGMA table_info(chat_sessions)").all() as any[]).map((r) => r.name);
+    if (cols.length > 0 && !cols.includes("auto")) {
+      this.#db.run("ALTER TABLE chat_sessions ADD COLUMN auto INTEGER NOT NULL DEFAULT 0");
+    }
+  }
+
+  // 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 +348,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
   // ---------------------------------------------------------------------------
@@ -708,6 +852,89 @@ export class ThatchDB {
     return this.#behaviors.listBehaviors(store);
   }
 
+  // ---------------------------------------------------------------------------
+  // Cross-session chat: delegates to ChatStore
+  // ---------------------------------------------------------------------------
+
+  registerChatSession(sessionID: string, project: string | null, topic: string | null, kind: ChatHostKind, nameBase: string | null = null) {
+    return this.#chat.register(sessionID, project, topic, kind, nameBase);
+  }
+
+  refreshChatTopic(sessionID: string, title: string) {
+    return this.#chat.refreshAutoTopic(sessionID, title);
+  }
+
+  pruneStaleChatAuto(cutoff: string) {
+    return this.#chat.pruneStaleAuto(cutoff);
+  }
+
+  hasChatLeaveTombstone(sessionID: string) {
+    return this.#chat.hasLeaveTombstone(sessionID);
+  }
+
+  clearChatLeaveTombstone(sessionID: string) {
+    return this.#chat.clearLeaveTombstone(sessionID);
+  }
+
+  chatLeaveSuperseded(sessionID: string, project: string | null) {
+    return this.#chat.leaveSuperseded(sessionID, project);
+  }
+
+  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/index.ts

@@ -22,7 +22,9 @@ 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, isDefaultSessionTitle, slugifyTitle } from "./chat";
+import { chatEnabled, chatAutoRegister, loadConfig } from "./config";
 import pkg from "../package.json";
 
 // ---------------------------------------------------------------------------
@@ -59,6 +61,12 @@ export const server: Plugin = async ({ client, worktree }) => {
   const dbPath = process.env.THATCH_DB_PATH ?? join(configHome, "thatch", "thatch.db");
   const modelName = process.env.THATCH_MODEL ?? "Xenova/bge-small-en-v1.5";
 
+  // Whether cross-session chat is on (chat.enabled, default on). Read once
+  // at init: it gates the chat poller and the prompt's chat section. The
+  // chat tools re-read the file per call, so a toggle takes effect there
+  // without a restart.
+  const chatOn = chatEnabled(loadConfig(dbPath).config);
+
   const db = new ThatchDB(dbPath);
   const model = new BgeEmbeddingModel(modelName);
   const extraction = new ExtractionPipeline();
@@ -86,28 +94,57 @@ 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>();
 
+  // The proactive-prompt gate, shared by both delivery registries (watchers
+  // and chat). Two layers, in cost order: the compacting set and the
+  // event-fed sessionStatus map answer cheaply, and a final check verifies
+  // against the server's live status - the map is only as fresh as the
+  // event stream, and a stale "idle" turns a wake into mid-turn context
+  // injection (observed live: a session read mail mid-burst, contradicted
+  // its own in-flight plan, and looped).
+  const canPromptSession = async (sessionID: string): Promise<boolean> => {
+    if (compacting.has(sessionID)) return false;
+    if (sessionStatus.get(sessionID) !== "idle") return false;
+    try {
+      const { data } = await client.session.status();
+      // The server's status map only carries ACTIVE sessions - it deletes
+      // the entry when a session goes idle (session/status.ts), so absent
+      // means idle. Fail closed on busy/retry, pass on idle-or-absent.
+      const live = data?.[sessionID];
+      return !live || live.type === "idle";
+    } catch (err) {
+      // Unreachable server: do not deliver (the mail stays pending).
+      console.error(`[thatch] status check failed for ${sessionID}: ${err}`);
+      return false;
+    }
+  };
+
   // In-memory watcher registry for proactive event notifications (GitHub PR
-  // watching today). Deliberately process-scoped: no SQLite, no cross-restart
-  // state. See src/watchers.ts for the rationale.
+  // and branch watching, plus local command watches). Deliberately
+  // process-scoped: no SQLite, no cross-restart state. See src/watchers.ts
+  // for the rationale.
   //
   // Delivery prompts the session with a synthetic part - the same mechanism
   // opencode uses for background task completions - so a watched event
-  // triggers a model turn even when the user is away. Events only carry
-  // pointer data; the model fetches details itself with gh.
+  // triggers a model turn even when the user is away. Events carry pointer
+  // data plus machine status (check conclusions, exit codes); the model
+  // fetches logs and further details itself with gh.
   const watchers = new WatcherRegistry({
     deliver: async (sessionID, events) => {
       // Events carry their watch's target label from the registry, so the
       // notification header is correct for every source (PRs, branches,
-      // CI events whose URLs would not parse).
+      // commands, CI events whose URLs would not parse).
       await client.session.promptAsync({
         path: { id: sessionID },
         body: {
-          parts: [{ type: "text", text: watcherNotificationNudge(events[0]?.target ?? "watched target", events), synthetic: true }],
+          parts: [{ type: "text", text: watcherNotificationNudge(events[0]?.target ?? "watched target", events, watchers.pollSeconds), synthetic: true }],
         },
       });
       // Toast: the notification part is TUI-hidden, so without this the
@@ -129,17 +166,61 @@ export const server: Plugin = async ({ client, worktree }) => {
         // TUI may not be connected. Best-effort.
       }
     },
-    canDeliver: (sessionID) =>
-      !compacting.has(sessionID) && sessionStatus.get(sessionID) === "idle",
+    canDeliver: canPromptSession,
     ghRunner: ghApiRun,
   });
-  // gh presence decides whether watch_create works; checked lazily by the
-  // tool, but log once at startup so misconfiguration is visible in debug logs.
+  // gh presence decides whether watch_create and watch_branch_create work;
+  // checked lazily by the tools, but log once at startup so misconfiguration
+  // is visible in debug logs. watch_command_create needs only bash, not gh.
   void ghAvailable().then((ok) => {
-    if (!ok) console.error("[thatch] gh CLI not found - watch tools will report unavailable");
+    if (!ok) console.error("[thatch] gh CLI not found - GitHub watch tools will report unavailable");
   });
   watchers.start();
 
+  // The proactive-prompt gate, shared by both delivery registries
+  // (watchers and chat). Two layers, in cost order: the compacting set and
+  // the event-fed sessionStatus map answer cheaply, and a final check
+  // verifies against the server's live status - the map is only as fresh
+  // as the event stream, and a stale "idle" turns a wake into mid-turn
+  // context injection (observed live: a session read mail mid-burst,
+  // contradicted its own in-flight plan, and looped).
+  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: canPromptSession,
+  });
+  // With chat disabled the tools refuse, so the poller would only heartbeat
+  // sessions and burn wake budget against a feature the user turned off.
+  if (chatOn) 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
@@ -211,7 +292,7 @@ export const server: Plugin = async ({ client, worktree }) => {
     console.error(`[thatch] skill install failed: ${err}`);
   }
 
-  const sys = systemPrompt(repo);
+  const sys = systemPrompt(repo, chatOn);
   const compact = compactionContext(repo);
 
   // Direct extraction: create a child session linked to the parent and prompt
@@ -300,6 +381,7 @@ export const server: Plugin = async ({ client, worktree }) => {
         return extraction.buildPayload(all, repo);
       },
       watcherRegistry: watchers,
+      projectDir: worktree,
     }),
 
     // 1. System prompt - always in context.
@@ -407,6 +489,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 +550,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),
@@ -732,6 +854,28 @@ export const server: Plugin = async ({ client, worktree }) => {
           }
           return;
         }
+        // Auto-registration: every top-level opencode session joins the
+        // chat directory on its first idle event (unless the user turned
+        // auto-registration off). The name is assigned, never chosen - a
+        // slug of the session title plus a never-reused counter - and the
+        // live title rides the topic column, refreshed on every idle so the
+        // roster tracks what the session is actually working on. Titles are
+        // usually placeholders at first idle and real within a turn or two,
+        // so both name and topic converge fast. Fire-and-forget: a failed
+        // registration or title fetch must never block event delivery.
+        if (chatOn && chatAutoRegister(loadConfig(dbPath).config) && sessionID && !db.hasChatLeaveTombstone(sessionID)) {
+          void (async () => {
+            try {
+              const { data } = await client.session.get({ path: { id: sessionID } });
+              const title = data?.title ?? "";
+              const base = title && !isDefaultSessionTitle(title) ? slugifyTitle(title) : null;
+              db.registerChatSession(sessionID, repo, base ? title : null, "opencode", base);
+              if (base) db.refreshChatTopic(sessionID, title);
+            } catch (err) {
+              console.error(`[thatch] chat auto-register failed for ${sessionID}: ${err}`);
+            }
+          })();
+        }
         // Parent went idle - trigger direct extraction if there are pending
         // tool interactions and no extraction is already running. Falls
         // back to the nudge path on the next chat.message if this throws.
@@ -757,10 +901,29 @@ 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);
+        // Tombstone the auto-registerer: an idle IIFE already in flight
+        // (title fetch pending) would otherwise re-insert a directory row
+        // for a session the user just deleted - a week-long roster zombie
+        // whose host is gone. The unregister below tombstones (see
+        // ChatStore.unregister), and the tombstone is cleared only by an
+        // explicit chat_register rejoin, so a genuinely new session is
+        // unaffected.
         // A child deleted before completing never processed its payload.
         const parentID = childToParent.get(id);
         if (parentID) {
@@ -776,8 +939,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 +986,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).