@jeffober/thatch 0.1.42 → 0.1.44

package/src/commands.ts

@@ -0,0 +1,107 @@
+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.`;
+
+const userMessageSection = `# User Message
+
+$ARGUMENTS
+
+(That section carries the text typed after the command. When it is empty, treat the user message as n/a - the command was run bare.)`;
+
+const COMPACT_TEMPLATE = `---
+description: Flush thatch persistence, check for loose ends, then compact if clear
+---
+${userMessageSection}
+
+# Pre-compact wrap-up
+
+Work through this checklist before responding:
+
+${sharedChecklist}
+
+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:
+
+${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
+---
+${userMessageSection}
+
+# 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/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 } from "./chat";
+export type { ChatSessionRow, ChatInboxItem, ChatNotificationRow, ChatWorktreeKind } from "./chat";
 
 export interface MemoryRow {
   slug: string;
@@ -239,7 +239,8 @@ export class ThatchDB {
         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
+        auto          INTEGER NOT NULL DEFAULT 0,
+        worktree      TEXT NOT NULL DEFAULT ('')
       )
     `);
 
@@ -283,12 +284,28 @@ export class ThatchDB {
       )
     `);
 
+    // Hook-parent-process -> session mapping (Claude Code identity anchor):
+    // hooks learn the true session id from the host's hook payload and run
+    // as children of the same process that spawned the MCP server, so the
+    // server resolves its own parent pid against this table - an identity
+    // the model cannot claim. Rows are timestamped; stale rows are ignored
+    // (pid reuse) rather than deleted.
+    this.#db.run(`
+      CREATE TABLE IF NOT EXISTS chat_host_pids (
+        ppid       INTEGER PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        seen_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();
+    this.#migrateChatHostPid();
   }
 
   // chat_sessions tables created before the auto column lack it; the ALTER
@@ -310,6 +327,26 @@ 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 ''");
+    }
+  }
+
+  // The released schema has no host_pid column (liveness is heartbeat age;
+  // see chatLiveness). A development database may carry one; drop it so
+  // every database matches a fresh install.
+  #migrateChatHostPid(): void {
+    const cols = (this.#db.query("PRAGMA table_info(chat_sessions)").all() as any[]).map((r) => r.name);
+    if (cols.includes("host_pid")) {
+      this.#db.run("ALTER TABLE chat_sessions DROP COLUMN host_pid");
+    }
+  }
+
   // 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).
@@ -856,8 +893,8 @@ export class ThatchDB {
   // 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);
+  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) {
@@ -923,6 +960,18 @@ export class ThatchDB {
     return this.#chat.unreadCount(sessionID);
   }
 
+  recordChatHostPid(ppid: number, sessionID: string) {
+    return this.#chat.recordHostPid(ppid, sessionID);
+  }
+
+  findChatSessionByHostPid(ppid: number, maxAgeSeconds: number): string | null {
+    return this.#chat.findSessionByHostPid(ppid, maxAgeSeconds);
+  }
+
+  continueChatSession(oldSessionID: string, newSessionID: string) {
+    return this.#chat.continueSession(oldSessionID, newSessionID);
+  }
+
   heartbeatChatSessions(sessionIDs: string[]) {
     return this.#chat.heartbeat(sessionIDs);
   }

package/src/debug.ts

@@ -0,0 +1,44 @@
+import { appendFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+// Opt-in diagnostic logging for questions a live harness cannot otherwise
+// answer ("what did the plugin actually see at init?"). Lines go to
+// debug.log beside the database, never to the host's stdout or stderr:
+// the plugin runs inside opencode's TUI process, where console output is
+// invisible or garbles the screen, and test sandboxes point the database at
+// a tmp dir so their debug output never reaches the quality gate.
+//
+// Off unless THATCH_DEBUG is set. THATCH_DEBUG=1 (or "all" / "*") logs every
+// tag. Otherwise it is a comma-separated list of tag filters: a filter
+// matches a tag when it equals the whole tag ("chat:startup") or the
+// feature part before the colon ("chat" matches every chat:* tag).
+//
+// Tags are `feature:aspect`, rendered in square brackets, so a grep on
+// "[chat:" pulls one feature's story out of a shared file.
+
+export type DebugLog = (tag: string, msg: string) => void;
+
+// Decide, from a THATCH_DEBUG value, whether a tag is enabled. Exported for
+// tests; callers use createDebugLog.
+export function debugEnabled(spec: string | undefined, tag: string): boolean {
+  if (!spec) return false;
+  const s = spec.trim();
+  if (s === "1" || s === "all" || s === "*") return true;
+  const feature = tag.split(":")[0];
+  return s.split(",").map((f) => f.trim()).filter(Boolean).some((f) => f === tag || f === feature);
+}
+
+// Build the logger for a database location. Every line: ISO timestamp,
+// bracketed tag, message. Writes never throw: diagnostics must not break
+// the host, so a missing directory or a full disk simply drops the line.
+export function createDebugLog(dbPath: string, spec: string | undefined = process.env.THATCH_DEBUG): DebugLog {
+  const file = join(dirname(dbPath), "debug.log");
+  return (tag, msg) => {
+    if (!debugEnabled(spec, tag)) return;
+    try {
+      appendFileSync(file, `${new Date().toISOString()} [${tag}] ${msg}\n`);
+    } catch {
+      // Intentionally silent; see above.
+    }
+  };
+}

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