@vellumai/assistant 0.6.0 → 0.6.1

package/src/__tests__/anthropic-provider.test.ts

@@ -187,6 +187,58 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(system[1].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
   });
 
+  test("drops static system block cache_control when total would exceed 4", async () => {
+    const staticBlock = "You are a helpful assistant.";
+    const dynamicBlock = "User workspace files here.";
+    const prompt = staticBlock + SYSTEM_PROMPT_CACHE_BOUNDARY + dynamicBlock;
+
+    // Boundary (2 system) + tools (1) + turn-start (1) + tail (1) = 5 → must cap at 4
+    const messages: Message[] = [
+      userMsg("Do something"),
+      toolUseMsg("tu_1", "bash"),
+      toolResultMsg("tu_1", "output"),
+    ];
+    await provider.sendMessage(messages, sampleTools, prompt);
+
+    const system = lastStreamParams!.system as Array<{
+      type: string;
+      text: string;
+      cache_control?: { type: string; ttl?: string };
+    }>;
+    expect(system).toHaveLength(2);
+    // Static block's cache_control dropped (small, cheap to re-read)
+    expect(system[0].cache_control).toBeUndefined();
+    // Dynamic block keeps its cache_control
+    expect(system[1].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+
+    // Tools breakpoint still present
+    const tools = lastStreamParams!.tools as Array<{
+      cache_control?: { type: string; ttl?: string };
+    }>;
+    expect(tools[tools.length - 1].cache_control).toEqual({
+      type: "ephemeral",
+      ttl: "1h",
+    });
+
+    // Turn-start + tail breakpoints still present
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{
+        type: string;
+        cache_control?: { type: string; ttl?: string };
+      }>;
+    }>;
+    const turnStart = sent[0];
+    expect(
+      turnStart.content[turnStart.content.length - 1].cache_control,
+    ).toEqual({ type: "ephemeral", ttl: "1h" });
+    const lastMsg = sent[sent.length - 1];
+    expect(lastMsg.content[lastMsg.content.length - 1].cache_control).toEqual({
+      type: "ephemeral",
+      ttl: "5m",
+    });
+  });
+
   // -----------------------------------------------------------------------
   // Tool cache control
   // -----------------------------------------------------------------------
@@ -225,33 +277,22 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
   });
 
   // -----------------------------------------------------------------------
-  // User turn cache breakpoints — second-to-last user turn only
+  // Advancing tail — 5m cache on last block after turn-starting message
   // -----------------------------------------------------------------------
-  test("single user turn does NOT get cache_control (no second-to-last)", async () => {
+  test("no advancing tail cache when turn-starting user message is last", async () => {
     await provider.sendMessage([userMsg("Hello")]);
 
-    const messages = lastStreamParams!.messages as Array<{
-      role: string;
-      content: Array<{
-        type: string;
-        text: string;
-        cache_control?: { type: string; ttl?: string };
-      }>;
-    }>;
-    const lastUser = messages[messages.length - 1];
-    expect(lastUser.role).toBe("user");
+    // No top-level cache_control — would conflict with the 1h block breakpoint
     expect(
-      lastUser.content[lastUser.content.length - 1].cache_control,
+      (lastStreamParams as Record<string, unknown>).cache_control,
     ).toBeUndefined();
   });
 
-  test("second-to-last user turn gets cache_control, others do not", async () => {
+  test("advancing tail: 5m cache on last block when tool results follow turn-starting message", async () => {
     const messages: Message[] = [
-      userMsg("Turn 1"), // user turn 0 — no cache
-      assistantMsg("Response 1"),
-      userMsg("Turn 2"), // user turn 1 — cache (second-to-last)
-      assistantMsg("Response 2"),
-      userMsg("Turn 3"), // user turn 2 — no cache (last)
+      userMsg("Do something"),
+      toolUseMsg("tu_1", "bash"),
+      toolResultMsg("tu_1", "output"),
     ];
     await provider.sendMessage(messages);
 
@@ -259,33 +300,30 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       role: string;
       content: Array<{
         type: string;
-        text: string;
         cache_control?: { type: string; ttl?: string };
       }>;
     }>;
 
-    // Find user messages in order
-    const userMessages = sent.filter((m) => m.role === "user");
-    expect(userMessages).toHaveLength(3);
-
-    // First user turn: no cache_control
-    const firstUserLastBlock =
-      userMessages[0].content[userMessages[0].content.length - 1];
-    expect(firstUserLastBlock.cache_control).toBeUndefined();
-
-    // Second user turn (second-to-last): cache_control ephemeral
-    const secondUserLastBlock =
-      userMessages[1].content[userMessages[1].content.length - 1];
-    expect(secondUserLastBlock.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
-
-    // Third user turn (last): no cache_control
-    const thirdUserLastBlock =
-      userMessages[2].content[userMessages[2].content.length - 1];
-    expect(thirdUserLastBlock.cache_control).toBeUndefined();
+    // Turn-starting user message (first) keeps 1h
+    const turnStart = sent[0];
+    const turnStartLast = turnStart.content[turnStart.content.length - 1];
+    expect(turnStartLast.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+
+    // Last message (tool_result) gets 5m advancing tail
+    const lastMessage = sent[sent.length - 1];
+    const lastBlock = lastMessage.content[lastMessage.content.length - 1];
+    expect(lastBlock.cache_control).toEqual({ type: "ephemeral", ttl: "5m" });
   });
 
-  test("single user turn does NOT get cache_control (only one user = no second-to-last)", async () => {
-    await provider.sendMessage([userMsg("Only turn")]);
+  test("turn-starting user message gets 1h cache on last block", async () => {
+    const messages: Message[] = [
+      userMsg("Turn 1"),
+      assistantMsg("Response 1"),
+      userMsg("Turn 2"),
+      assistantMsg("Response 2"),
+      userMsg("Turn 3"),
+    ];
+    await provider.sendMessage(messages);
 
     const sent = lastStreamParams!.messages as Array<{
       role: string;
@@ -295,35 +333,17 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
         cache_control?: { type: string; ttl?: string };
       }>;
     }>;
-    const userMessages = sent.filter((m) => m.role === "user");
-    expect(userMessages).toHaveLength(1);
-    expect(
-      userMessages[0].content[userMessages[0].content.length - 1].cache_control,
-    ).toBeUndefined();
-  });
 
-  // -----------------------------------------------------------------------
-  // User turn with tool_result — cache breakpoint on second-to-last
-  // -----------------------------------------------------------------------
-  test("user turn containing tool_result gets cache_control on second-to-last user turn only", async () => {
-    const messages: Message[] = [
-      userMsg("Read file"),
-      toolUseMsg("tu_1", "file_read"),
-      toolResultMsg("tu_1", "file contents here"),
-    ];
-    await provider.sendMessage(messages);
-
-    const sent = lastStreamParams!.messages as Array<{
-      role: string;
-      content: Array<{ type: string; cache_control?: { type: string; ttl?: string } }>;
-    }>;
-    const userMsgs = sent.filter((m) => m.role === "user");
-    // First user msg (second-to-last) should get cache
-    const firstLast = userMsgs[0].content[userMsgs[0].content.length - 1];
-    expect(firstLast.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
-    // tool_result msg (last) should NOT get cache
-    const secondLast = userMsgs[1].content[userMsgs[1].content.length - 1];
-    expect(secondLast.cache_control).toBeUndefined();
+    const userMessages = sent.filter((m) => m.role === "user");
+    // Only the last user message (turn-starting) gets cache_control
+    for (const user of userMessages.slice(0, -1)) {
+      for (const block of user.content) {
+        expect(block.cache_control).toBeUndefined();
+      }
+    }
+    const lastUser = userMessages[userMessages.length - 1];
+    const lastBlock = lastUser.content[lastUser.content.length - 1];
+    expect(lastBlock.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
   });
 
   // -----------------------------------------------------------------------
@@ -358,7 +378,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
   // -----------------------------------------------------------------------
   // Multi-block user message: cache lands on LAST block
   // -----------------------------------------------------------------------
-  test("multi-block single user message does NOT get cache (no second-to-last)", async () => {
+  test("multi-block single user message gets cache on last block", async () => {
     const multiBlockUser: Message = {
       role: "user",
       content: [
@@ -378,7 +398,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     }>;
     const user = sent[0];
     expect(user.content[0].cache_control).toBeUndefined();
-    expect(user.content[1].cache_control).toBeUndefined();
+    expect(user.content[1].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
   });
 
   // -----------------------------------------------------------------------
@@ -395,14 +415,14 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
   // -----------------------------------------------------------------------
   // Cache compatibility with workspace context injection
   // -----------------------------------------------------------------------
-  test("workspace-prepended single user message does NOT get cache (no second-to-last)", async () => {
+  test("workspace-prepended single user message gets cache on last block", async () => {
     // Simulates what applyRuntimeInjections does: prepend workspace block, keep user text as trailing
     const workspaceInjectedUser: Message = {
       role: "user",
       content: [
         {
           type: "text",
-          text: "<workspace_top_level>\nRoot: /sandbox\nDirectories: src, tests\n</workspace_top_level>",
+          text: "<workspace>\nRoot: /sandbox\nDirectories: src, tests\n</workspace>",
         },
         { type: "text", text: "What files are in src?" },
       ],
@@ -421,18 +441,18 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(user.content).toHaveLength(2);
     // Workspace block (first): no cache_control
     expect(user.content[0].cache_control).toBeUndefined();
-    // User text (last): no cache_control (single user turn = no second-to-last)
-    expect(user.content[1].cache_control).toBeUndefined();
+    // User text (last): cache_control with 1h TTL
+    expect(user.content[1].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
   });
 
-  test("workspace + multi-block single user message: no cache (no second-to-last)", async () => {
+  test("workspace + multi-block single user message: cache on last block only", async () => {
     // Simulates workspace prepended + extra context block appended
     const injectedUser: Message = {
       role: "user",
       content: [
         {
           type: "text",
-          text: "<workspace_top_level>\nRoot: /sandbox\nDirectories: src, tests\n</workspace_top_level>",
+          text: "<workspace>\nRoot: /sandbox\nDirectories: src, tests\n</workspace>",
         },
         { type: "text", text: "Help me debug this" },
         {
@@ -453,10 +473,10 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     }>;
     const user = sent[0];
     expect(user.content).toHaveLength(3);
-    // No blocks get cache_control (single user turn = no second-to-last)
+    // Only last block gets cache_control
     expect(user.content[0].cache_control).toBeUndefined();
     expect(user.content[1].cache_control).toBeUndefined();
-    expect(user.content[2].cache_control).toBeUndefined();
+    expect(user.content[2].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
   });
 
   // -----------------------------------------------------------------------
@@ -550,7 +570,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
         content: [
           {
             type: "text",
-            text: "<workspace_top_level>\nRoot: /sandbox\n</workspace_top_level>",
+            text: "<workspace>\nRoot: /sandbox\n</workspace>",
           },
           {
             type: "tool_result",
@@ -1330,39 +1350,36 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(sent[4].content[0].text).toBe("Follow-up question");
   });
 
-  test("multi-turn with workspace injection: cache on second-to-last user turn only", async () => {
+  test("multi-turn with workspace injection: only last user message gets 1h cache", async () => {
     const messages: Message[] = [
-      // Turn 1: workspace + user text (no cache - 3rd-to-last)
       {
         role: "user",
         content: [
           {
             type: "text",
-            text: "<workspace_top_level>\nRoot: /sandbox\nDirectories: src\n</workspace_top_level>",
+            text: "<workspace>\nRoot: /sandbox\nDirectories: src\n</workspace>",
           },
           { type: "text", text: "Turn 1" },
         ],
       },
       assistantMsg("Response 1"),
-      // Turn 2: workspace + user text (cache - second-to-last)
       {
         role: "user",
         content: [
           {
             type: "text",
-            text: "<workspace_top_level>\nRoot: /sandbox\nDirectories: src, lib\n</workspace_top_level>",
+            text: "<workspace>\nRoot: /sandbox\nDirectories: src, lib\n</workspace>",
           },
           { type: "text", text: "Turn 2" },
         ],
       },
       assistantMsg("Response 2"),
-      // Turn 3: workspace + user text (no cache - last)
       {
         role: "user",
         content: [
           {
             type: "text",
-            text: "<workspace_top_level>\nRoot: /sandbox\nDirectories: src, lib, docs\n</workspace_top_level>",
+            text: "<workspace>\nRoot: /sandbox\nDirectories: src, lib, docs\n</workspace>",
           },
           { type: "text", text: "Turn 3" },
         ],
@@ -1381,17 +1398,65 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     const userMsgs = sent.filter((m) => m.role === "user");
     expect(userMsgs).toHaveLength(3);
 
-    // Turn 1: no cache on any block
-    expect(userMsgs[0].content[0].cache_control).toBeUndefined();
-    expect(userMsgs[0].content[1].cache_control).toBeUndefined();
+    // Earlier user messages: no cache_control
+    for (const user of userMsgs.slice(0, -1)) {
+      for (const block of user.content) {
+        expect(block.cache_control).toBeUndefined();
+      }
+    }
+
+    // Last user message (turn 3): 1h cache on last block only
+    const lastUser = userMsgs[userMsgs.length - 1];
+    expect(lastUser.content[0].cache_control).toBeUndefined();
+    expect(lastUser.content[1].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+
+    // No top-level cache_control — breakpoints are set directly on blocks
+    expect(
+      (lastStreamParams as Record<string, unknown>).cache_control,
+    ).toBeUndefined();
+  });
+
+  test("tool loop: turn-starting user message gets 1h cache, last tool_result gets 5m advancing tail", async () => {
+    const messages: Message[] = [
+      userMsg("Read the config file"),
+      toolUseMsg("tu_1", "file_read"),
+      toolResultMsg("tu_1", "config contents here"),
+      toolUseMsg("tu_2", "file_read"),
+      toolResultMsg("tu_2", "more contents"),
+    ];
+    await provider.sendMessage(messages);
 
-    // Turn 2 (second-to-last): cache on last block only
-    expect(userMsgs[1].content[0].cache_control).toBeUndefined();
-    expect(userMsgs[1].content[1].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{
+        type: string;
+        text?: string;
+        cache_control?: { type: string; ttl?: string };
+      }>;
+    }>;
+
+    // First message is the turn-starting user text — gets 1h cache
+    expect(sent[0].role).toBe("user");
+    expect(sent[0].content[0].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+
+    // Non-last tool result messages do NOT get cache_control
+    const toolResultMsgs = sent.filter(
+      (m) =>
+        m.role === "user" &&
+        Array.isArray(m.content) &&
+        m.content.every((b) => typeof b !== "string" && b.type === "tool_result"),
+    );
+    expect(toolResultMsgs.length).toBeGreaterThan(0);
+    for (const tr of toolResultMsgs.slice(0, -1)) {
+      for (const block of tr.content) {
+        expect(block.cache_control).toBeUndefined();
+      }
+    }
 
-    // Turn 3 (last): no cache
-    expect(userMsgs[2].content[0].cache_control).toBeUndefined();
-    expect(userMsgs[2].content[1].cache_control).toBeUndefined();
+    // Last message gets 5m advancing tail cache on its last block
+    const lastMsg = sent[sent.length - 1];
+    const lastBlock = lastMsg.content[lastMsg.content.length - 1];
+    expect(lastBlock.cache_control).toEqual({ type: "ephemeral", ttl: "5m" });
   });
 
   // -----------------------------------------------------------------------

package/src/__tests__/app-dir-path-guard.test.ts

@@ -18,6 +18,7 @@ import { describe, expect, test } from "bun:test";
 const ALLOWLIST = new Set([
   "assistant/src/memory/app-store.ts", // defines getAppsDir
   "assistant/src/memory/app-git-service.ts", // uses getAppsDir for git repo root, not per-app paths
+  "assistant/src/daemon/app-source-watcher.ts", // uses getAppsDir for recursive fs.watch root, not per-app paths
 ]);
 
 function isTestFile(filePath: string): boolean {

package/src/__tests__/app-executors.test.ts

@@ -11,7 +11,10 @@ mock.module("../bundler/app-compiler.js", () => ({
 
 import type { AppDefinition } from "../memory/app-store.js";
 import type { AppStore } from "../tools/apps/executors.js";
-import { executeAppCreate } from "../tools/apps/executors.js";
+import {
+  executeAppCreate,
+  executeAppRefresh,
+} from "../tools/apps/executors.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -158,3 +161,46 @@ describe("executeAppCreate", () => {
     expect(files["src/main.tsx"]).toBeDefined();
   });
 });
+
+// ---------------------------------------------------------------------------
+// executeAppRefresh
+// ---------------------------------------------------------------------------
+
+describe("executeAppRefresh", () => {
+  test("legacy app: bumps updatedAt without compiling", async () => {
+    const app = makeLegacyApp();
+    const store = mockStore(app);
+    const result = await executeAppRefresh({ app_id: app.id }, store);
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.refreshed).toBe(true);
+    expect(parsed.appId).toBe(app.id);
+    // Legacy apps should not have compile-related fields
+    expect(parsed.compiled).toBeUndefined();
+    expect(parsed.compile_errors).toBeUndefined();
+  });
+
+  test("multifile app: compiles src/ and returns result", async () => {
+    const app = makeMultifileApp();
+    const store = mockStore(app);
+    const result = await executeAppRefresh({ app_id: app.id }, store);
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.refreshed).toBe(true);
+    expect(parsed.appId).toBe(app.id);
+    expect(parsed.compiled).toBe(true);
+    expect(parsed.compile_duration_ms).toBeDefined();
+  });
+
+  test("returns error for unknown app", async () => {
+    const app = makeLegacyApp();
+    const store = mockStore(app);
+    const result = await executeAppRefresh({ app_id: "nonexistent" }, store);
+
+    expect(result.isError).toBe(true);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.error).toContain("not found");
+  });
+});

package/src/__tests__/app-source-watcher.test.ts

@@ -0,0 +1,159 @@
+/**
+ * Tests for AppSourceWatcher — filesystem watcher that detects app source
+ * file changes and triggers debounced recompile + surface refresh.
+ */
+
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — must be set up before importing the module under test
+// ---------------------------------------------------------------------------
+
+const TEST_APPS_DIR = "/tmp/test-apps";
+const testDirNameMap = new Map<string, string>([["my-app", "app-id-1"]]);
+
+let capturedWatchCallback: ((eventType: string, filename: string | null) => void) | null = null;
+const mockWatcher = { close: mock(() => {}) };
+
+mock.module("node:fs", () => {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const actualFs = require("node:fs");
+  return {
+    ...actualFs,
+    existsSync: mock((p: string) => p === TEST_APPS_DIR),
+    watch: mock(
+      (
+        _path: string,
+        _opts: Record<string, unknown>,
+        callback: (eventType: string, filename: string | null) => void,
+      ) => {
+        capturedWatchCallback = callback;
+        return mockWatcher;
+      },
+    ),
+  };
+});
+
+mock.module("../memory/app-store.js", () => ({
+  getAppsDir: mock(() => TEST_APPS_DIR),
+  resolveAppIdByDirName: mock(
+    (dirName: string) => testDirNameMap.get(dirName) ?? null,
+  ),
+}));
+
+// ---------------------------------------------------------------------------
+// Import after mocks
+// ---------------------------------------------------------------------------
+
+import { AppSourceWatcher } from "../daemon/app-source-watcher.js";
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("AppSourceWatcher", () => {
+  let watcher: AppSourceWatcher;
+  let onChangeSpy: ReturnType<typeof mock>;
+
+  beforeEach(() => {
+    watcher = new AppSourceWatcher();
+    onChangeSpy = mock(() => {});
+    capturedWatchCallback = null;
+    mockWatcher.close.mockClear();
+  });
+
+  afterEach(() => {
+    watcher.stop();
+  });
+
+  test("start() creates a recursive watcher on the apps directory", () => {
+    watcher.start(onChangeSpy);
+    expect(capturedWatchCallback).not.toBeNull();
+  });
+
+  test("source file change triggers callback with resolved appId", async () => {
+    watcher.start(onChangeSpy);
+    capturedWatchCallback!("change", "my-app/src/main.tsx");
+
+    // Wait for debounce (500ms + margin)
+    await new Promise((r) => setTimeout(r, 600));
+    expect(onChangeSpy).toHaveBeenCalledTimes(1);
+    expect(onChangeSpy).toHaveBeenCalledWith("app-id-1");
+  });
+
+  test("root-level app file triggers callback", async () => {
+    watcher.start(onChangeSpy);
+    capturedWatchCallback!("change", "my-app/index.html");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(onChangeSpy).toHaveBeenCalledTimes(1);
+    expect(onChangeSpy).toHaveBeenCalledWith("app-id-1");
+  });
+
+  test("dist/ files are filtered out", async () => {
+    watcher.start(onChangeSpy);
+    capturedWatchCallback!("change", "my-app/dist/index.html");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(onChangeSpy).not.toHaveBeenCalled();
+  });
+
+  test("records/ files are filtered out", async () => {
+    watcher.start(onChangeSpy);
+    capturedWatchCallback!("change", "my-app/records/rec-1.json");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(onChangeSpy).not.toHaveBeenCalled();
+  });
+
+  test("files directly in apps/ (no subdirectory) are filtered out", async () => {
+    watcher.start(onChangeSpy);
+    capturedWatchCallback!("change", "my-app.json");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(onChangeSpy).not.toHaveBeenCalled();
+  });
+
+  test("unknown app directory is filtered out", async () => {
+    watcher.start(onChangeSpy);
+    capturedWatchCallback!("change", "unknown-app/src/main.tsx");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(onChangeSpy).not.toHaveBeenCalled();
+  });
+
+  test("null filename is ignored", async () => {
+    watcher.start(onChangeSpy);
+    capturedWatchCallback!("change", null);
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(onChangeSpy).not.toHaveBeenCalled();
+  });
+
+  test("rapid changes to same app are debounced into single callback", async () => {
+    watcher.start(onChangeSpy);
+
+    capturedWatchCallback!("change", "my-app/src/main.tsx");
+    capturedWatchCallback!("change", "my-app/src/styles.css");
+    capturedWatchCallback!("change", "my-app/src/utils.ts");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(onChangeSpy).toHaveBeenCalledTimes(1);
+  });
+
+  test("stop() closes watcher and cancels pending timers", () => {
+    watcher.start(onChangeSpy);
+    capturedWatchCallback!("change", "my-app/src/main.tsx");
+
+    watcher.stop();
+
+    expect(mockWatcher.close).toHaveBeenCalledTimes(1);
+  });
+});