pi-gauntlet 8.3.0 → 8.4.0

package/extensions/lib/gauntlet-settings.test.ts

@@ -12,7 +12,6 @@ import {
   planDirsFor,
   resolveVerifyBeforeShip,
   resolveTelemetry,
-  DEFAULT_TELEMETRY_DIR,
   DEFAULT_TELEMETRY_BUCKETS,
   DEFAULT_TEST_COMMANDS,
   buildTestCmdRegex,
@@ -250,11 +249,10 @@ test("verifyBeforeShip: default vs override", () => {
   assert.equal(o.warningReference, "doc/t.md");
 });
 
-test("telemetry: absent block -> enabled, default dir, default buckets, no warning", () => {
+test("telemetry: absent block -> enabled, default buckets, no directory key or warning", () => {
   const r = resolveTelemetry({});
   assert.equal(r.enabled, true);
-  assert.equal(r.dir, DEFAULT_TELEMETRY_DIR);
-  assert.equal(r.dir, ".pi/gauntlet/telemetry");
+  assert.equal("dir" in r, false);
   assert.deepEqual(r.buckets, DEFAULT_TELEMETRY_BUCKETS);
   assert.equal(r.warning, undefined);
 });
@@ -265,10 +263,10 @@ test("telemetry: enabled false is the only way to disable", () => {
   assert.equal(resolveTelemetry({ telemetry: { enabled: 0 } }).enabled, true);
 });
 
-test("telemetry: dir accepts a non-empty relative path, otherwise default + warning", () => {
-  assert.equal(resolveTelemetry({ telemetry: { dir: "telemetry/" } }).dir, "telemetry");
-  assert.equal(resolveTelemetry({ telemetry: { dir: "a/../b" } }).dir, "b");
-  for (const bad of [
+test("telemetry: retired dir setting is ignored with one migration warning", () => {
+  for (const dir of [
+    "telemetry/",
+    "a/../b",
     "",
     "   ",
     5,
@@ -284,9 +282,9 @@ test("telemetry: dir accepts a non-empty relative path, otherwise default + warn
     "a/../../outside",
     "..",
   ]) {
-    const r = resolveTelemetry({ telemetry: { dir: bad } });
-    assert.equal(r.dir, DEFAULT_TELEMETRY_DIR);
-    assert.match(r.warning ?? "", /telemetry\.dir/);
+    const r = resolveTelemetry(mergeGauntlet(undefined, { telemetry: { dir } }));
+    assert.equal("dir" in r, false);
+    assert.equal(r.warning, "piGauntlet.telemetry.dir is retired; records live on the gauntlet/telemetry branch - set piGauntlet.telemetry.remote to redirect them");
   }
 });
 
@@ -307,9 +305,9 @@ test("telemetry: malformed buckets -> default + warning", () => {
   }
 });
 
-test("telemetry: dir and buckets warnings join with '; '", () => {
-  const r = resolveTelemetry({ telemetry: { dir: 1, buckets: 2 } });
-  assert.match(r.warning ?? "", /telemetry\.dir.*; .*telemetry\.buckets/);
+test("telemetry: retired dir and invalid buckets each warn once", () => {
+  const r = resolveTelemetry(mergeGauntlet(undefined, { telemetry: { dir: 1, buckets: 2 } }));
+  assert.equal(r.warning, "piGauntlet.telemetry.dir is retired; records live on the gauntlet/telemetry branch - set piGauntlet.telemetry.remote to redirect them; telemetry.buckets is not an object of non-empty glob arrays; using the defaults");
 });
 
 test("DEFAULT_TEST_COMMANDS + buildTestCmdRegex match the documented entrypoints", () => {

package/extensions/lib/gauntlet-settings.ts

@@ -13,7 +13,7 @@ export interface PiGauntlet {
   escalationLoop?: { implModel?: unknown };
   loopEngine?: { maxIterationsPerRow?: unknown; escalateAfter?: unknown; maxIterations?: unknown };
   phaseModels?: { plan?: unknown; implement?: unknown; verify?: unknown; ship?: unknown };
-  telemetry?: { enabled?: unknown; dir?: unknown; buckets?: unknown };
+  telemetry?: { enabled?: unknown; remote?: unknown; buckets?: unknown };
 }
 
 // Whole-object second-level merge: each piGauntlet key present in the repo layer
@@ -230,7 +230,7 @@ export const DEFAULT_TELEMETRY_BUCKETS: [string, string[]][] = [
 
 export interface TelemetryResolved {
   enabled: boolean;
-  dir: string;
+  remote?: string;
   buckets: [string, string[]][];
   warning: string | undefined;
 }
@@ -239,19 +239,8 @@ export function resolveTelemetry(g: PiGauntlet): TelemetryResolved {
   const t = g.telemetry;
   const warnings: string[] = [];
   const enabled = t?.enabled !== false;
-
-  let dir = DEFAULT_TELEMETRY_DIR;
-  if (t?.dir !== undefined) {
-    const value = nonEmptyString(t.dir) ? t.dir.trim().replace(/\/+$/, "") : "";
-    const canonical = value.replace(/\\/g, "/");
-    const normalized = path.posix.normalize(canonical);
-    if (
-      value &&
-      path.win32.parse(canonical).root === "" &&
-      normalized !== ".." &&
-      !normalized.startsWith("../")
-    ) dir = normalized;
-    else warnings.push("telemetry.dir must be a non-empty path relative to the git toplevel; using the default");
+  if (t && Object.hasOwn(t, "dir")) {
+    warnings.push("piGauntlet.telemetry.dir is retired; records live on the gauntlet/telemetry branch - set piGauntlet.telemetry.remote to redirect them");
   }
 
   let buckets = DEFAULT_TELEMETRY_BUCKETS;
@@ -267,7 +256,9 @@ export function resolveTelemetry(g: PiGauntlet): TelemetryResolved {
     else warnings.push("telemetry.buckets is not an object of non-empty glob arrays; using the defaults");
   }
 
-  return { enabled, dir, buckets, warning: joinWarn(warnings) };
+  const remote = nonEmptyString(t?.remote) ? t.remote.trim() : undefined;
+  if (t?.remote !== undefined && !remote) warnings.push("telemetry.remote must be a non-empty URL; using origin");
+  return { enabled, ...(remote ? { remote } : {}), buckets, warning: joinWarn(warnings) };
 }
 
 export function settingsErrorWarning(errors: string[]): string {

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

@@ -0,0 +1,102 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync, chmodSync } from "node:fs";
+import { isolatedGitEnv } from "../test-support/git-env.mjs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+
+const library = new URL("./telemetry-branch.ts", import.meta.url).href;
+
+function fixture() {
+  const scratch = mkdtempSync(join(tmpdir(), "telemetry-identity-"));
+  const root = join(scratch, "primary product");
+  const home = join(scratch, "home");
+  mkdirSync(root); mkdirSync(home);
+  const env = { ...process.env, HOME: home, ...isolatedGitEnv(scratch) };
+  const run = (binary: string, args: string[], cwd = root) => {
+    const result = spawnSync(binary, args, { cwd, env, encoding: "utf8", timeout: 10_000 });
+    assert.equal(result.status, 0, `${binary} ${args.join(" ")}: ${result.stderr}`);
+    return result.stdout.trim();
+  };
+  const git = (...args: string[]) => run("git", ["-c", "commit.gpgsign=false", ...args]);
+  git("init", "-b", "main");
+  const identity = (cwd = root) => JSON.parse(run(process.execPath, ["--input-type=module", "--eval",
+    `import { telemetryRepo } from ${JSON.stringify(library)}; console.log(JSON.stringify(telemetryRepo(process.cwd()) ?? null));`,
+  ], cwd));
+  return { scratch, root, git, identity, run };
+}
+
+test("repository identity normalizes origin URL forms and keeps every namespace segment", async (t) => {
+  const f = fixture();
+  for (const [name, url, expected] of [
+    ["scp", "git@host.test:team/product.git", "team/product"],
+    ["ssh", "ssh://git@host.test/team/product.git", "team/product"],
+    ["ssh port and nested namespace", "ssh://git@host.test:2222/group/sub/product.git/", "group/sub/product"],
+    ["https", "https://host.test/team/product.git/", "team/product"],
+    ["nested scp", "git@host.test:group/sub/product.git", "group/sub/product"],
+    ["nested https", "https://host.test/group/other/product/", "group/other/product"],
+    ["case preserved", "https://host.test/Team/Product.git", "Team/Product"],
+  ]) {
+    await t.test(name, () => {
+      f.git("config", "remote.origin.url", url);
+      assert.equal(f.identity(), expected);
+    });
+  }
+  mkdirSync(join(f.root, ".pi"));
+  writeFileSync(join(f.root, ".pi/settings.json"), JSON.stringify({ piGauntlet: { telemetry: { remote: "https://elsewhere.test/central/telemetry.git" } } }));
+  assert.equal(f.identity(), "Team/Product", "telemetry.remote never changes product identity");
+});
+
+test("failed telemetry ref commit reports committed: false and preserves the feature index", (t) => {
+  const f = fixture();
+  t.after(() => rmSync(f.scratch, { recursive: true, force: true }));
+  writeFileSync(join(f.root, "file"), "feature\n");
+  f.git("add", "file");
+  f.git("commit", "-m", "initial");
+  const before = f.git("rev-parse", "HEAD");
+  const index = readFileSync(join(f.root, ".git/index"));
+  const hook = join(f.root, ".git/hooks/reference-transaction");
+  writeFileSync(hook, '#!/bin/sh\nif [ "$1" = prepared ]; then echo rejected >&2; exit 1; fi\n');
+  chmodSync(hook, 0o755);
+  const result = JSON.parse(f.run(process.execPath, ["--input-type=module", "--eval",
+    `import { syncTelemetryBranch } from ${JSON.stringify(library)}; console.log(JSON.stringify(syncTelemetryBranch(process.cwd(), new Map([["team/product/brainstorming/x.yaml", "schema: 1\\n"]]))));`,
+  ]));
+  assert.equal(result.ok, false);
+  assert.equal(result.committed, false);
+  assert.equal(result.pushed, false);
+  assert.match(result.reason, /rejected|reference transaction/);
+  assert.equal(f.git("rev-parse", "HEAD"), before);
+  assert.deepEqual(readFileSync(join(f.root, ".git/index")), index);
+  assert.equal(f.git("for-each-ref", "refs/heads/gauntlet/telemetry"), "");
+});
+
+test("origin-less identity uses repo from the first-found overrides Issue tracker section", () => {
+  const f = fixture();
+  mkdirSync(join(f.root, ".pi"));
+  mkdirSync(join(f.root, "doc"));
+  writeFileSync(join(f.root, "doc/gauntlet-overrides.md"), "## Issue tracker\n- repo: doc/product\n");
+  assert.equal(f.identity(), "doc/product");
+  writeFileSync(join(f.root, "gauntlet-overrides.md"), "## Issue tracker\n- repo: root/product\n");
+  assert.equal(f.identity(), "root/product");
+  writeFileSync(join(f.root, ".pi/gauntlet-overrides.md"), "## Other\n- repo: wrong/product\n## Issue tracker\n- tracker: none\n- repo: group/sub/product\n## Later\n- repo: also/wrong\n");
+  assert.equal(f.identity(), "group/sub/product");
+  f.git("config", "remote.origin.url", "git@host.test:origin/product.git");
+  assert.equal(f.identity(), "origin/product", "origin takes precedence over overrides");
+});
+
+test("local fallback uses the primary directory from linked worktrees and ignores later overrides", () => {
+  const f = fixture();
+  assert.equal(f.identity(), "local/primary product");
+  mkdirSync(join(f.root, ".pi"));
+  writeFileSync(join(f.root, ".pi/gauntlet-overrides.md"), "## Issue tracker\n- repo:\n- tracker: none\n## Other\n- repo: wrong/product\n");
+  writeFileSync(join(f.root, "gauntlet-overrides.md"), "## Issue tracker\n- repo: ignored/product\n");
+  assert.equal(f.identity(), "local/primary product");
+  f.git("commit", "--allow-empty", "-m", "initial");
+  const linked = join(f.scratch, "different worktree");
+  f.git("worktree", "add", "-b", "feature", linked);
+  const nested = join(linked, "nested");
+  mkdirSync(nested);
+  assert.equal(f.identity(linked), "local/primary product");
+  assert.equal(f.identity(nested), "local/primary product");
+});

package/extensions/lib/telemetry-branch.ts

@@ -0,0 +1,145 @@
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import { checkoutOfSync } from "./checkout.ts";
+import { gitRun } from "./vcs.ts";
+
+export const TELEMETRY_REF = "refs/heads/gauntlet/telemetry";
+
+export function trackerRefs(text: string): string[] {
+  const tokens = text.match(/https?:\/\/[^\s<>\])]+|[\w.-]+\/[\w.-]+#\d+|#\d+|\b[A-Z][A-Z0-9]*-\d+\b|\bgh-\d+\b/g) ?? [];
+  return [...new Set(tokens.map(ref => ref.replace(/[.,;]+$/, ""))
+    .filter(ref => !ref.startsWith("http") || /\/(?:issues\/\d+|pull\/\d+|issue\/[A-Z][A-Z0-9]*-\d+)(?:\/[^\s]*)?$/.test(ref))
+    .map(ref => ref.startsWith("gh-") ? `#${ref.slice(3)}` : ref))];
+}
+
+export function telemetryDir(root: string): string | undefined {
+  const result = gitRun(["rev-parse", "--path-format=absolute", "--git-common-dir"], root);
+  return result.ok ? join(result.stdout, "gauntlet", "telemetry") : undefined;
+}
+
+export function telemetryRepo(root: string): string {
+  // Read the configured URL, not get-url's transport rewrite (which may be local).
+  const result = gitRun(["config", "--get", "remote.origin.url"], root);
+  const match = result.stdout.match(/^(?:https?:\/\/[^/]+\/|ssh:\/\/(?:[^@/]+@)?[^/]+\/|(?:[^@\s]+@)?[^:\s/]+:)(.+)$/);
+  const path = match?.[1].replace(/^\/+|\/+$/g, "").replace(/\.git$/, "");
+  if (result.ok && path) return path;
+
+  const top = checkoutOfSync(root)?.toplevel ?? root;
+  for (const file of [".pi/gauntlet-overrides.md", "gauntlet-overrides.md", "doc/gauntlet-overrides.md"]) {
+    const path = join(top, file);
+    if (!existsSync(path)) continue;
+    const section = readFileSync(path, "utf8").split(/^##\s+Issue tracker\s*$/m)[1]?.split(/^##\s/m)[0] ?? "";
+    const repo = /^-[\t ]*repo:[\t ]*(\S[^\r\n]*)$/m.exec(section)?.[1].trim();
+    if (repo) return repo;
+    break;
+  }
+  const worktrees = gitRun(["worktree", "list", "--porcelain", "-z"], root);
+  const primary = worktrees.ok ? /^worktree ([^\0]+)/.exec(worktrees.stdout)?.[1] : undefined;
+  return `local/${basename(primary ?? top)}`;
+}
+
+const trackingRef = (remote: string) => `refs/remotes/${remote === "origin" ? "origin" : "telemetry"}/gauntlet/telemetry`;
+const fetchBranch = (root: string, remote: string) => gitRun(["fetch", "--no-tags", remote, `+${TELEMETRY_REF}:${trackingRef(remote)}`], root);
+
+export function syncTelemetryBranch(root: string, records: ReadonlyMap<string, string>, remote = "origin"): { ok: boolean; committed: boolean; pushed: boolean; reason?: string; warning?: string } {
+  const scratch = mkdtempSync(join(tmpdir(), "gauntlet-telemetry-index-"));
+  const env = { GIT_INDEX_FILE: join(scratch, "index") };
+  const git = (args: string[], input?: string) => {
+    const result = gitRun(args, root, undefined, { env, input });
+    if (!result.ok) throw new Error(result.stderr);
+    return result.stdout;
+  };
+  const tracking = trackingRef(remote);
+  let fetchWarning: string | undefined;
+  const fetch = () => {
+    const result = fetchBranch(root, remote);
+    fetchWarning = result.ok ? undefined : `fetch failed: ${result.stderr}`;
+    return result;
+  };
+  const resolve = (ref: string) => {
+    const result = gitRun(["rev-parse", "--verify", ref], root);
+    return result.ok ? result.stdout : undefined;
+  };
+  const commit = (tree: string, parent: string | undefined, message: string) =>
+    git(["-c", "commit.gpgsign=false", "commit-tree", tree, ...(parent ? ["-p", parent] : []), "-m", message]);
+  let committed = false;
+  try {
+    let tip = resolve(TELEMETRY_REF);
+    committed = records.size === 0 && !!tip;
+    fetch();
+    let upstream = resolve(tracking);
+    if (records.size) {
+      const parent = tip ?? upstream;
+      git(parent ? ["read-tree", parent] : ["read-tree", "--empty"]);
+      for (const [path, content] of records) {
+        const blob = git(["hash-object", "-w", "--stdin"], content);
+        git(["update-index", "--add", "--cacheinfo", "100644", blob, path]);
+      }
+      const tree = git(["write-tree"]);
+      const next = parent && git(["rev-parse", `${parent}^{tree}`]) === tree
+        ? parent : commit(tree, parent, "telemetry: update records");
+      git(["update-ref", TELEMETRY_REF, next, tip ?? ""]);
+      tip = next;
+      committed = true;
+    }
+    const pending = () => tip ? git(["rev-list", "--reverse", "--topo-order", tip, ...(upstream ? [`^${upstream}`] : [])]).split("\n").filter(Boolean) : [];
+    if (!pending().length) return { ok: true, committed, pushed: false, warning: fetchWarning };
+    const push = () => gitRun(["push", remote, `${TELEMETRY_REF}:${TELEMETRY_REF}`], root);
+    const first = push();
+    if (first.ok) return { ok: true, committed, pushed: true, warning: fetchWarning };
+    const fetched = fetch();
+    if (!fetched.ok) throw new Error(`${first.stderr}; refresh failed: ${fetched.stderr}`);
+    upstream = resolve(tracking);
+    let replayed = upstream;
+    for (const sha of pending()) {
+      git(replayed ? ["read-tree", replayed] : ["read-tree", "--empty"]);
+      // Apply only this commit's changes, not its whole tree: remote-only records survive.
+      const changes = git(["diff-tree", "--root", "--no-commit-id", "--raw", "--no-abbrev", "--no-renames", "-r", "-z", sha]).split("\0");
+      for (let i = 0; i + 1 < changes.length; i += 2) {
+        const [, mode, , blob] = changes[i].split(" ");
+        const path = changes[i + 1];
+        git(mode === "000000" ? ["update-index", "--force-remove", "--", path] : ["update-index", "--add", "--cacheinfo", mode, blob, path]);
+      }
+      replayed = commit(git(["write-tree"]), replayed, git(["log", "-1", "--format=%B", sha]));
+    }
+    // Publish the replay atomically only after every pending commit has survived it.
+    if (replayed) git(["update-ref", TELEMETRY_REF, replayed, tip!]);
+    const second = push();
+    if (!second.ok) throw new Error(second.stderr);
+    return { ok: true, committed, pushed: true };
+  } catch (error) {
+    const reason = (error as Error).message;
+    return { ok: false, committed, pushed: false, reason, warning: [fetchWarning, `telemetry: not pushed (${reason})`].filter(Boolean).join("; ") };
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+}
+
+export function readTelemetryBranch(root: string, { remote = "origin", prefix = "" }: { remote?: string; prefix?: string } = {}): { records: { path: string; bytes: string }[]; warning?: string } {
+  const records: { path: string; bytes: string }[] = [];
+  let warning: string | undefined;
+  try {
+    const synced = syncTelemetryBranch(root, new Map(), remote);
+    warning = synced.warning;
+    if (synced.pushed) {
+      const fetched = fetchBranch(root, remote);
+      warning = fetched.ok ? undefined : `fetch failed: ${fetched.stderr}`;
+    }
+    const tip = gitRun(["rev-parse", "--verify", trackingRef(remote)], root);
+    if (!tip.ok) return { records, warning: [warning, "no telemetry ref fetched yet"].filter(Boolean).join("; ") };
+    const tree = gitRun(["ls-tree", "-r", "-z", tip.stdout, ...(prefix ? ["--", prefix] : [])], root);
+    if (!tree.ok) throw new Error(tree.stderr);
+    for (const entry of tree.stdout.split("\0").filter(Boolean)) {
+      const [meta, path] = entry.split("\t");
+      const [, type, sha] = meta.split(" ");
+      if (type !== "blob" || !path.startsWith(prefix) || !path.endsWith(".yaml")) continue;
+      const blob = gitRun(["cat-file", "blob", sha], root, undefined, { raw: true });
+      if (!blob.ok) throw new Error(blob.stderr);
+      records.push({ path, bytes: blob.stdout });
+    }
+    return { records, warning };
+  } catch (error) {
+    return { records, warning: [warning, `read failed: ${(error as Error).message}`].filter(Boolean).join("; ") };
+  }
+}

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

@@ -16,7 +16,7 @@ test("aggregateNumstat sums per bucket over the given file set; binary rows coun
   });
 });
 
-test("computeGitDiff: merge-base, name-only minus spec/plan/dir, numstat buckets, telemetry-free commit count", async () => {
+test("computeGitDiff: merge-base, name-only minus spec/plan/dir, numstat buckets, all product commits counted", async () => {
   const calls: string[][] = [];
   const git = (args: string[]) => {
     calls.push(args);
@@ -31,7 +31,7 @@ test("computeGitDiff: merge-base, name-only minus spec/plan/dir, numstat buckets
   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"]);
+  assert.deepEqual(calls.at(-1), ["rev-list", "--count", "abc123..HEAD"]);
 });
 
 test("computeGitDiff: custom plan dir excludes only configured plans", async () => {

package/extensions/lib/telemetry-diff.ts

@@ -57,6 +57,6 @@ export async function computeGitDiff(o: { git: Runner; cwd: string; spec: string
   const names = await o.git(["diff", "--name-only", `${base}...HEAD`], o.cwd);
   const files = modifiedFilesFrom(names.stdout, o.spec, o.dir, o.planDirs);
   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);
+  const count = await o.git(["rev-list", "--count", `${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-leg.ts

@@ -0,0 +1,163 @@
+import { join } from "node:path";
+import { stringify } from "yaml";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { Deps } from "../telemetry.ts";
+import { checkoutOf } from "./checkout.ts";
+import { syncTelemetryBranch, telemetryRepo, trackerRefs } from "./telemetry-branch.ts";
+import { textOf } from "./telemetry-collect.ts";
+import { addTokens, compact, emptyAccumulators, zeroTokens, type Accumulators, type Tokens } from "./telemetry-record.ts";
+
+const skills = ["shape-ticket", "gatekeep-pr", "check-delivery"] as const;
+type LegSkill = (typeof skills)[number];
+export interface LegItem {
+  kind: "ticket" | "pr";
+  key?: string;
+  ticket?: string;
+  outcome: string;
+}
+export interface LegRecord {
+  skill: LegSkill;
+  session: string;
+  author: { name?: string; email?: string };
+  gauntlet_version?: string;
+  models: string[];
+  tokens: Omit<Tokens, "cost">;
+  cost: number;
+  repo: string;
+  ts: string;
+  items: LegItem[];
+}
+
+const legSkill = (name: string | undefined): LegSkill | undefined => skills.find((skill) => skill === name);
+
+const ticketRef = (ref: string) => trackerRefs(ref).includes(ref);
+const outcomes: Record<LegSkill, string> = {
+  "shape-ticket": "written|created|closed|close failed \\(.*\\)|close by hand|dropped|declined|stopped|no-op|unfetched",
+  "gatekeep-pr": "approved|merged|closed-pr|final|merge-queued|stopped|stuck - .+",
+  "check-delivery": "delivered|manual|declined|already recorded|skipped|failed - .+",
+};
+
+export function settlementItems(skill: LegSkill, text: string, trackerless = false): LegItem[] | undefined {
+  const [marker, ...lines] = text.split("\n");
+  if (!/^gauntlet: (?:done|stuck)\b/.test(marker)) return undefined;
+  const row = new RegExp(`^(.+?): (${outcomes[skill]})$`);
+  const items = lines.flatMap((line): LegItem[] => {
+    let ticket: string | undefined;
+    const annotation = / \(([^()]+)\)$/.exec(line);
+    if (skill === "gatekeep-pr" && annotation && (trackerless || ticketRef(annotation[1]))) {
+      ticket = annotation[1];
+      line = line.slice(0, annotation.index);
+    }
+    const match = row.exec(line);
+    if (!match || match[1].startsWith("# ") || match[1].startsWith("#### ")) return [];
+    const [, ref, outcome] = match;
+    const pr = /^#\d+@[a-f\d]+$/i.test(ref) || /^https?:\/\/\S+\/pull\/\d+(?:@[a-f\d]+)?$/i.test(ref);
+    if (trackerless || pr || ticketRef(ref)) return [compact({ kind: pr || skill === "gatekeep-pr" ? "pr" : "ticket", key: ref, ticket, outcome }) as LegItem];
+    if (skill === "shape-ticket" && (outcome === "dropped" || outcome === "declined")) return [{ kind: "ticket", outcome }];
+    return [];
+  });
+  return items;
+}
+
+export function registerLegTelemetry(pi: ExtensionAPI, deps: Deps, runBound: () => boolean): () => Accumulators | undefined {
+  let active: { skill: LegSkill; provisional: boolean; session: string; ts: string; acc: Accumulators; models: Set<string> } | undefined;
+  let terminal: string | undefined;
+  let lastSkill: LegSkill | undefined;
+  const trackerless = (root: string): boolean => {
+    for (const path of [".pi/gauntlet-overrides.md", "gauntlet-overrides.md", "doc/gauntlet-overrides.md"]) {
+      const text = deps.fs.readFile(join(root, path));
+      if (text === undefined) continue;
+      const section = text.split(/^##\s+Issue tracker\s*$/m)[1]?.split(/^##\s/m)[0] ?? "";
+      return /^-\s*tracker:\s*none\s*$/m.test(section);
+    }
+    return false;
+  };
+  const enabled = (ctx: ExtensionContext) => Number(process.env.PI_SUBAGENT_DEPTH ?? "0") === 0 && deps.settings(ctx.cwd).telemetry.enabled;
+  const reset = () => { active = undefined; terminal = undefined; };
+  const start = (skill: LegSkill | undefined, ctx: ExtensionContext, provisional = false) => {
+    if (!skill || !enabled(ctx) || runBound()) return;
+    if (active) {
+      if (active.provisional && !provisional) {
+        active.skill = skill;
+        active.provisional = false;
+        lastSkill = skill;
+      }
+      return;
+    }
+    lastSkill = skill;
+    active = { skill, provisional, session: ctx.sessionManager.getSessionId(), ts: deps.now(), acc: emptyAccumulators(), models: new Set() };
+    if (ctx.model) active.models.add(`${ctx.model.provider}/${ctx.model.id}`);
+    terminal = undefined;
+  };
+  const notify = (reason: string) => pi.sendMessage({
+    customType: "telemetry-warning", content: `telemetry: not pushed (${reason.split("\n")[0]})`, display: true,
+  });
+
+  for (const event of ["session_start", "session_switch", "session_fork", "session_tree", "session_shutdown"] as const) {
+    pi.on(event, async () => { reset(); lastSkill = undefined; });
+  }
+  pi.on("input", async (event, ctx) => {
+    terminal = undefined;
+    if (event.source !== "extension") start(legSkill(/^\/skill:([^\s]+)/.exec(event.text)?.[1]), ctx);
+  });
+  pi.on("before_agent_start", async (event, ctx) => {
+    terminal = undefined;
+    if (event.messageType === "user") {
+      const skill = legSkill(/^<skill name="([^"]+)" location="/.exec(event.prompt)?.[1]);
+      start(skill ?? lastSkill, ctx, !skill);
+    }
+  });
+  pi.on("tool_call", async (event, ctx) => {
+    terminal = undefined;
+    if (event.toolName !== "read") return;
+    const path = (event.input as { path?: unknown }).path;
+    if (typeof path === "string") start(legSkill(/(?:^|\/)skills\/([^/]+)\/SKILL\.md$/.exec(path)?.[1]), ctx);
+  });
+  pi.on("model_select", async (event, ctx) => {
+    if (active && enabled(ctx) && !runBound()) active.models.add(`${event.model.provider}/${event.model.id}`);
+  });
+  pi.on("message_end", async (event, ctx) => {
+    if (event.message.role !== "assistant") return;
+    if (active && enabled(ctx) && !runBound()) {
+      if (event.message.provider && event.message.model) active.models.add(`${event.message.provider}/${event.message.model}`);
+      const text = textOf(event.message.content);
+      terminal = /^gauntlet: (?:done|stuck)\b/.test(text) ? text : undefined;
+    } else terminal = undefined;
+  });
+  // agent_end can precede queued follow-on work; only the final live message at settlement seals.
+  pi.on("agent_settled", async (event, ctx) => {
+    if (!active || !terminal || event.aborted || !enabled(ctx) || runBound()) return;
+    const run = active;
+    const text = terminal;
+    try {
+      const checkout = await checkoutOf(ctx.cwd, deps.git, deps.jj);
+      if (!checkout || checkout.via !== "git") {
+        reset();
+        return notify(checkout ? "jj workspace: no git remote" : "no repository");
+      }
+      const items = settlementItems(run.skill, text, trackerless(checkout.toplevel));
+      if (!items) return;
+      reset();
+      const repo = (deps.telemetryRepo ?? telemetryRepo)(checkout.toplevel);
+      const [name, email] = await Promise.all([
+        deps.git(["config", "user.name"], checkout.toplevel),
+        deps.git(["config", "user.email"], checkout.toplevel),
+      ]);
+      const { cost, ...tokens } = Object.values(run.acc.phases).reduce((total, phase) => addTokens(total, phase.tokens ?? zeroTokens()), zeroTokens());
+      for (const persona of Object.values(run.acc.personas)) for (const model of persona.models) run.models.add(model);
+      const record: LegRecord = {
+        skill: run.skill, session: run.session, ts: run.ts, repo, items,
+        author: compact({ name: name.stdout.trim() || undefined, email: email.stdout.trim() || undefined }),
+        gauntlet_version: deps.settings(ctx.cwd).versions["pi-gauntlet"], models: [...run.models], tokens, cost,
+      };
+      const stamp = run.ts.replace(/[-:]/g, "");
+      const path = `${repo}/${run.skill}/${stamp}-${run.session}.yaml`;
+      const result = (deps.syncTelemetryBranch ?? syncTelemetryBranch)(checkout.toplevel, new Map([[path, stringify(record)]]), deps.settings(ctx.cwd).telemetry.remote);
+      if (!result.ok) notify(result.reason ?? "unknown failure");
+    } catch (error) {
+      reset();
+      notify(String((error as Error).message ?? error));
+    }
+  });
+  return () => runBound() ? undefined : active?.acc;
+}

package/extensions/lib/telemetry-record.ts

@@ -103,6 +103,8 @@ export const validLegs = (legs: unknown): legs is TelemetryLeg[] => Array.isArra
   ((typeof leg.sha === "string" && leg.sha.trim().length > 0 && leg.pr === undefined) ||
    (typeof leg.pr === "string" && /^https?:\/\/\S+$/.test(leg.pr) && leg.sha === undefined)));
 export interface TelemetryRecord {
+  repo?: string;
+  tickets?: string[];
   legs?: TelemetryLeg[];
   schema: 1; spec: string; run_id: string; branch?: string; status: RecordStatus; created_at: string; approved_at?: string; shipped_at?: string; abandoned_at?: string;
   supersedes?: string[]; fixes?: string[]; versions?: Record<string, string>; author?: { name?: string; email?: string }; agent_overrides?: Record<string, unknown>;

package/extensions/lib/vcs.ts

@@ -6,21 +6,23 @@ import { checkoutOfSync } from "./checkout.ts";
 import { computeGitDiff, computeJjDiff, JJ_FORK_POINT, type Buckets, type DiffOutcome, type RunResult } from "./telemetry-diff.ts";
 
 export interface VcsResult extends RunResult { ok: boolean }
-export type VcsRun = (args: string[], cwd: string, timeoutMs?: number) => VcsResult;
+export type VcsRun = (args: string[], cwd: string, timeoutMs?: number, options?: { input?: string; env?: NodeJS.ProcessEnv; raw?: boolean }) => VcsResult;
 export interface Vcs { kind: "git" | "jj"; root: string; run: VcsRun }
 
 // Prompts off so a credential or editor request cannot hang a non-interactive caller.
 const NO_PROMPT_ENV = { ...process.env, GIT_TERMINAL_PROMPT: "0", GIT_EDITOR: "true" };
 
-const runBinary = (bin: "git" | "jj"): VcsRun => (args, cwd, timeoutMs = 10_000) => {
+const runBinary = (bin: "git" | "jj"): VcsRun => (args, cwd, timeoutMs = 10_000, options = {}) => {
   // jj diff --git returns full patches; spawnSync's 1 MiB default buffer truncates them (ENOBUFS).
-  const r = spawnSync(bin, args, { cwd, encoding: "utf8", env: NO_PROMPT_ENV, timeout: timeoutMs, maxBuffer: 64 * 1024 * 1024 });
+  const r = spawnSync(bin, args, { cwd, encoding: "utf8", input: options.input, env: { ...NO_PROMPT_ENV, ...options.env }, timeout: timeoutMs, maxBuffer: 64 * 1024 * 1024 });
   const err = r.error as NodeJS.ErrnoException | undefined;
   const timedOut = err?.code === "ETIMEDOUT";
   const stderr = timedOut ? "timed out" : (r.stderr ?? "").trim().split("\n")[0] || err?.message || `${bin} exited ${r.status}`;
-  return { ok: !timedOut && r.status === 0, code: timedOut ? 1 : (r.status ?? 1), stdout: (r.stdout ?? "").trim(), stderr };
+  return { ok: !timedOut && r.status === 0, code: timedOut ? 1 : (r.status ?? 1), stdout: options.raw ? (r.stdout ?? "") : (r.stdout ?? "").trim(), stderr };
 };
 
+export const gitRun: VcsRun = runBinary("git");
+
 export function vcsFor(absPath: string): Vcs | undefined {
   const co = checkoutOfSync(absPath);
   return co && { kind: co.via, root: co.toplevel, run: runBinary(co.via) };
@@ -53,22 +55,3 @@ export function changedNames(vcs: Vcs, base: string): VcsResult {
   if (!fork) return { ok: false, code: 1, stdout: "", stderr: "jj mainline unresolved (trunk() is root(); no main/master bookmark)" };
   return vcs.run(["--color=never", "diff", "--name-only", "--from", fork, "--to", "@"], vcs.root);
 }
-
-// git: sealed == tracked and clean (ls-files --error-unmatch, diff --quiet HEAD).
-// jj: no commit step, so a shipped record is always sealed.
-export function recordSealed(vcs: Vcs, rel: string): boolean {
-  if (vcs.kind === "jj") return true;
-  return vcs.run(["ls-files", "--error-unmatch", "--", rel], vcs.root).ok
-    && vcs.run(["diff", "--quiet", "HEAD", "--", rel], vcs.root).ok;
-}
-
-// jj has no commit step: `file track --include-ignored` is the `git add -f` equivalent - it
-// snapshots the stamped record into the working-copy change even under a gitignored dir.
-export function commitRecordFile(vcs: Vcs, rel: string, message: string): VcsResult {
-  if (vcs.kind === "jj") return vcs.run(["file", "track", "--include-ignored", "--", rel], vcs.root);
-  const add = vcs.run(["add", "-f", "--", rel], vcs.root);
-  const commit = add.ok ? vcs.run(["commit", "-q", "-m", message, "--", rel], vcs.root, 30_000) : add;
-  // Unstage the -f add so a retry sees the same state.
-  if (!commit.ok) vcs.run(["reset", "-q", "--", rel], vcs.root);
-  return commit;
-}