pi-gauntlet 5.18.6 → 5.18.7

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## v5.18.7 - 2026-09-24
+
+### Added
+
+- The telemetry recorder derives `modified_files` and diff buckets in plain jj workspaces through `jj` (remote trunk or local `main`/`master` as the mainline), with jj-named warnings and an intact record on any jj failure. (#51)
+
 ## v5.18.6 - 2026-09-24
 
 ### Changed

package/extensions/lib/telemetry-paths.test.ts

@@ -9,6 +9,7 @@ import {
   matchDiscardStatement,
   matchShipStatement,
   matchTestStatement,
+  parsePatchNumstat,
   parseSpecLinks,
   planSpecHeader,
   recordPathFor,
@@ -95,6 +96,48 @@ test("aggregateNumstat sums per bucket over the given file set; binary rows coun
   });
 });
 
+const patch = (...blocks: string[][]) => blocks.map((b) => b.join("\n")).join("\n") + "\n";
+
+test("parsePatchNumstat counts hunk lines and paths with spaces", () => {
+  const p = patch(
+    ["diff --git a/src/a.ts b/src/a.ts", "--- a/src/a.ts", "+++ b/src/a.ts", "@@ -1 +1 @@", "+a", "+b", "-c", "\"],
+    ["diff --git a/sp ace.txt b/sp ace.txt", "--- a/sp ace.txt", "+++ b/sp ace.txt", "@@ -1 +1 @@", "-x", "+y"],
+  );
+  assert.deepEqual(parsePatchNumstat(p), [{ added: 2, removed: 1, path: "src/a.ts" }, { added: 1, removed: 1, path: "sp ace.txt" }]);
+});
+
+test("parsePatchNumstat handles renames and delete/add pairs", () => {
+  assert.deepEqual(parsePatchNumstat(patch(
+    ["diff --git a/old.ts b/new.ts", "rename from old.ts", "rename to new.ts"],
+    ["diff --git a/o2.ts b/n2.ts", "rename from o2.ts", "rename to n2.ts", "--- a/o2.ts", "+++ b/n2.ts", "@@ -1 +1,2 @@", " k", "+extra"],
+    ["diff --git a/gone.ts b/gone.ts", "deleted file mode 100644", "--- a/gone.ts", "+++ /dev/null", "@@ -1 +0,0 @@", "-old"],
+    ["diff --git a/newer.ts b/newer.ts", "new file mode 100644", "--- /dev/null", "+++ b/newer.ts", "@@ -0,0 +1 @@", "+new"],
+  )), [
+    { added: 0, removed: 0, path: "new.ts" }, { added: 1, removed: 0, path: "n2.ts" },
+    { added: 0, removed: 1, path: "gone.ts" }, { added: 1, removed: 0, path: "newer.ts" },
+  ]);
+});
+
+test("parsePatchNumstat handles binary, mode-only and positional hunk headers", () => {
+  assert.deepEqual(parsePatchNumstat(patch(
+    ["diff --git a/dir b/icon.png b/dir b/icon.png", "Binary files a/dir b/icon.png and b/dir b/icon.png differ"],
+    ["diff --git a/run.sh b/run.sh", "old mode 100644", "new mode 100755"],
+    ["diff --git a/image.png b/image.png", "GIT binary patch", "literal 4"],
+    ["diff --git a/test/fm.md b/test/fm.md", "--- a/test/fm.md", "+++ b/test/fm.md", "@@ -1 +1 @@", "----", "++text"],
+  )), [
+    { added: 0, removed: 0, path: "dir b/icon.png" }, { added: 0, removed: 0, path: "run.sh" },
+    { added: 0, removed: 0, path: "image.png" }, { added: 1, removed: 1, path: "test/fm.md" },
+  ]);
+});
+
+test("parsePatchNumstat rejects malformed input and accepts empty patches", () => {
+  assert.deepEqual(parsePatchNumstat(""), []);
+  assert.deepEqual(parsePatchNumstat("  \n\n"), []);
+  assert.equal(parsePatchNumstat("garbage\n"), null);
+  assert.equal(parsePatchNumstat("diff --git a/x b/y\nindex 1..2\n"), null);
+  assert.equal(parsePatchNumstat("diff --git c/x b/x\n"), null);
+});
+
 test("parseSpecLinks reads Supersedes/Fixes banners as paths or markdown links", () => {
   const body = "# T\n\n> **Supersedes:** [doc/specs/a.md](./a.md), doc/specs/b.md\n> **Fixes:** [doc/specs/c.md](./c.md)\n";
   assert.deepEqual(parseSpecLinks(body), { supersedes: ["doc/specs/a.md", "doc/specs/b.md"], fixes: ["doc/specs/c.md"] });

package/extensions/lib/telemetry-paths.ts

@@ -116,6 +116,60 @@ export function aggregateNumstat(numstat: string, files: Set<string>, buckets: [
   return out;
 }
 
+export interface PatchRow {
+  added: number;
+  removed: number;
+  path: string;
+}
+
+function patchBlockPath(headers: string[]): string | undefined {
+  const plus = headers.find((l) => l.startsWith("+++ b/"));
+  if (plus) return plus.slice(6);
+  const renameTo = headers.find((l) => l.startsWith("rename to "));
+  if (renameTo) return renameTo.slice(10);
+  const minus = headers.find((l) => l.startsWith("--- a/"));
+  if (minus && headers.includes("+++ /dev/null")) return minus.slice(6);
+  if (!headers[0].startsWith("diff --git a/")) return undefined;
+  const rest = headers[0].slice("diff --git a/".length);
+  const mid = (rest.length - 3) / 2;
+  if (Number.isInteger(mid) && mid > 0 && rest.slice(mid, mid + 3) === " b/" && rest.slice(0, mid) === rest.slice(mid + 3)) return rest.slice(0, mid);
+  return undefined;
+}
+
+function parsePatchBlock(block: string[]): PatchRow | undefined {
+  const hunk = block.findIndex((l) => l.startsWith("@@"));
+  const headers = hunk < 0 ? block : block.slice(0, hunk);
+  const path = patchBlockPath(headers);
+  if (path === undefined) return undefined;
+  let added = 0;
+  let removed = 0;
+  for (const line of hunk < 0 ? [] : block.slice(hunk)) {
+    if (line.startsWith("+")) added++;
+    else if (line.startsWith("-")) removed++;
+  }
+  return { added, removed, path };
+}
+
+// jj has no numstat: --stat truncates paths and -T exposes no line counts.
+// Headers end at the first @@; subsequent ---- and ++text lines count as content.
+export function parsePatchNumstat(patch: string): PatchRow[] | null {
+  if (!patch.trim()) return [];
+  const lines = patch.split("\n");
+  if (!lines.find((l) => l.trim())!.startsWith("diff --git ")) return null;
+  const blocks: string[][] = [];
+  for (const line of lines) {
+    if (line.startsWith("diff --git ")) blocks.push([line]);
+    else if (blocks.length) blocks[blocks.length - 1].push(line);
+  }
+  const rows: PatchRow[] = [];
+  for (const block of blocks) {
+    const row = parsePatchBlock(block);
+    if (!row) return null;
+    rows.push(row);
+  }
+  return rows;
+}
+
 // ---- spec banners --------------------------------------------------------------
 
 const LINK_BANNER_RE = /^> \*\*(Supersedes|Fixes):\*\*\s*(.+)$/gm;

package/extensions/telemetry.test.ts

@@ -20,7 +20,7 @@
 
   type Handler = (event: any, ctx: any) => unknown;
 
-  function harness(o: { branch?: unknown[]; enabled?: boolean; gitFail?: (args: string[], cwd: string) => GitResult | undefined; jjWorkspace?: boolean; cwdSub?: string; sessionId?: string; model?: { provider: string; id: string }; thinkingLevel?: string; contextTokens?: number | null; telemetryWarning?: string; telemetryDir?: string } = {}) {
+  function harness(o: { branch?: unknown[]; enabled?: boolean; gitFail?: (args: string[], cwd: string) => GitResult | undefined; jjWorkspace?: boolean; jjFail?: (args: string[], cwd: string) => GitResult | undefined; cwdSub?: string; sessionId?: string; model?: { provider: string; id: string }; thinkingLevel?: string; contextTokens?: number | null; telemetryWarning?: string; telemetryDir?: string } = {}) {
     const root = mkdtempSync(join(tmpdir(), "telemetry-test-"));
     tempDirs.push(root);
     mkdirSync(join(root, "doc/specs"), { recursive: true });
@@ -29,6 +29,7 @@
     const handlers = new Map<string, Handler[]>();
     const gitCalls: string[][] = [];
     const gitCwds: string[] = [];
+    const jjCalls: string[][] = [];
     const readFileCalls: string[] = [];
     let clock = Date.parse("2026-09-17T10:00:00Z");
     const deps: Deps = {
@@ -53,7 +54,13 @@
       },
       settings: () => ({ telemetry: { enabled: o.enabled ?? true, dir: o.telemetryDir ?? ".pi/gauntlet/telemetry", buckets: DEFAULT_TELEMETRY_BUCKETS, warning: o.telemetryWarning }, errors: [], agentOverrides: { implementer: { model: "p/x" } }, versions: { pi: "0.85.1" } }),
       // A plain jj workspace: `jj root` answers the temp root while git rev-parse fails.
-      ...(o.jjWorkspace ? { jj: async () => ({ code: 0, stdout: root + "\n", stderr: "" }) } : {}),
+      jj: async (args, cwd) => {
+        jjCalls.push(args);
+        const forced = o.jjFail?.(args, cwd);
+        if (forced) return forced;
+        if (!o.jjWorkspace) return { code: 1, stdout: "", stderr: "jj stub: not a jj workspace" };
+        return shipJj(args, root);
+      },
     };
     let branch = o.branch ?? [];
     const ctx = {
@@ -79,11 +86,39 @@
       await emit("tool_call", { toolName: "write", toolCallId: "w", input: { path: rel, content: body } });
       return emit("tool_result", { toolName: "write", toolCallId: "w", input: { path: rel, content: body }, content: [], isError: false, details: undefined });
     };
-    return { root, handlers, emit, gitCalls, gitCwds, readFileCalls, commits, recordPath, readRecord, phaseResult, writeSpec, setBranch: (b: unknown[]) => (branch = b), ctx };
+    return { root, handlers, emit, gitCalls, gitCwds, jjCalls, readFileCalls, commits, recordPath, readRecord, phaseResult, writeSpec, setBranch: (b: unknown[]) => (branch = b), ctx };
   }
 
   const P = (over: Record<string, string> = {}) => Object.fromEntries(["brainstorm", "plan", "implement", "verify", "ship"].map((p) => [p, { status: over[p] ?? "pending" }]));
 
+  const JJ_PATCH = [
+    "diff --git a/src/a.ts b/src/a.ts",
+    "index 1111111..2222222 100644",
+    "--- a/src/a.ts",
+    "+++ b/src/a.ts",
+    "@@ -1,4 +1,12 @@",
+    ...Array.from({ length: 10 }, (_, i) => `+added ${i}`),
+    "-removed 1",
+    "-removed 2",
+    " context",
+    "diff --git a/test/a.test.ts b/test/a.test.ts",
+    "new file mode 100644",
+    "index 0000000..3333333",
+    "--- /dev/null",
+    "+++ b/test/a.test.ts",
+    "@@ -0,0 +1,5 @@",
+    ...Array.from({ length: 5 }, (_, i) => `+t ${i}`),
+    "",
+  ].join("\n");
+
+  function shipJj(args: string[], root: string): GitResult {
+    if (args[0] === "root") return { code: 0, stdout: root + "\n", stderr: "" };
+    if (args.includes("--count")) return { code: 0, stdout: args.some((a) => a.includes('files(~glob:".pi/gauntlet/telemetry/**")')) ? "2\n" : "3\n", stderr: "" };
+    if (args.includes("log")) return { code: 0, stdout: "jjbase0001\n", stderr: "" };
+    if (args.includes("diff")) return { code: 0, stdout: JJ_PATCH, stderr: "" };
+    return { code: 1, stdout: "", stderr: `jj stub: unexpected call ${args.join(" ")}` };
+  }
+
   test("enabled: false registers handlers that no-op", async () => {
     const h = harness({ enabled: false });
     await h.emit("session_start", { type: "session_start", reason: "startup" });
@@ -726,6 +761,100 @@
     assert.ok(rec.events.some((e) => e.kind === "warning" && /base/.test((e as any).message)));
   });
 
+  async function boundInJjShip(jjFail?: (args: string[]) => GitResult | undefined) {
+    const h = harness({
+      jjWorkspace: true,
+      jjFail: jjFail ? (args) => jjFail(args) : undefined,
+      gitFail: (args) => (args[0] === "rev-parse" && args.includes("--path-format=absolute") ? { code: 128, stdout: "", stderr: "fatal: not a git repository" } : undefined),
+    });
+    await h.phaseResult("start", P({ brainstorm: "in_progress" }));
+    await h.writeSpec("doc/specs/a.md");
+    await h.phaseResult("complete", P({ brainstorm: "complete" }));
+    await h.phaseResult("start", P({ brainstorm: "complete", plan: "complete", implement: "complete", verify: "complete", ship: "in_progress" }));
+    await h.phaseResult("complete", P({ brainstorm: "complete", plan: "complete", implement: "complete", verify: "complete", ship: "complete" }));
+    return h;
+  }
+
+  const diffWarnings = (h: { readRecord: () => ReturnType<typeof parseRecord> }) =>
+    h.readRecord()!.events.filter((e) => e.kind === "warning").map((e: any) => e.message as string).filter((m) => m.startsWith("diff omitted"));
+
+  const isBaseLog = (args: string[]) => args.includes("log") && !args.includes("--count");
+
+  test("jj ship (AC 1): keep path derives modified_files and diff through jj with pinned output flags", async () => {
+    const h = await boundInJjShip();
+    const rec = h.readRecord();
+    assert.equal(rec.status, "shipped");
+    assert.equal(rec.derived.gates.ship_option, "keep");
+    assert.deepEqual(rec.derived.modified_files, ["src/a.ts", "test/a.test.ts"]);
+    assert.deepEqual(rec.derived.diff, { base: "jjbase0001", commits: 2, buckets: { code: { files: 1, insertions: 10, deletions: 2 }, test: { files: 1, insertions: 5, deletions: 0 } } });
+    assert.deepEqual(diffWarnings(h), []);
+    const diffSteps = h.jjCalls.filter((a) => a[0] !== "root");
+    assert.equal(diffSteps.length, 3);
+    assert.ok(diffSteps.every((a) => a.includes("--color=never")));
+    assert.deepEqual(diffSteps[1].slice(0, 4), ["--color=never", "--config", "diff.git.show-path-prefix=true", "diff"]);
+    assert.ok(diffSteps[0].some((a) => a.includes("fork_point(") && a.includes("~ root() & ::")));
+  });
+
+  test("jj ship (AC 2): empty mainline -> jj-named warning, both derived fields absent, record written", async () => {
+    const h = await boundInJjShip((args) => (isBaseLog(args) ? { code: 0, stdout: "", stderr: "" } : undefined));
+    const rec = h.readRecord();
+    assert.equal(rec.status, "shipped");
+    assert.equal(rec.derived.diff, undefined);
+    assert.equal(rec.derived.modified_files, undefined);
+    assert.deepEqual(diffWarnings(h), ["diff omitted: jj mainline unresolved (trunk() is root(); no main/master bookmark)"]);
+  });
+
+  test("jj ship: jj diff nonzero exit -> first stderr line in the warning", async () => {
+    const h = await boundInJjShip((args) => (args.includes("diff") ? { code: 1, stdout: "", stderr: "Error: Revision `jjbase0001` doesn't exist\nHint: try jj log\n" } : undefined));
+    assert.deepEqual(diffWarnings(h), ["diff omitted: jj diff failed: Error: Revision `jjbase0001` doesn't exist"]);
+    assert.equal(h.readRecord().derived.diff, undefined);
+  });
+
+  test("jj ship: ENOENT-shaped runner result (empty stderr) -> 'unknown error'", async () => {
+    const h = await boundInJjShip((args) => (isBaseLog(args) ? { code: 127, stdout: "", stderr: "" } : undefined));
+    assert.deepEqual(diffWarnings(h), ["diff omitted: jj log failed: unknown error"]);
+    assert.equal(h.readRecord().status, "shipped");
+  });
+
+  test("jj ship: unparseable patch -> warning, neither field set", async () => {
+    const h = await boundInJjShip((args) => (args.includes("diff") ? { code: 0, stdout: "not a patch\n", stderr: "" } : undefined));
+    assert.deepEqual(diffWarnings(h), ["diff omitted: jj diff unparseable"]);
+    const rec = h.readRecord();
+    assert.equal(rec.derived.diff, undefined);
+    assert.equal(rec.derived.modified_files, undefined);
+  });
+
+  test("jj ship: malformed patch header -> warning, neither field set, record shipped", async () => {
+    const h = await boundInJjShip((args) => (args.includes("diff") ? { code: 0, stdout: "diff --git c/x b/x\n", stderr: "" } : undefined));
+    assert.deepEqual(diffWarnings(h), ["diff omitted: jj diff unparseable"]);
+    const rec = h.readRecord();
+    assert.equal(rec.status, "shipped");
+    assert.equal(rec.derived.diff, undefined);
+    assert.equal(rec.derived.modified_files, undefined);
+  });
+
+  test("jj ship: --count failure -> jj log warning, no derived diff", async () => {
+    const h = await boundInJjShip((args) => (args.includes("--count") ? { code: 1, stdout: "", stderr: "Error: invalid revset\nHint: check the mainline\n" } : undefined));
+    assert.deepEqual(diffWarnings(h), ["diff omitted: jj log failed: Error: invalid revset"]);
+    const rec = h.readRecord();
+    assert.equal(rec.status, "shipped");
+    assert.equal(rec.derived.diff, undefined);
+    assert.equal(rec.derived.modified_files, undefined);
+  });
+
+  test("jj ship: unparseable --count -> warning with the raw output", async () => {
+    const h = await boundInJjShip((args) => (args.includes("--count") ? { code: 0, stdout: "abc\n", stderr: "" } : undefined));
+    assert.deepEqual(diffWarnings(h), ["diff omitted: jj log --count unparseable: abc"]);
+    assert.equal(h.readRecord().derived.diff, undefined);
+  });
+
+  test("git ship never calls jj", async () => {
+    const h = await boundInShip();
+    await h.bash("s1", "git push");
+    assert.deepEqual(h.readRecord().derived.modified_files, ["README.md", "extensions/telemetry.test.ts", "extensions/telemetry.ts"]);
+    assert.deepEqual(h.jjCalls, []);
+  });
+
   test("guard: write to a shipped spec during brainstorm is blocked before any state change; edit passes; other phases pass", async () => {
     const h = await boundInShip();
     await h.bash("s1", "git push");

package/extensions/telemetry.ts

@@ -18,7 +18,7 @@
   import { checkoutOf } from "./lib/checkout.ts";
   import { CONTEXT_DRAFT_MARKER } from "./lib/phase-tracker-helpers.ts";
   import { sha256 } from "./lib/plan-check.ts";
-  import { SUPERSEDED_BY_RE, aggregateNumstat, isPlanPath, isSpecPath, isSupersededByBanner, matchDiscardStatement, matchShipStatement, matchTestStatement, parseSpecLinks, planSpecHeader, recordPathFor, repoRelativeToolPath, toPosix, truncateCommand } from "./lib/telemetry-paths.ts";
+  import { SUPERSEDED_BY_RE, aggregateNumstat, isPlanPath, isSpecPath, isSupersededByBanner, matchDiscardStatement, matchShipStatement, matchTestStatement, parsePatchNumstat, parseSpecLinks, planSpecHeader, recordPathFor, repoRelativeToolPath, toPosix, truncateCommand } from "./lib/telemetry-paths.ts";
   import { COUNTED_USER_PHASES, REVIEWER_AGENTS, countFindings, countOpenGaps, hasReopen, insertedText, planTotals, textOf, usageToTokens } from "./lib/telemetry-collect.ts";
   import { addTokens, capEvents, compact, currentPhase, derive, diffPhases, emptyAccumulators, emptyPhases, foldAccumulators, implementAutoCompletes, liveShipEvent, newRecord, parseRecord, serializeRecord, type Accumulators, type BaseEvent, type PhaseAcc, type PhaseKey, type PhaseMap, type TelemetryEvent, type TelemetryRecord, type Tokens } from "./lib/telemetry-record.ts";
   import { BASE_REFS, guardReason, modifiedFilesFrom } from "./lib/telemetry-ship.ts";
@@ -48,7 +48,7 @@
   export interface Deps {
     fs: FsPort;
     git: (args: string[], cwd: string) => Promise<GitResult>;
-    // Optional jj override for tests; production resolves plain jj workspaces via jjSync.
+    // jj runner; production uses realJj for both checkout detection and the ship-time diff.
     jj?: (args: string[], cwd: string) => GitResult | Promise<GitResult>;
     now: () => string;
     settings: (cwd: string) => SettingsSnapshot;
@@ -78,6 +78,16 @@
       });
     });
 
+  // jj diff --git returns full patches; execFile's default buffer is too small.
+  // On ENOENT stderr is empty, so preserve the error message.
+  export const realJj = (args: string[], cwd: string): Promise<GitResult> =>
+    new Promise((res) => {
+      execFile("jj", args, { cwd, timeout: 10_000, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 }, (err, stdout, stderr) => {
+        const code = err ? (typeof (err as { code?: unknown }).code === "number" ? ((err as { code: number }).code) : 1) : 0;
+        res({ code, stdout: String(stdout ?? ""), stderr: String(stderr ?? "").trim() || String(err?.message ?? "") });
+      });
+    });
+
   const isoNow = (): string => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
 
   const readPkgVersion = (p: string): string | undefined => {
@@ -115,7 +125,7 @@
     return { telemetry, errors, agentOverrides, versions: realVersions(), testCommands };
   }
 
-  export const realDeps: Deps = { fs: realFs, git: realGit, now: isoNow, settings: realSettings };
+  export const realDeps: Deps = { fs: realFs, git: realGit, jj: realJj, now: isoNow, settings: realSettings };
 
   // ---- replay ------------------------------------------------------------------------
 
@@ -635,6 +645,38 @@
     let pendingShip: { id: string; option: "squash" | "pr" | "discard" } | undefined;
 
     const computeDiff = async (snap: SettingsSnapshot) => {
+      if (checkoutVia === "jj") await computeJjDiff(snap);
+      else await computeGitDiff(snap);
+    };
+
+    const JJ_MAINLINE = "coalesce(trunk() ~ root(), present(main), present(master))";
+
+    const computeJjDiff = async (snap: SettingsSnapshot) => {
+      if (!record || !toplevel) return;
+      const jj = deps.jj ?? realJj;
+      const failed = (sub: string, r: GitResult) => warn(`diff omitted: jj ${sub} failed: ${r.stderr.trim().split("\n")[0] || "unknown error"}`);
+      // Without the ::M guard an empty mainline resolves to @ and counts the full history.
+      const baseR = await jj(["--color=never", "log", "-r", `fork_point(${JJ_MAINLINE} | @) ~ root() & ::${JJ_MAINLINE}`, "--no-graph", "-T", 'commit_id ++ "\\n"'], toplevel);
+      if (baseR.code !== 0) return failed("log", baseR);
+      const base = baseR.stdout.trim().split("\n")[0].trim();
+      if (!base) return warn("diff omitted: jj mainline unresolved (trunk() is root(); no main/master bookmark)");
+      const patch = await jj(["--color=never", "--config", "diff.git.show-path-prefix=true", "diff", "--from", base, "--to", "@", "--git"], toplevel);
+      if (patch.code !== 0) return failed("diff", patch);
+      const rows = parsePatchNumstat(patch.stdout);
+      if (!rows) return warn("diff omitted: jj diff unparseable");
+      const dir = currentDir.replace(/\/+$/, "");
+      // Exclude record-only @ and other telemetry-only revisions from the count.
+      const count = await jj(["--color=never", "log", "-r", `(${base}::@ ~ ${base}) & files(~glob:"${dir}/**")`, "--count"], toplevel);
+      if (count.code !== 0) return failed("log", count);
+      const n = count.stdout.trim();
+      if (!/^\d+$/.test(n)) return warn(`diff omitted: jj log --count unparseable: ${n}`);
+      const files = modifiedFilesFrom(rows.map((r) => r.path).join("\n"), record.spec, currentDir);
+      const numstat = rows.map((r) => `${r.added}\t${r.removed}\t${r.path}`).join("\n");
+      record.derived.modified_files = files;
+      record.derived.diff = { base, commits: Number(n), buckets: aggregateNumstat(numstat, new Set(files), snap.telemetry.buckets) };
+    };
+
+    const computeGitDiff = async (snap: SettingsSnapshot) => {
       if (!record || !toplevel) return;
       let baseRef: string | undefined;
       for (const ref of BASE_REFS) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-gauntlet",
-  "version": "5.18.6",
+  "version": "5.18.7",
   "description": "Opinionated, gated workflow skills, subagent personas, and runtime extensions for the pi coding agent.",
   "author": "Jacek Juraszek",
   "type": "module",