pi-gauntlet 8.3.0 → 8.4.1

package/extensions/phase-tracker.ts

@@ -933,6 +933,7 @@ export default function (pi: ExtensionAPI) {
 
   pi.registerTool({
     name: "plan_check",
+    exposure: "model-only",
     label: "Plan Check",
     description:
       "Deterministically verify an implementation plan against its spec (mechanical checks); " +
@@ -1088,6 +1089,7 @@ export default function (pi: ExtensionAPI) {
 
   pi.registerTool({
     name: "phase_tracker",
+    exposure: "model-only",
     label: "Phase Tracker",
     description:
       "Track workflow phase progress (brainstorm → plan → implement → verify → ship); " +

package/extensions/plan-tracker.test.ts

@@ -15,6 +15,7 @@ function harness(branch: unknown[] = [], cwd = process.cwd()) {
   const tools: {
     name: string;
     description: string;
+    exposure?: string;
     executionMode?: string;
     parameters: any;
     execute: (...args: any[]) => unknown;
@@ -752,8 +753,9 @@ test("refresh rejects unreadable or malformed ledgers atomically, including abse
   }
 });
 
-test("registration: sequential, tasks schema is Array<Union<String, Object>>, description carries the contract", () => {
-  const { executionMode, parameters, description } = harness();
+test("registration: model-only, sequential, tasks schema is Array<Union<String, Object>>, description carries the contract", () => {
+  const { tool, executionMode, parameters, description } = harness();
+  assert.equal(tool().exposure, "model-only");
   assert.equal(executionMode(), "sequential");
   const tasksSchema = parameters().args[0].tasks.args[0];
   assert.equal(tasksSchema.kind, "Array");

package/extensions/plan-tracker.ts

@@ -237,6 +237,7 @@ export default function (pi: ExtensionAPI) {
 
   pi.registerTool({
     name: "plan_tracker",
+    exposure: "model-only",
     label: "Plan Tracker",
     description:
       "Track progress while EXECUTING an implementation plan (the implement phase), a verify-phase conformance fix wave, or another bounded gate checklist (e.g. pre-merge PR verification). Statuses: pending (not yet touched), in_progress (started; several at once is fine), complete, failed (terminal-negative: ran and did not pass; never counted done), skipped (terminal: not applicable in this run; counted done). Rule: pending tasks must trail every started or finished task - an update that would leave a pending task ahead of a non-pending one is rejected with the fix. update never sets pending; init and add do. Actions: init (set task list; elements are task-name strings or { name, status } to recreate a list with known statuses), add (append tasks as pending; existing statuses preserved), update (change task status), status (show current state), clear (remove plan), refresh (derive tasks from an artifact path while retaining other tasks). Do NOT use for brainstorming, research, or planning checklists: those phases are open-ended and a bounded task list misrepresents them as a fixed N-step process.",

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], []);
+  });
+}