fix(watchers): revive dead skill and memory file watchers

chokidar v4+ dropped glob support, so the literal glob paths handed to
chokidar (skills/watcher.ts, memory/index.ts) matched nothing: the watchers
registered but never fired. Skill hot-reload was fully dead, and root-level
.md edits never triggered a memory reindex.

Watch the containing directories instead and filter events in the handler:
- skills: watch the skill roots, react only to SKILL.md basenames
- memory: watch the workspace root + sessions dir, filter to indexed files
- replace the unanchored substring ignore regexes (/build/, /dist/, ...)
  with exact path-segment matching scoped below the watch roots, so a skill
  named 'prompt-builder' or a memory file like 'node_modules-notes.md' is no
  longer silently pruned

Add integration tests that write real files and assert the watcher fires, and
that vendored dirs / non-target files stay ignored.

Author: rich7420

src/memory/index.ts

@@ -13,7 +13,7 @@
 
 import { Database } from "bun:sqlite";
 import { existsSync, readFileSync, statSync, mkdirSync, readdirSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { join, dirname, sep } from "node:path";
 import { createSubsystemLogger } from "../logging/index.js";
 import { getConfigDir } from "../storage/config.js";
 import { createSchema, setMeta, getMeta } from "./schema.js";
@@ -792,22 +792,38 @@ export class MemoryIndex {
 
   private startWatcher(): void {
     const wsPath = this.workspacePath;
-    const watchPaths: string[] = [];
+    const sessionsPath = this.sessionsPath;
 
+    // chokidar v4+ dropped glob support, so `wsPath/*.md` no longer matches
+    // anything. Watch the containing directories and filter changed paths down
+    // to the files listWorkspaceFiles() would actually index.
+    const watchDirs: string[] = [];
     if (existsSync(wsPath)) {
-      watchPaths.push(join(wsPath, "*.md"), join(wsPath, "memory"));
+      watchDirs.push(wsPath); // covers root *.md and the memory/ subtree
     }
-
-    // Watch sessions directory for changes (even if workspace is absent)
-    if (this.sessionsPath && existsSync(this.sessionsPath)) {
-      watchPaths.push(this.sessionsPath);
+    if (sessionsPath && existsSync(sessionsPath)) {
+      watchDirs.push(sessionsPath);
     }
 
-    if (watchPaths.length === 0) return;
+    if (watchDirs.length === 0) return;
+
+    const memDir = join(wsPath, "memory");
+    const isInside = (dir: string, p: string): boolean =>
+      p === dir || p.startsWith(dir.endsWith(sep) ? dir : dir + sep);
+
+    const shouldReindex = (p: string): boolean => {
+      // Session JSONL files (recursive)
+      if (sessionsPath && isInside(sessionsPath, p)) return p.endsWith(".jsonl");
+      // memory/ subtree: indexed .md and .jsonl (recursive)
+      if (isInside(memDir, p)) return p.endsWith(".md") || p.endsWith(".jsonl");
+      // Workspace root: top-level .md files only (not nested)
+      if (dirname(p) === wsPath) return p.endsWith(".md");
+      return false;
+    };
 
-    this.watcher = createMemoryWatcher(watchPaths, () => {
+    this.watcher = createMemoryWatcher(watchDirs, () => {
       this.dirty = true;
-    });
+    }, shouldReindex);
   }
 }
 

src/memory/watcher.ts

@@ -7,29 +7,58 @@
 // =============================================================================
 
 import { watch } from "chokidar";
+import { sep } from "node:path";
 
 export interface MemoryWatcher {
   close(): void;
 }
 
+// Vendored/generated directories we never descend into. Matched per path
+// *segment* (not as substrings), so a memory file like "node_modules-notes.md"
+// or a path under a project that merely contains ".git" is not mistaken for
+// one of these directories.
+const IGNORED_DIRS = new Set([".git", "node_modules"]);
+
+/**
+ * Build a chokidar `ignored` predicate that skips IGNORED_DIRS by exact path
+ * segment, only for segments below one of the watch roots — never the roots or
+ * their ancestors (a root may live under e.g. a `node_modules/` directory).
+ */
+function makeIgnored(roots: string[]): (path: string) => boolean {
+  const normRoots = roots.map((r) => (r.endsWith(sep) ? r.slice(0, -1) : r));
+  return (path: string): boolean => {
+    const root = normRoots.find((r) => path === r || path.startsWith(r + sep));
+    if (!root) return false;
+    const rel = path.slice(root.length + 1);
+    if (!rel) return false; // the root itself
+    return rel.split(sep).some((segment) => IGNORED_DIRS.has(segment));
+  };
+}
+
 /**
  * Create a file watcher for workspace memory files.
  * Calls onDirty() when files change (debounced).
+ *
+ * `watchPaths` must be plain directories — chokidar v4+ dropped glob support,
+ * so callers watch containing directories and pass `filter` to decide which
+ * changed paths are relevant (e.g. only top-level `.md`, or `.jsonl` sessions).
  */
 export function createMemoryWatcher(
   watchPaths: string[],
   onDirty: () => void,
+  filter?: (path: string) => boolean,
   debounceMs = 1500,
 ): MemoryWatcher {
   let timer: ReturnType<typeof setTimeout> | null = null;
 
   const watcher = watch(watchPaths, {
     ignoreInitial: true,
     depth: 2,
-    ignored: [/\.git/, /node_modules/],
+    ignored: makeIgnored(watchPaths),
   });
 
-  watcher.on("all", () => {
+  watcher.on("all", (_event, path) => {
+    if (filter && (!path || !filter(path))) return;
     if (timer) clearTimeout(timer);
     timer = setTimeout(onDirty, debounceMs);
   });

src/skills/watcher.ts

@@ -6,7 +6,7 @@
 // =============================================================================
 
 import { watch } from "chokidar";
-import { join } from "node:path";
+import { join, basename, sep } from "node:path";
 import { getConfigDir } from "../storage/config.js";
 
 // -----------------------------------------------------------------------------
@@ -16,17 +16,38 @@ import { getConfigDir } from "../storage/config.js";
 let dirty = false;
 let watcherInstance: { close: () => void } | null = null;
 
-// Ignored directories (same as memory watcher)
-const IGNORED = [
-  /\.git/,
-  /node_modules/,
-  /dist/,
-  /\.venv/,
-  /venv/,
-  /__pycache__/,
-  /build/,
-  /\.cache/,
-];
+// Vendored/generated directories we never descend into. Matched per path
+// *segment* (not as substrings), and only below the watch roots, so a skill
+// named "prompt-builder" or even "build" is not mistaken for a "build" dir.
+const IGNORED_DIRS = new Set([
+  ".git",
+  "node_modules",
+  "dist",
+  ".venv",
+  "venv",
+  "__pycache__",
+  "build",
+  ".cache",
+]);
+
+/**
+ * Build a chokidar `ignored` predicate that skips IGNORED_DIRS by exact path
+ * segment, scoped to *inside* a skill folder. Never treats a watch root, its
+ * ancestors (a root may live under e.g. a `build/` directory), or a skill
+ * folder's own name (a skill may be named "build") as junk — only vendored
+ * dirs nested within a skill.
+ */
+function makeIgnored(roots: string[]): (path: string) => boolean {
+  const normRoots = roots.map((r) => (r.endsWith(sep) ? r.slice(0, -1) : r));
+  return (path: string): boolean => {
+    const root = normRoots.find((r) => path === r || path.startsWith(r + sep));
+    if (!root) return false;
+    const rel = path.slice(root.length + 1);
+    if (!rel) return false; // the root itself
+    // rel[0] is the skill folder name; only segments *within* it can be junk.
+    return rel.split(sep).slice(1).some((segment) => IGNORED_DIRS.has(segment));
+  };
+}
 
 // -----------------------------------------------------------------------------
 // Public API
@@ -54,28 +75,32 @@ export function markSkillsDirty(): void {
 export function startSkillsWatcher(workspacePath?: string): void {
   if (watcherInstance) return; // Already watching
 
-  const watchPaths: string[] = [];
+  // chokidar v4+ dropped glob support, so a path containing "*" is treated as a
+  // literal filename and matches nothing. Watch the containing skill directories
+  // directly and filter events down to SKILL.md files in the handler.
+  const watchDirs: string[] = [];
 
-  // User skills
-  const userSkillsDir = join(getConfigDir(), "skills");
-  watchPaths.push(join(userSkillsDir, "*/SKILL.md"));
+  // User skills: <config root>/skills/<name>/SKILL.md
+  watchDirs.push(join(getConfigDir(), "skills"));
 
-  // Workspace skills
+  // Workspace skills: <workspace>/skills/<name>/SKILL.md
   if (workspacePath) {
-    watchPaths.push(join(workspacePath, "skills", "*/SKILL.md"));
+    watchDirs.push(join(workspacePath, "skills"));
   }
 
-  if (watchPaths.length === 0) return;
+  if (watchDirs.length === 0) return;
 
   let timer: ReturnType<typeof setTimeout> | null = null;
 
-  const watcher = watch(watchPaths, {
+  const watcher = watch(watchDirs, {
     ignoreInitial: true,
     depth: 2,
-    ignored: IGNORED,
+    ignored: makeIgnored(watchDirs),
   });
 
-  watcher.on("all", () => {
+  watcher.on("all", (_event, path) => {
+    // The directory watch also sees sibling files; only SKILL.md matters.
+    if (!path || basename(path) !== "SKILL.md") return;
     if (timer) clearTimeout(timer);
     timer = setTimeout(() => {
       dirty = true;

tests/test-memory-watcher.ts

@@ -0,0 +1,144 @@
+// =============================================================================
+// Memory Watcher Tests
+//
+// Regression guard for #9 — createMemoryWatcher previously received glob paths
+// (e.g. "<ws>/*.md") from startWatcher(). chokidar v4+ dropped glob support, so
+// those paths matched nothing and the watcher never fired. These tests write
+// real files under a watched directory and assert the debounced onDirty runs,
+// and that the path filter suppresses irrelevant files.
+// =============================================================================
+
+import { describe, expect, test, beforeEach, afterEach } from "bun:test";
+import { mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { createMemoryWatcher, type MemoryWatcher } from "../src/memory/watcher.js";
+import { MemoryIndex } from "../src/memory/index.js";
+
+let tempDir: string;
+let watcher: MemoryWatcher | null = null;
+
+async function pollFor(fn: () => Promise<boolean>, timeoutMs = 5000, stepMs = 150): Promise<boolean> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (await fn()) return true;
+    await new Promise((r) => setTimeout(r, stepMs));
+  }
+  return fn();
+}
+
+async function waitFor(cond: () => boolean, timeoutMs = 5000, stepMs = 50): Promise<boolean> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (cond()) return true;
+    await new Promise((r) => setTimeout(r, stepMs));
+  }
+  return cond();
+}
+
+beforeEach(() => {
+  tempDir = join(tmpdir(), `hawky-mem-watch-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(tempDir, { recursive: true });
+});
+
+afterEach(() => {
+  watcher?.close();
+  watcher = null;
+  if (existsSync(tempDir)) rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe("createMemoryWatcher fires on real file changes", () => {
+  test("writing a top-level .md triggers onDirty", async () => {
+    let dirty = false;
+    // Short debounce so the test stays fast.
+    watcher = createMemoryWatcher([tempDir], () => { dirty = true; }, undefined, 50);
+
+    // Let chokidar finish its initial scan before writing (ignoreInitial: true).
+    await new Promise((r) => setTimeout(r, 400));
+    writeFileSync(join(tempDir, "HAWKY.md"), "# root memory\n");
+
+    expect(await waitFor(() => dirty)).toBe(true);
+  });
+
+  test("filter suppresses irrelevant files but allows .md", async () => {
+    let dirty = false;
+    const filter = (p: string) => p.endsWith(".md");
+    watcher = createMemoryWatcher([tempDir], () => { dirty = true; }, filter, 50);
+
+    await new Promise((r) => setTimeout(r, 400));
+    // A non-.md write must NOT flip dirty.
+    writeFileSync(join(tempDir, "scratch.txt"), "ignore me\n");
+    await new Promise((r) => setTimeout(r, 600));
+    expect(dirty).toBe(false);
+
+    // A .md write in the same directory must flip it.
+    writeFileSync(join(tempDir, "notes.md"), "index me\n");
+    expect(await waitFor(() => dirty)).toBe(true);
+  });
+
+  // Regression: the old ignore was /node_modules/ (unanchored substring), which
+  // pruned a file whose name merely contains "node_modules".
+  test("a .md whose name contains an ignored word still fires", async () => {
+    let dirty = false;
+    const filter = (p: string) => p.endsWith(".md");
+    watcher = createMemoryWatcher([tempDir], () => { dirty = true; }, filter, 50);
+
+    await new Promise((r) => setTimeout(r, 400));
+    writeFileSync(join(tempDir, "node_modules-notes.md"), "still index me\n");
+    expect(await waitFor(() => dirty)).toBe(true);
+  });
+
+  // A real vendored directory nested under the root must still be ignored.
+  test("a file inside a real node_modules/ dir is ignored", async () => {
+    let dirty = false;
+    const filter = (p: string) => p.endsWith(".md");
+    watcher = createMemoryWatcher([tempDir], () => { dirty = true; }, filter, 50);
+
+    await new Promise((r) => setTimeout(r, 400));
+    const nm = join(tempDir, "node_modules");
+    mkdirSync(nm, { recursive: true });
+    writeFileSync(join(nm, "dep.md"), "vendored\n");
+
+    // Past the debounce window — must NOT have fired.
+    await new Promise((r) => setTimeout(r, 600));
+    expect(dirty).toBe(false);
+  });
+});
+
+// End-to-end through the real MemoryIndex: exercises the startWatcher()
+// `dirname(p) === wsPath` branch (root .md) that the unit tests above don't
+// cover, and proves a live edit becomes searchable — the exact behavior #9
+// silently lost.
+describe("MemoryIndex reindexes a live-edited root .md", () => {
+  test("a top-level .md written after startup becomes searchable", async () => {
+    const dbPath = join(tempDir, "index.db");
+    const wsPath = join(tempDir, "workspace");
+    mkdirSync(wsPath, { recursive: true });
+
+    const idx = new MemoryIndex({
+      workspacePath: wsPath,
+      dbPath,
+      sessionsPath: null,
+      enableWatcher: true,
+    });
+    try {
+      // First search clears the startup dirty flag (initial sync).
+      await idx.search("warmup");
+      // Let chokidar finish its initial scan (ignoreInitial: true).
+      await new Promise((r) => setTimeout(r, 500));
+
+      const marker = `zqxmarker${Math.random().toString(36).slice(2)}`;
+      writeFileSync(join(wsPath, "PROBE.md"), `# probe\n${marker} lives here\n`);
+
+      // The watcher (1500ms debounce) must flip dirty so the next search syncs
+      // and indexes the new file. Poll until the marker is retrievable.
+      const found = await pollFor(async () => {
+        const results = await idx.search(marker);
+        return results.some((r) => JSON.stringify(r).includes(marker));
+      }, 6000);
+      expect(found).toBe(true);
+    } finally {
+      idx.close();
+    }
+  });
+});