@jeffober/thatch 0.1.41 → 0.1.43

package/src/commands.ts

@@ -0,0 +1,97 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+/**
+ * Thatch's wrap-up slash commands for opencode, shipped as command markdown
+ * files synced into the global opencode config dir (~/.config/opencode/command/
+ * thatch/). The plugin writes them on every load so template updates self-heal
+ * without a reinstall. Config is loaded before plugins during server startup,
+ * so a first-ever install becomes visible on the next start.
+ */
+
+/** Greenlight token ending /thatch/compact's assistant response when compaction is safe. */
+export const COMPACT_READY_TOKEN = "THATCH_COMPACT_READY";
+
+/** Greenlight token ending /thatch/exit's assistant response when exiting is safe. */
+export const EXIT_READY_TOKEN = "THATCH_EXIT_READY";
+
+/**
+ * The plugin triggers compaction by running the TUI's compact action. The
+ * execute-command route only accepts legacy alias names, and "session_compact"
+ * maps to the same session.compact action the built-in /compact command runs.
+ * There is no exit alias, so the exit path publishes the TUI keymap command
+ * ("app.exit") directly via /tui/publish.
+ */
+
+const sharedChecklist = `1. Flush pending persistence. Call thatch_get_extraction_payload; if it returns buffered tool interactions, process them now (write any memories worth keeping), then call thatch_extraction_done to mark them complete. Complete any memory writes you promised earlier but have not made.
+2. Check for loose ends. Review the conversation for todos, follow-ups, or open questions raised earlier that were never addressed, and surface anything the user should address before the wrap-up completes.
+
+Do not start new work beyond this checklist. If every item is handled and nothing needs the user's attention first, end your final response with exactly this token as the very last line, with no formatting around it:`;
+
+const COMPACT_TEMPLATE = `---
+description: Flush thatch persistence, check for loose ends, then compact if clear
+---
+$ARGUMENTS
+
+Pre-compaction wrap-up. Work through this checklist before responding:
+
+${sharedChecklist}
+
+${COMPACT_READY_TOKEN}
+
+If anything is outstanding, list the items concisely so the user can address them, and do NOT include the token. The session will only be compacted when the token is present.`;
+
+const EXIT_TEMPLATE = `---
+description: Flush thatch persistence, check for loose ends, then exit opencode if clear
+---
+$ARGUMENTS
+
+Pre-exit wrap-up. Work through this checklist before responding:
+
+${sharedChecklist}
+3. Leave the chat directory. Call thatch_chat_unregister for this session - the session is exiting, so other sessions must stop addressing mail to it.
+
+Do not start new work beyond this checklist. If every item is handled and nothing needs the user's attention first, end your final response with exactly this token as the very last line, with no formatting around it:
+
+${EXIT_READY_TOKEN}
+
+If anything is outstanding, list the items concisely so the user can address them, and do NOT include the token. opencode will only exit when the token is present.`;
+
+/** One wrap-up command: the command name (minus the thatch/ prefix) and its full markdown file content. */
+export interface CommandDef {
+  name: string;
+  content: string;
+}
+
+/** The wrap-up command set, as full command-file contents ready to write. */
+export function opencodeCommandDefs(): CommandDef[] {
+  return [
+    { name: "compact", content: COMPACT_TEMPLATE },
+    { name: "exit", content: EXIT_TEMPLATE },
+  ];
+}
+
+/**
+ * Sync the wrap-up commands into <configHome>/opencode/command/thatch/.
+ * Idempotent: each file is written only when its on-disk content differs.
+ * Returns the paths that were written (empty when everything was current).
+ */
+export function installOpencodeCommands(configHome: string): string[] {
+  const dir = join(configHome, "opencode", "command", "thatch");
+  const written: string[] = [];
+  for (const def of opencodeCommandDefs()) {
+    const path = join(dir, `${def.name}.md`);
+    let current: string | null = null;
+    try {
+      current = readFileSync(path, "utf8");
+    } catch {
+      current = null;
+    }
+    if (current !== def.content) {
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(path, def.content);
+      written.push(path);
+    }
+  }
+  return written;
+}

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,13 +4,13 @@ import {
   PredictionEngine,
 } from "./prediction";
 import { BehaviorEngine } from "./behavior";
-import { ChatStore, type ChatHostKind } from "./chat";
+import { ChatStore, type ChatHostKind, type ChatWorktreeKind } 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 type { ChatSessionRow, ChatInboxItem, ChatNotificationRow, ChatWorktreeKind } from "./chat";
 
 export interface MemoryRow {
   slug: string;
@@ -238,7 +238,9 @@ export class ThatchDB {
         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'))
+        last_seen     TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now')),
+        auto          INTEGER NOT NULL DEFAULT 0,
+        worktree      TEXT NOT NULL DEFAULT ('')
       )
     `);
 
@@ -262,11 +264,43 @@ export class ThatchDB {
 
     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();
+    this.#migrateChatWorktree();
+  }
+
+  // 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
@@ -278,6 +312,16 @@ export class ThatchDB {
     }
   }
 
+  // chat_sessions tables created before the worktree column lack it; the
+  // ALTER adds it, and existing rows read as undetected (rendered as no
+  // loc token in chat_list) - they registered before the capture existed.
+  #migrateChatWorktree(): void {
+    const cols = (this.#db.query("PRAGMA table_info(chat_sessions)").all() as any[]).map((r) => r.name);
+    if (cols.length > 0 && !cols.includes("worktree")) {
+      this.#db.run("ALTER TABLE chat_sessions ADD COLUMN worktree TEXT NOT NULL DEFAULT ''");
+    }
+  }
+
   // 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).
@@ -824,12 +868,28 @@ export class ThatchDB {
   // 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);
+  registerChatSession(sessionID: string, project: string | null, topic: string | null, kind: ChatHostKind, nameBase: string | null = null, worktree: ChatWorktreeKind = null) {
+    return this.#chat.register(sessionID, project, topic, kind, nameBase, worktree);
+  }
+
+  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);
   }
 
-  assignChatName(sessionID: string, project: string | null, topic: string | null, kind: ChatHostKind) {
-    return this.#chat.assign(sessionID, project, topic, kind);
+  chatLeaveSuperseded(sessionID: string, project: string | null) {
+    return this.#chat.leaveSuperseded(sessionID, project);
   }
 
   broadcastChatMessage(fromSession: string, body: string) {

package/src/git.ts

@@ -1,4 +1,26 @@
 import { $ } from "bun";
+import { statSync } from "node:fs";
+import { join } from "node:path";
+
+/**
+ * Classifies the checkout the given directory serves: "worktree" for a
+ * linked git worktree (its .git is a FILE pointing at the main repo's
+ * gitdir), "root" for the project's main checkout (.git is a DIRECTORY),
+ * and null when undetectable (no .git at all, or no directory given).
+ * Synchronous and cheap: callers capture this once at chat registration,
+ * so the roster can show which sessions share the main tree.
+ */
+export function detectWorktreeKind(dir?: string | null): "root" | "worktree" | null {
+  if (!dir) return null;
+  try {
+    const st = statSync(join(dir, ".git"));
+    if (st.isFile()) return "worktree";
+    if (st.isDirectory()) return "root";
+    return null;
+  } catch {
+    return null;
+  }
+}
 
 /**
  * Extracts an `owner/repo` slug from a git remote URL. Handles the common

package/src/index.ts

@@ -2,7 +2,7 @@ import { join } from "node:path";
 import type { Plugin } from "@opencode-ai/plugin";
 import { ThatchDB } from "./db";
 import { BgeEmbeddingModel } from "./embeddings";
-import { detectRepo } from "./git";
+import { detectRepo, detectWorktreeKind } from "./git";
 import { createTools } from "./tools";
 import {
   systemPrompt,
@@ -18,12 +18,14 @@ import {
 } from "./prompts";
 import { ExtractionPipeline, type ToolInteraction } from "./extraction";
 import { installSkills, SHARED_SKILLS, OPENCODE_ONLY_SKILLS } from "./skills";
+import { installOpencodeCommands, COMPACT_READY_TOKEN, EXIT_READY_TOKEN } from "./commands";
 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, chatNotificationNudge, chatEchoText, isChatEchoParts } from "./prompts";
-import { ChatPoller } from "./chat";
+import { ChatPoller, isDefaultSessionTitle, slugifyTitle } from "./chat";
+import { chatEnabled, chatAutoRegister, loadConfig } from "./config";
 import pkg from "../package.json";
 
 // ---------------------------------------------------------------------------
@@ -51,6 +53,15 @@ const PREDICTION_THRESHOLD = parseFloat(process.env.THATCH_PREDICTION_THRESHOLD
 // situation genuinely matches.
 const BEHAVIOR_THRESHOLD = parseFloat(process.env.THATCH_BEHAVIOR_THRESHOLD ?? "0.60");
 
+// Wrap-up command registry: command name as opencode derives it from the
+// installed file path (~/.config/opencode/command/thatch/<name>.md), the
+// greenlight token the command instructs the model to end its response with,
+// and which TUI action the greenlight triggers.
+const WRAPUP_COMMANDS: Record<string, { token: string; kind: "compact" | "exit" }> = {
+  "thatch/compact": { token: COMPACT_READY_TOKEN, kind: "compact" },
+  "thatch/exit": { token: EXIT_READY_TOKEN, kind: "exit" },
+};
+
 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.
@@ -60,6 +71,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();
@@ -95,23 +112,49 @@ export const server: Plugin = async ({ client, worktree }) => {
   // 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
@@ -133,25 +176,24 @@ 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();
 
-  // 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.
+  // 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: () => {
@@ -183,10 +225,11 @@ 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,
   });
-  chatPoller.start();
+  // 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
@@ -247,6 +290,15 @@ export const server: Plugin = async ({ client, worktree }) => {
   // Keyed by child session ID. Cleaned up on child idle, error, or deletion.
   const childMetrics = new Map<string, { new: number; updated: number; deleted: number }>();
 
+  // Wrap-up slash commands (/thatch/compact, /thatch/exit) awaiting their
+  // greenlight check. command.execute.before marks the session when one of
+  // these commands runs; when the session next goes idle, the plugin reads
+  // the final assistant message for the ready token (the greenlight) and
+  // triggers the TUI action. Token absence means the model listed blockers
+  // instead, so nothing fires beyond a toast. Cleared on resolution or on
+  // session deletion.
+  const pendingWrapUp = new Map<string, { token: string; kind: "compact" | "exit" }>();
+
   // 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.
@@ -259,7 +311,16 @@ export const server: Plugin = async ({ client, worktree }) => {
     console.error(`[thatch] skill install failed: ${err}`);
   }
 
-  const sys = systemPrompt(repo);
+  // Same for the wrap-up slash commands: synced into the global config dir on
+  // every load so template updates self-heal. Config is loaded before plugins
+  // during server startup, so a first-ever install lands on the next start.
+  try {
+    installOpencodeCommands(configHome);
+  } catch (err) {
+    console.error(`[thatch] command install failed: ${err}`);
+  }
+
+  const sys = systemPrompt(repo, chatOn);
   const compact = compactionContext(repo);
 
   // Direct extraction: create a child session linked to the parent and prompt
@@ -348,6 +409,7 @@ export const server: Plugin = async ({ client, worktree }) => {
         return extraction.buildPayload(all, repo);
       },
       watcherRegistry: watchers,
+      projectDir: worktree,
     }),
 
     // 1. System prompt - always in context.
@@ -515,6 +577,14 @@ export const server: Plugin = async ({ client, worktree }) => {
     // Skipped during compaction: the agent can't call tools while generating
     // a summary, so a nudge that says "use thatch_memory_recall" triggers a
     // blocked-tool error.
+    // Wrap-up commands mark their session here; the actual trigger happens
+    // on the session's next idle event, once the model's greenlight response
+    // is complete.
+    "command.execute.before": async (input) => {
+      const wrapUp = WRAPUP_COMMANDS[input.command];
+      if (wrapUp) pendingWrapUp.set(input.sessionID, wrapUp);
+    },
+
     "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
@@ -820,6 +890,101 @@ export const server: Plugin = async ({ client, worktree }) => {
           }
           return;
         }
+        // Wrap-up command resolution: the session went idle right after
+        // /thatch/compact or /thatch/exit. The final assistant message's
+        // trailing token is the greenlight - the command instructs the model
+        // to end with it only after flushing persistence and confirming no
+        // loose ends. Token absence means the model listed blockers, so the
+        // action never fires; a toast points the user at the blockers above.
+        const wrapUp = sessionID ? pendingWrapUp.get(sessionID) : undefined;
+        if (wrapUp) {
+          pendingWrapUp.delete(sessionID);
+          let ready = false;
+          try {
+            const { data } = await client.session.messages({ path: { id: sessionID } });
+            const last = [...(data ?? [])].reverse().find((m) => m.info.role === "assistant");
+            const text = (last?.parts ?? [])
+              .filter((p) => p.type === "text")
+              .map((p) => p.text ?? "")
+              .join("\n")
+              .trimEnd();
+            ready = text.endsWith(wrapUp.token);
+          } catch (err) {
+            console.error(`[thatch] wrap-up message fetch failed: ${err}`);
+          }
+          if (ready) {
+            // An exit-greenlit session is leaving the process: leave the
+            // chat directory too, so other sessions stop addressing mail to
+            // a roster entry whose host is about to vanish. The unregister
+            // tombstone also stops any straggler auto-register from
+            // resurrecting the row during shutdown. Compact keeps the
+            // session alive, so only the exit path does this.
+            if (wrapUp.kind === "exit") {
+              try {
+                db.unregisterChatSession(sessionID);
+              } catch (err) {
+                console.error(`[thatch] chat unregister on exit failed: ${err}`);
+              }
+            }
+            try {
+              if (wrapUp.kind === "compact") {
+                // executeCommand only accepts legacy alias names;
+                // "session_compact" maps to the TUI's session.compact action,
+                // the same thing the built-in /compact command runs.
+                await client.tui.executeCommand({ body: { command: "session_compact" } });
+              } else {
+                // No exit alias exists, so publish the TUI keymap command
+                // directly - the same dispatch as the /exit slash command.
+                await client.tui.publish({
+                  body: { type: "tui.command.execute", properties: { command: "app.exit" } },
+                });
+              }
+            } catch (err) {
+              console.error(`[thatch] wrap-up action failed: ${err}`);
+            }
+            // Skip extraction and pending deliveries: compaction is starting
+            // (the checklist drained the buffer) or the process is exiting.
+            return;
+          }
+          try {
+            await client.tui.showToast({
+              body: {
+                message:
+                  wrapUp.kind === "compact"
+                    ? "\u23F8 Not compacting - resolve the items listed above, then run /thatch/compact again"
+                    : "\u23F8 Not exiting - resolve the items listed above, then run /thatch/exit again",
+                variant: "warning",
+                duration: 8000,
+              },
+            });
+          } catch {
+            // TUI may not be connected (e.g. headless mode).
+          }
+          // Blocked: fall through so extraction and pending deliveries still
+          // run - the model may have buffered tool interactions to flush.
+        }
+        // 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, detectWorktreeKind(worktree));
+              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.
@@ -861,6 +1026,13 @@ export const server: Plugin = async ({ client, worktree }) => {
         // 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) {
@@ -871,6 +1043,7 @@ export const server: Plugin = async ({ client, worktree }) => {
         parentSnapshots.delete(id);
         childMetrics.delete(id);
         extractionChildren.delete(id);
+        pendingWrapUp.delete(id);
         // A deleted parent takes its accepted entries with it, and its
         // watchers die with it - the session that would receive their
         // notifications no longer exists.