@cueloop/daemon 0.1.0-alpha.9 → 0.1.0-alpha.91

package/src/curate.ts

@@ -0,0 +1,109 @@
+/**
+ * The curated patch of a diff review: the submitted changes minus the hunks and
+ * change blocks the reviewer rejected. The daemon computes it from the
+ * session's reject decisions so the working copy every client sees is one and
+ * the same; the client only maps rows to decisions.
+ */
+
+import { diffAcceptRejectHunk, parseDiffFromFile, type FileDiffMetadata } from "@pierre/diffs";
+import {
+  unifiedDiffText,
+  type DiffFileContents,
+  type DiffFileStatus,
+  type HunkRejection,
+} from "@cueloop/schema";
+
+/**
+ * Context lines around each change. Matching git's default (3) makes the model
+ * split hunks like the rendered working-tree patch does; a row is mapped by
+ * absolute line number, never by counting hunks, so a whole-hunk reject can
+ * only ever span the model hunk it lands in.
+ */
+export const DIFF_CONTEXT = 3;
+
+/** Parse one file's full contents into a non-partial diff model. */
+export function parseFileDiff(file: DiffFileContents): FileDiffMetadata {
+  return parseDiffFromFile(
+    { name: file.path, contents: file.oldContents },
+    { name: file.path, contents: file.newContents },
+    { context: DIFF_CONTEXT },
+  );
+}
+
+/**
+ * Apply one file's rejections and return its curated patch, or null when the
+ * curated content equals the old content (every change rejected - no patch).
+ * Whole-hunk rejections supersede change-level ones for the same hunk. Because
+ * `diffAcceptRejectHunk` returns a model with the same hunk/content shape, the
+ * indices stay valid across calls; they are applied high-to-low regardless, so
+ * the order is deterministic.
+ */
+function curateFilePatch(file: DiffFileContents, rejections: HunkRejection[]): string | null {
+  let model = parseFileDiff(file);
+  const wholeHunks = new Set(
+    rejections
+      .filter((rejection) => rejection.changeIndex === undefined)
+      .map((rejection) => rejection.hunkIndex),
+  );
+
+  for (const hunkIndex of [...wholeHunks].sort((a, b) => b - a)) {
+    model = diffAcceptRejectHunk(model, hunkIndex, "reject");
+  }
+  const changeRejections = rejections
+    .filter(
+      (rejection) => rejection.changeIndex !== undefined && !wholeHunks.has(rejection.hunkIndex),
+    )
+    .sort((a, b) => b.hunkIndex - a.hunkIndex || b.changeIndex! - a.changeIndex!);
+
+  for (const rejection of changeRejections) {
+    model = diffAcceptRejectHunk(model, rejection.hunkIndex, {
+      type: "reject",
+      changeIndex: rejection.changeIndex!,
+    });
+  }
+  const curatedNew = model.additionLines.join("");
+
+  if (curatedNew === file.oldContents) return null;
+  const patch = unifiedDiffText(file.oldContents, curatedNew, file.path);
+
+  if (patch === null) return null;
+
+  return withFileStateHeaders(patch, file.path, file.status, curatedNew);
+}
+
+/**
+ * Point the diff headers at /dev/null for a created or fully-deleted file so the
+ * curated patch applies. git's status - not empty contents - decides existence,
+ * so editing an existing empty file stays a modify; a deletion whose removals
+ * were partly restored also falls back to a modify.
+ */
+function withFileStateHeaders(
+  patch: string,
+  path: string,
+  status: DiffFileStatus,
+  curatedNew: string,
+): string {
+  if (status === "added") return patch.replace(`--- a/${path}`, "--- /dev/null");
+  if (status === "deleted" && curatedNew === "") {
+    return patch.replace(`+++ b/${path}`, "+++ /dev/null");
+  }
+
+  return patch;
+}
+
+/**
+ * The curated unified-diff patch of the accepted changes across every file.
+ * Files with no net change (unchanged, or with all changes rejected) drop out.
+ */
+export function curateDiff(files: DiffFileContents[], rejections: HunkRejection[]): string {
+  const parts: string[] = [];
+
+  for (const file of files) {
+    const fileRejections = rejections.filter((rejection) => rejection.path === file.path);
+    const patch = curateFilePatch(file, fileRejections);
+
+    if (patch) parts.push(patch);
+  }
+
+  return parts.join("\n");
+}

package/src/daemon-version.test.ts

@@ -0,0 +1,142 @@
+/**
+ * Version handshake: a client must never keep talking to a daemon from an
+ * earlier build (the stale-daemon-after-upgrade bug). The ping carries the
+ * daemon's version; a mismatch without autostart is a clear error, and a
+ * matching version connects normally.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DaemonServer } from "./server";
+import { DaemonClient, DaemonClientError, daemonSpawnCommand } from "./client";
+import { DAEMON_VERSION } from "./version";
+import { pidPath } from "./paths";
+import type { Artifact, WorkspaceKey } from "@cueloop/schema";
+
+const WS: WorkspaceKey = { repoRoot: "/repo", branch: "main" };
+const PLAN: Artifact = { type: "plan", content: "# P\n\nBody.\n", meta: {} };
+
+let home: string;
+const servers: DaemonServer[] = [];
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-version-"));
+});
+afterEach(() => {
+  for (const runningServer of servers.splice(0)) runningServer.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+function server(version?: string): DaemonServer {
+  const daemonServer = new DaemonServer({
+    home,
+    idleExitMs: 0,
+    version,
+    onIdleExit: () => {},
+  });
+
+  servers.push(daemonServer);
+
+  return daemonServer;
+}
+
+describe("daemon version handshake", () => {
+  test("a stale daemon is rejected when there is nothing to replace it", async () => {
+    // Arrange - a daemon posing as an earlier build
+    server("0.0.0-stale").start();
+
+    // Act + Assert - without autostart the client cannot restart it, so it says why
+    await expect(DaemonClient.connect({ home, autostart: false })).rejects.toMatchObject({
+      code: "version_mismatch",
+    });
+    await expect(DaemonClient.connect({ home, autostart: false })).rejects.toBeInstanceOf(
+      DaemonClientError,
+    );
+  });
+
+  test("autostart never replaces a live daemon from another version", async () => {
+    const liveServer = server("0.1.0-alpha.81");
+
+    liveServer.start();
+    const session = liveServer.core.sessionCreate({ workspace: WS, artifact: PLAN });
+    let replacement: DaemonClient | undefined;
+    let connectionError: unknown;
+
+    try {
+      replacement = await DaemonClient.connect({ home, autostart: true });
+    } catch (error) {
+      connectionError = error;
+    }
+
+    replacement?.close();
+    expect(connectionError).toBeInstanceOf(DaemonClientError);
+    expect(connectionError).toMatchObject({ code: "version_mismatch" });
+    expect(readFileSync(pidPath(home), "utf8")).toBe(String(process.pid));
+    expect(liveServer.core.sessionGet(session.id).id).toBe(session.id);
+  });
+
+  test("a rejected client releases its connection so the daemon can become idle", async () => {
+    let idleExited = false;
+    const liveServer = new DaemonServer({
+      home,
+      idleExitMs: 50,
+      version: "0.1.0-alpha.81",
+      onIdleExit: () => {
+        idleExited = true;
+      },
+    });
+
+    servers.push(liveServer);
+    liveServer.start();
+
+    await expect(DaemonClient.connect({ home, autostart: true })).rejects.toMatchObject({
+      code: "version_mismatch",
+    });
+    await Bun.sleep(100);
+
+    expect(idleExited).toBe(true);
+  });
+
+  test("a current daemon connects and serves normally", async () => {
+    // Arrange - a daemon on this build
+    server(DAEMON_VERSION).start();
+    const client = await DaemonClient.connect({ home, autostart: false });
+
+    // Act - a round-trip proves the connection is live, not replaced
+    const created = await client.sessionCreate(WS, PLAN);
+    const listed = await client.sessionList();
+
+    // Assert
+    expect(listed.map((session) => session.id)).toContain(created.id);
+    client.close();
+  });
+});
+
+describe("daemon spawn command", () => {
+  const SOURCE_URL = "file:///repo/packages/daemon/src/client.ts";
+
+  test("from source it bun-runs main.ts", () => {
+    expect(daemonSpawnCommand("/bin/bun", SOURCE_URL, false)).toEqual([
+      "/bin/bun",
+      "run",
+      "/repo/packages/daemon/src/main.ts",
+    ]);
+  });
+
+  test("dev-watch reloads the daemon on source edits", () => {
+    expect(daemonSpawnCommand("/bin/bun", SOURCE_URL, true)).toEqual([
+      "/bin/bun",
+      "--watch",
+      "run",
+      "/repo/packages/daemon/src/main.ts",
+    ]);
+  });
+
+  test("a compiled binary re-execs its own daemon command, never --watch", () => {
+    expect(
+      daemonSpawnCommand("/usr/local/bin/cueloop", "file:///$bunfs/root/cueloop", true),
+    ).toEqual(["/usr/local/bin/cueloop", "daemon", "--autostart"]);
+  });
+});

package/src/diff-hot-reload.test.ts

@@ -0,0 +1,419 @@
+/**
+ * Diff hot-reload: session.refreshDiff re-captures a diff session's working
+ * tree, and the fs watcher drives it on a real change. Exercised against a
+ * real temp git repo so the capture path is the production one.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DaemonCore } from "./api";
+import { workingTreeDiff } from "./working-tree";
+import { resolveWorkspace } from "./thread-review";
+import type { Artifact } from "@cueloop/schema";
+
+function git(args: string[], cwd: string): void {
+  const result = Bun.spawnSync(["git", ...args], { cwd, stdout: "ignore", stderr: "ignore" });
+
+  if (result.exitCode !== 0) throw new Error(`git ${args.join(" ")} failed in ${cwd}`);
+}
+
+let home: string;
+let repo: string;
+let core: DaemonCore;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-hotreload-home-"));
+  repo = mkdtempSync(join(tmpdir(), "cueloop-hotreload-repo-"));
+  git(["init", "-q", "-b", "main"], repo);
+  git(["config", "user.email", "t@t"], repo);
+  git(["config", "user.name", "t"], repo);
+  writeFileSync(join(repo, "a.ts"), "export const a = 1;\n");
+  git(["add", "."], repo);
+  git(["commit", "-qm", "init"], repo);
+  core = new DaemonCore(home);
+});
+
+afterEach(() => {
+  core.dispose();
+  rmSync(home, { recursive: true, force: true });
+  rmSync(repo, { recursive: true, force: true });
+});
+
+/** Open a diff session over the temp repo's current working tree. */
+async function openDiffSession() {
+  const workspace = await resolveWorkspace(repo);
+  const diff = await workingTreeDiff(repo);
+  const artifact: Artifact = { type: "diff", content: diff.patch, files: diff.files, meta: {} };
+
+  return core.sessionCreate({ workspace, artifact });
+}
+
+describe("session.refreshDiff", () => {
+  test("a JJ rewrite with the same patch records its new commit identity", async () => {
+    const init = Bun.spawnSync(["jj", "git", "init", "--colocate", repo], {
+      cwd: repo,
+      stdout: "ignore",
+      stderr: "pipe",
+    });
+
+    if (init.exitCode !== 0) throw new Error(init.stderr.toString());
+    writeFileSync(join(repo, "a.ts"), "export const a = 2;\n");
+    const first = await core.repoDiff(repo);
+    const workspace = await resolveWorkspace(repo);
+    const session = core.sessionCreate({
+      workspace,
+      artifact: {
+        type: "diff",
+        content: first.patch,
+        files: first.files,
+        meta: {
+          vcs: "jj",
+          vcsChangeId: first.source!.changeId,
+          vcsRevisionId: first.source!.revisionId,
+        },
+      },
+    });
+    const describe = Bun.spawnSync(["jj", "describe", "-m", "same patch, new commit"], {
+      cwd: repo,
+      stderr: "pipe",
+    });
+
+    if (describe.exitCode !== 0) throw new Error(describe.stderr.toString());
+    const result = await core.sessionRefreshDiff(session.id);
+    const current = core.sessionGet(session.id);
+
+    expect(result.changed).toBe(false);
+    expect(current.revisions).toHaveLength(2);
+    expect(current.revisions[0]?.content).toBe(current.revisions[1]?.content);
+    expect(current.revisions[0]?.source?.revisionId).toBe(first.source!.revisionId);
+    expect(current.revisions[1]?.source?.revisionId).toBe(current.artifact.meta.vcsRevisionId);
+    expect(current.revisions[1]?.source?.revisionId).not.toBe(first.source!.revisionId);
+  });
+
+  test("a submitted JJ change keeps its prior snapshot when refreshed after a rewrite", async () => {
+    const init = Bun.spawnSync(["jj", "git", "init", "--colocate", repo], {
+      cwd: repo,
+      stdout: "ignore",
+      stderr: "pipe",
+    });
+
+    if (init.exitCode !== 0) throw new Error(init.stderr.toString());
+    writeFileSync(join(repo, "a.ts"), "export const a = 2;\n");
+    const first = await core.repoDiff(repo);
+    const workspace = await resolveWorkspace(repo);
+    const session = core.sessionCreate({
+      workspace,
+      artifact: {
+        type: "diff",
+        content: first.patch,
+        files: first.files,
+        meta: {
+          vcs: "jj",
+          vcsChangeId: first.source!.changeId,
+          vcsRevisionId: first.source!.revisionId,
+        },
+      },
+    });
+
+    writeFileSync(join(repo, "a.ts"), "export const a = 3;\n");
+    const result = await core.sessionRefreshDiff(session.id);
+    const current = core.sessionGet(session.id);
+
+    expect(result.changed).toBe(true);
+    expect(current.revisions.map((revision) => revision.content)).toEqual([
+      first.patch,
+      current.artifact.content,
+    ]);
+    expect(current.revisions[0]?.source?.revisionId).toBe(first.source!.revisionId);
+    expect(current.revisions[0]?.files).toEqual(first.files);
+    expect(current.revisions[1]?.source?.revisionId).toBe(current.artifact.meta.vcsRevisionId);
+    expect(current.revisions[1]?.files).toEqual(current.artifact.files);
+    expect(current.artifact.meta.vcsChangeId).toBe(first.source!.changeId);
+    expect(current.artifact.meta.vcsRevisionId).not.toBe(first.source!.revisionId);
+    expect(current.artifact.content).toContain("+export const a = 3;");
+  });
+
+  test("re-captures the working tree and updates the artifact when the patch changed", async () => {
+    // Given an open diff session whose working tree then gains a new change
+    const session = await openDiffSession();
+
+    writeFileSync(join(repo, "a.ts"), "export const a = 2;\n");
+
+    // When the diff is refreshed
+    const result = await core.sessionRefreshDiff(session.id);
+
+    // Then the change is reported and the stored artifact carries the fresh patch and files
+    expect(result.changed).toBe(true);
+    const refreshed = core.sessionGet(session.id);
+
+    expect(refreshed.artifact.content).toContain("+export const a = 2;");
+    const modified = refreshed.artifact.files!.find((file) => file.path === "a.ts")!;
+
+    expect(modified.newContents).toBe("export const a = 2;\n");
+  });
+
+  test("reports no change and emits nothing when the working tree is unchanged", async () => {
+    // Given an open diff session and a listener for session events
+    const session = await openDiffSession();
+    const events: string[] = [];
+
+    core.onEvent((event) => events.push(event.event));
+
+    // When the diff is refreshed without any working-tree change
+    const result = await core.sessionRefreshDiff(session.id);
+
+    // Then nothing changed and no session.updated event fired
+    expect(result.changed).toBe(false);
+    expect(events).not.toContain("session.updated");
+  });
+
+  test("a changed refresh emits session.updated so attached clients re-fetch", async () => {
+    // Given an open diff session, a listener, and a fresh working-tree change
+    const session = await openDiffSession();
+    const events: string[] = [];
+
+    core.onEvent((event) => events.push(event.event));
+    writeFileSync(join(repo, "a.ts"), "export const a = 3;\n");
+
+    // When the diff is refreshed
+    await core.sessionRefreshDiff(session.id);
+
+    // Then a session.updated event fired for this session
+    expect(events).toContain("session.updated");
+  });
+
+  test("a tree move after a refresh keeps the fresh patch", async () => {
+    // Given a refreshed diff session
+    const session = await openDiffSession();
+
+    writeFileSync(join(repo, "a.ts"), "export const a = 4;\n");
+    await core.sessionRefreshDiff(session.id);
+
+    // When the owner branches off and switches back
+    core.sessionBranch(session.id, "alt");
+    const shown = core.sessionSwitch(session.id, "main");
+
+    // Then the artifact still shows the re-captured working tree, and the history has one revision
+    expect(shown.artifact.content).toContain("+export const a = 4;");
+    expect(shown.history!.entries.filter((entry) => entry.type === "revision")).toHaveLength(1);
+  });
+
+  test("is a no-op for a non-diff (plan) session", async () => {
+    // Given a plan session in the same workspace
+    const workspace = await resolveWorkspace(repo);
+    const plan: Artifact = { type: "plan", content: "# Plan\n\nBody.\n", meta: {} };
+    const session = core.sessionCreate({ workspace, artifact: plan });
+
+    // When a refresh is attempted
+    const result = await core.sessionRefreshDiff(session.id);
+
+    // Then it reports no change and leaves the plan content untouched
+    expect(result.changed).toBe(false);
+    expect(core.sessionGet(session.id).artifact.content).toBe("# Plan\n\nBody.\n");
+  });
+
+  test("refusing a resolved diff session never mutates it (no revive of a closed review)", async () => {
+    // Given a diff session that has been resolved
+    const session = await openDiffSession();
+
+    core.sessionSendMessage(session.id, "approved", "");
+    const resolvedContent = core.sessionGet(session.id).artifact.content;
+
+    writeFileSync(join(repo, "a.ts"), "export const a = 99;\n");
+
+    // When a refresh is attempted on the resolved session
+    // Then it is rejected and the frozen artifact is untouched
+    expect(core.sessionRefreshDiff(session.id)).rejects.toThrow(/resolved/);
+    expect(core.sessionGet(session.id).artifact.content).toBe(resolvedContent);
+  });
+
+  test("overlapping refreshes settle to one coherent artifact without error", async () => {
+    // Given a live diff session with a fresh working-tree change
+    const session = await openDiffSession();
+
+    writeFileSync(join(repo, "a.ts"), "export const a = 7;\n");
+
+    // When two refreshes run concurrently over the same session
+    const [first, second] = await Promise.all([
+      core.sessionRefreshDiff(session.id),
+      core.sessionRefreshDiff(session.id),
+    ]);
+
+    // Then both settle and the stored artifact reflects the current tree exactly
+    // once - the generation guard keeps the older capture from regressing it
+    expect(first.changed || second.changed).toBe(true);
+    expect(core.sessionGet(session.id).artifact.content).toContain("+export const a = 7;");
+  });
+});
+
+describe("PR review sessions", () => {
+  test("refresh re-pulls the PR diff via gh and never clobbers it with the working tree", async () => {
+    // Given a stub gh that reports a PR diff distinct from the local working tree
+    const ghStub = join(repo, "gh-stub.sh");
+    const ghLog = join(repo, "gh-stub.log");
+
+    writeFileSync(
+      ghStub,
+      `#!/bin/sh
+printf '%s\n' "$*" >> '${ghLog}'
+case "$2" in
+  diff) printf "STUB PR DIFF\\n" ;;
+  view) printf '{"baseRefOid":"base-2","headRefOid":"sha-2"}\\n' ;;
+esac
+`,
+    );
+    chmodSync(ghStub, 0o755);
+    const previousGh = process.env.CUELOOP_GH;
+
+    process.env.CUELOOP_GH = ghStub;
+
+    try {
+      // Given a PR review over the same repo root, and a local working-tree change present
+      const workspace = await resolveWorkspace(repo);
+      const artifact: Artifact = {
+        type: "diff",
+        content: "OLD PR DIFF\n",
+        files: [],
+        meta: {
+          pr: "1",
+          prUrl: "https://github.com/org/repo/pull/1",
+          prBaseSha: "base-1",
+          prHeadSha: "sha-1",
+          prRefreshBaseSha: "base-2",
+          prRefreshHeadSha: "sha-2",
+        },
+      };
+      const session = core.sessionCreate({ workspace, artifact });
+
+      writeFileSync(join(repo, "a.ts"), "export const a = 123;\n");
+
+      // When the diff is refreshed
+      const result = await core.sessionRefreshDiff(session.id);
+
+      // Then it carries the PR diff from gh, not the local working-tree change
+      expect(result.changed).toBe(true);
+      const refreshed = core.sessionGet(session.id);
+
+      expect(refreshed.artifact.content).toContain("STUB PR DIFF");
+      expect(refreshed.artifact.content).not.toContain("export const a = 123;");
+      expect(refreshed.artifact.meta.prBaseSha).toBe("base-2");
+      expect(refreshed.artifact.meta.prHeadSha).toBe("sha-2");
+      expect(refreshed.artifact.meta.prRefreshBaseSha).toBeUndefined();
+      expect(refreshed.artifact.meta.prRefreshHeadSha).toBeUndefined();
+      expect(refreshed.revisions.map((revision) => revision.content)).toEqual([
+        "OLD PR DIFF\n",
+        refreshed.artifact.content,
+      ]);
+      expect(refreshed.revisions.map((revision) => revision.source?.revisionId)).toEqual([
+        "sha-1",
+        "sha-2",
+      ]);
+      expect(refreshed.history!.entries.filter((entry) => entry.type === "revision")).toHaveLength(
+        2,
+      );
+      expect(readFileSync(ghLog, "utf8")).toContain("https://github.com/org/repo/pull/1");
+      writeFileSync(ghStub, readFileSync(ghStub, "utf8").replace("sha-2", "sha-3"));
+      const samePatch = await core.sessionRefreshDiff(session.id);
+      const movedHead = core.sessionGet(session.id);
+
+      expect(samePatch.changed).toBe(false);
+      expect(movedHead.revisions).toHaveLength(3);
+      expect(movedHead.revisions[2]?.content).toBe(movedHead.revisions[1]?.content);
+      expect(movedHead.revisions[2]?.source?.revisionId).toBe("sha-3");
+    } finally {
+      if (previousGh === undefined) delete process.env.CUELOOP_GH;
+      else process.env.CUELOOP_GH = previousGh;
+    }
+  });
+});
+
+describe("the fs watcher drives hot-reload", () => {
+  test("a JJ workbench refreshes in place after the working copy changes", async () => {
+    git(["status"], repo);
+    const init = Bun.spawnSync(["jj", "git", "init", "--colocate", repo], {
+      cwd: repo,
+      stdout: "ignore",
+      stderr: "pipe",
+    });
+
+    if (init.exitCode !== 0) throw new Error(init.stderr.toString());
+    const session = await core.workbenchSession(repo);
+
+    expect(session.artifact.meta.vcs).toBe("jj");
+    writeFileSync(join(repo, "a.ts"), "export const a = 42;\n");
+    const deadline = Date.now() + 8_000;
+    let current = core.sessionGet(session.id);
+
+    while (!current.artifact.content.includes("+export const a = 42;") && Date.now() < deadline) {
+      await Bun.sleep(100);
+      current = core.sessionGet(session.id);
+    }
+    expect(current.artifact.content).toContain("+export const a = 42;");
+    expect(current.revisions).toHaveLength(1);
+    expect(current.artifact.meta.vcsChangeId).toBeTruthy();
+  }, 12_000);
+
+  test("a working-tree change under a live diff session refreshes it in place", async () => {
+    // Given a live diff session whose repo the daemon is watching
+    const session = await openDiffSession();
+
+    // When a tracked file changes on disk
+    writeFileSync(join(repo, "a.ts"), "export const a = 42;\n");
+
+    // Then the watcher debounces and re-captures the diff without any manual call.
+    // Watchers can be slow under CI contention, so poll generously.
+    const deadline = Date.now() + 8_000;
+    let content = core.sessionGet(session.id).artifact.content;
+
+    while (!content.includes("+export const a = 42;") && Date.now() < deadline) {
+      await Bun.sleep(100);
+      content = core.sessionGet(session.id).artifact.content;
+    }
+    expect(content).toContain("+export const a = 42;");
+  }, 12_000);
+
+  test("watches a directory created after open, so a change inside it refreshes", async () => {
+    // Given an open diff session over a repo that had no such directory
+    const session = await openDiffSession();
+
+    // When a new directory appears, the watcher extends into it (a recursive watch got this free)
+    mkdirSync(join(repo, "pkg"));
+    await Bun.sleep(500);
+    writeFileSync(join(repo, "pkg", "inside.ts"), "export const inside = 1;\n");
+
+    // Then a change inside the new directory drives a re-capture
+    const deadline = Date.now() + 8_000;
+    let content = core.sessionGet(session.id).artifact.content;
+
+    while (!content.includes("+export const inside = 1;") && Date.now() < deadline) {
+      await Bun.sleep(100);
+      content = core.sessionGet(session.id).artifact.content;
+    }
+    expect(content).toContain("+export const inside = 1;");
+  }, 12_000);
+
+  test("a commit refreshes the diff even though no working-tree file changed", async () => {
+    // Given an open diff session showing an uncommitted change to a.ts
+    writeFileSync(join(repo, "a.ts"), "export const a = 5;\n");
+    const session = await openDiffSession();
+
+    expect(core.sessionGet(session.id).artifact.content).toContain("+export const a = 5;");
+
+    // When the change is committed - moving refs/HEAD, touching no working-tree file -
+    // the working tree now equals HEAD, so `git diff HEAD` is empty
+    git(["add", "a.ts"], repo);
+    git(["commit", "-qm", "land a"], repo);
+
+    // Then the git-metadata watch drives a re-capture and the diff empties out
+    const deadline = Date.now() + 8_000;
+    let content = core.sessionGet(session.id).artifact.content;
+
+    while (content.includes("+export const a = 5;") && Date.now() < deadline) {
+      await Bun.sleep(100);
+      content = core.sessionGet(session.id).artifact.content;
+    }
+    expect(content).not.toContain("+export const a = 5;");
+  }, 12_000);
+});