@cueloop/daemon 0.1.0-alpha.89 → 0.1.0-alpha.90

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/daemon",
-  "version": "0.1.0-alpha.89",
+  "version": "0.1.0-alpha.90",
   "description": "The cueloop session daemon and its client: socket protocol, atomic store, resumable waits",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -21,6 +21,7 @@
     ".": "./src/index.ts",
     "./client": "./src/client.ts",
     "./thread-review": "./src/thread-review.ts",
+    "./vcs-source": "./src/vcs-source.ts",
     "./api": "./src/api.ts",
     "./working-tree": "./src/working-tree.ts",
     "./store": "./src/store.ts",
@@ -38,7 +39,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@cueloop/schema": "0.1.0-alpha.89",
+    "@cueloop/extension-api": "0.1.0-alpha.90",
+    "@cueloop/schema": "0.1.0-alpha.90",
     "@pierre/diffs": "^1.4.1",
     "effect": "^4.0.0-rc.116",
     "smol-toml": "^1.8.0",

package/src/api.ts

@@ -36,6 +36,7 @@ import {
   type Annotation,
   type DiffFileStatus,
   type DiffFileContents,
+  type DiffSource,
   type HunkRejection,
   type NewEntry,
   type Artifact,
@@ -66,9 +67,10 @@ import { HarnessStateStore } from "./harness-state-store";
 import { DiffWatcher } from "./diff-watcher";
 import { PrReviewPoller } from "./pr-poller";
 import { prSnapshot } from "./gh";
-import { workingTreeDiff, workingChangeList, type WorkingTreeDiff } from "./working-tree";
+import type { VcsDiffSnapshot } from "@cueloop/extension-api";
 import { listProjectFiles, readProjectFile } from "./project-files";
 import { resolveWorkspace } from "./thread-review";
+import { VcsSourceManager } from "./vcs-source";
 import { DaemonError } from "./errors";
 
 /** Reviewer-controlled fields that make an annotation new or edited for delivery. */
@@ -132,6 +134,7 @@ export class DaemonCore {
   private readonly diffWatcher: DiffWatcher;
   /** Drives PR-review hot-reload: polls each open PR review for a moved head. */
   private readonly prPoller: PrReviewPoller;
+  private readonly vcsSources = new VcsSourceManager();
   /**
    * Per-diff-session capture generation. Bumped when a refresh begins; a
    * capture whose generation is stale by the time it finishes discards its
@@ -307,7 +310,27 @@ export class DaemonCore {
       id: this.newSessionId(now),
       workspace: params.workspace,
       artifact: params.artifact,
-      revisions: [{ revision: 1, content: params.artifact.content, submittedAt: now }],
+      revisions: [
+        {
+          revision: 1,
+          content: params.artifact.content,
+          submittedAt: now,
+          files: params.artifact.type === "diff" ? params.artifact.files : undefined,
+          source: params.artifact.meta.prHeadSha
+            ? {
+                vcs: "git",
+                revisionId: params.artifact.meta.prHeadSha,
+                baseRevisionId: params.artifact.meta.prBaseSha,
+              }
+            : params.artifact.meta.vcsRevisionId && params.artifact.meta.vcs
+              ? {
+                  vcs: params.artifact.meta.vcs,
+                  changeId: params.artifact.meta.vcsChangeId,
+                  revisionId: params.artifact.meta.vcsRevisionId,
+                }
+              : undefined,
+        },
+      ],
       annotations: [],
       message: null,
       status: "pending",
@@ -547,7 +570,12 @@ export class DaemonCore {
 
   /** Tracked, repo-relative file paths for the session's workspace; [] when it has no repo. */
   projectFiles(id: string): Promise<string[]> {
-    return listProjectFiles(this.sessionGet(id).workspace.repoRoot);
+    const session = this.sessionGet(id);
+
+    return this.vcsSources
+      .select(session.workspace.repoRoot, session.artifact.meta.vcs ?? "git")
+      .then(({ adapter, repoRoot }) => adapter.listFiles(repoRoot))
+      .catch(() => listProjectFiles(session.workspace.repoRoot));
   }
 
   /** UTF-8 contents of a repo-relative file in the session's workspace, or null when it cannot be read safely. */
@@ -557,7 +585,9 @@ export class DaemonCore {
 
   /** Tracked, repo-relative file paths for the git repo containing `cwd`; [] when it is not a repo. Owner-only. */
   async repoFiles(cwd: string): Promise<string[]> {
-    return listProjectFiles((await resolveWorkspace(cwd)).repoRoot);
+    const { adapter, repoRoot } = await this.vcsSources.select(cwd);
+
+    return adapter.listFiles(repoRoot);
   }
 
   /** UTF-8 contents of a repo-relative file in the repo containing `cwd`, or null when unreadable. Owner-only. */
@@ -567,7 +597,9 @@ export class DaemonCore {
 
   /** Changed files (repo-relative path plus git status) in the working tree at `cwd`. Owner-only. */
   repoChanges(cwd: string): Promise<{ path: string; status: DiffFileStatus }[]> {
-    return workingChangeList(cwd);
+    return this.vcsSources
+      .select(cwd)
+      .then(({ adapter, repoRoot }) => adapter.listChanges(repoRoot));
   }
 
   /**
@@ -575,8 +607,8 @@ export class DaemonCore {
    * the same unified patch plus full per-file contents a `cueloop diff` captures,
    * so the Changes navigator renders a real diff for any thread. Owner-only.
    */
-  repoDiff(cwd: string): Promise<WorkingTreeDiff> {
-    return workingTreeDiff(cwd);
+  repoDiff(cwd: string, vcs?: string): Promise<VcsDiffSnapshot & { vcs: string }> {
+    return this.vcsSources.capture(cwd, vcs);
   }
 
   /**
@@ -586,8 +618,10 @@ export class DaemonCore {
    * first comment without an agent submission. Owner-only.
    */
   async workbenchSession(cwd: string): Promise<Thread> {
+    const selected = await this.vcsSources.select(cwd);
     const workspace = await resolveWorkspace(cwd);
-    const key = workspace.rootCommit ?? "_standalone";
+    workspace.repoRoot = selected.repoRoot;
+    const key = `${workspace.rootCommit ?? selected.repoRoot}:${selected.adapter.id}`;
     // an open workbench is reused; a resolved one is immutable and would reject the note, so a fresh
     // one is created past it
     const open = this.store
@@ -596,7 +630,9 @@ export class DaemonCore {
         (session) =>
           session.artifact.meta.workbench === true &&
           session.status !== "resolved" &&
-          (session.workspace.rootCommit ?? "_standalone") === key,
+          (session.workspace.rootCommit ?? session.workspace.repoRoot) ===
+            (workspace.rootCommit ?? selected.repoRoot) &&
+          (session.artifact.meta.vcs ?? "git") === selected.adapter.id,
       );
 
     if (open) return open;
@@ -604,14 +640,21 @@ export class DaemonCore {
     const inFlight = this.workbenchCreation.get(key);
 
     if (inFlight) return inFlight;
-    const creation = workingTreeDiff(cwd).then((diff) =>
+    const creation = this.vcsSources.capture(cwd, selected.adapter.id).then((diff) =>
       this.sessionCreate({
         workspace,
         artifact: {
           type: "diff",
           content: diff.patch,
           files: diff.files,
-          meta: { workbench: true, title: "Workbench", cwd },
+          meta: {
+            workbench: true,
+            title: "Workbench",
+            cwd,
+            vcs: diff.vcs,
+            vcsChangeId: diff.source?.changeId,
+            vcsRevisionId: diff.source?.revisionId,
+          },
         },
       }),
     );
@@ -883,13 +926,21 @@ export class DaemonCore {
     content: string,
     addressedAnnotationIds: string[] = [],
     files?: DiffFileContents[],
+    source?: DiffSource,
   ): Thread {
     const session = this.sessionGet(id);
     const now = new Date().toISOString();
     const revisionNumber = session.revisions.length + 1;
 
-    session.revisions.push({ revision: revisionNumber, content, submittedAt: now });
+    session.revisions.push({
+      revision: revisionNumber,
+      content,
+      submittedAt: now,
+      source,
+      files: session.artifact.type === "diff" ? (files ?? session.artifact.files) : undefined,
+    });
     session.artifact = { ...session.artifact, content, files: files ?? session.artifact.files };
+    applyRevisionSource(session.artifact, source);
     // the agent's revision lands on main wherever its tip sits; the artifact
     // shows the head of the branch the reviewer is on
     const entryId = this.recordOnMain(session, {
@@ -1053,7 +1104,18 @@ export class DaemonCore {
     const generation = (this.diffRefreshGenerations.get(id) ?? 0) + 1;
 
     this.diffRefreshGenerations.set(id, generation);
-    const diff = await workingTreeDiff(session.workspace.repoRoot);
+    const pinnedChange =
+      session.artifact.meta.workbench !== true ? session.artifact.meta.vcsChangeId : undefined;
+    const diff = pinnedChange
+      ? await this.vcsSources.captureChange(
+          session.workspace.repoRoot,
+          session.artifact.meta.vcs ?? "git",
+          pinnedChange,
+        )
+      : await this.vcsSources.capture(
+          session.workspace.repoRoot,
+          session.artifact.meta.vcs ?? "git",
+        );
 
     // The capture yields the event loop: a newer refresh may have started, or a
     // concurrent resolve/delete may have closed the session. Discard a stale
@@ -1064,16 +1126,78 @@ export class DaemonCore {
 
     if (!current || current.status !== "pending" || current.artifact.type !== "diff")
       return { changed: false };
-    if (diff.patch === current.artifact.content) return { changed: false };
-    current.artifact = { ...current.artifact, content: diff.patch, files: diff.files };
-    // the history keeps showing the same revision, re-captured, so a later tree move derives this patch
-    const history = withHistory(current).history;
+    const contentChanged = diff.patch !== current.artifact.content;
+    const sourceChanged = diff.source?.revisionId !== current.artifact.meta.vcsRevisionId;
 
-    if (history) current.history = recaptureMainHead(history, diff.patch);
+    if (!contentChanged && !sourceChanged) return { changed: false };
+    current.artifact = {
+      ...current.artifact,
+      content: diff.patch,
+      files: diff.files,
+      meta: {
+        ...current.artifact.meta,
+        vcs: diff.vcs,
+        vcsChangeId: diff.source?.changeId,
+        vcsRevisionId: diff.source?.revisionId,
+      },
+    };
+    this.recordCapturedDiffRevision(
+      current,
+      diff,
+      Boolean(pinnedChange),
+      contentChanged || sourceChanged,
+    );
     this.store.upsert(current);
     this.emit("session.updated", id);
 
-    return { changed: true };
+    return { changed: contentChanged };
+  }
+
+  /** Live captures replace their revision; a submitted JJ change gets a new review revision. */
+  private recordCapturedDiffRevision(
+    session: Thread,
+    diff: VcsDiffSnapshot & { vcs: string },
+    pinned: boolean,
+    changed: boolean,
+  ): void {
+    if (pinned && changed) {
+      const now = new Date().toISOString();
+
+      session.revisions.push({
+        revision: session.revisions.length + 1,
+        content: diff.patch,
+        submittedAt: now,
+        files: diff.files,
+        source: {
+          vcs: diff.vcs,
+          changeId: diff.source?.changeId,
+          revisionId: diff.source?.revisionId,
+        },
+      });
+      this.recordOnMain(session, {
+        type: "revision",
+        by: "agent",
+        content: diff.patch,
+        createdAt: now,
+      });
+
+      return;
+    }
+    if (changed) {
+      const history = withHistory(session).history;
+
+      if (history) session.history = recaptureMainHead(history, diff.patch);
+    }
+    if (pinned) return;
+    const liveRevision = session.revisions.at(-1);
+
+    if (liveRevision) {
+      liveRevision.content = diff.patch;
+      liveRevision.files = diff.files;
+      liveRevision.source = diff.source
+        ? { vcs: diff.vcs, changeId: diff.source.changeId, revisionId: diff.source.revisionId }
+        : undefined;
+    }
   }
 
   /**
@@ -1103,6 +1227,9 @@ export class DaemonCore {
     if (!current || current.status !== "pending" || current.artifact.type !== "diff")
       return { changed: false };
     const contentChanged = snapshot.patch !== current.artifact.content;
+    const sourceChanged =
+      snapshot.baseSha !== current.artifact.meta.prBaseSha ||
+      snapshot.headSha !== current.artifact.meta.prHeadSha;
 
     if (
       !contentChanged &&
@@ -1123,9 +1250,26 @@ export class DaemonCore {
         prRefreshHeadSha: undefined,
       },
     };
-    const history = withHistory(current).history;
-
-    if (history && contentChanged) current.history = recaptureMainHead(history, snapshot.patch);
+    if (contentChanged || sourceChanged) {
+      const now = new Date().toISOString();
+
+      current.revisions.push({
+        revision: current.revisions.length + 1,
+        content: snapshot.patch,
+        submittedAt: now,
+        source: {
+          vcs: "git",
+          baseRevisionId: snapshot.baseSha,
+          revisionId: snapshot.headSha,
+        },
+      });
+      this.recordOnMain(current, {
+        type: "revision",
+        by: "agent",
+        content: snapshot.patch,
+        createdAt: now,
+      });
+    }
     this.store.upsert(current);
     this.emit("session.updated", id);
 
@@ -1174,7 +1318,11 @@ export class DaemonCore {
 
   private trackLiveDiffSession(session: Thread): void {
     if (isWorkingTreeDiffSession(session))
-      this.diffWatcher.trackDiffRepo(session.workspace.repoRoot, session.id);
+      this.diffWatcher.trackDiffRepo(
+        session.workspace.repoRoot,
+        session.id,
+        session.artifact.meta.vcs,
+      );
     else if (isPrReviewSession(session))
       this.prPoller.trackPr(
         session.id,
@@ -1326,12 +1474,21 @@ function forkedAnnotation(annotation: Annotation, source: Thread, fork: Thread):
     : { ...annotation, resolution: { ...resolution, revision: inFork.revision } };
 }
 
+function applyRevisionSource(artifact: Artifact, source?: DiffSource): void {
+  if (source) artifact.meta.vcs = source.vcs;
+  if (artifact.type !== "diff") return;
+
+  artifact.meta.vcsChangeId = source?.changeId;
+  artifact.meta.vcsRevisionId = source?.revisionId;
+}
+
 /** A pending diff of the local working tree: hot-reloads by watching its repo. A PR review is excluded. */
 function isWorkingTreeDiffSession(session: Thread): boolean {
   return (
     session.status === "pending" &&
     session.artifact.type === "diff" &&
-    session.artifact.meta.pr === undefined
+    session.artifact.meta.pr === undefined &&
+    !(session.artifact.meta.vcsChangeId && session.artifact.meta.workbench !== true)
   );
 }
 

package/src/client.ts

@@ -141,7 +141,7 @@ export interface ThreadClient {
   /** Changed files (path plus git status) in the working tree at `cwd`. */
   repoChanges?(cwd: string): Promise<{ path: string; status: DiffFileStatus }[]>;
   /** The live working-tree diff (patch plus per-file contents) at `cwd`. */
-  repoDiff?(cwd: string): Promise<WorkingTreeDiff>;
+  repoDiff?(cwd: string, vcs?: string): Promise<WorkingTreeDiff>;
   /** Refresh a local diff or explicitly pull a moved PR head. */
   sessionRefreshDiff?(id: string): Promise<{ changed: boolean }>;
   /** Find-or-create the per-repo workbench thread for `cwd`, so a bare launch's first comment persists. */
@@ -574,11 +574,21 @@ export class DaemonClient implements ThreadClient {
       v.array(v.object({ path: v.string(), status: v.picklist(["added", "modified", "deleted"]) })),
     );
   }
-  repoDiff(cwd: string): Promise<WorkingTreeDiff> {
+  repoDiff(
+    cwd: string,
+    vcs?: string,
+  ): Promise<
+    WorkingTreeDiff & { vcs?: string; source?: { changeId?: string; revisionId: string } }
+  > {
     return this.request(
       "repo.diff",
-      { cwd },
-      v.object({ patch: v.string(), files: v.array(DiffFileContentsSchema) }),
+      { cwd, vcs },
+      v.object({
+        patch: v.string(),
+        files: v.array(DiffFileContentsSchema),
+        vcs: v.optional(v.string()),
+        source: v.optional(v.object({ changeId: v.optional(v.string()), revisionId: v.string() })),
+      }),
     );
   }
   sessionWorkbench(cwd: string): Promise<Thread> {
@@ -660,10 +670,11 @@ export class DaemonClient implements ThreadClient {
     content: string,
     addressedAnnotationIds: string[] = [],
     files?: DiffFileContents[],
+    source?: import("@cueloop/schema").DiffSource,
   ): Promise<Thread> {
     return this.request(
       "session.submitRevision",
-      { id, content, addressedAnnotationIds, files },
+      { id, content, addressedAnnotationIds, files, source },
       ThreadRecordSchema,
     );
   }

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

@@ -51,6 +51,90 @@ async function openDiffSession() {
 }
 
 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();
@@ -218,7 +302,26 @@ esac
       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;
@@ -227,6 +330,31 @@ esac
 });
 
 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();

package/src/diff-watcher.ts

@@ -21,7 +21,7 @@ const DIFF_REFRESH_DEBOUNCE_MS = 300;
  * index, lock files) cannot loop; `node_modules` churns on installs and is never
  * review content.
  */
-const ALWAYS_IGNORED_DIRS = new Set([".git", "node_modules"]);
+const ALWAYS_IGNORED_DIRS = new Set([".git", ".jj", "node_modules"]);
 
 /**
  * Absolute paths of the directories git ignores under a repo root, resolved once
@@ -93,6 +93,8 @@ interface RepoWatch {
   handles: FSWatcher[];
   /** Live diff session ids sharing this repo root; the watch closes when the last one leaves. */
   sessionIds: Set<string>;
+  jjSessionIds: Set<string>;
+  jjPoll: ReturnType<typeof setInterval> | null;
   /** Absolute paths git ignores under the root, so the walk skips them. */
   ignored: Set<string>;
   /** Directories already watched, so a runtime-created dir is not watched twice. */
@@ -112,28 +114,32 @@ export class DiffWatcher {
   constructor(private readonly onRepoChange: (repoRoot: string) => void) {}
 
   /** Start (or join) watching a repo root for one diff session. Idempotent per (root, session). */
-  trackDiffRepo(repoRoot: string, sessionId: string): void {
+  trackDiffRepo(repoRoot: string, sessionId: string, vcs = "git"): void {
     const existing = this.repoWatches.get(repoRoot);
 
     if (existing) {
       existing.sessionIds.add(sessionId);
+      if (vcs === "jj") this.startJjPoll(existing, repoRoot, sessionId);
 
       return;
     }
     const repoWatch: RepoWatch = {
       handles: [],
       sessionIds: new Set([sessionId]),
+      jjSessionIds: new Set(),
+      jjPoll: null,
       ignored: ignoredDirectories(repoRoot),
       watchedDirs: new Set(),
       debounce: null,
     };
 
     this.repoWatches.set(repoRoot, repoWatch);
+    if (vcs === "jj") this.startJjPoll(repoWatch, repoRoot, sessionId);
 
     // one watcher per non-ignored working-tree directory; a tracked-file change re-captures
     if (!this.watchTree(repoRoot, repoRoot)) {
       // repo root gone or not watchable on this platform: skip, no hot-reload here
-      this.repoWatches.delete(repoRoot);
+      this.untrackDiffRepo(repoRoot, sessionId);
 
       return;
     }
@@ -159,6 +165,12 @@ export class DiffWatcher {
     }
   }
 
+  private startJjPoll(repoWatch: RepoWatch, repoRoot: string, sessionId: string): void {
+    repoWatch.jjSessionIds.add(sessionId);
+    if (repoWatch.jjPoll !== null) return;
+    repoWatch.jjPoll = setInterval(() => this.scheduleRepoRefresh(repoRoot), 2000);
+  }
+
   /**
    * Watch `dir` (non-recursive) and every non-ignored directory under it, adding
    * each to the repo's handles. Returns whether `dir` itself got a watcher, so
@@ -246,8 +258,14 @@ export class DiffWatcher {
 
     if (!repoWatch) return;
     repoWatch.sessionIds.delete(sessionId);
+    repoWatch.jjSessionIds.delete(sessionId);
+    if (repoWatch.jjSessionIds.size === 0 && repoWatch.jjPoll !== null) {
+      clearInterval(repoWatch.jjPoll);
+      repoWatch.jjPoll = null;
+    }
     if (repoWatch.sessionIds.size > 0) return;
     if (repoWatch.debounce !== null) clearTimeout(repoWatch.debounce);
+    if (repoWatch.jjPoll !== null) clearInterval(repoWatch.jjPoll);
     for (const handle of repoWatch.handles) handle.close();
     this.repoWatches.delete(repoRoot);
   }
@@ -267,6 +285,7 @@ export class DiffWatcher {
   close(): void {
     for (const repoWatch of this.repoWatches.values()) {
       if (repoWatch.debounce !== null) clearTimeout(repoWatch.debounce);
+      if (repoWatch.jjPoll !== null) clearInterval(repoWatch.jjPoll);
       for (const handle of repoWatch.handles) handle.close();
     }
     this.repoWatches.clear();