pi-gauntlet 5.18.5 → 5.18.7

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 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
+
+- `gauntlet-spec-index` prints the recorded modified-file paths that still exist in the repository in its `files` column, `;`-separated, with `missing` marking a telemetry record that has no list; the brainstorming scout renders them as a `Predecessor anchors` section for named predecessors. (#52)
+
 ## v5.18.5 - 2026-09-23
 
 - The TDD RED step directs authors to reuse existing setup helpers and consolidate near-identical cases into parametrized or table-driven examples. (#49)

package/README.md

@@ -134,7 +134,7 @@ Pin an exact release with `npm:pi-gauntlet@X.Y.Z`. See [doc/install-internals.md
 
 ## Spec search index
 
-`gauntlet-spec-index` provides lexical search across `doc/specs/*.md` at the repository root and one service level down. From a repository worktree, run `node <pi-gauntlet-package>/bin/gauntlet-spec-index.mjs --query "<text>" [--limit N]`; it requires Node >=24.15.0, refreshes its FTS5 index on every query, and prints tab-separated `score`, `path`, `service`, `title`, `status`, `shipped_at`, `files`, and `snippet` columns. The per-worktree cache lives at `.pi/gauntlet/index.sqlite`, and its first creation adds `/.pi/gauntlet/index.sqlite*` to Git's `info/exclude` so the database and SQLite sidecars stay out of `git status`.
+`gauntlet-spec-index` provides lexical search across `doc/specs/*.md` at the repository root and one service level down. From a repository worktree, run `node <pi-gauntlet-package>/bin/gauntlet-spec-index.mjs --query "<text>" [--limit N]`; it requires Node >=24.15.0, refreshes its FTS5 index on every query, and prints tab-separated `score`, `path`, `service`, `title`, `status`, `shipped_at`, `files`, and `snippet` columns. The `files` column is a `;`-separated list of repo-relative paths the spec's shipped change modified and that still exist in the repository, the literal `missing` when the spec's telemetry record has no `derived.modified_files` list, or blank when there is no readable record or no recorded path remains. The per-worktree cache lives at `.pi/gauntlet/index.sqlite`, and its first creation adds `/.pi/gauntlet/index.sqlite*` to Git's `info/exclude` so the database and SQLite sidecars stay out of `git status`.
 
 ## Performance digest
 

package/bin/gauntlet-spec-index.mjs

@@ -176,7 +176,7 @@ const toMatch = (query) =>
   query.split(/\s+/).filter((t) => t.length >= 2).map((t) => `"${t.replaceAll('"', '""')}"`).join(" OR ");
 
 function telemetry(root, specPath) {
-  const blank = { status: null, shipped_at: null, files: null };
+  const blank = { status: null, shipped_at: null, files: "" };
   const p = join(root, ".pi/gauntlet/telemetry", specPath.replace(/\.md$/, ".yaml"));
   if (!existsSync(p)) return blank;
   let rec;
@@ -186,12 +186,17 @@ function telemetry(root, specPath) {
     process.stderr.write(`gauntlet-spec-index: warning: unreadable telemetry ${p}\n`);
     return blank;
   }
-  if (!rec || typeof rec !== "object") return blank;
+  if (!rec || typeof rec !== "object" || Array.isArray(rec)) return blank;
   const mf = rec.derived?.modified_files;
-  return { status: rec.status ?? null, shipped_at: rec.shipped_at ?? null, files: Array.isArray(mf) ? mf.length : null };
+  const files = Array.isArray(mf)
+    ? mf.filter((f) => typeof f === "string" && existsSync(join(root, f))).join(";")
+    : "missing";
+  return { status: rec.status ?? null, shipped_at: rec.shipped_at ?? null, files };
 }
 
 const cell = (v) => (v === null || v === undefined ? "" : String(v).replace(/\s+/g, " ").trim());
+// Paths keep their spaces; only column and row delimiters are neutralised.
+const filesCell = (v) => v.replace(/[\t\r\n]+/g, " ");
 
 async function main() {
   if (!nodeOk()) die(`gauntlet-spec-index needs Node >=24.15.0 (found ${process.versions.node})`);
@@ -211,7 +216,7 @@ async function main() {
   const out = [HEADER.join("\t")];
   for (const r of rows) {
     const t = telemetry(root, r.path);
-    out.push([r.score.toFixed(3), r.path, r.service, r.title, t.status, t.shipped_at, t.files, r.snippet].map(cell).join("\t"));
+    out.push([...[r.score.toFixed(3), r.path, r.service, r.title, t.status, t.shipped_at].map(cell), filesCell(t.files), cell(r.snippet)].join("\t"));
   }
   process.stdout.write(out.join("\n") + "\n");
   db.close();

package/bin/gauntlet-spec-index.test.mjs

@@ -112,13 +112,17 @@ test("6: telemetry join is output-only and tolerant", (t) => {
   t.after(() => rmSync(root, { recursive: true, force: true }));
   run(root, ["--query", "zephyr"]);
   const filesBefore = withDb(root, (database) => JSON.stringify(database.prepare("SELECT * FROM files ORDER BY path").all()));
+  write(root, "x", "x\n");
+  write(root, "y", "y\n");
   write(root, ".pi/gauntlet/telemetry/doc/specs/a.yaml", "status: shipped\nshipped_at: 2026-09-17T10:00:00Z\nderived:\n  modified_files:\n    - x\n    - y\n");
   let r = run(root, ["--query", "zephyr"]);
-  assert.deepEqual(r.rows[0].slice(4, 7), ["shipped", "2026-09-17T10:00:00Z", "2"]);
+  assert.deepEqual(r.rows[0].slice(4, 7), ["shipped", "2026-09-17T10:00:00Z", "x;y"]);
+  assert.equal(r.rows[0].length, 8);
+  assert.equal(r.rows[1][6], "");
   assert.equal(withDb(root, (database) => JSON.stringify(database.prepare("SELECT * FROM files ORDER BY path").all())), filesBefore);
   write(root, ".pi/gauntlet/telemetry/doc/specs/a.yaml", "status: in_progress\nshipped_at: 2026-09-18T10:00:00Z\n");
   r = run(root, ["--query", "zephyr"]);
-  assert.deepEqual(r.rows[0].slice(4, 7), ["in_progress", "2026-09-18T10:00:00Z", ""]);
+  assert.deepEqual(r.rows[0].slice(4, 7), ["in_progress", "2026-09-18T10:00:00Z", "missing"]);
   write(root, ".pi/gauntlet/telemetry/doc/specs/a.yaml", "status: [unclosed\n");
   r = run(root, ["--query", "zephyr"]);
   assert.equal(r.status, 0);
@@ -126,6 +130,51 @@ test("6: telemetry join is output-only and tolerant", (t) => {
   assert.match(r.stderr, /a\.yaml/);
 });
 
+test("6b: files cell is the AC fixture - present paths kept, gone paths dropped, no list is missing", (t) => {
+  const root = mkdtempSync(join(tmpdir(), "gsi-"));
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+  spawnSync("git", ["init", "-q"], { cwd: root });
+  write(root, "doc/specs/a.md", "# Alpha quokka\n\n**Goal:** quokka.\n");
+  write(root, "doc/specs/b.md", "# Beta quokka\n\n**Goal:** quokka too.\n");
+  write(root, "src/x.ts", "export {};\n");
+  write(root, ".pi/gauntlet/telemetry/doc/specs/a.yaml", "status: shipped\nderived:\n  modified_files:\n    - src/x.ts\n    - src/gone.ts\n");
+  write(root, ".pi/gauntlet/telemetry/doc/specs/b.yaml", "status: shipped\n");
+  spawnSync("git", ["add", "-A"], { cwd: root });
+  spawnSync("git", ["-c", "user.name=t", "-c", "user.email=t@t", "commit", "-q", "-m", "fixture"], { cwd: root });
+  const r = run(root, ["--query", "quokka"]);
+  assert.equal(r.status, 0, r.stderr);
+  const cells = Object.fromEntries(r.rows.map((row) => [row[1], row[6]]));
+  assert.equal(cells["doc/specs/a.md"], "src/x.ts");
+  assert.equal(cells["doc/specs/b.md"], "missing");
+  for (const row of r.rows) assert.equal(row.length, 8);
+});
+
+test("6c: files cell edge cases - order, spaces kept, all gone, non-array, null record", (t) => {
+  const root = repo();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+  const yaml = ".pi/gauntlet/telemetry/doc/specs/a.yaml";
+  const files = () => run(root, ["--query", "zephyr"]).rows[0][6];
+  write(root, "b.js", "");
+  write(root, "a.js", "");
+  write(root, "sp  aced.txt", "");
+  write(root, yaml, "status: shipped\nderived:\n  modified_files:\n    - a.js\n    - b.js\n");
+  assert.equal(files(), "a.js;b.js");
+  write(root, "tab\there.js", "");
+  write(root, yaml, 'status: shipped\nderived:\n  modified_files:\n    - a.js\n    - "tab\\there.js"\n');
+  assert.equal(files(), "a.js;tab here.js");
+  assert.equal(run(root, ["--query", "zephyr"]).rows[0].length, 8);
+  write(root, yaml, "status: shipped\nderived:\n  modified_files:\n    - 'sp  aced.txt'\n    - 7\n");
+  assert.equal(files(), "sp  aced.txt");
+  write(root, yaml, "status: shipped\nderived:\n  modified_files:\n    - nope1\n    - nope2\n");
+  assert.equal(files(), "");
+  write(root, yaml, 'status: shipped\nderived:\n  modified_files: "x"\n');
+  assert.equal(files(), "missing");
+  write(root, yaml, "");
+  assert.equal(files(), "");
+  write(root, yaml, "- a\n- b\n");
+  assert.equal(files(), "");
+});
+
 test("7: query sanitising tolerates embedded quotes", (t) => {
   const root = repo();
   t.after(() => rmSync(root, { recursive: true, force: true }));

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.5",
+  "version": "5.18.7",
   "description": "Opinionated, gated workflow skills, subagent personas, and runtime extensions for the pi coding agent.",
   "author": "Jacek Juraszek",
   "type": "module",

package/skills/brainstorming/gatherer.md

@@ -63,8 +63,23 @@ Scout (always dispatched):
 > handoff. Either way open at
 > most five candidates whose topic matches this request, and name any whose design
 > this request replaces or amends with the section(s) affected - `Predecessor:
-> <path>, <scope>` - or `Predecessor: none`. Judge by topic; shared file paths never
-> decide. End with an
+> <path>, <scope>` - or `Predecessor: none`.
+> Judge by topic; shared file paths never decide.
+> The `files` column of each candidate row is the `;`-separated list of repo-relative
+> paths that predecessor's ship modified and that still exist, or the literal `missing`,
+> or blank; do not recompute it from git or telemetry. After the `Predecessor:` line(s),
+> and only when at least one predecessor is named, render a `Predecessor anchors`
+> section: list every attributed path exactly once, attributed to the first named
+> predecessor in index output order whose cell lists it, with no per-path commentary
+> (bookkeeping paths such as `CHANGELOG.md` are listed like any other); for each named
+> predecessor whose cell is `missing`, write one line
+> `<spec>: modified file list missing for this spec`, where `<spec>` is the path exactly
+> as written in its `Predecessor:` line. A blank cell contributes nothing for that spec;
+> a named predecessor with no index row (reached through a supersession banner, or named
+> from the directory-listing fallback) contributes no path and no `missing` line. When
+> no path and no `missing` line results - including whenever the index was unavailable -
+> omit the section entirely; `Predecessor: none` produces no anchors section. The anchors
+> are a recon hint, never a selection input. End with an
 > "Open questions that matter for the spec"
 > section. Compact handoff, not a dump.