pi-gauntlet 5.12.0 → 5.12.1

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## v5.12.1 - 2026-09-19
+
+- Fixed: `gauntlet-telemetry-salvage` and `gauntlet-performance` no longer crash with `ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING` when run from an npm-installed copy - both bins are now committed esbuild bundles (sources in `src/bins/`, rebuild with `npm run build:bins`), guarded by a CI freshness check, bundle pack assertions, and a packed-install smoke test. (#39)
+
 ## v5.12.0 - 2026-09-19
 
 - New human-only `/skill:gauntlet-performance` and parse-only `gauntlet-performance` bin: the CLI digests committed telemetry records (current repo, plus `--dir <path>` repos; `--since <version>` narrows; `--json`) into per-run rows and per-version p50/max, and the skill turns the digest into one example-led recommendation, cornerstones, and a three-item menu (render on request, ticket via `shape-ticket`, drill-down). `gauntlet-telemetry-salvage` now stamps a record still `in_progress` with no ship phase as `status: shipped` + `shipped_at` at landing (`present`/`restored ... (marked shipped)`, `unfinished` under `--check`); `finishing-a-development-branch` and `gatekeep-pr` carry the new lines. The gh-37 record on this repo is backfilled to `shipped`. (#35)

package/bin/gauntlet-performance.mjs

@@ -1,82 +1,109 @@
 #!/usr/bin/env node
-// Digest committed gauntlet telemetry records: one row per run plus p50/max per pi-gauntlet
-// version. Parse and aggregate only; the gauntlet-performance skill reasons over the output.
+
+// src/bins/gauntlet-performance.mjs
 import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
 import process from "node:process";
 import { parse as parseYaml } from "yaml";
-import { mergeGauntlet, resolveTelemetry } from "../extensions/lib/gauntlet-settings.ts";
 
-const PHASES = ["brainstorm", "plan", "implement", "verify", "ship"];
-const TOKEN_KEYS = ["input", "output", "cache_read", "cache_write"];
-const RUN_HEADER = ["run_id", "repo", "spec", "version", "status", "wall", "b/p/i/v/s min", "tokens", "cost", "models", "disp", "grants", "reopens", "loops", "findings", "council"];
-const VERSION_HEADER = ["version", "n", "shipped", "truncated", "wall p50/max", "tokens p50/max", "cost p50/max", "disp p50", "grants p50/max", "reopens p50/max", "loops p50/max", "findings p50 b/M/m", "models"];
+// extensions/lib/gauntlet-settings.ts
+import path from "node:path";
+function mergeGauntlet(preset, repo) {
+  return { ...preset ?? {}, ...repo ?? {} };
+}
+var nonEmptyString = (v) => typeof v === "string" && v.trim().length > 0;
+var joinWarn = (ws) => ws.length ? ws.join("; ") : void 0;
+var DEFAULT_TELEMETRY_DIR = ".pi/gauntlet/telemetry";
+var DEFAULT_TELEMETRY_BUCKETS = [
+  ["test", ["**/test/**", "**/tests/**", "**/__tests__/**", "**/*.test.*", "**/*.spec.*", "**/*_test.*"]],
+  ["docs", ["**/*.md"]],
+  ["config", ["**/*.json", "**/*.yaml", "**/*.yml", "**/*.toml", "**/*.lock", "**/*-lock.*"]]
+];
+function resolveTelemetry(g) {
+  const t = g.telemetry;
+  const warnings = [];
+  const enabled = t?.enabled !== false;
+  let dir = DEFAULT_TELEMETRY_DIR;
+  if (t?.dir !== void 0) {
+    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");
+  }
+  let buckets = DEFAULT_TELEMETRY_BUCKETS;
+  if (t?.buckets !== void 0) {
+    const b = t.buckets;
+    const valid = b !== null && typeof b === "object" && !Array.isArray(b) && Object.keys(b).length > 0 && Object.values(b).every((v) => Array.isArray(v) && v.length > 0 && v.every(nonEmptyString));
+    if (valid) buckets = Object.entries(b).map(([name, globs]) => [name, [...globs]]);
+    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 usage = () => {
+// src/bins/gauntlet-performance.mjs
+var PHASES = ["brainstorm", "plan", "implement", "verify", "ship"];
+var TOKEN_KEYS = ["input", "output", "cache_read", "cache_write"];
+var RUN_HEADER = ["run_id", "repo", "spec", "version", "status", "wall", "b/p/i/v/s min", "tokens", "cost", "models", "disp", "grants", "reopens", "loops", "findings", "council"];
+var VERSION_HEADER = ["version", "n", "shipped", "truncated", "wall p50/max", "tokens p50/max", "cost p50/max", "disp p50", "grants p50/max", "reopens p50/max", "loops p50/max", "findings p50 b/M/m", "models"];
+var usage = () => {
   process.stderr.write("usage: gauntlet-performance [--dir <repo root or telemetry dir>]... [--since <version>] [--json]\n");
   process.exit(1);
 };
-
-const semver = (s) => {
+var semver = (s) => {
   const m = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.exec(typeof s === "string" ? s.trim() : "");
-  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : undefined;
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : void 0;
 };
-const cmpSemver = (a, b) => a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
-
+var cmpSemver = (a, b) => a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
 function parseArgs(argv) {
-  const opts = { dirs: [], since: undefined, json: false };
+  const opts = { dirs: [], since: void 0, json: false };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
-    if (a === "--dir" && argv[i + 1] !== undefined && !argv[i + 1].startsWith("--")) opts.dirs.push(argv[++i]);
-    else if (a === "--since" && argv[i + 1] !== undefined && !argv[i + 1].startsWith("--")) opts.since = argv[++i];
+    if (a === "--dir" && argv[i + 1] !== void 0 && !argv[i + 1].startsWith("--")) opts.dirs.push(argv[++i]);
+    else if (a === "--since" && argv[i + 1] !== void 0 && !argv[i + 1].startsWith("--")) opts.since = argv[++i];
     else if (a === "--json") opts.json = true;
     else usage();
   }
-  if (opts.since !== undefined && !semver(opts.since)) usage();
+  if (opts.since !== void 0 && !semver(opts.since)) usage();
   return opts;
 }
-
 function readLayer(file) {
   if (!existsSync(file)) return {};
   try {
     return JSON.parse(readFileSync(file, "utf8"));
   } catch (e) {
-    process.stderr.write(`warning: ${file}: ${e.message}; using {} for this layer\n`);
+    process.stderr.write(`warning: ${file}: ${e.message}; using {} for this layer
+`);
     return {};
   }
 }
-
-// Same two layers the recorder and salvage read.
 function telemetryDirOf(root) {
   const agentDir = process.env.PI_CODING_AGENT_DIR || join(homedir(), ".pi", "agent");
   const preset = readLayer(join(agentDir, "settings.json"));
   const repo = readLayer(join(root, ".pi", "settings.json"));
   const t = resolveTelemetry(mergeGauntlet(preset?.piGauntlet, repo?.piGauntlet));
-  if (t.warning) process.stderr.write(`warning: ${t.warning}\n`);
+  if (t.warning) process.stderr.write(`warning: ${t.warning}
+`);
   return join(root, t.dir);
 }
-
-const gitToplevel = (cwd) => {
-  const r = spawnSync("git", ["-C", cwd, "rev-parse", "--show-toplevel"], { encoding: "utf8", timeout: 10_000 });
-  return r.status === 0 ? r.stdout.trim() : undefined;
+var gitToplevel = (cwd) => {
+  const r = spawnSync("git", ["-C", cwd, "rev-parse", "--show-toplevel"], { encoding: "utf8", timeout: 1e4 });
+  return r.status === 0 ? r.stdout.trim() : void 0;
 };
-
-// A git toplevel contributes its resolved telemetry dir; anything else is a telemetry dir itself.
-function corpusFor(path) {
-  const label = basename(resolve(path));
-  if (!existsSync(path)) return { label, skip: "not found" };
-  const abs = realpathSync(path);
+function corpusFor(path2) {
+  const label = basename(resolve(path2));
+  if (!existsSync(path2)) return { label, skip: "not found" };
+  const abs = realpathSync(path2);
   const top = gitToplevel(abs);
-  if (top !== undefined && realpathSync(top) === abs) {
+  if (top !== void 0 && realpathSync(top) === abs) {
     const dir = telemetryDirOf(abs);
     return existsSync(dir) ? { label, dir } : { label, skip: "no telemetry dir" };
   }
   if (!statSync(abs).isDirectory()) return { label, skip: "not a directory" };
   return { label, dir: abs };
 }
-
 function* yamlFiles(dir) {
   if (!existsSync(dir)) return;
   for (const e of readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
@@ -85,15 +112,13 @@ function* yamlFiles(dir) {
     else if (e.isFile() && e.name.endsWith(".yaml")) yield p;
   }
 }
-
-const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : null);
-const str = (v) => (typeof v === "string" ? v : null);
-const obj = (v) => (v && typeof v === "object" && !Array.isArray(v) ? v : null);
-const sumOrNull = (vals) => {
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+var str = (v) => typeof v === "string" ? v : null;
+var obj = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : null;
+var sumOrNull = (vals) => {
   const xs = vals.filter((v) => v !== null);
   return xs.length ? xs.reduce((a, b) => a + b, 0) : null;
 };
-
 function loadRecord(file, label) {
   let doc;
   try {
@@ -103,7 +128,7 @@ function loadRecord(file, label) {
   }
   const d = obj(doc);
   if (!d) return { skip: "unparseable" };
-  if (d.schema !== 1) return { skip: `schema ${d.schema === undefined ? "missing" : String(d.schema)}` };
+  if (d.schema !== 1) return { skip: `schema ${d.schema === void 0 ? "missing" : String(d.schema)}` };
   if (typeof d.spec !== "string" || typeof d.run_id !== "string") return { skip: "not a record" };
   const derived = obj(d.derived) ?? {};
   const phases = obj(derived.phases) ?? {};
@@ -114,21 +139,17 @@ function loadRecord(file, label) {
   const gates = obj(derived.gates) ?? {};
   const version = str(obj(d.versions)?.["pi-gauntlet"]);
   const reviewEntries = reviews === null ? null : Object.values(reviews);
-  const findings = reviewEntries === null
-    ? null
-    : reviewEntries.length === 0
-      ? { blocker: 0, major: 0, minor: 0 }
-      : Object.fromEntries(["blocker", "major", "minor"].map((severity) => {
-        const counters = reviewEntries.map((r) => {
-          const review = obj(r);
-          if (review === null) return null;
-          if (!Object.hasOwn(review, "findings")) return 0;
-          const reviewFindings = obj(review.findings);
-          if (reviewFindings === null) return null;
-          return Object.hasOwn(reviewFindings, severity) ? num(reviewFindings[severity]) : 0;
-        });
-        return [severity, counters.includes(null) ? null : counters.reduce((a, b) => a + b, 0)];
-      }));
+  const findings = reviewEntries === null ? null : reviewEntries.length === 0 ? { blocker: 0, major: 0, minor: 0 } : Object.fromEntries(["blocker", "major", "minor"].map((severity) => {
+    const counters = reviewEntries.map((r) => {
+      const review = obj(r);
+      if (review === null) return null;
+      if (!Object.hasOwn(review, "findings")) return 0;
+      const reviewFindings = obj(review.findings);
+      if (reviewFindings === null) return null;
+      return Object.hasOwn(reviewFindings, severity) ? num(reviewFindings[severity]) : 0;
+    });
+    return [severity, counters.includes(null) ? null : counters.reduce((a, b) => a + b, 0)];
+  }));
   const truncated = ph("ship") === null;
   return {
     row: {
@@ -157,27 +178,25 @@ function loadRecord(file, label) {
       findings,
       council: num(obj(personas["spec-council-member"])?.dispatches),
       ship_option: str(gates.ship_option),
-      tests: str(obj(derived.tests)?.result),
-    },
+      tests: str(obj(derived.tests)?.result)
+    }
   };
 }
-
-const p50 = (xs) => {
+var p50 = (xs) => {
   const s = [...xs].sort((a, b) => a - b);
   const m = s.length >> 1;
   return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
 };
-const stat = (rows, pick) => {
-  const xs = rows.map(pick).filter((v) => v !== null && v !== undefined);
+var stat = (rows, pick) => {
+  const xs = rows.map(pick).filter((v) => v !== null && v !== void 0);
   return xs.length ? { p50: p50(xs), max: Math.max(...xs) } : { p50: null, max: null };
 };
-const versionOrder = (a, b) => {
+var versionOrder = (a, b) => {
   const x = semver(a), y = semver(b);
   return x && y ? cmpSemver(x, y) : x ? -1 : y ? 1 : 0;
 };
-
 function aggregate(rows) {
-  const groups = new Map();
+  const groups = /* @__PURE__ */ new Map();
   for (const r of rows) {
     if (!groups.has(r.version)) groups.set(r.version, []);
     groups.get(r.version).push(r);
@@ -201,58 +220,84 @@ function aggregate(rows) {
       findings: {
         blocker: { p50: stat(shipped, (r) => r.findings?.blocker ?? null).p50 },
         major: { p50: stat(shipped, (r) => r.findings?.major ?? null).p50 },
-        minor: { p50: stat(shipped, (r) => r.findings?.minor ?? null).p50 },
+        minor: { p50: stat(shipped, (r) => r.findings?.minor ?? null).p50 }
       },
-      models,
+      models
     };
   });
 }
-
-const dash = (v) => (v === null || v === undefined ? "-" : String(v));
-const fmtMin = (s) => (s === null ? "-" : `${Math.round(s / 60)}m`);
-const fmtCount = (n) => (n === null ? "-" : n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(n));
-const fmtCost = (c) => (c === null ? "-" : c.toFixed(2));
-const pair = (s, f) => `${f(s.p50)}/${f(s.max)}`;
-const findingsCell = (f) => (f === null ? "-" : `${dash(f.blocker)}/${dash(f.major)}/${dash(f.minor)}`);
-const table = (header, rows) => {
+var dash = (v) => v === null || v === void 0 ? "-" : String(v);
+var fmtMin = (s) => s === null ? "-" : `${Math.round(s / 60)}m`;
+var fmtCount = (n) => n === null ? "-" : n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(n);
+var fmtCost = (c) => c === null ? "-" : c.toFixed(2);
+var pair = (s, f) => `${f(s.p50)}/${f(s.max)}`;
+var findingsCell = (f) => f === null ? "-" : `${dash(f.blocker)}/${dash(f.major)}/${dash(f.minor)}`;
+var table = (header, rows) => {
   const w = header.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
   return [header, ...rows].map((r) => r.map((c, i) => c.padEnd(w[i])).join("  ").trimEnd()).join("\n");
 };
-const runRow = (r) => [
-  r.run_id.slice(0, 8), r.repo, r.spec, r.version, `${dash(r.status)}${r.truncated ? "*" : ""}`, fmtMin(r.wall_s),
-  PHASES.map((p) => (r.phase_min[p] === null ? "-" : String(Math.round(r.phase_min[p])))).join("/"),
-  fmtCount(r.tokens), fmtCost(r.cost), r.models.join(",") || "-", dash(r.dispatches), dash(r.grants), dash(r.reopens), dash(r.loops),
-  findingsCell(r.findings), dash(r.council),
+var runRow = (r) => [
+  r.run_id.slice(0, 8),
+  r.repo,
+  r.spec,
+  r.version,
+  `${dash(r.status)}${r.truncated ? "*" : ""}`,
+  fmtMin(r.wall_s),
+  PHASES.map((p) => r.phase_min[p] === null ? "-" : String(Math.round(r.phase_min[p]))).join("/"),
+  fmtCount(r.tokens),
+  fmtCost(r.cost),
+  r.models.join(",") || "-",
+  dash(r.dispatches),
+  dash(r.grants),
+  dash(r.reopens),
+  dash(r.loops),
+  findingsCell(r.findings),
+  dash(r.council)
 ];
-const versionRow = (g) => [
-  g.version, String(g.n), String(g.shipped), String(g.truncated), pair(g.wall_s, fmtMin), pair(g.tokens, fmtCount), pair(g.cost, fmtCost),
-  dash(g.dispatches.p50), pair(g.grants, dash), pair(g.reopens, dash), pair(g.loops, dash),
+var versionRow = (g) => [
+  g.version,
+  String(g.n),
+  String(g.shipped),
+  String(g.truncated),
+  pair(g.wall_s, fmtMin),
+  pair(g.tokens, fmtCount),
+  pair(g.cost, fmtCost),
+  dash(g.dispatches.p50),
+  pair(g.grants, dash),
+  pair(g.reopens, dash),
+  pair(g.loops, dash),
   `${dash(g.findings.blocker.p50)}/${dash(g.findings.major.p50)}/${dash(g.findings.minor.p50)}`,
-  Object.entries(g.models).map(([m, n]) => `${m}:${n}`).join(",") || "-",
+  Object.entries(g.models).map(([m, n]) => `${m}:${n}`).join(",") || "-"
 ];
-
 function main() {
   const opts = parseArgs(process.argv.slice(2));
   const corpora = [];
   const skipped = [];
   const top = gitToplevel(process.cwd());
-  if (top === undefined) process.stderr.write(`not a git checkout: ${process.cwd()}\n`);
+  if (top === void 0) process.stderr.write(`not a git checkout: ${process.cwd()}
+`);
   else corpora.push({ label: basename(top), dir: telemetryDirOf(top) });
   for (const p of opts.dirs) {
     const c = corpusFor(p);
     if (c.skip) skipped.push({ file: p, reason: c.skip });
     else corpora.push(c);
   }
-  const since = opts.since === undefined ? undefined : semver(opts.since);
-  const seen = new Set();
+  const since = opts.since === void 0 ? void 0 : semver(opts.since);
+  const seen = /* @__PURE__ */ new Set();
   const corpus = {};
   const rows = [];
   for (const c of corpora) {
     corpus[c.label] = corpus[c.label] ?? 0;
     for (const file of yamlFiles(c.dir)) {
       const res = loadRecord(file, c.label);
-      if (res.skip) { skipped.push({ file, reason: res.skip }); continue; }
-      if (seen.has(res.row.run_id)) { skipped.push({ file, reason: "duplicate run_id" }); continue; }
+      if (res.skip) {
+        skipped.push({ file, reason: res.skip });
+        continue;
+      }
+      if (seen.has(res.row.run_id)) {
+        skipped.push({ file, reason: "duplicate run_id" });
+        continue;
+      }
       seen.add(res.row.run_id);
       const v = semver(res.row.version);
       if (since && (!v || cmpSemver(v, since) < 0)) continue;
@@ -266,7 +311,7 @@ function main() {
     console.log(JSON.stringify({ corpus, since: opts.since ?? null, runs: rows, by_version: byVersion, skipped }, null, 2));
     return;
   }
-  console.log(`corpus: ${Object.entries(corpus).map(([k, v]) => `${k}=${v}`).join(", ")}${opts.since === undefined ? "" : `   since: ${opts.since}`}`);
+  console.log(`corpus: ${Object.entries(corpus).map(([k, v]) => `${k}=${v}`).join(", ")}${opts.since === void 0 ? "" : `   since: ${opts.since}`}`);
   if (rows.length === 0) {
     console.log(`no records found in ${corpora.map((c) => c.dir).join(", ") || process.cwd()}`);
   } else {
@@ -279,5 +324,4 @@ function main() {
   if (rows.length && skipped.length) console.log("");
   if (rows.length) for (const s of skipped) console.log(`skipped: ${s.file}: ${s.reason}`);
 }
-
 main();

package/bin/gauntlet-telemetry-salvage.mjs

@@ -1,86 +1,182 @@
 #!/usr/bin/env node
-// Restore a gauntlet telemetry record that a plan strip or a gate fix commit removed
-// from the branch. The recorder pathspec-commits the record at every checkpoint, so the
-// newest copy is always in the deleting commit's parent. An in_progress record with no
-// ship phase is stamped shipped at landing. Exit 0 on every outcome: the callers are ship
-// paths and this script never blocks one.
+
+// src/bins/gauntlet-telemetry-salvage.mjs
 import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { isAbsolute, join } from "node:path";
 import { spawnSync } from "node:child_process";
 import process from "node:process";
-import { mergeGauntlet, resolveTelemetry } from "../extensions/lib/gauntlet-settings.ts";
-import { isSpecPath, recordPathFor } from "../extensions/lib/telemetry-paths.ts";
-import { BASE_REFS } from "../extensions/lib/telemetry-ship.ts";
-import { parseRecord, serializeRecord } from "../extensions/lib/telemetry-record.ts";
 
-const GIT_TIMEOUT_MS = 10_000;
-const COMMIT_TIMEOUT_MS = Number(process.env.GAUNTLET_SALVAGE_COMMIT_TIMEOUT_MS) || 30_000;
-const GIT_ENV = { ...process.env, GIT_TERMINAL_PROMPT: "0", GIT_EDITOR: "true" };
+// extensions/lib/gauntlet-settings.ts
+import path from "node:path";
+function mergeGauntlet(preset, repo) {
+  return { ...preset ?? {}, ...repo ?? {} };
+}
+var nonEmptyString = (v) => typeof v === "string" && v.trim().length > 0;
+var joinWarn = (ws) => ws.length ? ws.join("; ") : void 0;
+var DEFAULT_TELEMETRY_DIR = ".pi/gauntlet/telemetry";
+var DEFAULT_TELEMETRY_BUCKETS = [
+  ["test", ["**/test/**", "**/tests/**", "**/__tests__/**", "**/*.test.*", "**/*.spec.*", "**/*_test.*"]],
+  ["docs", ["**/*.md"]],
+  ["config", ["**/*.json", "**/*.yaml", "**/*.yml", "**/*.toml", "**/*.lock", "**/*-lock.*"]]
+];
+function resolveTelemetry(g) {
+  const t = g.telemetry;
+  const warnings = [];
+  const enabled = t?.enabled !== false;
+  let dir = DEFAULT_TELEMETRY_DIR;
+  if (t?.dir !== void 0) {
+    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");
+  }
+  let buckets = DEFAULT_TELEMETRY_BUCKETS;
+  if (t?.buckets !== void 0) {
+    const b = t.buckets;
+    const valid = b !== null && typeof b === "object" && !Array.isArray(b) && Object.keys(b).length > 0 && Object.values(b).every((v) => Array.isArray(v) && v.length > 0 && v.every(nonEmptyString));
+    if (valid) buckets = Object.entries(b).map(([name, globs]) => [name, [...globs]]);
+    else warnings.push("telemetry.buckets is not an object of non-empty glob arrays; using the defaults");
+  }
+  return { enabled, dir, buckets, warning: joinWarn(warnings) };
+}
+
+// extensions/lib/phase-tracker-helpers.ts
+var STMT_START = "(?:^|[\\n;&|(])\\s*";
+
+// extensions/lib/telemetry-paths.ts
+var isSpecPath = (rel) => /(^|\/)doc\/specs\/[^/]+\.md$/.test(rel);
+var recordPathFor = (dir, specRel) => `${dir}/${specRel.replace(/\.md$/, ".yaml")}`;
+var GIT_FLAGS = "git\\s+(?:-\\S+(?:\\s+\\S+)?\\s+)*";
+var SHIP_RE = new RegExp(STMT_START + "(" + GIT_FLAGS + "(?:merge\\s+--squash|push)(?=\\s|$)|gh\\s+pr\\s+create)");
+var DISCARD_RE = new RegExp(STMT_START + "(" + GIT_FLAGS + "(?:worktree\\s+remove|branch\\s+-D)(?=\\s|$))");
+var SQUASH_RE = new RegExp("^" + GIT_FLAGS + "merge\\s+--squash");
+
+// extensions/lib/telemetry-ship.ts
+var BASE_REFS = ["origin/HEAD", "main", "master"];
+
+// extensions/lib/telemetry-record.ts
+import { Document, isCollection, isMap, isSeq, parse as parseYaml, stringify as stringifyYaml } from "yaml";
+var emptyAccumulators = () => ({ phases: {}, personas: {}, reviews: {}, spec_writes: {}, gates: { spec_rounds: 0, plan_rounds: 0, fix_round_grants: 0, task_reopens: 0 }, conformance_loops: 0, amendments: 0, spec_edits_after_ship: 0, events_dropped: 0 });
+function newRecord(o) {
+  return { schema: 1, spec: o.spec, run_id: o.runId, branch: o.branch, status: "in_progress", created_at: o.now, sessions: [o.session], derived: { duration_s: 0, phases: {}, personas: {}, conformance_loops: 0, gates: { spec_rounds: 0, plan_rounds: 0, fix_round_grants: 0, task_reopens: 0 }, amendments: 0, spec_edits_after_ship: 0, spec_writes: {}, events_dropped: 0 }, accumulators: {}, events: [] };
+}
+var stripUndefined = (v) => {
+  if (Array.isArray(v)) return v.map(stripUndefined);
+  if (v && typeof v === "object") return Object.fromEntries(Object.entries(v).filter(([, x]) => x !== void 0).map(([k, x]) => [k, stripUndefined(x)]));
+  return v;
+};
+var flowLeafChildren = (map, blockLists = /* @__PURE__ */ new Set()) => {
+  for (const pair of map.items) {
+    const key = String(pair.key);
+    const child = pair.value;
+    if (!isCollection(child) || blockLists.has(key)) continue;
+    if (isMap(child) && child.items.length > 0 && child.items.every((item) => isMap(item.value))) {
+      for (const item of child.items) if (isCollection(item.value)) item.value.flow = true;
+    } else {
+      child.flow = true;
+    }
+  }
+};
+var flowModelLists = (node) => {
+  if (isMap(node)) {
+    for (const pair of node.items) {
+      if (String(pair.key) === "models" && isSeq(pair.value)) pair.value.flow = true;
+      flowModelLists(pair.value);
+    }
+  } else if (isSeq(node)) {
+    for (const item of node.items) flowModelLists(item);
+  }
+};
+function serializeRecord(rec) {
+  const { derived, accumulators, events, ...head } = rec;
+  const body = stripUndefined({ ...head, derived, accumulators });
+  const doc = new Document(body);
+  const derivedNode = doc.get("derived", true);
+  if (isMap(derivedNode)) flowLeafChildren(derivedNode, /* @__PURE__ */ new Set(["modified_files"]));
+  const accumulatorNode = doc.get("accumulators", true);
+  if (isMap(accumulatorNode)) {
+    for (const session of accumulatorNode.items) if (isMap(session.value)) flowLeafChildren(session.value);
+  }
+  flowModelLists(doc.contents);
+  const bodyText = doc.toString({ lineWidth: 0 });
+  const eventLines = events.map((e) => "  - " + stringifyYaml(stripUndefined(e), { collectionStyle: "flow", lineWidth: 0 }).trim());
+  return bodyText + "events:\n" + (eventLines.length ? eventLines.join("\n") + "\n" : "");
+}
+function parseRecord(text) {
+  let doc;
+  try {
+    doc = parseYaml(text);
+  } catch {
+    return void 0;
+  }
+  if (!doc || typeof doc !== "object") return void 0;
+  const d = doc;
+  if (d.schema !== 1 || typeof d.spec !== "string" || typeof d.run_id !== "string") return void 0;
+  const accumulators = Object.fromEntries(Object.entries(d.accumulators ?? {}).flatMap(
+    ([session, block]) => block && typeof block === "object" && !Array.isArray(block) ? [[session, { ...emptyAccumulators(), ...block }]] : []
+  ));
+  return { ...d, sessions: Array.isArray(d.sessions) ? d.sessions : [], derived: d.derived ?? newRecord({ spec: d.spec, session: "", now: d.created_at ?? "", runId: d.run_id }).derived, accumulators, events: Array.isArray(d.events) ? d.events : [] };
+}
 
-const usage = () => {
+// src/bins/gauntlet-telemetry-salvage.mjs
+var GIT_TIMEOUT_MS = 1e4;
+var COMMIT_TIMEOUT_MS = Number(process.env.GAUNTLET_SALVAGE_COMMIT_TIMEOUT_MS) || 3e4;
+var GIT_ENV = { ...process.env, GIT_TERMINAL_PROMPT: "0", GIT_EDITOR: "true" };
+var usage = () => {
   process.stderr.write("usage: gauntlet-telemetry-salvage --worktree <abs path> [--base <ref>] [--dir <telemetry dir>] [--check]\n");
   process.exit(1);
 };
-
 function parseArgs(argv) {
-  const opts = { worktree: undefined, base: undefined, dir: undefined, check: false };
+  const opts = { worktree: void 0, base: void 0, dir: void 0, check: false };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
-    if (a === "--worktree" && argv[i + 1] !== undefined && !argv[i + 1].startsWith("--")) opts.worktree = argv[++i];
-    else if (a === "--base" && argv[i + 1] !== undefined && !argv[i + 1].startsWith("--")) opts.base = argv[++i];
-    else if (a === "--dir" && argv[i + 1] !== undefined && !argv[i + 1].startsWith("--")) opts.dir = argv[++i];
+    if (a === "--worktree" && argv[i + 1] !== void 0 && !argv[i + 1].startsWith("--")) opts.worktree = argv[++i];
+    else if (a === "--base" && argv[i + 1] !== void 0 && !argv[i + 1].startsWith("--")) opts.base = argv[++i];
+    else if (a === "--dir" && argv[i + 1] !== void 0 && !argv[i + 1].startsWith("--")) opts.dir = argv[++i];
     else if (a === "--check") opts.check = true;
     else usage();
   }
   if (!opts.worktree || !isAbsolute(opts.worktree)) usage();
   return opts;
 }
-
 function git(cwd, args, timeout = GIT_TIMEOUT_MS) {
   const r = spawnSync("git", args, { cwd, encoding: "utf8", env: GIT_ENV, timeout });
   const timedOut = r.error?.code === "ETIMEDOUT";
   const stderr = timedOut ? "timed out" : (r.stderr ?? "").trim().split("\n")[0] || r.error?.message || `git exited ${r.status}`;
   return { ok: !timedOut && r.status === 0, stdout: (r.stdout ?? "").trim(), stderr, timedOut };
 }
-
 function readLayer(file) {
   if (!existsSync(file)) return {};
   try {
     return JSON.parse(readFileSync(file, "utf8"));
   } catch (e) {
-    process.stderr.write(`warning: ${file}: ${e.message}; using {} for this layer\n`);
+    process.stderr.write(`warning: ${file}: ${e.message}; using {} for this layer
+`);
     return {};
   }
 }
-
-// Same two layers the recorder reads (gauntlet-settings-loader.ts), without the pi import.
 function telemetrySettings(root) {
   const agentDir = process.env.PI_CODING_AGENT_DIR || join(homedir(), ".pi", "agent");
   const preset = readLayer(join(agentDir, "settings.json"));
   const repo = readLayer(join(root, ".pi", "settings.json"));
   return resolveTelemetry(mergeGauntlet(preset?.piGauntlet, repo?.piGauntlet));
 }
-
 function resolveBase(root, explicit) {
   for (const ref of explicit ? [explicit] : BASE_REFS) {
     if (git(root, ["rev-parse", "--verify", "-q", `${ref}^{commit}`]).ok) return ref;
   }
-  return undefined;
+  return void 0;
 }
-
-// in_progress with no ship phase: the recorder lost its binding before the ship, so the
-// landing finishes the record instead of leaving it in_progress on main forever.
-const unfinished = (rec) => {
+var unfinished = (rec) => {
   const phases = rec?.derived?.phases;
   return rec?.status === "in_progress" && (phases === null || typeof phases !== "object" || !("ship" in phases));
 };
-const stamped = (rec, now) => serializeRecord({ ...rec, status: "shipped", shipped_at: now });
-
+var stamped = (rec, now) => serializeRecord({ ...rec, status: "shipped", shipped_at: now });
 function stampPresent(root, rec, check) {
   const line = `present ${rec}`;
   const abs = join(root, rec);
-  // Only a copy identical to HEAD in both worktree and index is script-owned.
   if (!existsSync(abs) || !git(root, ["diff", "--quiet", "HEAD", "--", rec]).ok || !git(root, ["diff", "--quiet", "--cached", "HEAD", "--", rec]).ok) return line;
   const parsed = parseRecord(readFileSync(abs, "utf8"));
   if (!unfinished(parsed)) return line;
@@ -91,14 +187,13 @@ function stampPresent(root, rec, check) {
     git(root, ["reset", "-q", "--", rec]);
     return `restore failed ${rec}: ${reason}`;
   };
-  writeFileSync(abs, stamped(parsed, new Date().toISOString()));
+  writeFileSync(abs, stamped(parsed, (/* @__PURE__ */ new Date()).toISOString()));
   const add = git(root, ["add", "-f", "--", rec]);
   if (!add.ok) return failed(add.stderr);
   const commit = git(root, ["commit", "-q", "-m", `telemetry: mark ${rec} shipped at landing`, "--", rec], COMMIT_TIMEOUT_MS);
   if (!commit.ok) return failed(commit.stderr);
   return `${line} (marked shipped)`;
 }
-
 function salvage(root, rec, base, check) {
   const presence = git(root, ["cat-file", "-e", `HEAD:${rec}`]);
   if (presence.timedOut) return `restore failed ${rec}: timed out`;
@@ -111,11 +206,9 @@ function salvage(root, rec, base, check) {
   const del = deletion.stdout;
   if (!del) return `never written ${rec}`;
   if (check) return `stripped ${rec} in ${del}`;
-
   const abs = join(root, rec);
   const onDisk = existsSync(abs);
   const preStaged = git(root, ["ls-files", "--", rec]).stdout !== "";
-  // A pre-staged record is user-owned and can only be committed when the worktree matches it.
   if (preStaged && (!onDisk || !git(root, ["diff", "--quiet", "--", rec]).ok)) {
     return `restore failed ${rec}: staged copy differs from worktree`;
   }
@@ -123,7 +216,7 @@ function salvage(root, rec, base, check) {
   let stagedByScript = false;
   let priorBytes;
   const rollback = () => {
-    if (priorBytes !== undefined) {
+    if (priorBytes !== void 0) {
       writeFileSync(abs, priorBytes);
       if (preStaged) git(root, ["add", "-f", "--", rec]);
     }
@@ -134,7 +227,6 @@ function salvage(root, rec, base, check) {
     rollback();
     return `restore failed ${rec}: ${reason}`;
   };
-
   if (!onDisk) {
     const co = git(root, ["checkout", `${del}^`, "--", rec]);
     if (!co.ok) return `restore failed ${rec}: ${co.stderr}`;
@@ -145,7 +237,7 @@ function salvage(root, rec, base, check) {
   const parsed = parseRecord(readFileSync(abs, "utf8"));
   if (unfinished(parsed)) {
     priorBytes = readFileSync(abs);
-    writeFileSync(abs, stamped(parsed, new Date().toISOString()));
+    writeFileSync(abs, stamped(parsed, (/* @__PURE__ */ new Date()).toISOString()));
     suffix = " (marked shipped)";
   }
   const add = git(root, ["add", "-f", "--", rec]);
@@ -154,21 +246,20 @@ function salvage(root, rec, base, check) {
   if (!commit.ok) return failed(commit.stderr);
   return `restored ${rec} from ${del}${suffix}`;
 }
-
 function main() {
   const opts = parseArgs(process.argv.slice(2));
-  const override = opts.dir === undefined
-    ? undefined
-    : resolveTelemetry({ telemetry: { enabled: true, dir: opts.dir } });
+  const override = opts.dir === void 0 ? void 0 : resolveTelemetry({ telemetry: { enabled: true, dir: opts.dir } });
   if (override?.warning) usage();
   const top = git(opts.worktree, ["rev-parse", "--show-toplevel"]);
   if (!existsSync(opts.worktree) || !top.ok) {
-    process.stderr.write(`not a git worktree: ${opts.worktree}\n`);
+    process.stderr.write(`not a git worktree: ${opts.worktree}
+`);
     return;
   }
   const root = top.stdout;
   const telemetry = telemetrySettings(root);
-  if (telemetry.warning) process.stderr.write(`warning: ${telemetry.warning}\n`);
+  if (telemetry.warning) process.stderr.write(`warning: ${telemetry.warning}
+`);
   if (!telemetry.enabled) return console.log("telemetry disabled");
   const dir = override?.dir ?? telemetry.dir;
   const base = resolveBase(root, opts.base);
@@ -179,5 +270,4 @@ function main() {
   if (specs.length === 0) return console.log("no spec on branch");
   for (const spec of specs) console.log(salvage(root, recordPathFor(dir, spec), base, opts.check));
 }
-
 main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-gauntlet",
-  "version": "5.12.0",
+  "version": "5.12.1",
   "description": "Opinionated, gated workflow skills, subagent personas, and runtime extensions for the pi coding agent.",
   "author": "Jacek Juraszek",
   "type": "module",
@@ -58,9 +58,13 @@
   "scripts": {
     "postinstall": "node ./bin/install-agents.mjs",
     "link-agents": "node ./bin/install-agents.mjs",
+    "build:bins": "node scripts/build-bins.mjs",
     "test": "node scripts/ci.mjs"
   },
   "dependencies": {
     "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "esbuild": "0.28.2"
   }
 }