@pi-archimedes/footer 2.10.4 → 2.11.1

package/src/utils/git.test.ts

@@ -17,11 +17,12 @@ describe("getGitStatus", () => {
   let getGitStatus: () => GitStatus;
   let isInsideLinkedWorktree: () => boolean;
 
-  async function loadModule(mockExecSync: ReturnType<typeof vi.fn>) {
+  async function loadModule(mockExecSync: ReturnType<typeof vi.fn>, mockExecFile = vi.fn()) {
     vi.resetModules();
 
     vi.doMock("child_process", () => ({
       execSync: mockExecSync,
+      execFile: mockExecFile,
     }));
 
     vi.doMock("fs", () => ({
@@ -31,6 +32,8 @@ describe("getGitStatus", () => {
     const mod = await import("./git.js");
     getGitStatus = mod.getGitStatus;
     isInsideLinkedWorktree = mod.isInsideLinkedWorktree;
+    // Same module registry generation as git.js, so both see one listener set
+    return await import("./vcs-change-events.js");
   }
 
   afterEach(() => {
@@ -93,6 +96,107 @@ describe("getGitStatus", () => {
     expect(result).toEqual({ staged: 0, unstaged: 0, untracked: 0, ahead: 3, behind: 2 });
   });
 
+  it("refreshes stale status asynchronously and timestamps failed refreshes", async () => {
+    const mockExecSync = vi.fn(() => "1 AM file.txt\n");
+    const mockExecFile = vi.fn();
+    await loadModule(mockExecSync, mockExecFile);
+    const now = vi.spyOn(Date, "now").mockReturnValue(1_000);
+
+    expect(getGitStatus()).toEqual({ staged: 1, unstaged: 1, untracked: 0, ahead: 0, behind: 0 });
+    now.mockReturnValue(3_000);
+    expect(getGitStatus()).toEqual({ staged: 1, unstaged: 1, untracked: 0, ahead: 0, behind: 0 });
+    getGitStatus(); // renders while the refresh is pending
+    getGitStatus();
+    expect(mockExecFile).toHaveBeenCalledTimes(1);
+    expect(mockExecSync).toHaveBeenCalledTimes(1);
+
+    type Done = (error: Error | null, stdout: string) => void;
+    (mockExecFile.mock.calls[0]![3] as Done)(null, "?  new.txt\n");
+    expect(getGitStatus()).toEqual({ staged: 0, unstaged: 0, untracked: 1, ahead: 0, behind: 0 });
+
+    now.mockReturnValue(5_001);
+    expect(getGitStatus()).toEqual({ staged: 0, unstaged: 0, untracked: 1, ahead: 0, behind: 0 });
+    (mockExecFile.mock.calls[1]![3] as Done)(new Error("git failed"), "");
+    expect(getGitStatus()).toEqual({ staged: 0, unstaged: 0, untracked: 1, ahead: 0, behind: 0 });
+
+    now.mockReturnValue(6_000);
+    getGitStatus();
+    expect(mockExecFile).toHaveBeenCalledTimes(2);
+  });
+
+  it("publishes a VCS change when a background refresh moves the counts", async () => {
+    const mockExecSync = vi.fn(() => "1 AM file.txt\n");
+    const mockExecFile = vi.fn();
+    const events = await loadModule(mockExecSync, mockExecFile);
+    const now = vi.spyOn(Date, "now").mockReturnValue(1_000);
+    const listener = vi.fn();
+    const unsubscribe = events.onVcsChange(listener);
+
+    getGitStatus(); // first call is synchronous, nothing to announce yet
+    expect(listener).not.toHaveBeenCalled();
+
+    now.mockReturnValue(3_000);
+    getGitStatus(); // stale returned, refresh scheduled
+    expect(listener).not.toHaveBeenCalled();
+
+    type Done = (error: Error | null, stdout: string) => void;
+    (mockExecFile.mock.calls[0]![3] as Done)(null, "1 AM file.txt\n1 AM other.txt\n");
+    expect(listener).toHaveBeenCalledTimes(1);
+    expect(getGitStatus().unstaged).toBe(2);
+
+    unsubscribe();
+    now.mockReturnValue(6_000);
+    getGitStatus();
+    (mockExecFile.mock.calls[1]![3] as Done)(null, "1 AM a\n1 AM b\n1 AM c\n");
+    expect(listener).toHaveBeenCalledTimes(1); // unsubscribed: silent
+  });
+
+  it("stays silent when a refresh returns identical counts or fails", async () => {
+    const mockExecSync = vi.fn(() => "1 AM file.txt\n");
+    const mockExecFile = vi.fn();
+    const events = await loadModule(mockExecSync, mockExecFile);
+    const now = vi.spyOn(Date, "now").mockReturnValue(1_000);
+    const listener = vi.fn();
+    events.onVcsChange(listener);
+
+    getGitStatus();
+    now.mockReturnValue(3_000);
+    getGitStatus();
+    type Done = (error: Error | null, stdout: string) => void;
+    (mockExecFile.mock.calls[0]![3] as Done)(null, "1 AM file.txt\n"); // same numbers
+    expect(listener).not.toHaveBeenCalled();
+
+    now.mockReturnValue(6_000);
+    getGitStatus();
+    (mockExecFile.mock.calls[1]![3] as Done)(new Error("git failed"), ""); // keeps stale
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it("publishes a VCS change when the worktree answer flips", async () => {
+    const cwd = process.cwd();
+    const mockExecSync = vi.fn(() => "worktree /nope/main\n\n" + `worktree ${cwd}\n`);
+    const mockExecFile = vi.fn();
+    const events = await loadModule(mockExecSync, mockExecFile);
+    const now = vi.spyOn(Date, "now").mockReturnValue(1_000);
+    const listener = vi.fn();
+    events.onVcsChange(listener);
+
+    expect(isInsideLinkedWorktree()).toBe(true);
+    expect(listener).not.toHaveBeenCalled();
+
+    now.mockReturnValue(3_000);
+    isInsideLinkedWorktree(); // schedules the refresh
+    type Done = (error: Error | null, stdout: string) => void;
+    (mockExecFile.mock.calls[0]![3] as Done)(null, `worktree ${cwd}\n`); // now the main worktree
+    expect(listener).toHaveBeenCalledTimes(1);
+    expect(isInsideLinkedWorktree()).toBe(false);
+
+    now.mockReturnValue(6_000);
+    isInsideLinkedWorktree();
+    (mockExecFile.mock.calls[1]![3] as Done)(null, `worktree ${cwd}\n`); // same answer
+    expect(listener).toHaveBeenCalledTimes(1);
+  });
+
   it("malformed lines ignored gracefully", async () => {
     const mockExecSync = vi.fn(() => "this is not valid\n\n  \n1 AM valid.txt\n");
     await loadModule(mockExecSync);
@@ -134,6 +238,26 @@ describe("getGitStatus", () => {
     expect(isInsideLinkedWorktree()).toBe(true);
   });
 
+  it("refreshes stale worktree status asynchronously", async () => {
+    const cwd = process.cwd();
+    const mockExecSync = vi.fn(() => "worktree /nope/main\n\n" + `worktree ${cwd}\n`);
+    const mockExecFile = vi.fn();
+    await loadModule(mockExecSync, mockExecFile);
+    const now = vi.spyOn(Date, "now").mockReturnValue(1_000);
+
+    expect(isInsideLinkedWorktree()).toBe(true);
+    now.mockReturnValue(3_000);
+    expect(isInsideLinkedWorktree()).toBe(true);
+    isInsideLinkedWorktree(); // renders while the refresh is pending
+    isInsideLinkedWorktree();
+    expect(mockExecFile).toHaveBeenCalledTimes(1);
+    expect(mockExecSync).toHaveBeenCalledTimes(1);
+
+    type Done = (error: Error | null, stdout: string) => void;
+    (mockExecFile.mock.calls[0]![3] as Done)(null, `worktree ${cwd}\n`);
+    expect(isInsideLinkedWorktree()).toBe(false);
+  });
+
   it("property: getGitStatus never throws (catches execSync errors gracefully)", async () => {
     const mockExecSync = vi.fn(() => { throw new Error("git not found"); });
     await loadModule(mockExecSync);
@@ -142,7 +266,12 @@ describe("getGitStatus", () => {
     expect(result).toEqual({ staged: 0, unstaged: 0, untracked: 0, ahead: 0, behind: 0 });
   });
 
-  it("property: parseGitOutput handles arbitrary git porcelain output without throwing", async () => {
+  // Each of the 100 default runs re-imports the module (`vi.resetModules` +
+  // dynamic import in `loadModule`), so the cost is module-graph work, not
+  // parsing: 1217 ms idle, but up to 8247 ms with the repo's own type-check
+  // looped over it, and it crossed the 5 s default in 2 of 5 pre-fix loaded runs
+  // (5118 ms, 5178 ms). Same shield as the subagent width audit — see #131.
+  it("property: parseGitOutput handles arbitrary git porcelain output without throwing", { timeout: 30_000 }, async () => {
     await fc.assert(
       fc.asyncProperty(fc.string({ maxLength: 500 }), async (output) => {
         const mockExecSync = vi.fn(() => output);

package/src/utils/git.ts

@@ -1,5 +1,6 @@
-import { execSync } from "child_process";
+import { execFile, execSync } from "child_process";
 import { realpathSync } from "fs";
+import { notifyVcsChange } from "./vcs-change-events.js";
 
 export interface GitStatus {
   staged: number;
@@ -30,7 +31,8 @@ interface WorktreeCacheEntry {
 
 let gitStatusCache: GitCacheEntry | undefined;
 let worktreeCache: WorktreeCacheEntry | undefined;
-let gitRefreshTimer: ReturnType<typeof setTimeout> | undefined;
+let gitRefreshInFlight = false;
+let worktreeRefreshInFlight = false;
 
 interface FileStates {
   indexField: string;
@@ -81,23 +83,35 @@ function parseGitOutput(output: string): GitStatus {
   return status;
 }
 
-/** Schedule a background git status refresh (debounced). */
+function gitStatusEquals(a: GitStatus, b: GitStatus): boolean {
+  return (
+    a.staged === b.staged &&
+    a.unstaged === b.unstaged &&
+    a.untracked === b.untracked &&
+    a.ahead === b.ahead &&
+    a.behind === b.behind
+  );
+}
+
+/** Refresh git status without blocking the render loop. */
 function scheduleGitRefresh(): void {
-  if (gitRefreshTimer) return; // Already scheduled
-  gitRefreshTimer = setTimeout(() => {
-    gitRefreshTimer = undefined;
-    try {
-      const output = execSync(GIT_STATUS_CMD, {
-        cwd: process.cwd(),
-        encoding: "utf8",
-        stdio: ["pipe", "pipe", "pipe"],
-        timeout: 2_000,
-      });
-      gitStatusCache = { value: parseGitOutput(output), timestamp: Date.now() };
-    } catch {
-      /* not a git repo or command failed — keep stale cache */
-    }
-  }, 0);
+  if (gitRefreshInFlight || !gitStatusCache) return;
+  gitRefreshInFlight = true;
+  const staleValue = gitStatusCache.value;
+  execFile(
+    "git",
+    ["status", "--porcelain=v2", "--branch", "-uall"],
+    { cwd: process.cwd(), encoding: "utf8", timeout: 2_000 },
+    (error, stdout) => {
+      gitRefreshInFlight = false;
+      const next = error ? staleValue : parseGitOutput(stdout);
+      gitStatusCache = { value: next, timestamp: Date.now() };
+      // Ask for a frame only when a displayed count actually moved: the footer
+      // painted the stale value, and pi draws no frame unless one is requested.
+      // An unchanged reply must stay silent, or the TTL drives a render forever.
+      if (!gitStatusEquals(next, staleValue)) notifyVcsChange();
+    },
+  );
 }
 
 export function getGitStatus(): GitStatus {
@@ -112,7 +126,7 @@ export function getGitStatus(): GitStatus {
     return gitStatusCache.value;
   }
 
-  // First call — sync fetch + schedule background refresh
+  // First call — sync fetch so the first render is correct
   const emptyStatus: GitStatus = { staged: 0, unstaged: 0, untracked: 0, ahead: 0, behind: 0 };
   try {
     const output = execSync(GIT_STATUS_CMD, {
@@ -126,10 +140,48 @@ export function getGitStatus(): GitStatus {
     /* not a git repo or command failed */
     gitStatusCache = { value: emptyStatus, timestamp: Date.now() };
   }
-  scheduleGitRefresh();
   return gitStatusCache.value;
 }
 
+function parseWorktreeOutput(output: string, realCwd: string): boolean {
+  const worktreeEntries = output.trim().split("\n\n").filter(Boolean);
+  if (worktreeEntries.length <= 1) return false;
+
+  // The first porcelain entry is always the main worktree: only linked ones
+  // can match.
+  for (let i = 1; i < worktreeEntries.length; i++) {
+    const pathLine = worktreeEntries[i]!.split("\n").find((line) => line.startsWith("worktree "));
+    const worktreePath = pathLine?.replace("worktree ", "");
+    if (worktreePath && (realCwd === worktreePath || realCwd.startsWith(worktreePath + "/"))) return true;
+  }
+  return false;
+}
+
+function scheduleWorktreeRefresh(): void {
+  if (worktreeRefreshInFlight || !worktreeCache) return;
+  worktreeRefreshInFlight = true;
+  const staleValue = worktreeCache.value;
+  execFile(
+    "git",
+    ["worktree", "list", "--porcelain"],
+    { cwd: process.cwd(), encoding: "utf8", timeout: 2_000 },
+    (error, stdout) => {
+      worktreeRefreshInFlight = false;
+      let value = staleValue;
+      if (!error) {
+        try {
+          value = parseWorktreeOutput(stdout, realpathSync(process.cwd()));
+        } catch {
+          /* keep stale value */
+        }
+      }
+      worktreeCache = { value, timestamp: Date.now() };
+      // Same rule as git status: repaint only when the answer changed.
+      if (value !== staleValue) notifyVcsChange();
+    },
+  );
+}
+
 /**
  * Returns true when cwd is inside a linked worktree (not the main clone).
  * Returns false when cwd is the main clone or not a git repo.
@@ -140,6 +192,11 @@ export function isInsideLinkedWorktree(): boolean {
     return worktreeCache.value;
   }
 
+  if (worktreeCache) {
+    scheduleWorktreeRefresh();
+    return worktreeCache.value;
+  }
+
   try {
     const worktreeOutput = execSync("git worktree list --porcelain", {
       cwd: process.cwd(),
@@ -147,29 +204,7 @@ export function isInsideLinkedWorktree(): boolean {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 2_000,
     });
-
-    const worktreeEntries = worktreeOutput.trim().split("\n\n").filter(Boolean);
-    if (worktreeEntries.length <= 1) {
-      worktreeCache = { value: false, timestamp: Date.now() };
-      return false;
-    }
-
-    const currentDirectoryPath = realpathSync(process.cwd());
-    let result = false;
-    // The first porcelain entry is always the main worktree: being in the
-    // main clone isn't "being in a worktree", so only linked ones (index >= 1)
-    // can match.
-    for (let i = 1; i < worktreeEntries.length; i++) {
-      const entry = worktreeEntries[i]!;
-      const entryLines = entry.split("\n");
-      const pathLine = entryLines.find((l) => l.startsWith("worktree "));
-      const worktreePath = pathLine?.replace("worktree ", "");
-
-      if (worktreePath && (currentDirectoryPath === worktreePath || currentDirectoryPath.startsWith(worktreePath + "/"))) {
-        result = true;
-        break;
-      }
-    }
+    const result = parseWorktreeOutput(worktreeOutput, realpathSync(process.cwd()));
     worktreeCache = { value: result, timestamp: Date.now() };
     return result;
   } catch {

package/src/utils/jj.test.ts

@@ -12,8 +12,9 @@ async function load({ paths = [".jj", ".git"], output = "main\n", throws = false
   const execFile = vi.fn();
   vi.doMock("child_process", () => ({ execFileSync, execFile }));
   vi.doMock("fs", () => ({ existsSync: (p: string) => existing.has(p) }));
-  const { getJjBookmark } = await import("./jj.js");
-  return { getJjBookmark, execFileSync, execFile, existing };
+  const { getJjBookmark, getJjChangedFiles } = await import("./jj.js");
+  const events = await import("./vcs-change-events.js");
+  return { getJjBookmark, getJjChangedFiles, execFileSync, execFile, existing, events };
 }
 
 describe("getJjBookmark", () => {
@@ -38,6 +39,18 @@ describe("getJjBookmark", () => {
     expect(getJjBookmark()).toBe(expected);
   });
 
+  it("parses the jj changed-file count", async () => {
+    const { getJjBookmark, getJjChangedFiles } = await load({ output: "@mooqvmmx\nmain\n\t3\n" });
+    expect(getJjBookmark()).toBe("main");
+    expect(getJjChangedFiles()).toBe(3);
+  });
+
+  it("keeps bookmarks that start with !", async () => {
+    const { getJjBookmark, getJjChangedFiles } = await load({ output: "!feature\n\t3\n" });
+    expect(getJjBookmark()).toBe("!feature");
+    expect(getJjChangedFiles()).toBe(3);
+  });
+
   it("returns null when jj fails", async () => {
     const { getJjBookmark } = await load({ throws: true });
     expect(getJjBookmark()).toBeNull();
@@ -67,4 +80,57 @@ describe("getJjBookmark", () => {
     expect(getJjBookmark()).toBe("feature-x");
     now.mockRestore();
   });
+
+  it("publishes a VCS change when a refresh moves the bookmark or the file count", async () => {
+    const { getJjBookmark, execFile, events } = await load({ output: "main\n\t1\n" });
+    const now = vi.spyOn(Date, "now").mockReturnValue(1_000);
+    const listener = vi.fn();
+    events.onVcsChange(listener);
+
+    expect(getJjBookmark()).toBe("main"); // synchronous first call: nothing to announce
+    expect(listener).not.toHaveBeenCalled();
+
+    type Done = (e: Error | null, out: string) => void;
+    now.mockReturnValue(10_000);
+    getJjBookmark(); // stale while refreshing
+    (execFile.mock.calls[0]![3] as Done)(null, "main\n\t4\n"); // same bookmark, more files
+    expect(listener).toHaveBeenCalledTimes(1);
+
+    now.mockReturnValue(20_000);
+    getJjBookmark();
+    (execFile.mock.calls[1]![3] as Done)(null, "main\n\t4\n"); // identical → silent
+    expect(listener).toHaveBeenCalledTimes(1);
+    now.mockRestore();
+  });
+
+  it("stays silent on a failed refresh and on a reply that raced a cwd change", async () => {
+    // The other repo also looks like a jj repo to the mocked fs, so a call
+    // after chdir replaces the cache entry with one keyed to the new cwd.
+    const other = "/somewhere/else";
+    const { getJjBookmark, getJjChangedFiles, execFile, events } = await load({
+      output: "main\n\t1\n",
+      paths: [".jj", ".git", `${other}/.jj`],
+    });
+    const now = vi.spyOn(Date, "now").mockReturnValue(1_000);
+    const listener = vi.fn();
+    events.onVcsChange(listener);
+    getJjBookmark();
+
+    type Done = (e: Error | null, out: string) => void;
+    now.mockReturnValue(10_000);
+    getJjBookmark(); // schedules the refresh for the original cwd
+    (execFile.mock.calls[0]![3] as Done)(new Error("lock timeout"), "");
+    expect(listener).not.toHaveBeenCalled();
+
+    now.mockReturnValue(20_000);
+    getJjBookmark(); // still the original cwd, request in flight
+    const cwdSpy = vi.spyOn(process, "cwd").mockReturnValue(other);
+    expect(getJjBookmark()).toBe("main"); // moved: cache rewritten for the new cwd
+    expect(getJjChangedFiles()).toBe(1);
+    (execFile.mock.calls[1]![3] as Done)(null, "other-branch\n\t9\n"); // late reply for the old cwd
+    expect(getJjBookmark()).toBe("main"); // the dropped reply must not resurface
+    cwdSpy.mockRestore();
+    expect(listener).not.toHaveBeenCalled();
+    now.mockRestore();
+  });
 });

package/src/utils/jj.ts

@@ -1,6 +1,7 @@
 import { execFile, execFileSync } from "child_process";
 import { existsSync } from "fs";
 import { dirname, join } from "path";
+import { notifyVcsChange } from "./vcs-change-events.js";
 
 // Same TTL as git status: bookmarks (and repo markers) don't change on every render
 const JJ_CACHE_TTL_MS = 2_000;
@@ -13,11 +14,12 @@ const JJ_ARGS = [
   "--no-graph",
   "--ignore-working-copy",
   "--color", "never",
-  "-T", 'if(local_bookmarks, local_bookmarks.map(|b| b.name()).join(" "), "@" ++ change_id.shortest(8)) ++ "\\n"',
+  // Count line is tab-tagged (git refs can't contain tabs); it comes from the last snapshot, so it lags until jj snapshots.
+  "-T", 'if(local_bookmarks, local_bookmarks.map(|b| b.name()).join(" "), "@" ++ change_id.shortest(8)) ++ "\\n" ++ if(current_working_copy, "\\t" ++ self.diff().files().len() ++ "\\n")',
 ];
 
 let jjRepoCache: { cwd: string; isJj: boolean; timestamp: number } | undefined;
-let bookmarkCache: { cwd: string; value: string | null; timestamp: number } | undefined;
+let bookmarkCache: { cwd: string; value: string | null; changedFiles: number; timestamp: number } | undefined;
 let refreshInFlight = false;
 
 function isJjRepo(cwd: string): boolean {
@@ -43,13 +45,19 @@ function isJjRepo(cwd: string): boolean {
  * Several bookmarks on one commit collapse to `first +N` — footer chunks are
  * atomic, so an unbounded list could push other sections onto their own lines.
  */
-function parseJjOutput(output: string): string | null {
-  const lines = output.split("\n").filter(Boolean);
-  const bookmarks = lines.find((l) => !l.startsWith("@"));
-  if (!bookmarks) return lines[0]?.slice(1) || null;
+function parseJjOutput(output: string): { value: string | null; changedFiles: number } {
+  const outputLines = output.split("\n").filter(Boolean);
+  const changedFilesLine = outputLines.find((line) => line.startsWith("\t"));
+  const changedFiles = Number(changedFilesLine?.slice(1)) || 0;
+  const revisionLines = outputLines.filter((line) => !line.startsWith("\t"));
+  const bookmarks = revisionLines.find((line) => !line.startsWith("@"));
+  if (!bookmarks) return { value: revisionLines[0]?.slice(1) || null, changedFiles };
   // Space-joined by the template: git ref names can't contain spaces
-  const [first, ...rest] = bookmarks.split(" ");
-  return rest.length ? `${first} +${rest.length}` : first!;
+  const [firstBookmark, ...remainingBookmarks] = bookmarks.split(" ");
+  return {
+    value: remainingBookmarks.length ? `${firstBookmark} +${remainingBookmarks.length}` : firstBookmark!,
+    changedFiles,
+  };
 }
 
 function refreshInBackground(cwd: string): void {
@@ -57,12 +65,28 @@ function refreshInBackground(cwd: string): void {
   refreshInFlight = true;
   execFile("jj", JJ_ARGS, { cwd, encoding: "utf8", timeout: 2_000 }, (error, stdout) => {
     refreshInFlight = false;
-    if (bookmarkCache?.cwd !== cwd) return; // cwd moved on; don't clobber the new entry
-    // On failure keep the stale value (transient lock/timeout shouldn't flash "detached")
-    bookmarkCache = { cwd, value: error ? bookmarkCache.value : parseJjOutput(stdout), timestamp: Date.now() };
+    const previous = bookmarkCache;
+    if (!previous || previous.cwd !== cwd) return; // cwd moved on; don't clobber the new entry
+    // On failure keep stale values (transient lock/timeout shouldn't flash "detached")
+    if (error) {
+      bookmarkCache = { ...previous, timestamp: Date.now() };
+      return;
+    }
+    const parsedOutput = parseJjOutput(stdout);
+    bookmarkCache = { cwd, ...parsedOutput, timestamp: Date.now() };
+    // The footer painted the stale bookmark/count and pi draws no frame unless
+    // one is requested, so a reply that moved either has to ask for a repaint.
+    if (previous.value !== parsedOutput.value || previous.changedFiles !== parsedOutput.changedFiles) {
+      notifyVcsChange();
+    }
   });
 }
 
+/** @'s changed-file count; only meaningful when getJjBookmark() returned non-null this render. */
+export function getJjChangedFiles(): number {
+  return bookmarkCache?.cwd === process.cwd() ? bookmarkCache.changedFiles : 0;
+}
+
 /**
  * Current jj bookmark for the footer branch section, or null when cwd isn't in
  * a jj repo or jj can't be run (caller falls back to pi's git branch).
@@ -77,6 +101,7 @@ export function getJjBookmark(): string | null {
   }
 
   let value: string | null = null;
+  let changedFiles = 0;
   try {
     const output = execFileSync("jj", JJ_ARGS, {
       cwd,
@@ -84,10 +109,12 @@ export function getJjBookmark(): string | null {
       stdio: ["ignore", "pipe", "ignore"],
       timeout: 2_000,
     });
-    value = parseJjOutput(output);
+    const parsedOutput = parseJjOutput(output);
+    value = parsedOutput.value;
+    changedFiles = parsedOutput.changedFiles;
   } catch {
     /* jj missing or failed */
   }
-  bookmarkCache = { cwd, value, timestamp: Date.now() };
+  bookmarkCache = { cwd, value, changedFiles, timestamp: Date.now() };
   return value;
 }

package/src/utils/stats.test.ts

@@ -85,7 +85,7 @@ function makeCompactionEntry(id: string, usage?: MessageUsage): SessionEntry {
 
 function makeCtx(entries: SessionEntry[], contextUsage?: { contextWindow?: number; percent?: number }, modelContextWindow?: number): any {
   return {
-    sessionManager: { getEntries: () => entries },
+    sessionManager: { getEntries: () => entries, getSessionId: () => "session-1", getLeafId: () => entries.at(-1)?.id ?? null },
     getContextUsage: () => contextUsage,
     model: modelContextWindow ? { contextWindow: modelContextWindow } : undefined,
   };
@@ -366,11 +366,13 @@ describe("getTokenUsageStats", () => {
 
 describe("getContextWindowInfo", () => {
   let getContextWindowInfo: typeof import("./stats.js").getContextWindowInfo;
+  let resetStatsState: typeof import("./stats.js").resetStatsState;
 
   async function loadModule() {
     vi.resetModules();
     const mod = await import("./stats.js");
     getContextWindowInfo = mod.getContextWindowInfo;
+    resetStatsState = mod.resetStatsState;
   }
 
   it("computes percentage correctly", async () => {
@@ -405,4 +407,36 @@ describe("getContextWindowInfo", () => {
     expect(result.percentValue).toBe(10);
     expect(result.windowSize).toBe(10000);
   });
+
+  it("reuses context usage until the session moves", async () => {
+    await loadModule();
+    const entries = [makeAssistantEntry({ input: 500, output: 500, cacheRead: 0, cacheWrite: 0, cost: { total: 0 } })];
+    const ctx = makeCtx(entries, { contextWindow: 10000, percent: 10 });
+    const getContextUsageSpy = vi.spyOn(ctx, "getContextUsage");
+
+    getContextWindowInfo(ctx);
+    getContextWindowInfo(ctx);
+    expect(getContextUsageSpy).toHaveBeenCalledTimes(1);
+
+    entries.push(makeAssistantEntry({ input: 100, output: 100, cacheRead: 0, cacheWrite: 0, cost: { total: 0 } }));
+    getContextWindowInfo(ctx);
+    expect(getContextUsageSpy).toHaveBeenCalledTimes(2);
+  });
+
+  // Each key alone must invalidate: same entry count, new usage -> new percent
+  it.each([
+    ["session", (ctx: any) => { ctx.sessionManager.getSessionId = () => "session-2"; }],
+    ["leaf (same entry count)", (ctx: any) => { ctx.sessionManager.getLeafId = () => "other-leaf"; }],
+    ["model", (ctx: any) => { ctx.model = { contextWindow: 10000 }; }],
+    ["reset", () => resetStatsState()],
+  ])("recomputes context usage after a %s change", async (_change, applyChange) => {
+    await loadModule();
+    const ctx = makeCtx([makeAssistantEntry({ input: 500, output: 500, cacheRead: 0, cacheWrite: 0, cost: { total: 0 } })], { contextWindow: 10000, percent: 10 });
+    expect(getContextWindowInfo(ctx).percentValue).toBe(10);
+
+    ctx.getContextUsage = () => ({ contextWindow: 10000, percent: 25 });
+    expect(getContextWindowInfo(ctx).percentValue).toBe(10); // cached
+    applyChange(ctx);
+    expect(getContextWindowInfo(ctx).percentValue).toBe(25);
+  });
 });

package/src/utils/stats.ts

@@ -195,6 +195,25 @@ export function getTokenUsageStats(ctx: ExtensionContext): TokenUsageStats {
   return runningTotal;
 }
 
+// getContextUsage() rebuilds the session projection; only recompute when the session moves
+let contextUsageCache:
+  | { sessionId: string; leafId: string | null; entryCount: number; model: unknown; value: ReturnType<ExtensionContext["getContextUsage"]> }
+  | undefined;
+
+function getCachedContextUsage(ctx: ExtensionContext): ReturnType<ExtensionContext["getContextUsage"]> {
+  const sessionId = ctx.sessionManager.getSessionId();
+  const leafId = ctx.sessionManager.getLeafId();
+  const entryCount = ctx.sessionManager.getEntries().length;
+  const model = ctx.model;
+  const cached = contextUsageCache;
+  if (cached && cached.sessionId === sessionId && cached.leafId === leafId && cached.entryCount === entryCount && cached.model === model) {
+    return cached.value;
+  }
+  const value = ctx.getContextUsage();
+  contextUsageCache = { sessionId, leafId, entryCount, model, value };
+  return value;
+}
+
 /** Clear the stats cache — call when a new message arrives. */
 export function invalidateStatsCache(): void {
   statsCache = undefined;
@@ -208,6 +227,7 @@ export function resetStatsState(): void {
   lastAnchorEntryId = undefined;
   lastTailUsage = undefined;
   statsCache = undefined;
+  contextUsageCache = undefined;
 }
 
 export interface ContextWindowInfo {
@@ -217,7 +237,7 @@ export interface ContextWindowInfo {
 }
 
 export function getContextWindowInfo(ctx: ExtensionContext): ContextWindowInfo {
-  const contextUsage = ctx.getContextUsage();
+  const contextUsage = getCachedContextUsage(ctx);
   const modelContextWindow = contextUsage?.contextWindow ?? ctx.model?.contextWindow ?? 0;
   const tokenStats = getTokenUsageStats(ctx);
 

package/src/utils/vcs-change-events.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect, vi } from "vitest";
+import { onVcsChange, notifyVcsChange } from "./vcs-change-events.js";
+
+describe("vcs-change-events", () => {
+  it("notifies every listener", () => {
+    const a = vi.fn();
+    const b = vi.fn();
+    onVcsChange(a);
+    onVcsChange(b);
+    notifyVcsChange();
+    expect(a).toHaveBeenCalledTimes(1);
+    expect(b).toHaveBeenCalledTimes(1);
+  });
+
+  it("stops notifying after unsubscribe", () => {
+    const listener = vi.fn();
+    const unsubscribe = onVcsChange(listener);
+    unsubscribe();
+    unsubscribe(); // idempotent
+    notifyVcsChange();
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it("a throwing listener does not break the others or the publisher", () => {
+    const bad = vi.fn(() => {
+      throw new Error("dead footer");
+    });
+    const good = vi.fn();
+    onVcsChange(bad);
+    onVcsChange(good);
+    expect(() => notifyVcsChange()).not.toThrow();
+    expect(good).toHaveBeenCalledTimes(1);
+  });
+});