pi-gauntlet 5.18.7 → 5.20.0

package/bin/gauntlet-telemetry-seal.test.mjs

@@ -0,0 +1,271 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync, chmodSync, realpathSync, symlinkSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { parse as parseYaml } from "yaml";
+
+const CLI = join(dirname(fileURLToPath(import.meta.url)), "gauntlet-telemetry-seal.mjs");
+const SPEC = "doc/specs/x.md";
+const REC = ".pi/gauntlet/telemetry/doc/specs/x.yaml";
+const RECORD = [
+  "schema: 1",
+  "spec: doc/specs/x.md",
+  "run_id: r-1",
+  "status: in_progress",
+  "created_at: 2026-09-17T16:00:00Z",
+  "sessions: [s1]",
+  "derived:",
+  "  duration_s: 60",
+  "  phases: {}",
+  "  personas: {}",
+  "  conformance_loops: 0",
+  "  gates: { spec_rounds: 0, plan_rounds: 0, fix_round_grants: 0, task_reopens: 0 }",
+  "  amendments: 0",
+  "  spec_edits_after_ship: 0",
+  "  spec_writes: {}",
+  "  events_dropped: 0",
+  "accumulators: {}",
+  "events:",
+  "  - { ts: 2026-09-17T16:00:00Z, session: s1, phase: brainstorm, kind: phase, action: start, name: brainstorm }",
+  "",
+].join("\n");
+const SEALED = RECORD.replace("status: in_progress", "status: shipped\nshipped_at: 2026-09-17T18:00:00Z");
+
+const git = (cwd, args, env = {}) =>
+  spawnSync("git", ["-c", "user.name=t", "-c", "user.email=t@t", "-c", "commit.gpgsign=false", ...args], { cwd, encoding: "utf8", env: { ...process.env, ...env } });
+const out = (cwd, args) => git(cwd, args).stdout.trim();
+const write = (root, rel, text) => {
+  mkdirSync(join(root, dirname(rel)), { recursive: true });
+  writeFileSync(join(root, rel), text);
+};
+const commit = (root, msg, ...paths) => {
+  git(root, ["add", "-f", "--", ...paths]);
+  git(root, ["commit", "-q", "-m", msg, "--", ...paths]);
+  return out(root, ["rev-parse", "HEAD"]);
+};
+// main: README only. feat: spec + src/a.ts; the record is untracked unless a test commits it.
+const repo = (options = {}) => {
+  const record = Object.hasOwn(options, "record") ? options.record : RECORD;
+  const root = mkdtempSync(join(tmpdir(), "gts-"));
+  git(root, ["init", "-q", "-b", "main"]);
+  write(root, "README.md", "# fixture\n");
+  commit(root, "init", "README.md");
+  git(root, ["checkout", "-q", "-b", "feat"]);
+  write(root, SPEC, "# Spec X\n\n**Goal:** g.\n");
+  write(root, "src/a.ts", "export const a = 1;\n");
+  commit(root, "Add spec and code", SPEC, "src/a.ts");
+  if (record !== undefined) write(root, REC, record);
+  return root;
+};
+const EMPTY_AGENT = mkdtempSync(join(tmpdir(), "gts-empty-agent-"));
+process.on("exit", () => rmSync(EMPTY_AGENT, { recursive: true, force: true }));
+const IDENTITY = { GIT_AUTHOR_NAME: "t", GIT_AUTHOR_EMAIL: "t@t", GIT_COMMITTER_NAME: "t", GIT_COMMITTER_EMAIL: "t@t" };
+const invoke = (args, env = {}) => {
+  const r = spawnSync(process.execPath, [CLI, ...args], { encoding: "utf8", env: { ...process.env, ...IDENTITY, PI_CODING_AGENT_DIR: EMPTY_AGENT, ...env } });
+  return { status: r.status, stdout: r.stdout.trim(), stderr: r.stderr.trim(), lines: r.stdout.split("\n").filter(Boolean) };
+};
+const run = (root, args = [], env = {}) => invoke(["--worktree", root, "--option", "squash", "--base", "main", ...args], env);
+const head = (root) => out(root, ["rev-parse", "HEAD"]);
+const commitCount = (root) => Number(out(root, ["rev-list", "--count", "HEAD"]));
+const headSubject = (root) => out(root, ["log", "-1", "--format=%s"]);
+const headFiles = (root) => out(root, ["show", "--name-only", "--format=", "HEAD"]).split("\n").filter(Boolean);
+const porcelain = (root) => out(root, ["status", "--porcelain", "--untracked-files=all"]);
+const record = (root) => parseYaml(readFileSync(join(root, REC), "utf8"));
+const cleanup = (t, ...roots) => t.after(() => roots.forEach((r) => rmSync(r, { recursive: true, force: true })));
+
+test("seals an untracked in_progress record: stamp, ship event, diff, re-derived duration, one telemetry: commit touching only the record", (t) => {
+  const root = repo(); cleanup(t, root);
+  const n = commitCount(root);
+  const r = run(root, ["--spec", SPEC]);
+  assert.equal(r.status, 0, r.stderr);
+  assert.deepEqual(r.lines, [`sealed ${REC}`]);
+  const rec = record(root);
+  assert.equal(rec.status, "shipped");
+  assert.match(rec.shipped_at, /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/);
+  assert.equal(rec.derived.gates.ship_option, "squash");
+  assert.equal(typeof rec.derived.gates.ship_option, "string");
+  assert.equal(rec.events.at(-1).kind, "ship");
+  assert.equal(rec.events.at(-1).option, "squash");
+  assert.deepEqual(rec.derived.modified_files, ["src/a.ts"]);
+  assert.equal(rec.derived.diff.commits, 1, "the seal commit is excluded from the count");
+  assert.equal(rec.derived.diff.buckets.code.files, 1);
+  // created_at is 2026-09-17; sealing now re-derives duration_s from created_at to shipped_at, far above the recorded 60.
+  assert.ok(rec.derived.duration_s > 60, `duration re-derived at seal time, got ${rec.derived.duration_s}`);
+  assert.equal(commitCount(root), n + 1);
+  assert.equal(headSubject(root), `telemetry: ${SPEC}`);
+  assert.deepEqual(headFiles(root), [REC]);
+  assert.equal(porcelain(root), "");
+});
+
+test("--spec accepts an absolute path within the checkout", (t) => {
+  const root = repo(); cleanup(t, root);
+  const r = run(root, ["--spec", join(realpathSync(root), SPEC)]);
+  assert.equal(r.status, 0, r.stderr);
+  assert.deepEqual(r.lines, [`sealed ${REC}`]);
+});
+
+test("--spec absolute through a symlinked prefix still resolves to the repo-relative record", (t) => {
+  const root = repo();
+  const linkDir = mkdtempSync(join(tmpdir(), "gts-link-"));
+  cleanup(t, root, linkDir);
+  const link = join(linkDir, "checkout");
+  symlinkSync(root, link);
+  const r = run(root, ["--spec", join(link, SPEC)]);
+  assert.equal(r.status, 0, r.stderr);
+  assert.deepEqual(r.lines, [`sealed ${REC}`]);
+});
+
+test("--spec accepts a dot-relative path", (t) => {
+  const root = repo(); cleanup(t, root);
+  const r = run(root, ["--spec", `./${SPEC}`]);
+  assert.equal(r.status, 0, r.stderr);
+  assert.deepEqual(r.lines, [`sealed ${REC}`]);
+});
+
+test("--option pr is recorded; without --spec the candidates are the existing records of changed specs", (t) => {
+  const root = repo(); cleanup(t, root);
+  const r = invoke(["--worktree", root, "--option", "pr", "--base", "main"]);
+  assert.equal(r.status, 0, r.stderr);
+  assert.deepEqual(r.lines, [`sealed ${REC}`]);
+  assert.equal(record(root).derived.gates.ship_option, "pr");
+});
+
+test("already sealed: a shipped, tracked, clean record is left alone", (t) => {
+  const root = repo({ record: SEALED }); cleanup(t, root);
+  commit(root, "telemetry: doc/specs/x.md", REC);
+  const before = head(root);
+  const r = run(root, ["--spec", SPEC]);
+  assert.equal(r.status, 0, r.stderr);
+  assert.deepEqual(r.lines, [`already sealed ${REC}`]);
+  assert.equal(head(root), before);
+  assert.equal(record(root).shipped_at, "2026-09-17T18:00:00Z");
+});
+
+test("an abandoned record is already sealed even when untracked", (t) => {
+  const root = repo({ record: RECORD.replace("status: in_progress", "status: abandoned") }); cleanup(t, root);
+  const before = head(root);
+  const r = run(root, ["--spec", SPEC]);
+  assert.equal(r.status, 0, r.stderr);
+  assert.deepEqual(r.lines, [`already sealed ${REC}`]);
+  assert.equal(head(root), before);
+  assert.equal(record(root).status, "abandoned");
+});
+
+test("a shipped but untracked record (previous commit failed) is committed as is on retry", (t) => {
+  const root = repo({ record: SEALED }); cleanup(t, root);
+  const n = commitCount(root);
+  const r = run(root, ["--spec", SPEC]);
+  assert.equal(r.status, 0, r.stderr);
+  assert.deepEqual(r.lines, [`sealed ${REC}`]);
+  assert.equal(commitCount(root), n + 1);
+  assert.equal(record(root).shipped_at, "2026-09-17T18:00:00Z", "bytes committed as they were");
+  assert.equal(porcelain(root), "");
+});
+
+test("--spec with no record -> no record at <path>, exit 2, no commit", (t) => {
+  const root = repo({ record: undefined }); cleanup(t, root);
+  const n = commitCount(root);
+  const r = run(root, ["--spec", SPEC]);
+  assert.equal(r.status, 2);
+  assert.equal(r.stderr, `no record at ${REC}`);
+  assert.equal(commitCount(root), n);
+});
+
+test("unparseable record -> parser message, exit 2, file untouched", (t) => {
+  const root = repo({ record: "schema: 1\nspec: doc/specs/x.md\n" }); cleanup(t, root);
+  const r = run(root, ["--spec", SPEC]);
+  assert.equal(r.status, 2);
+  assert.match(r.stderr, new RegExp(`^unparseable record ${REC.replace(/\./g, "\\.")}`));
+  assert.equal(readFileSync(join(root, REC), "utf8"), "schema: 1\nspec: doc/specs/x.md\n");
+});
+
+test("no telemetry run: a changed spec without a record is not a candidate (supersession edit)", (t) => {
+  const root = repo({ record: undefined }); cleanup(t, root);
+  const r = run(root);
+  assert.equal(r.status, 0, r.stderr);
+  assert.deepEqual(r.lines, ["no telemetry run"]);
+});
+
+test("telemetry disabled -> exit 0, nothing touched", (t) => {
+  const root = repo(); cleanup(t, root);
+  write(root, ".pi/settings.json", JSON.stringify({ piGauntlet: { telemetry: { enabled: false } } }));
+  const r = run(root, ["--spec", SPEC]);
+  assert.equal(r.status, 0, r.stderr);
+  assert.deepEqual(r.lines, ["telemetry disabled"]);
+  assert.equal(record(root).status, "in_progress");
+});
+
+test("gitignored telemetry dir is staged with -f", (t) => {
+  const root = repo(); cleanup(t, root);
+  write(root, ".gitignore", ".pi/gauntlet/telemetry/\n");
+  commit(root, "ignore telemetry", ".gitignore");
+  const r = run(root, ["--spec", SPEC]);
+  assert.equal(r.status, 0, r.stderr);
+  assert.deepEqual(headFiles(root), [REC]);
+});
+
+test("commit failure (rejecting pre-commit hook) restores the pre-seal bytes, unstages, exits 1", (t) => {
+  const root = repo(); cleanup(t, root);
+  const hook = join(root, ".git/hooks/pre-commit");
+  writeFileSync(hook, "#!/bin/sh\necho rejected >&2\nexit 1\n");
+  chmodSync(hook, 0o755);
+  const n = commitCount(root);
+  const r = run(root, ["--spec", SPEC]);
+  assert.equal(r.status, 1);
+  assert.match(r.stderr, /rejected/);
+  assert.equal(readFileSync(join(root, REC), "utf8"), RECORD, "pre-seal bytes restored");
+  assert.equal(out(root, ["diff", "--cached", "--name-only"]), "", "nothing left staged");
+  assert.equal(commitCount(root), n);
+});
+
+test("commit failure restores a previously tracked record and clears the index", (t) => {
+  const root = repo(); cleanup(t, root);
+  commit(root, "Track ongoing telemetry", REC);
+  const hook = join(root, ".git/hooks/pre-commit");
+  writeFileSync(hook, "#!/bin/sh\necho rejected >&2\nexit 1\n");
+  chmodSync(hook, 0o755);
+  const n = commitCount(root);
+  const r = run(root, ["--spec", SPEC]);
+  assert.equal(r.status, 1);
+  assert.match(r.stderr, /rejected/);
+  assert.equal(readFileSync(join(root, REC), "utf8"), RECORD);
+  assert.equal(out(root, ["diff", "--cached", "--name-only"]), "");
+  assert.equal(commitCount(root), n);
+});
+
+test("usage and environment errors exit 1", (t) => {
+  const root = repo(); cleanup(t, root);
+  const noArgs = invoke([]);
+  assert.equal(noArgs.status, 1);
+  assert.match(noArgs.stderr, /^usage: gauntlet-telemetry-seal --worktree <abs path> --option <pr\|squash> --base <ref> \[--spec <spec path inside the checkout>\] \[--dir <telemetry dir>\]/);
+  assert.equal(invoke(["--worktree", root, "--option", "rebase", "--base", "main"]).status, 1);
+  assert.equal(invoke(["--worktree", root, "--option", "squash"]).status, 1, "--base is required");
+  const noBase = invoke(["--worktree", root, "--option", "squash", "--base", "nope"]);
+  assert.equal(noBase.status, 1);
+  assert.equal(noBase.stderr, "no base ref nope");
+  for (const spec of ["/tmp/elsewhere/doc/specs/x.md", "README.md"]) {
+    const invalid = run(root, ["--spec", spec]);
+    assert.equal(invalid.status, 1);
+    assert.match(invalid.stderr, /^usage:/);
+  }
+  write(root, ".pi/settings.json", JSON.stringify({ piGauntlet: { telemetry: { enabled: false } } }));
+  const disabledInvalid = run(root, ["--spec", "/tmp/elsewhere/doc/specs/x.md"]);
+  assert.equal(disabledInvalid.status, 1);
+  assert.match(disabledInvalid.stderr, /^usage:/);
+  const notGit = mkdtempSync(join(tmpdir(), "gts-nogit-")); cleanup(t, notGit);
+  const ng = invoke(["--worktree", notGit, "--option", "squash", "--base", "main"]);
+  assert.equal(ng.status, 1);
+  assert.equal(ng.stderr, "not a git checkout");
+});
+
+test("--dir overrides the telemetry dir", (t) => {
+  const root = repo({ record: undefined }); cleanup(t, root);
+  write(root, "tele/doc/specs/x.yaml", RECORD);
+  const r = run(root, ["--spec", SPEC, "--dir", "tele"]);
+  assert.equal(r.status, 0, r.stderr);
+  assert.deepEqual(r.lines, ["sealed tele/doc/specs/x.yaml"]);
+  assert.deepEqual(headFiles(root), ["tele/doc/specs/x.yaml"]);
+});

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

@@ -0,0 +1,108 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { DEFAULT_TELEMETRY_BUCKETS } from "./gauntlet-settings.ts";
+import { JJ_MAINLINE, aggregateNumstat, computeGitDiff, computeJjDiff, type RunResult } from "./telemetry-diff.ts";
+
+const ok = (stdout: string): RunResult => ({ code: 0, stdout, stderr: "" });
+const DIR = ".pi/gauntlet/telemetry";
+
+test("aggregateNumstat sums per bucket over the given file set; binary rows count 0 lines", () => {
+  const numstat = ["10\t2\textensions/telemetry.ts", "5\t0\textensions/lib/telemetry-paths.test.ts", "-\t-\timg.png", "3\t3\tdoc/specs/a.md", "1\t1\t{old => new}/x.ts"].join("\n");
+  const files = new Set(["extensions/telemetry.ts", "extensions/lib/telemetry-paths.test.ts", "img.png", "new/x.ts"]);
+  assert.deepEqual(aggregateNumstat(numstat, files, DEFAULT_TELEMETRY_BUCKETS), {
+    code: { files: 3, insertions: 11, deletions: 3 },
+    test: { files: 1, insertions: 5, deletions: 0 },
+  });
+});
+
+test("computeGitDiff: merge-base, name-only minus spec/plan/dir, numstat buckets, telemetry-free commit count", async () => {
+  const calls: string[][] = [];
+  const git = (args: string[]) => {
+    calls.push(args);
+    if (args[0] === "merge-base") return ok("abc123\n");
+    if (args[0] === "diff" && args.includes("--name-only")) return ok("extensions/telemetry.ts\nextensions/telemetry.test.ts\ndoc/specs/a.md\ndoc/plans/a.md\n.pi/gauntlet/telemetry/doc/specs/a.yaml\nREADME.md\n");
+    if (args[0] === "diff" && args.includes("--numstat")) return ok("100\t5\textensions/telemetry.ts\n40\t0\textensions/telemetry.test.ts\n9\t9\tdoc/specs/a.md\n2\t1\tREADME.md\n");
+    if (args[0] === "rev-list") return ok("9\n");
+    return { code: 1, stdout: "", stderr: `unexpected ${args.join(" ")}` };
+  };
+  const out = await computeGitDiff({ git, cwd: "/repo", spec: "doc/specs/a.md", dir: DIR, buckets: DEFAULT_TELEMETRY_BUCKETS, base: "main" });
+  assert.deepEqual(out.modified_files, ["README.md", "extensions/telemetry.test.ts", "extensions/telemetry.ts"]);
+  assert.deepEqual(out.diff, { base: "abc123", commits: 9, buckets: { code: { files: 1, insertions: 100, deletions: 5 }, test: { files: 1, insertions: 40, deletions: 0 }, docs: { files: 1, insertions: 2, deletions: 1 } } });
+  assert.equal(out.warning, undefined);
+  assert.deepEqual(calls[0], ["merge-base", "HEAD", "main"]);
+  assert.deepEqual(calls.at(-1), ["rev-list", "--count", "--invert-grep", "--grep=^telemetry: ", "abc123..HEAD"]);
+});
+
+test("computeGitDiff: merge-base failure -> warning, both fields absent", async () => {
+  const out = await computeGitDiff({ git: () => ({ code: 128, stdout: "", stderr: "fatal: no merge base\nmore" }), cwd: "/repo", spec: "doc/specs/a.md", dir: DIR, buckets: DEFAULT_TELEMETRY_BUCKETS, base: "main" });
+  assert.deepEqual(out, { warning: "diff omitted: merge-base failed: fatal: no merge base" });
+});
+
+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");
+
+const jjStub = (over?: (args: string[]) => RunResult | undefined) => {
+  const calls: string[][] = [];
+  const jj = async (args: string[]): Promise<RunResult> => {
+    calls.push(args);
+    const forced = over?.(args);
+    if (forced) return forced;
+    if (args.includes("--count")) return ok(args.some((a) => a.includes(`files(~glob:"${DIR}/**")`)) ? "2\n" : "3\n");
+    if (args.includes("log")) return ok("jjbase0001\n");
+    if (args.includes("diff")) return ok(JJ_PATCH);
+    return { code: 1, stdout: "", stderr: `unexpected ${args.join(" ")}` };
+  };
+  return { jj, calls };
+};
+const runJj = (over?: (args: string[]) => RunResult | undefined) => {
+  const s = jjStub(over);
+  return computeJjDiff({ jj: s.jj, cwd: "/ws", spec: "doc/specs/a.md", dir: DIR, buckets: DEFAULT_TELEMETRY_BUCKETS }).then((out) => ({ out, calls: s.calls }));
+};
+const isBaseLog = (args: string[]) => args.includes("log") && !args.includes("--count");
+
+test("computeJjDiff: pinned flags, mainline revset, telemetry-only revisions excluded from the count", async () => {
+  const { out, calls } = await runJj();
+  assert.deepEqual(out.modified_files, ["src/a.ts", "test/a.test.ts"]);
+  assert.deepEqual(out.diff, { base: "jjbase0001", commits: 2, buckets: { code: { files: 1, insertions: 10, deletions: 2 }, test: { files: 1, insertions: 5, deletions: 0 } } });
+  assert.equal(out.warning, undefined);
+  assert.equal(calls.length, 3);
+  assert.ok(calls.every((a) => a.includes("--color=never")));
+  assert.deepEqual(calls[1].slice(0, 4), ["--color=never", "--config", "diff.git.show-path-prefix=true", "diff"]);
+  assert.ok(calls[0].some((a) => a.includes(`fork_point(${JJ_MAINLINE} | @) ~ root() & ::${JJ_MAINLINE}`)));
+});
+
+test("computeJjDiff: empty mainline -> jj-named warning", async () => {
+  const { out } = await runJj((args) => (isBaseLog(args) ? ok("") : undefined));
+  assert.deepEqual(out, { warning: "diff omitted: jj mainline unresolved (trunk() is root(); no main/master bookmark)" });
+});
+
+test("computeJjDiff: nonzero exit -> first stderr line; empty stderr -> unknown error", async () => {
+  const a = await runJj((args) => (args.includes("diff") ? { code: 1, stdout: "", stderr: "boom\nmore" } : undefined));
+  assert.deepEqual(a.out, { warning: "diff omitted: jj diff failed: boom" });
+  const b = await runJj((args) => (isBaseLog(args) ? { code: 1, stdout: "", stderr: "" } : undefined));
+  assert.deepEqual(b.out, { warning: "diff omitted: jj log failed: unknown error" });
+});
+
+test("computeJjDiff: unparseable patch and unparseable count", async () => {
+  const a = await runJj((args) => (args.includes("diff") ? ok("not a patch") : undefined));
+  assert.deepEqual(a.out, { warning: "diff omitted: jj diff unparseable" });
+  const b = await runJj((args) => (args.includes("--count") ? ok("many\n") : undefined));
+  assert.deepEqual(b.out, { warning: "diff omitted: jj log --count unparseable: many" });
+});

package/extensions/lib/telemetry-diff.ts

@@ -0,0 +1,61 @@
+import { classifyBucket, numstatPath, parsePatchNumstat, type BucketStat } from "./telemetry-paths.ts";
+import type { DiffSummary } from "./telemetry-record.ts";
+import { modifiedFilesFrom } from "./telemetry-ship.ts";
+
+export interface RunResult { code: number; stdout: string; stderr: string }
+export type Runner = (args: string[], cwd: string) => RunResult | Promise<RunResult>;
+export type Buckets = [string, string[]][];
+// warning set => both fields absent; the caller records the warning as an event.
+export interface DiffOutcome { diff?: DiffSummary; modified_files?: string[]; warning?: string }
+
+export function aggregateNumstat(numstat: string, files: Set<string>, buckets: Buckets): Record<string, BucketStat> {
+  const out: Record<string, BucketStat> = {};
+  for (const line of numstat.split("\n")) {
+    if (!line.trim()) continue;
+    const [ins, del, ...rest] = line.split("\t");
+    const path = numstatPath(rest.join("\t"));
+    if (!files.has(path)) continue;
+    const bucket = classifyBucket(path, buckets);
+    const stat = (out[bucket] ??= { files: 0, insertions: 0, deletions: 0 });
+    stat.files += 1;
+    stat.insertions += ins === "-" ? 0 : Number(ins) || 0;
+    stat.deletions += del === "-" ? 0 : Number(del) || 0;
+  }
+  return out;
+}
+
+export const JJ_MAINLINE = "coalesce(trunk() ~ root(), present(main), present(master))";
+const firstLine = (s: string): string => s.trim().split("\n")[0];
+
+export async function computeJjDiff(o: { jj: Runner; cwd: string; spec: string; dir: string; buckets: Buckets }): Promise<DiffOutcome> {
+  const failed = (sub: string, r: RunResult): DiffOutcome => ({ warning: `diff omitted: jj ${sub} failed: ${firstLine(r.stderr) || "unknown error"}` });
+  // Without the ::M guard an empty mainline resolves to @ and counts the full history.
+  const baseR = await o.jj(["--color=never", "log", "-r", `fork_point(${JJ_MAINLINE} | @) ~ root() & ::${JJ_MAINLINE}`, "--no-graph", "-T", 'commit_id ++ "\\n"'], o.cwd);
+  if (baseR.code !== 0) return failed("log", baseR);
+  const base = firstLine(baseR.stdout).trim();
+  if (!base) return { warning: "diff omitted: jj mainline unresolved (trunk() is root(); no main/master bookmark)" };
+  const patch = await o.jj(["--color=never", "--config", "diff.git.show-path-prefix=true", "diff", "--from", base, "--to", "@", "--git"], o.cwd);
+  if (patch.code !== 0) return failed("diff", patch);
+  const rows = parsePatchNumstat(patch.stdout);
+  if (!rows) return { warning: "diff omitted: jj diff unparseable" };
+  const dir = o.dir.replace(/\/+$/, "");
+  // Exclude record-only @ and other telemetry-only revisions from the count.
+  const count = await o.jj(["--color=never", "log", "-r", `(${base}::@ ~ ${base}) & files(~glob:"${dir}/**")`, "--count"], o.cwd);
+  if (count.code !== 0) return failed("log", count);
+  const n = count.stdout.trim();
+  if (!/^\d+$/.test(n)) return { warning: `diff omitted: jj log --count unparseable: ${n}` };
+  const files = modifiedFilesFrom(rows.map((r) => r.path).join("\n"), o.spec, o.dir);
+  const numstat = rows.map((r) => `${r.added}\t${r.removed}\t${r.path}`).join("\n");
+  return { modified_files: files, diff: { base, commits: Number(n), buckets: aggregateNumstat(numstat, new Set(files), o.buckets) } };
+}
+
+export async function computeGitDiff(o: { git: Runner; cwd: string; spec: string; dir: string; buckets: Buckets; base: string }): Promise<DiffOutcome> {
+  const mb = await o.git(["merge-base", "HEAD", o.base], o.cwd);
+  if (mb.code !== 0 || !mb.stdout.trim()) return { warning: `diff omitted: merge-base failed: ${firstLine(mb.stderr)}` };
+  const base = mb.stdout.trim();
+  const names = await o.git(["diff", "--name-only", `${base}...HEAD`], o.cwd);
+  const files = modifiedFilesFrom(names.stdout, o.spec, o.dir);
+  const numstat = await o.git(["diff", "--numstat", `${base}...HEAD`], o.cwd);
+  const count = await o.git(["rev-list", "--count", "--invert-grep", "--grep=^telemetry: ", `${base}..HEAD`], o.cwd);
+  return { modified_files: files, diff: { base, commits: Number(count.stdout.trim()) || 0, buckets: aggregateNumstat(numstat.stdout, new Set(files), o.buckets) } };
+}

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

@@ -1,12 +1,10 @@
 import assert from "node:assert/strict";
 import { test } from "node:test";
 import {
-  aggregateNumstat,
   classifyBucket,
   isPlanPath,
   isSpecPath,
   isSupersededByBanner,
-  matchDiscardStatement,
   matchShipStatement,
   matchTestStatement,
   parsePatchNumstat,
@@ -44,30 +42,6 @@ test("planSpecHeader extracts the **Spec:** path", () => {
   assert.equal(planSpecHeader("no header"), undefined);
 });
 
-test("matchShipStatement needs a statement start (STMT_START)", () => {
-  assert.deepEqual(matchShipStatement("git merge --squash gh-33 && git commit"), { option: "squash", statement: "git merge --squash gh-33" });
-  assert.deepEqual(matchShipStatement("cd x; git push -u origin HEAD"), { option: "pr", statement: "git push -u origin HEAD" });
-  assert.equal(matchShipStatement('gh pr create --fill')?.option, "pr");
-  assert.equal(matchShipStatement('rg "git push" skills/'), undefined);
-  assert.equal(matchShipStatement("echo git push"), undefined);
-});
-
-test("matchDiscardStatement matches worktree remove and branch -D", () => {
-  assert.equal(matchDiscardStatement("git worktree remove .worktrees/x"), "git worktree remove .worktrees/x");
-  assert.equal(matchDiscardStatement("cd .. && git branch -D gh-33"), "git branch -D gh-33");
-  assert.equal(matchDiscardStatement("git branch -d gh-33"), undefined);
-});
-
-test("matchShipStatement/matchDiscardStatement accept git -C <path> global flags", () => {
-  assert.deepEqual(matchShipStatement("git -C /p merge --squash f"), { option: "squash", statement: "git -C /p merge --squash f" });
-  assert.equal(matchShipStatement("git -C /p push -u origin HEAD")?.option, "pr");
-  assert.equal(matchShipStatement("git -c user.name=t -C /p merge --squash f")?.option, "squash");
-  assert.equal(matchShipStatement("git -C /p log"), undefined);
-  assert.equal(matchDiscardStatement("git -C /p worktree remove x"), "git -C /p worktree remove x");
-  assert.equal(matchDiscardStatement("git -C /p branch -D f"), "git -C /p branch -D f");
-  assert.equal(matchDiscardStatement("git -C /p branch -d f"), undefined);
-});
-
 test("matchTestStatement returns the first statement matching a test fragment", () => {
   assert.equal(matchTestStatement("cd repo && npm test -- --grep x", DEFAULT_TEST_COMMANDS), "npm test -- --grep x");
   assert.equal(matchTestStatement("make test-smoke", DEFAULT_TEST_COMMANDS), undefined);
@@ -87,15 +61,6 @@ test("classifyBucket: first match wins, else code", () => {
   assert.equal(classifyBucket("doc/specs/a.md", [["spec", ["doc/specs/**"]], ["docs", ["**/*.md"]]]), "spec");
 });
 
-test("aggregateNumstat sums per bucket over the given file set; binary rows count 0 lines", () => {
-  const numstat = ["10\t2\textensions/telemetry.ts", "5\t0\textensions/lib/telemetry-paths.test.ts", "-\t-\timg.png", "3\t3\tdoc/specs/a.md", "1\t1\t{old => new}/x.ts"].join("\n");
-  const files = new Set(["extensions/telemetry.ts", "extensions/lib/telemetry-paths.test.ts", "img.png", "new/x.ts"]);
-  assert.deepEqual(aggregateNumstat(numstat, files, DEFAULT_TELEMETRY_BUCKETS), {
-    code: { files: 3, insertions: 11, deletions: 3 },
-    test: { files: 1, insertions: 5, deletions: 0 },
-  });
-});
-
 const patch = (...blocks: string[][]) => blocks.map((b) => b.join("\n")).join("\n") + "\n";
 
 test("parsePatchNumstat counts hunk lines and paths with spaces", () => {
@@ -149,3 +114,14 @@ test("isSupersededByBanner detects the predecessor banner and its successor labe
   assert.equal(isSupersededByBanner("> **Superseded by:** [doc/specs/other.md](./other.md)", "doc/specs/new.md"), false);
   assert.equal(isSupersededByBanner("plain text", "doc/specs/new.md"), false);
 });
+
+test("matchShipStatement needs a statement start (STMT_START) and accepts git global flags", () => {
+  assert.deepEqual(matchShipStatement("git merge --squash gh-33 && git commit"), { option: "squash", statement: "git merge --squash gh-33" });
+  assert.deepEqual(matchShipStatement("cd x; git push -u origin HEAD"), { option: "pr", statement: "git push -u origin HEAD" });
+  assert.equal(matchShipStatement("gh pr create --fill")?.option, "pr");
+  assert.equal(matchShipStatement('rg "git push" skills/'), undefined);
+  assert.equal(matchShipStatement("echo git push"), undefined);
+  assert.deepEqual(matchShipStatement("git -C /p merge --squash f"), { option: "squash", statement: "git -C /p merge --squash f" });
+  assert.equal(matchShipStatement("git -c user.name=t -C /p merge --squash f")?.option, "squash");
+  assert.equal(matchShipStatement("git -C /p log"), undefined);
+});

package/extensions/lib/telemetry-paths.ts

@@ -1,19 +1,16 @@
 // Pure helpers for the telemetry extension (#33): record path mapping, pi-cwd
-// path resolution, ship/discard/test command matchers, diff buckets, spec banners.
-//
-// Ship detection runs on a `bash` `tool_call` while `ship` is in progress and matches
-// the first statement against
+// path resolution, ship/test command matchers, diff buckets, spec banners.
+// Ship detection matches the first statement against
 //   STMT_START + git <global flags> (merge --squash | push) | gh pr create
-// and discard against
-//   STMT_START + git <global flags> (worktree remove | branch -D)
-// with STMT_START from phase-tracker-helpers.ts:39.
+// with STMT_START from phase-tracker-helpers.ts.
+//
 // Default bucket globs (DEFAULT_TELEMETRY_BUCKETS): test = **/test/**, **/tests/**,
 // **/__tests__/**, **/*.test.*, **/*.spec.*, **/*_test.*; docs = **/*.md;
 // config = **/*.json, **/*.yaml, **/*.yml, **/*.toml, **/*.lock, **/*-lock.*; else code.
 
 import { isAbsolute, matchesGlob, relative, resolve } from "node:path";
-import { STMT_START } from "./phase-tracker-helpers.ts";
 import { buildTestCmdRegex } from "./gauntlet-settings.ts";
+import { STMT_START } from "./phase-tracker-helpers.ts";
 
 // ---- paths -------------------------------------------------------------------
 
@@ -40,34 +37,24 @@ export const planSpecHeader = (planBody: string): string | undefined => SPEC_HEA
 
 // ---- command matchers ----------------------------------------------------------
 
+const STATEMENT_END = /\n|;|&&|\|\||\|/;
+
+export const truncateCommand = (s: string): string => (s.length > 120 ? s.slice(0, 120) : s);
+export type ShipOption = "squash" | "pr";
+
 // `git <global flags> <subcommand>`: same flags-span grammar as parseGitCommand in
 // phase-tracker-helpers.ts, so `git -C <worktree> push` from the primary checkout counts.
 const GIT_FLAGS = "git\\s+(?:-\\S+(?:\\s+\\S+)?\\s+)*";
 const SHIP_RE = new RegExp(STMT_START + "(" + GIT_FLAGS + "(?:merge\\s+--squash|push)(?=\\s|$)|gh\\s+pr\\s+create)");
-const DISCARD_RE = new RegExp(STMT_START + "(" + GIT_FLAGS + "(?:worktree\\s+remove|branch\\s+-D)(?=\\s|$))");
 const SQUASH_RE = new RegExp("^" + GIT_FLAGS + "merge\\s+--squash");
-const STATEMENT_END = /\n|;|&&|\|\||\|/;
-
-export const truncateCommand = (s: string): string => (s.length > 120 ? s.slice(0, 120) : s);
-
-// The statement that begins at the regex's group-1 match, up to the next separator.
-function statementAt(command: string, re: RegExp): string | undefined {
-  const m = re.exec(command);
-  if (!m) return undefined;
-  const start = m.index + m[0].indexOf(m[1]);
-  return command.slice(start).split(STATEMENT_END)[0].trim();
-}
-
-export type ShipOption = "squash" | "pr";
 
 export function matchShipStatement(command: string): { option: ShipOption; statement: string } | undefined {
-  const statement = statementAt(command, SHIP_RE);
-  if (!statement) return undefined;
+  const m = SHIP_RE.exec(command);
+  if (!m) return undefined;
+  const statement = command.slice(m.index + m[0].indexOf(m[1])).split(STATEMENT_END)[0].trim();
   return { option: SQUASH_RE.test(statement) ? "squash" : "pr", statement };
 }
 
-export const matchDiscardStatement = (command: string): string | undefined => statementAt(command, DISCARD_RE);
-
 // First statement matching one of the resolved verifyBeforeShip.testCommands
 // fragments, using the same \b-anchored construction as verify-before-ship.ts.
 export function matchTestStatement(command: string, testCommands: string[]): string | undefined {
@@ -100,22 +87,6 @@ export function numstatPath(raw: string): string {
   return arrow >= 0 ? braced.slice(arrow + 4) : braced;
 }
 
-export function aggregateNumstat(numstat: string, files: Set<string>, buckets: [string, string[]][]): Record<string, BucketStat> {
-  const out: Record<string, BucketStat> = {};
-  for (const line of numstat.split("\n")) {
-    if (!line.trim()) continue;
-    const [ins, del, ...rest] = line.split("\t");
-    const path = numstatPath(rest.join("\t"));
-    if (!files.has(path)) continue;
-    const bucket = classifyBucket(path, buckets);
-    const stat = (out[bucket] ??= { files: 0, insertions: 0, deletions: 0 });
-    stat.files += 1;
-    stat.insertions += ins === "-" ? 0 : Number(ins) || 0;
-    stat.deletions += del === "-" ? 0 : Number(del) || 0;
-  }
-  return out;
-}
-
 export interface PatchRow {
   added: number;
   removed: number;

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

@@ -1,11 +1,9 @@
 import assert from "node:assert/strict";
 import { test } from "node:test";
-import { STMT_START } from "./phase-tracker-helpers.ts";
 import {
   capEvents, derive, diffPhases, emptyAccumulators, emptyPhases, foldAccumulators, implementAutoCompletes,
   newRecord, parseRecord, serializeRecord, type Accumulators, type TelemetryEvent,
 } from "./telemetry-record.ts";
-import { matchShipStatement } from "./telemetry-paths.ts";
 
 const ev = (over: Partial<TelemetryEvent> & { kind: string }): TelemetryEvent =>
   ({ ts: "2026-09-17T10:00:00Z", session: "s1", phase: "unphased", ...over }) as TelemetryEvent;
@@ -167,7 +165,3 @@ test("parseRecord drops malformed accumulator blocks and fills missing fields",
   assert.equal(derive(parsed, "2026-09-17T10:01:00Z").amendments, 2);
 });
 
-test("STMT_START-anchored matcher is the one used for ship detection", () => {
-  assert.ok(new RegExp(STMT_START + "git\\s+push").test("cd x && git push"));
-  assert.equal(matchShipStatement('rg "git push"'), undefined);
-});

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

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { test } from "node:test";
-import { BASE_REFS, guardReason, modifiedFilesFrom } from "./telemetry-ship.ts";
+import { guardReason, modifiedFilesFrom } from "./telemetry-ship.ts";
 
 test("guardReason names spec, timestamp and record path", () => {
   assert.equal(
@@ -17,7 +17,3 @@ test("modifiedFilesFrom drops the spec, doc/plans/**, and the telemetry dir; sor
   const namesWithWhitespace = " lead.ts\ntrail.ts \nREADME.md\n";
   assert.deepEqual(modifiedFilesFrom(namesWithWhitespace, "doc/specs/a.md", "t/"), [" lead.ts", "README.md", "trail.ts "]);
 });
-
-test("BASE_REFS order is origin/HEAD, main, master", () => {
-  assert.deepEqual(BASE_REFS, ["origin/HEAD", "main", "master"]);
-});

package/extensions/lib/telemetry-ship.ts

@@ -1,7 +1,4 @@
-// Pure ship-time helpers for the telemetry extension (#33): diff file filter,
-// base-ref candidates, guard block reason.
-
-export const BASE_REFS = ["origin/HEAD", "main", "master"] as const;
+// Pure ship-time helpers for the telemetry extension: diff file filter and guard block reason.
 
 export const guardReason = (spec: string, shippedAt: string, recordRel: string): string =>
   `spec ${spec} shipped at ${shippedAt} (record ${recordRel}). Write a new date-slugged spec that supersedes it instead of reusing this file.`;