@jeffober/thatch 0.1.46 → 0.1.47

package/src/index.ts

@@ -2,9 +2,9 @@ import { join } from "node:path";
 import { readFileSync } from "node:fs";
 import { createDebugLog } from "./debug";
 import type { Plugin } from "@opencode-ai/plugin";
-import { ThatchDB } from "./db";
+import { ThatchDB, repoPathCache } from "./db";
 import { BgeEmbeddingModel } from "./embeddings";
-import { detectRepo, detectWorktreeKind } from "./git";
+import { detectRepo, detectWorktreeKind, resolveSpawnCwd } from "./git";
 import { createTools } from "./tools";
 import {
   systemPrompt,
@@ -24,7 +24,7 @@ import { installOpencodeCommands, COMPACT_READY_TOKEN, EXIT_READY_TOKEN } from "
 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 { WatcherRegistry, ghApiRun, ghAvailable, runWatchedCommand, withCwdFallback } from "./watchers";
 import { watcherNotificationNudge, chatNotificationNudge, chatEchoText, isChatEchoParts } from "./prompts";
 import { ChatPoller, createWakeGate, isDefaultSessionTitle } from "./chat";
 import { chatEnabled, chatAutoRegister, loadConfig } from "./config";
@@ -162,24 +162,31 @@ export function startupSessionId(osArgs: string[]): string | null {
   return startupSessionIdFromArgv(process.argv) ?? startupSessionIdFromArgv(osArgs);
 }
 
-export const server: Plugin = async ({ client, worktree }) => {
+export const server: Plugin = async ({ client, worktree, directory }) => {
   // The opencode server's cwd is wherever the server happened to start;
   // `worktree` is the project this plugin instance actually serves.
-  const repo = await detectRepo(worktree);
+  // `directory` is the session's own directory - on resume after the
+  // worktree was deleted, opencode reassigns worktree to "/" (it walks up
+  // from the missing dir, finds no .git, and boots the global project) but
+  // still forwards the original path as directory, which is the only input
+  // the repo_paths cache can recover identity from.
   const home = process.env.HOME ?? "/tmp";
   const configHome = process.env.XDG_CONFIG_HOME ?? join(home, ".config");
   const dbPath = process.env.THATCH_DB_PATH ?? join(configHome, "thatch", "thatch.db");
   const modelName = process.env.THATCH_MODEL ?? "Xenova/bge-small-en-v1.5";
 
+  // The DB must exist before identity detection: detectRepo consults the
+  // repo_paths cache when the session directory is gone.
+  const db = new ThatchDB(dbPath);
+  const repoCache = repoPathCache(db);
+  const repo = await detectRepo(directory ?? worktree, repoCache);
+
   // 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);
-  // Opt-in diagnostics (THATCH_DEBUG), written to debug.log beside the db.
-  // See debug.ts for the tag filter semantics.
   const debug = createDebugLog(dbPath);
   const model = new BgeEmbeddingModel(modelName);
   const extraction = new ExtractionPipeline();
@@ -244,6 +251,16 @@ export const server: Plugin = async ({ client, worktree }) => {
   // 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.
+  // Watched-command runner: resolves the spawn cwd per poll. When the
+  // project directory is deleted mid-watch (worktree merged and cleaned up),
+  // the poll falls back to the repo_paths cache's main checkout instead of
+  // spinning ENOENT errors until the TTL. The wrapper logs the fallback
+  // once per dead directory - per-cycle error logging is the existing
+  // failure mode and it spams.
+  const watchedCommandRunner = withCwdFallback(runWatchedCommand, (cwd) => resolveSpawnCwd(cwd, repoCache), (from, to) => {
+    console.error(`[thatch] project directory ${from} deleted; watcher falling back to main checkout ${to}`);
+  });
+
   const watchers = new WatcherRegistry({
     deliver: async (sessionID, events) => {
       // Events carry their watch's target label from the registry, so the
@@ -276,6 +293,7 @@ export const server: Plugin = async ({ client, worktree }) => {
     },
     canDeliver: canPromptSession,
     ghRunner: ghApiRun,
+    commandRunner: watchedCommandRunner,
   });
   // gh presence decides whether watch_create and watch_branch_create work;
   // checked lazily by the tools, but log once at startup so misconfiguration
@@ -1298,7 +1316,7 @@ export const server: Plugin = async ({ client, worktree }) => {
 
       let hygiene: string | null = null;
       try {
-        hygiene = await hygieneReport(db, repo, worktree);
+        hygiene = await hygieneReport(db, repo, worktree, repoCache);
       } catch (err) {
         console.error(`[thatch] hygiene report failed: ${err}`);
       }

package/src/mcp.ts

@@ -1,6 +1,6 @@
 import { resolve } from "node:path";
 import { z } from "zod";
-import { ThatchDB } from "./db";
+import { ThatchDB, repoPathCache } from "./db";
 import { mcpSessionID } from "./chat";
 import { BgeEmbeddingModel } from "./embeddings";
 import { detectRepo } from "./git";
@@ -121,14 +121,16 @@ export function compilePrompts(): Map<string, ActionDef> {
  */
 export async function runMcpServer(): Promise<void> {
   const projectDir = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
-  const repo = await detectRepo(projectDir);
 
   const home = process.env.HOME ?? "/tmp";
   const configHome = process.env.XDG_CONFIG_HOME ?? `${home}/.config`;
   const dbPath = process.env.THATCH_DB_PATH ?? `${configHome}/thatch/thatch.db`;
   const modelName = process.env.THATCH_MODEL ?? "Xenova/bge-small-en-v1.5";
 
+  // The DB must exist before identity detection: detectRepo consults the
+  // repo_paths cache when the project directory is gone (deleted worktree).
   const db = new ThatchDB(dbPath);
+  const repo = await detectRepo(projectDir, repoPathCache(db));
   const model = new BgeEmbeddingModel(modelName);
 
   await seedDefaultBehaviors(db, model);

package/src/prompts.ts

@@ -99,6 +99,7 @@ workflows. The host auto-discovers them, but reach for them proactively:
 - \`thatch-code-review\` - full multi-agent code review (dispatches 8 specialists + synthesizer). Requires sub-agent support.
 - \`thatch-review-followup\` - alternate entrypoint for follow-up review rounds. Verifies whether the author's responses and code changes since your last review adequately addressed prior findings, offers to reply on resolved items, then optionally re-runs the full structured review.
 - \`thatch-code-archaeology\` - investigate an existing feature, debug an unfamiliar area, or begin a new ticket. Explores the code base from multiple angles (data model, state flow, git history, sibling features) before proposing changes. The research skill; pair with \`thatch-coding-workflow\`.
+- \`thatch-plan-refinement\` - refine a plan before implementing it: fresh-context reviewer rounds until consensus, with an optional deep-mode lens fan-out (reuse, alternatives, hidden problems, safe-to-modify, archaeology). Use when a plan for a code change is about to be built or the user asks to stress-test a plan.
 - \`thatch-change-walkthrough\` - produces a teaching walkthrough of a diff with a specific format (SYNOPSIS + per-workflow orient/mechanism/numbered-stages + change overlay mirroring the same numbers) and calibrated prose rules. Load the skill for the format and prose rules, not just for the research method.
 - \`thatch-code-walkthrough\` - produces a teaching walkthrough for a feature/workflow as it stands today with a specific format (SYNOPSIS + per-workflow orient/mechanism/numbered-stages + Key files) and calibrated prose rules. Also use proactively to draft high-level docs for new or undocumented features (suitable for pkg/README.md or docs/features/<name>.md). Load the skill for the format and prose rules, not just for the research method.
 - \`thatch-review-context\` - gather project context (PRs, tickets, TODOs, deferred work) before a review.
@@ -408,6 +409,7 @@ Thatch ships skills for code review, project investigation, and memory
 workflows. The host auto-discovers them, but reach for them proactively:
 
 - \`thatch-code-archaeology\` - investigate an existing feature, debug an unfamiliar area, or begin a new ticket. Explores the code base from multiple angles (data model, state flow, git history, sibling features) before proposing changes. The research skill; pair with \`thatch-coding-workflow\`.
+- \`thatch-plan-refinement\` - refine a plan before implementing it: fresh-context reviewer rounds until consensus, with an optional deep-mode lens fan-out (reuse, alternatives, hidden problems, safe-to-modify, archaeology). Use when a plan for a code change is about to be built or the user asks to stress-test a plan.
 - \`thatch-change-walkthrough\` - produces a teaching walkthrough of a diff with a specific format (SYNOPSIS + per-workflow orient/mechanism/numbered-stages + change overlay mirroring the same numbers) and calibrated prose rules. Load the skill for the format and prose rules, not just for the research method.
 - \`thatch-code-walkthrough\` - produces a teaching walkthrough for a feature/workflow as it stands today with a specific format (SYNOPSIS + per-workflow orient/mechanism/numbered-stages + Key files) and calibrated prose rules. Also use proactively to draft high-level docs for new or undocumented features (suitable for pkg/README.md or docs/features/<name>.md). Load the skill for the format and prose rules, not just for the research method.
 - \`thatch-review-context\` - gather project context (PRs, tickets, TODOs, deferred work) before a review.

package/src/skills.ts

@@ -70,6 +70,7 @@ function loadSharedSkills(): SkillDef[] {
     "thatch-code-walkthrough",
     "thatch-session-reflection",
     "thatch-coding-workflow",
+    "thatch-plan-refinement",
     "thatch-pr-description",
     "thatch-ticket-description",
     "thatch-split-overlarge-pr",

package/src/tool-defs.ts

@@ -1432,8 +1432,9 @@ const watchCommandCreateDef: ToolDef = {
     "per-run timeout kills a blocking command each cycle, wasting up to " +
     "30s of the shared poll cycle on a check that can never succeed). " +
     "Use this for long or unknown-duration waits on any local condition " +
-    "instead of sleep-polling. The command runs in this project directory " +
-    "via bash -c about every 60s, killed at a 30s per-run timeout " +
+    "instead of sleep-polling. The command runs in the project directory " +
+    "(or the cd path) via bash -c about every 60s, killed at a 30s " +
+    "per-run timeout " +
     "(THATCH_WATCH_COMMAND_TIMEOUT_SECONDS overrides; a timed-out run " +
     "means not-done-yet). One-shot by design: it fires once on the first " +
     "exit 0, auto-cancels, and the notification carries only the exit code " +
@@ -1448,6 +1449,11 @@ const watchCommandCreateDef: ToolDef = {
       "The shell command to run as a condition: a fast, idempotent status " +
       "check that exits 0 when the wait is over. Its output is discarded.",
     ),
+    cd: z.string().optional().describe(
+      "Directory the command runs in (the bash cwd). Defaults to the " +
+      "project directory. Use only when the condition must be checked " +
+      "somewhere else; a nonexistent path is rejected at registration.",
+    ),
   },
   opencodeOnly: true,
   async execute(args, ctx, host) {
@@ -1457,11 +1463,12 @@ const watchCommandCreateDef: ToolDef = {
     if (!ctx.watchers) {
       return "Watching is unavailable: no watcher registry was wired by this host.";
     }
-    if (!ctx.projectDir) {
+    const dir = (args.cd as string | undefined) ?? ctx.projectDir;
+    if (!dir) {
       return "Watching is unavailable: no project directory was wired by this host.";
     }
     const command = args.command as string;
-    const result = await ctx.watchers.createCommand(host.sessionID, command, ctx.projectDir);
+    const result = await ctx.watchers.createCommand(host.sessionID, command, dir);
     if (!result.ok) return `Watcher not created: ${result.error}`;
     const w = result.watcher;
     return (

package/src/watchers.ts

@@ -233,6 +233,32 @@ export interface CommandRunResult {
 
 export type CommandRunner = (command: string, cwd: string, timeoutMs: number) => Promise<CommandRunResult>;
 
+/**
+ * Wraps a CommandRunner so the spawn cwd is resolved per poll: the given
+ * resolver returns the directory to run in (the project dir when alive, or
+ * the cached main checkout when the worktree was deleted mid-watch), or null
+ * to keep the original cwd (which then fails as before). A fallback fires
+ * at most once per dead directory - onFallback, when given, reports it so
+ * the host can log; per-cycle logging is the poll loop's existing failure
+ * mode and it spams. Exported for the fallback unit tests; the plugin wires
+ * the production instance.
+ */
+export function withCwdFallback(
+  base: CommandRunner,
+  resolve: (cwd: string) => Promise<string | null>,
+  onFallback?: (from: string, to: string) => void,
+): CommandRunner {
+  const logged = new Set<string>();
+  return async (command, cwd, timeoutMs) => {
+    const resolved = await resolve(cwd);
+    if (resolved && resolved !== cwd && !logged.has(cwd)) {
+      logged.add(cwd);
+      onFallback?.(cwd, resolved);
+    }
+    return base(command, resolved ?? cwd, timeoutMs);
+  };
+}
+
 export interface WatcherRegistryOptions {
   /** Delivers a batch of events for a session. Injected so tests never spawn. */
   deliver: (sessionID: string, events: WatcherEvent[]) => Promise<void>;