pi-gauntlet 8.2.1 → 8.4.0

package/extensions/telemetry-leg-failures.test.ts

@@ -0,0 +1,138 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { chmodSync, mkdtempSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { after, test } from "node:test";
+import { parse } from "yaml";
+import type { Deps } from "./telemetry.ts";
+import { isolatedGitEnv } from "./test-support/git-env.mjs";
+import { resolveTelemetry } from "./lib/gauntlet-settings.ts";
+
+const gitEnv = isolatedGitEnv(mkdtempSync(join(tmpdir(), "telemetry-leg-failures-env-")));
+const originalGitEnv = Object.fromEntries(Object.keys(gitEnv).map(key => [key, process.env[key]]));
+Object.assign(process.env, gitEnv);
+// vcs.ts snapshots the environment at import time, including publisher subprocess settings.
+const { default: registerTelemetry, realDeps } = await import("./telemetry.ts");
+const { syncTelemetryBranch, TELEMETRY_REF } = await import("./lib/telemetry-branch.ts");
+
+const originalDepth = process.env.PI_SUBAGENT_DEPTH;
+process.env.PI_SUBAGENT_DEPTH = "0";
+after(() => {
+  for (const [key, value] of Object.entries(originalGitEnv)) {
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+  if (originalDepth === undefined) delete process.env.PI_SUBAGENT_DEPTH;
+  else process.env.PI_SUBAGENT_DEPTH = originalDepth;
+});
+
+function session(root: string, deps: Deps) {
+  const handlers = new Map<string, ((event: any, ctx: any) => unknown)[]>();
+  const transcript: any[] = [];
+  registerTelemetry({
+    on: (name: string, handler: (event: any, ctx: any) => unknown) => handlers.set(name, [...(handlers.get(name) ?? []), handler]),
+    sendMessage: (message: unknown) => transcript.push(message),
+  } as any, deps);
+  const ctx = { cwd: root, sessionManager: { getBranch: () => [], getSessionId: () => "failure-session" } };
+  const emit = async (name: string, event: unknown = {}) => {
+    for (const handler of handlers.get(name) ?? []) await handler(event, ctx);
+  };
+  const say = async (text: string) => {
+    const message = { role: "assistant", content: [{ type: "text", text }], usage: { input: 12, output: 4, cost: 0.125 } };
+    transcript.push(message);
+    await emit("message_end", { message });
+    return message;
+  };
+  return { emit, say, transcript };
+}
+
+const settings = (enabled: boolean) => ({
+  telemetry: resolveTelemetry({ telemetry: { enabled } }), specDirs: [], planDirs: [], errors: [], versions: { "pi-gauntlet": "8.2.1" },
+});
+
+for (const [skill, marker, row] of [
+  ["shape-ticket", "done", "#42: written"],
+  ["gatekeep-pr", "stuck", "#9@abc123: stuck - checks failed"],
+  ["check-delivery", "done", "#42: declined"],
+]) {
+  test(`${skill} disabled performs no file writes, fetches or pushes`, async () => {
+    const calls: unknown[] = [];
+    const forbidden = (...args: unknown[]): never => {
+      calls.push(args);
+      throw new Error("disabled telemetry attempted I/O");
+    };
+    const h = session(tmpdir(), {
+      fs: { readFile: forbidden, exists: forbidden, writeFile: forbidden, rename: forbidden, mkdirp: forbidden, unlink: forbidden },
+      git: forbidden, jj: forbidden, telemetryRepo: forbidden, readTelemetryBranch: forbidden, syncTelemetryBranch: forbidden,
+      now: () => "2026-11-06T12:34:56Z", settings: () => settings(false),
+    });
+    await h.emit("session_start");
+    await h.emit("input", { source: "interactive", text: `/skill:${skill}` });
+    await h.emit("before_agent_start", { messageType: "user", prompt: `<skill name="${skill}" location="/package/skills/${skill}/SKILL.md">` });
+    await h.emit("tool_call", { type: "tool_call", toolCallId: "load-skill", toolName: "read", input: { path: `/package/skills/${skill}/SKILL.md` } });
+    const message = await h.say(`gauntlet: ${marker} settled\n${row}`);
+    await h.emit("agent_settled", { aborted: false });
+    await h.emit("session_shutdown");
+    assert.deepEqual(calls, []);
+    assert.deepEqual(h.transcript, [message]);
+  });
+
+  test(`${skill} rejected push preserves settlement and local record with one retry`, async () => {
+    const scratch = mkdtempSync(join(tmpdir(), "telemetry-leg-failure-"));
+    const root = join(scratch, "product");
+    const origin = join(scratch, "origin.git");
+    mkdirSync(root);
+    const git = (cwd: string, ...args: string[]) => execFileSync("git", ["-C", cwd, "-c", "commit.gpgsign=false", ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+    git(scratch, "init", "--bare", origin);
+    git(root, "init", "-b", "feature/example");
+    git(root, "config", "user.name", "Leg Tester");
+    git(root, "config", "user.email", "leg@example.test");
+    git(root, "remote", "add", "origin", "https://example.test/team/product.git");
+    git(root, "config", `url.${origin}.insteadOf`, "https://example.test/team/product.git");
+    writeFileSync(join(root, "file.txt"), "base\n");
+    git(root, "add", "file.txt");
+    git(root, "commit", "-m", "initial");
+    const head = git(root, "rev-parse", "HEAD");
+    const index = readFileSync(join(root, ".git/index"));
+    assert.equal(syncTelemetryBranch(root, new Map([["team/product/seed.yaml", "seed: true\n"]])).pushed, true);
+    const remoteBefore = git(origin, "rev-parse", TELEMETRY_REF);
+    const pushLog = join(scratch, "pushes");
+    const fetchLog = join(scratch, "fetches");
+    const hook = join(origin, "hooks/pre-receive");
+    writeFileSync(hook, `#!/bin/sh\necho push >> '${pushLog}'\necho 'rejected by fixture' >&2\nexit 1\n`);
+    chmodSync(hook, 0o755);
+    const upload = join(scratch, "upload-pack");
+    writeFileSync(upload, `#!/bin/sh\necho fetch >> '${fetchLog}'\nexec git-upload-pack "$@"\n`);
+    chmodSync(upload, 0o755);
+    git(root, "config", "remote.origin.uploadpack", `'${upload}'`);
+    const h = session(root, { ...realDeps, now: () => "2026-11-06T12:34:56Z", settings: () => settings(true) });
+    await h.emit("session_start");
+    await h.emit("input", { source: "interactive", text: `/skill:${skill}` });
+    const text = `gauntlet: ${marker} settled\n${row}`;
+    const message = await h.say(text);
+    await h.emit("agent_settled", { aborted: false });
+    await h.emit("agent_settled", { aborted: false });
+    await h.emit("session_shutdown");
+    assert.equal(readFileSync(pushLog, "utf8"), "push\npush\n", "initial push and exactly one retry");
+    assert.equal(readFileSync(fetchLog, "utf8"), "fetch\nfetch\n", "initial fetch and exactly one replay refresh");
+    assert.equal(h.transcript.length, 2);
+    assert.deepEqual(h.transcript[0], message);
+    assert.equal(message.content[0].text, text, "telemetry must not rewrite the menu outcome");
+    assert.equal(h.transcript[1].customType, "telemetry-warning");
+    assert.equal(h.transcript[1].display, true);
+    assert.match(h.transcript[1].content, /^telemetry: not pushed \(remote: rejected by fixture\s*\)$/);
+    const path = `team/product/${skill}/20261106T123456Z-failure-session.yaml`;
+    const bytes = git(root, "show", `${TELEMETRY_REF}:${path}`);
+    const record = parse(bytes);
+    assert.equal(record.cost, 0.125);
+    assert.equal(record.items[0].outcome, row.slice(row.indexOf(": ") + 2));
+    assert.equal(git(origin, "rev-parse", TELEMETRY_REF), remoteBefore);
+    assert.equal(git(root, "rev-parse", "HEAD"), head);
+    assert.deepEqual(readFileSync(join(root, ".git/index")), index);
+    assert.equal(readFileSync(join(root, "file.txt"), "utf8"), "base\n");
+    writeFileSync(hook, "#!/bin/sh\nexit 0\n");
+    assert.equal(syncTelemetryBranch(root, new Map()).pushed, true, "next push recovers the retained record without a new settlement");
+    assert.equal(git(origin, "show", `${TELEMETRY_REF}:${path}`), bytes);
+  });
+}

package/extensions/telemetry-leg-fields.test.ts

@@ -0,0 +1,130 @@
+import assert from "node:assert/strict";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { after, test } from "node:test";
+import { parse } from "yaml";
+import registerTelemetry, { realFs, type Deps } from "./telemetry.ts";
+import { resolveTelemetry } from "./lib/gauntlet-settings.ts";
+import { settlementItems } from "./lib/telemetry-leg.ts";
+
+const originalDepth = process.env.PI_SUBAGENT_DEPTH;
+process.env.PI_SUBAGENT_DEPTH = "0";
+after(() => {
+  if (originalDepth === undefined) delete process.env.PI_SUBAGENT_DEPTH;
+  else process.env.PI_SUBAGENT_DEPTH = originalDepth;
+});
+
+function harness() {
+  const root = mkdtempSync(join(tmpdir(), "telemetry-fields-"));
+  const handlers = new Map<string, ((event: any, ctx: any) => unknown)[]>();
+  const writes: { path: string; record: any }[] = [];
+  const deps: Deps = {
+    fs: realFs,
+    now: () => "2026-11-06T12:34:56Z",
+    settings: () => ({ telemetry: resolveTelemetry({}), specDirs: [], planDirs: [], errors: [], versions: { "pi-gauntlet": "8.2.1" } }),
+    git: async (args) => ({ code: 0, stderr: "", stdout: args[0] === "config"
+      ? args[1] === "user.name" ? "Observed Author\n" : "author@example.test\n"
+      : `${root}\n${root}/.git\n${root}/.git\n` }),
+    telemetryRepo: () => "team/product",
+    syncTelemetryBranch: (_root, records) => {
+      for (const [path, bytes] of records) writes.push({ path, record: parse(bytes) });
+      return { ok: true, committed: true, pushed: true };
+    },
+  };
+  const ctx = { cwd: root, model: { provider: "test", id: "initial" }, sessionManager: { getBranch: () => [], getSessionId: () => "observed-session" } };
+  registerTelemetry({
+    on: (name: string, handler: (event: any, ctx: any) => unknown) => handlers.set(name, [...(handlers.get(name) ?? []), handler]),
+    sendMessage: () => {},
+  } as any, deps);
+  const emit = async (name: string, event: unknown = {}) => {
+    for (const handler of handlers.get(name) ?? []) await handler(event, ctx);
+  };
+  const say = (text: string, usage?: unknown) => emit("message_end", { message: {
+    role: "assistant", provider: "test", model: "response", content: [{ type: "text", text }], usage,
+  } });
+  return { emit, say, writes };
+}
+
+for (const [skill, line, item] of [
+  ["shape-ticket", "#42: written", { kind: "ticket", key: "#42", outcome: "written" }],
+  ["gatekeep-pr", "#42@aBc123: approved (#17)", { kind: "pr", key: "#42@aBc123", ticket: "#17", outcome: "approved" }],
+  ["check-delivery", "ENG-17: already recorded", { kind: "ticket", key: "ENG-17", outcome: "already recorded" }],
+] as const) {
+  test(`${skill} record fields use observations, never assistant claims`, async () => {
+    const h = harness();
+    await h.emit("session_start");
+    await h.say("Not part of this leg", { input: 999, cost: 999 });
+    await h.emit("input", { source: "interactive", text: `/skill:${skill}` });
+    await h.say("Assessing", { input: 10, output: 2, cacheRead: 30, cacheWrite: 4, cost: { total: 0.25 } });
+    await h.emit("model_select", { model: { provider: "test", id: "selected" } });
+    await h.say(`gauntlet: done settled\n${line}\nworktree: done\n#### #55\nsession: forged\nauthor: forged\ngauntlet_version: forged\nmodels: forged\nrepo: forged\nts: forged\ntokens: 999\ncost: 999`,
+      { input: 20, output: 3, cacheRead: 40, cacheWrite: 5, cost: 0.5 });
+    await h.emit("agent_settled", { aborted: false });
+    assert.equal(h.writes.length, 1);
+    assert.equal(h.writes[0].path, `team/product/${skill}/20261106T123456Z-observed-session.yaml`);
+    assert.deepEqual(h.writes[0].record, {
+      skill, session: "observed-session", author: { name: "Observed Author", email: "author@example.test" },
+      gauntlet_version: "8.2.1", models: ["test/initial", "test/response", "test/selected"],
+      tokens: { input: 30, output: 5, cache_read: 70, cache_write: 9 }, cost: 0.75,
+      repo: "team/product", ts: "2026-11-06T12:34:56Z", items: [item],
+    });
+  });
+}
+
+test("shape-ticket includes council member usage once through the run dispatch reducer", async () => {
+  const h = harness();
+  await h.emit("session_start");
+  await h.emit("input", { source: "interactive", text: "/skill:shape-ticket" });
+  await h.say("Roasting", { input: 5, output: 2, cost: { total: 0.25 } });
+  await h.emit("tool_result", {
+    toolName: "subagent", isError: false, content: [], details: { results: [
+      { agent: "spec-council-member", model: "test/member-one", exitCode: 0, usage: { input: 10, output: 3, cacheRead: 7, cacheWrite: 1, cost: { total: 0.5 } } },
+      { agent: "spec-council-member", model: "test/member-two", exitCode: 1, usage: { input: 20, output: 4, cacheRead: 8, cacheWrite: 2, cost: 0.75 } },
+    ] },
+  });
+  await h.say("gauntlet: done written\n#42: written", { input: 6, output: 1, cost: 0.125 });
+  await h.emit("agent_settled", { aborted: false });
+  assert.equal(h.writes.length, 1);
+  assert.deepEqual(h.writes[0].record.tokens, { input: 41, output: 10, cache_read: 15, cache_write: 3 });
+  assert.equal(h.writes[0].record.cost, 1.625);
+  assert.deepEqual(h.writes[0].record.models, ["test/initial", "test/response", "test/member-one", "test/member-two"]);
+});
+
+for (const [skill, lines, keys] of [
+  ["shape-ticket", ["#11: written", "#12: declined", "#13: no-op"], ["#11", "#12", "#13"]],
+  ["gatekeep-pr", ["#11@abcd: approved", "#12@dcba: stopped"], ["#11@abcd", "#12@dcba"]],
+  ["check-delivery", ["ENG-11: delivered", "ENG-12: declined"], ["ENG-11", "ENG-12"]],
+] as const) {
+  test(`${skill} batches all settled refs into one cost-conserving record`, async () => {
+    const h = harness();
+    await h.emit("session_start");
+    await h.emit("input", { source: "interactive", text: `/skill:${skill}` });
+    await h.say("Assessing the set", { input: 5, cost: 0.25 });
+    await h.emit("tool_result", {
+      toolName: "subagent", isError: false, content: [], details: { results: [
+        { agent: "reviewer", model: "test/child", exitCode: 0, usage: { output: 7, cost: { total: 0.5 } } },
+      ] },
+    });
+    await h.say(`gauntlet: done settled\n${lines.join("\n")}`, { input: 3, output: 2, cost: 0.125 });
+    await h.emit("agent_settled", { aborted: false });
+    await h.emit("agent_settled", { aborted: false });
+    assert.equal(h.writes.length, 1);
+    assert.deepEqual(h.writes[0].record.items.map((item: any) => item.key), keys);
+    assert.deepEqual(h.writes[0].record.tokens, { input: 8, output: 9, cache_read: 0, cache_write: 0 });
+    assert.equal(h.writes[0].record.cost, 0.875);
+  });
+}
+
+test("settlement items preserve identity, ticket annotations and complete outcome tokens", () => {
+  for (const [skill, line, expected] of [
+    ["shape-ticket", "team/product#42: close failed (comment: permission denied)", { kind: "ticket", key: "team/product#42", outcome: "close failed (comment: permission denied)" }],
+    ["shape-ticket", "Create: a useful title: dropped", { kind: "ticket", outcome: "dropped" }],
+    ["shape-ticket", "https://example.test/team/product/issues/42: close by hand", { kind: "ticket", key: "https://example.test/team/product/issues/42", outcome: "close by hand" }],
+    ["gatekeep-pr", "#42@abcd: stuck - check: failed (ENG-17)", { kind: "pr", key: "#42@abcd", ticket: "ENG-17", outcome: "stuck - check: failed" }],
+    ["gatekeep-pr", "#43@dcba: merged", { kind: "pr", key: "#43@dcba", outcome: "merged" }],
+    ["check-delivery", "https://linear.app/team/issue/ENG-17/title: failed - deploy: missing", { kind: "ticket", key: "https://linear.app/team/issue/ENG-17/title", outcome: "failed - deploy: missing" }],
+  ] as const) {
+    assert.deepEqual(settlementItems(skill, `gauntlet: done settled\n${line}\nworktree: done\n#### #90\nSome prose: written`), [expected]);
+  }
+});

package/extensions/telemetry-leg-no-write.test.ts

@@ -0,0 +1,90 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { after, test } from "node:test";
+import { parse } from "yaml";
+import registerTelemetry, { realFs, type Deps } from "./telemetry.ts";
+import { resolveTelemetry } from "./lib/gauntlet-settings.ts";
+
+const originalDepth = process.env.PI_SUBAGENT_DEPTH;
+process.env.PI_SUBAGENT_DEPTH = "0";
+after(() => {
+  if (originalDepth === undefined) delete process.env.PI_SUBAGENT_DEPTH;
+  else process.env.PI_SUBAGENT_DEPTH = originalDepth;
+});
+
+for (const [skill, row, expected] of [
+  ["shape-ticket", "#42: declined", { kind: "ticket", key: "#42", outcome: "declined" }],
+  ["shape-ticket", "#42: no-op", { kind: "ticket", key: "#42", outcome: "no-op" }],
+  ["gatekeep-pr", "#42@abc123: stopped", { kind: "pr", key: "#42@abc123", outcome: "stopped" }],
+  ["check-delivery", "#42: declined", { kind: "ticket", key: "#42", outcome: "declined" }],
+  ["shape-ticket", "Uncreated ticket: declined", { kind: "ticket", outcome: "declined" }],
+  ["shape-ticket", "Uncreated ticket: dropped", { kind: "ticket", outcome: "dropped" }],
+] as const) {
+  test(`${skill} ${row} records without tracker or checkout writes`, async () => {
+    const root = mkdtempSync(join(tmpdir(), "telemetry-no-write-"));
+    const trackerPath = join(root, "tracker.json");
+    writeFileSync(trackerPath, JSON.stringify({
+      ticket: { body: "Ticket body\n", state: "open", labels: ["bug"], reviews: [] },
+      pr: { body: "PR body\n", state: "open", labels: ["review"], reviews: [{ state: "COMMENTED", body: "Keep this review\n" }] },
+    }, null, 2));
+    const before = readFileSync(trackerPath);
+    const records = new Map<string, string>();
+    const writes: unknown[] = [];
+    const warnings: unknown[] = [];
+    const handlers = new Map<string, ((event: any, ctx: any) => unknown)[]>();
+    const forbidden = (...args: unknown[]): never => {
+      writes.push(args);
+      throw new Error("no-write settlement attempted a non-telemetry write");
+    };
+    let pushes = 0;
+    const deps: Deps = {
+      fs: { ...realFs, writeFileSync: forbidden, renameSync: forbidden, mkdirSync: forbidden, unlinkSync: forbidden },
+      now: () => "2026-11-06T12:34:56.123Z",
+      settings: () => ({ telemetry: resolveTelemetry({}), specDirs: [], planDirs: [], errors: [], versions: { "pi-gauntlet": "8.2.1" } }),
+      git: async (args) => {
+        if (args[0] === "rev-parse") return { code: 0, stdout: `${root}\n${root}/.git\n${root}/.git\n`, stderr: "" };
+        if (args[0] === "config" && args.length === 2 && ["user.name", "user.email"].includes(args[1])) {
+          return { code: 0, stdout: "Tester\n", stderr: "" };
+        }
+        return forbidden(args);
+      },
+      telemetryRepo: () => "team/product",
+      syncTelemetryBranch: (_root, incoming) => {
+        pushes++;
+        for (const [path, bytes] of incoming) records.set(path, bytes);
+        return { ok: true, committed: true, pushed: true };
+      },
+    };
+    registerTelemetry({
+      on: (name: string, handler: (event: any, ctx: any) => unknown) => handlers.set(name, [...(handlers.get(name) ?? []), handler]),
+      exec: forbidden,
+      sendMessage: (message: unknown) => warnings.push(message),
+    } as any, deps);
+    const ctx = { cwd: root, sessionManager: { getBranch: () => [], getSessionId: () => "no-write-session" } };
+    const emit = async (name: string, event: unknown = {}) => {
+      for (const handler of handlers.get(name) ?? []) await handler(event, ctx);
+    };
+    await emit("session_start");
+    await emit("input", { source: "interactive", text: `/skill:${skill}` });
+    await emit("message_end", { message: {
+      role: "assistant", content: [{ type: "text", text: `gauntlet: done settled\n${row}` }],
+      usage: { input: 12, output: 4, cost: 0.125 },
+    } });
+    assert.equal(records.size, 0, "only settlement may publish the record");
+    await emit("agent_settled", { aborted: false });
+    await emit("agent_settled", { aborted: false });
+    assert.equal(pushes, 1);
+    assert.equal(records.size, 1);
+    const path = `team/product/${skill}/20261106T123456.123Z-no-write-session.yaml`;
+    const record = parse(records.get(path)!);
+    assert.deepEqual(record.items, [expected]);
+    assert.equal(record.cost, 0.125);
+    assert.equal(record.tokens.input, 12);
+    assert.equal(record.tokens.output, 4);
+    assert.deepEqual(writes, [], "no tracker command or checkout write may accompany telemetry");
+    assert.deepEqual(warnings, []);
+    assert.deepEqual(readFileSync(trackerPath), before, "ticket and PR body, state, labels and reviews remain byte-identical");
+  });
+}

package/extensions/telemetry-leg-rounds.test.ts

@@ -0,0 +1,157 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { after, test } from "node:test";
+import { parse, stringify } from "yaml";
+import type { Deps } from "./telemetry.ts";
+import { isolatedGitEnv } from "./test-support/git-env.mjs";
+import { resolveTelemetry } from "./lib/gauntlet-settings.ts";
+
+const gitEnv = isolatedGitEnv(mkdtempSync(join(tmpdir(), "telemetry-leg-rounds-env-")));
+const originalGitEnv = Object.fromEntries(Object.keys(gitEnv).map(key => [key, process.env[key]]));
+Object.assign(process.env, gitEnv);
+// vcs.ts snapshots the environment at import time, including publisher subprocess settings.
+const { default: registerTelemetry, realFs } = await import("./telemetry.ts");
+
+const originalDepth = process.env.PI_SUBAGENT_DEPTH;
+process.env.PI_SUBAGENT_DEPTH = "0";
+after(() => {
+  for (const [key, value] of Object.entries(originalGitEnv)) {
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+  if (originalDepth === undefined) delete process.env.PI_SUBAGENT_DEPTH;
+  else process.env.PI_SUBAGENT_DEPTH = originalDepth;
+});
+
+test("a plain follow-up can load another skill without losing provisional usage", async () => {
+  const root = mkdtempSync(join(tmpdir(), "telemetry-switch-"));
+  const records = new Map<string, string>();
+  const handlers = new Map<string, ((event: any, ctx: any) => unknown)[]>();
+  let round = 0;
+  registerTelemetry({
+    on: (name: string, handler: (event: any, ctx: any) => unknown) => handlers.set(name, [...(handlers.get(name) ?? []), handler]),
+    sendMessage: () => {},
+  } as any, {
+    fs: realFs, now: () => `2026-11-06T12:34:5${round}Z`,
+    settings: () => ({ telemetry: resolveTelemetry({}), specDirs: [], planDirs: [], errors: [], versions: {} }),
+    git: async (args) => ({ code: 0, stderr: "", stdout: args[0] === "config" ? "Tester\n" : `${root}\n${root}/.git\n${root}/.git\n` }),
+    telemetryRepo: () => "team/product",
+    syncTelemetryBranch: (_root, incoming) => {
+      for (const [path, bytes] of incoming) records.set(path, bytes);
+      return { ok: true, committed: true, pushed: true };
+    },
+  });
+  const ctx = { cwd: root, sessionManager: { getBranch: () => [], getSessionId: () => "same-session" } };
+  const emit = async (name: string, event: unknown = {}) => {
+    for (const handler of handlers.get(name) ?? []) await handler(event, ctx);
+  };
+  const say = (text: string, input: number, cost: number) => emit("message_end", {
+    message: { role: "assistant", content: [{ type: "text", text }], usage: { input, cost } },
+  });
+  await emit("session_start");
+  await emit("input", { source: "interactive", text: "/skill:shape-ticket" });
+  await say("gauntlet: done settled\n#42: written", 1, 0.1);
+  await emit("agent_settled", { aborted: false });
+  round++;
+  await emit("before_agent_start", { messageType: "user", prompt: "Review PR 7" });
+  await say("I'll load the PR review skill.", 2, 0.25);
+  await emit("tool_call", { type: "tool_call", toolCallId: "load-skill", toolName: "read", input: { path: "skills/gatekeep-pr/SKILL.md" } });
+  await say("gauntlet: done settled\n#7@abc123: approved (#42)", 3, 0.5);
+  await emit("agent_settled", { aborted: false });
+  const rows = [...records.values()].map(bytes => parse(bytes));
+  assert.deepEqual(rows.map(row => row.skill), ["shape-ticket", "gatekeep-pr"]);
+  assert.deepEqual(rows[1].items, [{ kind: "pr", key: "#7@abc123", ticket: "#42", outcome: "approved" }]);
+  assert.equal(rows[1].tokens.input, 5);
+  assert.equal(rows[1].cost, 0.75);
+  assert.match([...records.keys()][1], /\/gatekeep-pr\//);
+});
+
+for (const [skill, section, lines] of [
+  ["shape-ticket", "tickets", ["#42: written", "team/product#42: no-op", "https://example.test/team/product/issues/42: written"]],
+  ["gatekeep-pr", "prs", ["#42@abc123: approved", "https://example.test/team/product/pull/42@def456: merged", "#42@fed321: approved"]],
+] as const) {
+  test(`${skill} repeats append distinct records and digest chronological rounds`, async () => {
+    const root = mkdtempSync(join(tmpdir(), "telemetry-rounds-"));
+    const records = new Map<string, string>();
+    const handlers = new Map<string, ((event: any, ctx: any) => unknown)[]>();
+    let round = 0;
+    const timestamps = ["2026-11-06T12:34:56.001Z", "2026-11-06T12:34:56.002Z", "2026-11-06T12:34:56.002Z"];
+    const deps: Deps = {
+      fs: realFs, now: () => timestamps[round],
+      settings: () => ({ telemetry: resolveTelemetry({}), specDirs: [], planDirs: [], errors: [], versions: { "pi-gauntlet": "8.2.1" } }),
+      git: async (args) => ({ code: 0, stderr: "", stdout: args[0] === "config" ? "Tester\n" : `${root}\n${root}/.git\n${root}/.git\n` }),
+      telemetryRepo: () => "team/product",
+      syncTelemetryBranch: (_root, incoming) => {
+        for (const [path, bytes] of incoming) records.set(path, bytes);
+        return { ok: true, committed: true, pushed: true };
+      },
+    };
+    registerTelemetry({
+      on: (name: string, handler: (event: any, ctx: any) => unknown) => handlers.set(name, [...(handlers.get(name) ?? []), handler]),
+      sendMessage: () => {},
+    } as any, deps);
+    const ctx = { cwd: root, sessionManager: { getBranch: () => [], getSessionId: () => round < 2 ? "same-session" : "third-session" } };
+    const emit = async (name: string, event: unknown = {}) => {
+      for (const handler of handlers.get(name) ?? []) await handler(event, ctx);
+    };
+    await emit("session_start");
+    for (round = 0; round < lines.length; round++) {
+      if (round === 2) {
+        await emit("before_agent_start", { messageType: "user", prompt: "What is the weather?" });
+        await emit("message_end", { message: { role: "assistant", content: [{ type: "text", text: "It is sunny." }] } });
+        await emit("agent_settled", { aborted: false });
+        assert.equal(records.size, 2, "an unrelated follow-up without settlement writes nothing");
+        await emit("session_switch");
+        await emit("before_agent_start", { messageType: "user", prompt: "Check that again" });
+        await emit("message_end", { message: { role: "assistant", content: [{ type: "text", text: `gauntlet: done settled\n${lines[round]}` }] } });
+        await emit("agent_settled", { aborted: false });
+        assert.equal(records.size, 2, "session navigation clears the remembered skill");
+      }
+      if (round === 1) {
+        await emit("input", { source: "interactive", text: "Check that again" });
+        await emit("before_agent_start", { messageType: "user", prompt: "Check that again" });
+      } else {
+        await emit("input", { source: "interactive", text: `/skill:${skill}` });
+      }
+      await emit("message_end", { message: { role: "assistant", content: [{ type: "text", text: `gauntlet: done settled\n${lines[round]}` }], usage: { input: round + 1, cost: 0.25 } } });
+      await emit("agent_settled", { aborted: false });
+      assert.equal(records.size, round + 1, "repeating in one second must not overwrite an earlier leg");
+    }
+    assert.deepEqual([...records.values()].map(bytes => parse(bytes).tokens.input), [1, 2, 3], "each leg starts with fresh counters");
+    const write = (path: string, bytes: string) => {
+      mkdirSync(dirname(path), { recursive: true });
+      writeFileSync(path, bytes);
+    };
+    // Reverse file order and repeat the corpus to exercise chronological sorting and identity deduplication.
+    for (const [i, bytes] of [...records.values()].reverse().entries()) write(join(root, `round-${i}.yaml`), bytes);
+    const first = parse([...records.values()][0]);
+    write(join(root, "z-duplicate.yaml"), stringify(first));
+    const other = { ...first, repo: "other/product", session: "other-session", items: [{ ...first.items[0], key: "#42" }] };
+    write(join(root, "a-other-repo.yaml"), stringify(other));
+    write(join(root, "bad-leg.yaml"), stringify({ skill, ts: timestamps[0] }));
+    const cli = new URL("../src/bins/gauntlet-performance.mjs", import.meta.url).pathname;
+    const invoke = (args: string[], entrypoint = cli) => {
+      const result = spawnSync(process.execPath, [entrypoint, "--dir", root, ...args], { encoding: "utf8" });
+      assert.equal(result.status, 0, result.stderr);
+      return result.stdout;
+    };
+    const digest = JSON.parse(invoke(["--dir", root, "--json"]));
+    assert.deepEqual(JSON.parse(invoke(["--dir", root, "--json"], new URL("../bin/gauntlet-performance.mjs", import.meta.url).pathname)), digest);
+    assert.equal(digest.runs.length, 0, "legs are not brainstorming runs");
+    assert.equal(digest[section].length, 2, "repo-local numbers must not merge across repositories");
+    const group = digest[section].find((row: any) => row.repo === "team/product");
+    assert.equal(group.key, "team/product#42");
+    assert.equal(group.rounds.length, 3, "a different head or session is another round of the same ref");
+    assert.deepEqual(group.rounds.map((r: any) => [r.session, r.ts, r.items[0].outcome]), [
+      ["same-session", timestamps[0], skill === "shape-ticket" ? "written" : "approved"],
+      ["same-session", timestamps[1], skill === "shape-ticket" ? "no-op" : "merged"],
+      ["third-session", timestamps[2], skill === "shape-ticket" ? "written" : "approved"],
+    ]);
+    assert.equal(digest.skipped.filter((s: any) => s.reason === "not a leg record").length, 2);
+    assert.match(invoke([]), new RegExp(`${section}\\n[\\s\\S]*team/product#42\\s+3`));
+    assert.deepEqual(JSON.parse(invoke(["--since", "8.2.2", "--json"]))[section], []);
+  });
+}

package/extensions/telemetry-leg-trackers.test.ts

@@ -0,0 +1,114 @@
+import assert from "node:assert/strict";
+import { after, test } from "node:test";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { parse } from "yaml";
+import registerTelemetry, { type Deps } from "./telemetry.ts";
+import { resolveTelemetry } from "./lib/gauntlet-settings.ts";
+import type { LegRecord } from "./lib/telemetry-leg.ts";
+
+const originalDepth = process.env.PI_SUBAGENT_DEPTH;
+process.env.PI_SUBAGENT_DEPTH = "0";
+after(() => {
+  if (originalDepth === undefined) delete process.env.PI_SUBAGENT_DEPTH;
+  else process.env.PI_SUBAGENT_DEPTH = originalDepth;
+});
+
+const root = mkdtempSync(join(tmpdir(), "telemetry-trackers-"));
+const overrides = (tracker: string) => `# Project overrides\n\n## Issue tracker\n\n- tracker: ${tracker}\n- refs: prose, not a regular expression\n\n## Other settings\n- tracker: none\n`;
+
+async function settle(skill: string, rows: string[], files: Record<string, string>) {
+  const handlers = new Map<string, ((event: any, ctx: any) => unknown)[]>();
+  const publications = new Map<string, string>();
+  const warnings: unknown[] = [];
+  const forbiddenCalls: unknown[] = [];
+  const forbidden = (...args: unknown[]): never => {
+    forbiddenCalls.push(args);
+    throw new Error("telemetry must not call a tracker or write to the checkout");
+  };
+  const deps: Deps = {
+    fs: {
+      readFile: (path) => files[path], exists: (path) => path in files,
+      writeFile: forbidden, rename: forbidden, mkdirp: forbidden, unlink: forbidden,
+    },
+    now: () => "2026-11-06T12:34:56Z",
+    settings: () => ({ telemetry: resolveTelemetry({}), specDirs: [], planDirs: [], errors: [], versions: { "pi-gauntlet": "8.2.1" } }),
+    git: async (args, cwd) => {
+      assert.equal(cwd, root);
+      if (args[0] === "rev-parse") return { code: 0, stdout: `${root}\n${root}/.git\n${root}/.git\n`, stderr: "" };
+      if (args[0] === "config" && args.length === 2 && ["user.name", "user.email"].includes(args[1])) {
+        return { code: 0, stdout: "Tester\n", stderr: "" };
+      }
+      return forbidden(args);
+    },
+    telemetryRepo: () => "team/product",
+    syncTelemetryBranch: (cwd, incoming) => {
+      assert.equal(cwd, root);
+      for (const [path, bytes] of incoming) {
+        assert.equal(publications.has(path), false, "one publication per settlement");
+        publications.set(path, bytes);
+      }
+      return { ok: true, committed: true, pushed: true };
+    },
+  };
+  registerTelemetry({
+    on: (name: string, handler: (event: any, ctx: any) => unknown) => handlers.set(name, [...(handlers.get(name) ?? []), handler]),
+    exec: forbidden,
+    sendMessage: (message: unknown) => warnings.push(message),
+  } as any, deps);
+  const ctx = { cwd: root, sessionManager: { getBranch: () => [], getSessionId: () => "tracker-session" } };
+  const emit = async (name: string, event: unknown = {}) => {
+    for (const handler of handlers.get(name) ?? []) await handler(event, ctx);
+  };
+  await emit("session_start");
+  await emit("input", { source: "interactive", text: `/skill:${skill} ${rows.join("\n")}` });
+  await emit("message_end", { message: {
+    role: "assistant", provider: "fixture", model: "model", usage: { input: 12, output: 4, cost: 0.125 },
+    content: [{ type: "text", text: ["gauntlet: done settled", ...rows, "worktree: done", "#### heading: written", "Closing prose."].join("\n") }],
+  } });
+  assert.equal(publications.size, 0);
+  await emit("agent_settled", { aborted: false });
+  await emit("agent_settled", { aborted: false });
+  assert.deepEqual(forbiddenCalls, [], "tracker commands and non-telemetry writes are forbidden");
+  assert.deepEqual(warnings, []);
+  return [...publications].map(([path, bytes]) => ({ path, record: parse(bytes) as LegRecord }));
+}
+
+for (const [skill, outcome] of [["shape-ticket", "written"], ["gatekeep-pr", "approved"], ["check-delivery", "delivered"]] as const) {
+  test(`${skill} differs only in item refs across GitHub, Linear and no tracker`, async () => {
+    let baseline: unknown;
+    for (const [tracker, ref] of [["github", "#42"], ["linear", "OPS-42"], ["none", "local/backlog: rollout 7"]]) {
+      const pr = skill === "gatekeep-pr";
+      const key = pr ? "#9@abc123" : ref;
+      const row = `${key}: ${outcome}${pr ? ` (${ref})` : ""}`;
+      const records = await settle(skill, [row], { [`${root}/.pi/gauntlet-overrides.md`]: overrides(tracker) });
+      assert.equal(records.length, 1, `${tracker} must publish the leg`);
+      const { record } = records[0];
+      assert.deepEqual(record.items, [{ kind: pr ? "pr" : "ticket", key, ...(pr ? { ticket: ref } : {}), outcome }]);
+      assert.equal(record.cost, 0.125);
+      assert.equal(record.tokens.input, 12);
+      const normalized = { ...records[0], record: { ...record, items: record.items.map(({ key, ticket, ...item }) => item) } };
+      if (baseline) assert.deepEqual(normalized, baseline, "tracker selection must not alter measured fields or record path");
+      else baseline = normalized;
+    }
+  });
+}
+
+for (const [name, files, acceptsTypedRef] of [
+  ["root fallback", { "gauntlet-overrides.md": overrides("none") }, true],
+  ["doc fallback", { "doc/gauntlet-overrides.md": overrides("none") }, true],
+  ["first file wins", { ".pi/gauntlet-overrides.md": overrides("github"), "gauntlet-overrides.md": overrides("none") }, false],
+  ["first file lacks tracker section", { ".pi/gauntlet-overrides.md": "## Other settings\n- tracker: none\n", "doc/gauntlet-overrides.md": overrides("none") }, false],
+  ["no overrides", {}, false],
+] as const) {
+  test(`tracker selection: ${name}`, async () => {
+    const records = await settle("check-delivery", ["#42: delivered", "local/backlog: rollout 7: delivered"],
+      Object.fromEntries(Object.entries(files).map(([path, content]) => [`${root}/${path}`, content])));
+    assert.equal(records.length, 1);
+    assert.deepEqual(records[0].record.items, [
+      { kind: "ticket", key: "#42", outcome: "delivered" },
+      ...(acceptsTypedRef ? [{ kind: "ticket", key: "local/backlog: rollout 7", outcome: "delivered" }] : []),
+    ]);
+  });
+}