@geonosis/ratchet 2.2.0 → 2.3.1

package/README.md

@@ -1,5 +1,8 @@
 # @geonosis/ratchet
 
+Through the front door: `geonosis ratchet` — the metapackage pins this and every other kit tool at
+ONE version, and passes the exit code through unchanged.
+
 Debt as a number that may only shrink. It measures a repo's counters, compares each against a
 committed baseline, and fails **only** on regression — so a repo can adopt a gate the day it is
 written, with the existing debt named rather than forgiven, and nothing new can land behind it.
@@ -66,6 +69,34 @@ A counter you wrote yourself takes a `probe` beside its `run`: `{ input: (dir) =
 (dir) => string, params?, expect: number }`. `expect` is what the planted input is worth, and it is
 at least 1 — a probe that plants nothing proves nothing.
 
+### A probe proves the command, not the regex
+
+A shipped probe plants an input in the shape the counter's OWN default reads. `archViolations`
+plants a scanner that prints `✗ …` lines and exits non-zero; `sumOfCounts` plants a line its default
+`match` counts. That proves the command is spawned, its output is captured and its exit code is told
+apart from its findings — and it proves nothing whatever about a `match` YOUR config supplies,
+because the planted input was written for the default one.
+
+This was measured, not imagined: a consumer's mis-escaped `match` read 0 from a real scan, `--prove`
+said PROVEN off the shipped plant, and the ratchet lowered the baseline — ten pieces of debt erased
+with a congratulatory message (#140).
+
+So the counters that take a reading param — `archViolations` (`match`), `sumOfCounts` (`match`),
+`duplication` (`headings`), `todos` (`markers`) — require a sample from the config that supplied it:
+
+```jsonc
+{
+  "counter": "archViolations",
+  "command": "node scripts/scan-architecture.mjs",
+  "match": "^VIOLATION ",
+  "probe": { "sample": "VIOLATION a\nVIOLATION b\nfine\n", "expect": 2 }
+}
+```
+
+Without the `probe` block the line reads `UNPROVEN`, naming the param and its value. With it, the
+sample is run through YOUR match and must count `expect` — a sample your match cannot read is a
+refusal that names the match, not a zero.
+
 ### A baseline is not proof the gate still gates
 
 The ratchet compares a number against a number. Swapping the tool that produces it — a vendored lint
@@ -196,9 +227,9 @@ captured from the binary rather than guessed at:
 
 | Runner | The line | Read as |
 | --- | --- | --- |
-| vitest 3.2.7 | `      Tests  1 failed \| 1 passed (2)` | 1 |
-| vitest 3.2.7 | `      Tests  3 passed (3)` · `      Tests  2 skipped (2)` | 0 |
-| vitest 3.2.7 | `      Tests  no tests` (a suite that threw before collecting) | **refused** |
+| vitest 3.2.7 · 4.1.11 | `      Tests  1 failed \| 1 passed (2)` | 1 |
+| vitest 3.2.7 · 4.1.11 | `      Tests  3 passed (3)` · `      Tests  2 skipped (2)` | 0 |
+| vitest 3.2.7 · 4.1.11 | `      Tests  no tests` (a suite that threw before collecting) | **refused** |
 | bun 1.4.0 | ` 1 fail` on its own line | 1 |
 | bun 1.4.0 | ` 0 fail` | 0 |
 

package/dist/{chunk-IQ6TXLWC.js → chunk-E55APSHM.js}

@@ -74,8 +74,14 @@ var versionOf = (moduleUrl) => {
 import { randomUUID } from "crypto";
 import { linkSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
 import { homedir } from "os";
-import { dirname as dirname2, join as join2 } from "path";
-var heavyLockPath = () => process.env.GEONOSIS_HEAVY_LOCK ?? join2(homedir(), ".cache", "geonosis", "heavy.lock");
+import { dirname as dirname2, isAbsolute, join as join2 } from "path";
+var heavyLockPath = () => {
+  const named = process.env.GEONOSIS_HEAVY_LOCK;
+  if (named !== void 0 && named !== "") return named;
+  const declared = process.env.XDG_CACHE_HOME;
+  const cache = declared !== void 0 && isAbsolute(declared) ? declared : join2(homedir(), ".cache");
+  return join2(cache, "geonosis", "heavy.lock");
+};
 var sleep = (ms) => new Promise((done) => setTimeout(done, ms));
 var holderOf = (path) => {
   try {
@@ -606,6 +612,10 @@ var scannerProbe = {
 var archViolations = {
   id: "archViolations",
   probe: { ...scannerProbe, expect: 2 },
+  // #30: the shipped probe runs a scanner that prints `✗`, so it proves the COMMAND and never a
+  // `match` a repo configured for its own scanner's shape. Declared here, a customised match is
+  // UNPROVEN until the config declares a sample of its own.
+  readingParams: ["match"],
   run: async ({ params, run }) => {
     const command = stringParam("archViolations", params, "command");
     const match = new RegExp(stringParam("archViolations", params, "match", "^\u2717"));
@@ -790,9 +800,119 @@ var boundaryIssues = {
   }
 };
 
-// src/counters/format.ts
-import { existsSync as existsSync4 } from "fs";
+// src/counters/dx.ts
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "fs";
 import { resolve as resolve7 } from "path";
+var DEFAULT_BUMP_REPORT = ".geonosis/bump-report.json";
+var bumpFile = (id, cwd, params) => {
+  const relative = stringParam(id, params, "report", DEFAULT_BUMP_REPORT);
+  const path = resolve7(cwd, relative);
+  if (!existsSync4(path)) {
+    throw new CounterError(
+      id,
+      `no bump report at ${relative} \u2014 this repo has never run \`geonosis update\`, and a zero here would read as a bump that took no time`
+    );
+  }
+  try {
+    return JSON.parse(readFileSync6(path, "utf8"));
+  } catch (error) {
+    throw new CounterError(id, `${relative} is not readable JSON: ${error.message}`);
+  }
+};
+var REPORT_WITH_A_GREEN_DOCTOR = JSON.stringify({
+  at: "2026-09-03T09:00:00.000Z",
+  durationMs: 12e3,
+  ok: true,
+  steps: [
+    { detail: "", durationMs: 5e3, ok: true, ran: true, step: "install" },
+    { detail: "", durationMs: 7e3, ok: true, ran: true, step: "doctor" }
+  ],
+  to: "2.2.0"
+});
+var bumpDurationMs = {
+  id: "bumpDurationMs",
+  probe: {
+    expect: 12e3,
+    input: (dir) => plant(dir, DEFAULT_BUMP_REPORT, REPORT_WITH_A_GREEN_DOCTOR)
+  },
+  run: async ({ cwd, params }) => {
+    const report = bumpFile("bumpDurationMs", cwd, params);
+    if (typeof report.durationMs !== "number") {
+      throw new CounterError(
+        "bumpDurationMs",
+        "the bump report carries no durationMs \u2014 it was written by a build that did not time itself"
+      );
+    }
+    return report.durationMs;
+  },
+  tolerates: true
+};
+var timeToGreenDoctorMs = {
+  id: "timeToGreenDoctorMs",
+  probe: {
+    expect: 12e3,
+    input: (dir) => plant(dir, DEFAULT_BUMP_REPORT, REPORT_WITH_A_GREEN_DOCTOR)
+  },
+  run: async ({ cwd, params }) => {
+    const steps = bumpFile("timeToGreenDoctorMs", cwd, params).steps ?? [];
+    const at = steps.findIndex((one) => one.step === "doctor");
+    if (at === -1) {
+      throw new CounterError(
+        "timeToGreenDoctorMs",
+        "the bump report names no doctor step, so nothing in it says when this repo first read green"
+      );
+    }
+    if (steps[at]?.ok !== true) {
+      throw new CounterError(
+        "timeToGreenDoctorMs",
+        "the doctor step of the last bump was not green \u2014 there is no time to a green that never came"
+      );
+    }
+    return steps.slice(0, at + 1).reduce((total2, one) => total2 + (typeof one.durationMs === "number" ? one.durationMs : 0), 0);
+  },
+  tolerates: true
+};
+var SEPARATOR = /^\|[\s:|-]*\|\s*$/;
+var ROW = /^\|.*\|\s*$/;
+var cellsOf = (line) => line.replace(/^\|/, "").replace(/\|\s*$/, "").split("|").map((one) => one.trim());
+var openBacklogRows = {
+  id: "openBacklogRows",
+  probe: {
+    expect: 2,
+    input: (dir) => plant(
+      dir,
+      "backlog.md",
+      [
+        "| # | Finding | Status |",
+        "|---|---|---|",
+        "| 1 | closed | **DONE** |",
+        "| 2 | still here | open |",
+        "| 3 | also here | open \u2014 next |",
+        ""
+      ].join("\n")
+    ),
+    params: { path: "backlog.md" }
+  },
+  run: async ({ cwd, params }) => {
+    const relative = stringParam("openBacklogRows", params, "path");
+    const done = stringParam("openBacklogRows", params, "done", "DONE");
+    const at = resolve7(cwd, relative);
+    if (!existsSync4(at)) {
+      throw new CounterError("openBacklogRows", `no register at ${relative}`);
+    }
+    const lines = readFileSync6(at, "utf8").split("\n");
+    return lines.filter((line, index) => {
+      if (!ROW.test(line) || SEPARATOR.test(line)) return false;
+      if (SEPARATOR.test(lines[index + 1] ?? "")) return false;
+      const status = cellsOf(line).at(-1) ?? "";
+      return status !== "" && !status.includes(done);
+    }).length;
+  }
+};
+
+// src/counters/format.ts
+import { existsSync as existsSync5 } from "fs";
+import { resolve as resolve8 } from "path";
 var unformattedFiles = {
   id: "unformattedFiles",
   probe: {
@@ -807,13 +927,13 @@ var unformattedFiles = {
       "command",
       "npx oxfmt --config .oxfmtrc.json --list-different ."
     );
-    return run(command).output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && existsSync4(resolve7(cwd, line))).length;
+    return run(command).output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && existsSync5(resolve8(cwd, line))).length;
   }
 };
 
 // src/counters/gate-report.ts
-import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
-import { resolve as resolve8 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve9 } from "path";
 var DEFAULT_REPORT = ".geonosis/gate-report.json";
 var fastTierMs = {
   id: "fastTierMs",
@@ -836,9 +956,9 @@ var fastTierMs = {
     const wanted = stringParam("fastTierMs", params, "tier", "fast");
     const own = `.geonosis/gate-report.${wanted}.json`;
     const asked = stringParam("fastTierMs", params, "report", "");
-    const relative = asked !== "" ? asked : existsSync5(resolve8(cwd, own)) ? own : DEFAULT_REPORT;
-    const path = resolve8(cwd, relative);
-    if (!existsSync5(path)) {
+    const relative = asked !== "" ? asked : existsSync6(resolve9(cwd, own)) ? own : DEFAULT_REPORT;
+    const path = resolve9(cwd, relative);
+    if (!existsSync6(path)) {
       throw new CounterError(
         "fastTierMs",
         `no gate report at ${relative} \u2014 run \`geonosis-verify ${wanted}\` before measuring it`
@@ -846,7 +966,7 @@ var fastTierMs = {
     }
     let report;
     try {
-      report = JSON.parse(readFileSync6(path, "utf8"));
+      report = JSON.parse(readFileSync7(path, "utf8"));
     } catch (error) {
       throw new CounterError(
         "fastTierMs",
@@ -868,8 +988,8 @@ var fastTierMs = {
 };
 
 // src/counters/law.ts
-import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
-import { resolve as resolve9 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync8 } from "fs";
+import { resolve as resolve10 } from "path";
 var lawLineCount = {
   id: "lawLineCount",
   probe: {
@@ -879,15 +999,15 @@ var lawLineCount = {
   },
   run: async ({ cwd, params }) => {
     const relative = stringParam("lawLineCount", params, "path", "CLAUDE.md");
-    const path = resolve9(cwd, relative);
-    if (!existsSync6(path)) throw new CounterError("lawLineCount", `no law file at ${relative}`);
-    return readFileSync7(path, "utf8").replace(/\n$/, "").split("\n").length;
+    const path = resolve10(cwd, relative);
+    if (!existsSync7(path)) throw new CounterError("lawLineCount", `no law file at ${relative}`);
+    return readFileSync8(path, "utf8").replace(/\n$/, "").split("\n").length;
   }
 };
 
 // src/counters/oxlint.ts
-import { existsSync as existsSync7, readFileSync as readFileSync8, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "fs";
-import { resolve as resolve10 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync9, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "fs";
+import { resolve as resolve11 } from "path";
 var DEFAULT_COMMAND = "npx oxlint --format=unix --config .oxlintrc.json .";
 var PROBE_COMMAND = "oxlint --format=unix --config .oxlintrc.json .";
 var oxlintProbe = (severity, rule, source) => ({
@@ -1050,26 +1170,26 @@ var oxlintRule = {
     const config = typeof params.config === "string" ? params.config : "";
     const expect = expectedFormat("oxlintRule", params);
     if (config === "") return countRule(run(command), rule, expect);
-    const source = resolve10(cwd, config);
-    if (!existsSync7(source)) throw new CounterError("oxlintRule", `no config at ${config}`);
+    const source = resolve11(cwd, config);
+    if (!existsSync8(source)) throw new CounterError("oxlintRule", `no config at ${config}`);
     const strictName = `.oxlintrc.ratchet-${key}.json`;
-    const strict = readFileSync8(source, "utf8").replace(
+    const strict = readFileSync9(source, "utf8").replace(
       new RegExp(`("[^"]*${escapeForRegex(rule)}"\\s*:\\s*\\[?\\s*)"(warn|off)"`),
       '$1"error"'
     );
-    writeFileSync6(resolve10(cwd, strictName), strict);
+    writeFileSync6(resolve11(cwd, strictName), strict);
     try {
       return countRule(run(command.replace("{config}", strictName)), rule, expect);
     } finally {
-      rmSync3(resolve10(cwd, strictName), { force: true });
+      rmSync3(resolve11(cwd, strictName), { force: true });
     }
   }
 };
 
 // src/counters/probes.ts
-import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync10 } from "fs";
 import { createRequire } from "module";
-import { join as join6, resolve as resolve11 } from "path";
+import { join as join6, resolve as resolve12 } from "path";
 import { pathToFileURL } from "url";
 var ID = "probelessRules";
 var OFF = /* @__PURE__ */ new Set([0, "0", "allow", "off", false]);
@@ -1147,11 +1267,11 @@ var probelessRules = {
   },
   run: async ({ cwd, params }) => {
     const relative = stringParam(ID, params, "config", ".oxlintrc.json");
-    const path = resolve11(cwd, relative);
-    if (!existsSync8(path)) throw new CounterError(ID, `no oxlint config at ${relative}`);
+    const path = resolve12(cwd, relative);
+    if (!existsSync9(path)) throw new CounterError(ID, `no oxlint config at ${relative}`);
     let config;
     try {
-      config = JSON.parse(readFileSync9(path, "utf8"));
+      config = JSON.parse(readFileSync10(path, "utf8"));
     } catch (error) {
       throw new CounterError(ID, `${relative} does not parse: ${error.message}`);
     }
@@ -1188,8 +1308,8 @@ import { readdirSync as readdirSync3 } from "fs";
 import { join as join8 } from "path";
 
 // src/counters/workspace.ts
-import { existsSync as existsSync9, readdirSync as readdirSync2, readFileSync as readFileSync10 } from "fs";
-import { join as join7, resolve as resolve12 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync2, readFileSync as readFileSync11 } from "fs";
+import { join as join7, resolve as resolve13 } from "path";
 var SKIP = /^(node_modules|\.)/;
 var childDirs = (dir) => {
   try {
@@ -1203,14 +1323,14 @@ var expand = (root, pattern) => {
   const segments = pattern.split("/").filter((one) => one !== "" && one !== ".");
   let dirs = [root];
   for (const segment of segments) {
-    dirs = segment === "*" ? dirs.flatMap((dir) => childDirs(dir)) : segment === "**" ? dirs.flatMap((dir) => descendants(dir, 3)) : dirs.map((dir) => join7(dir, segment)).filter((dir) => existsSync9(dir));
+    dirs = segment === "*" ? dirs.flatMap((dir) => childDirs(dir)) : segment === "**" ? dirs.flatMap((dir) => descendants(dir, 3)) : dirs.map((dir) => join7(dir, segment)).filter((dir) => existsSync10(dir));
   }
   return dirs;
 };
 var QUOTED = /^['"]|['"]$/g;
 var cleaned = (value) => value.replace(/#.*$/, "").trim().replaceAll(QUOTED, "");
 var pnpmPatterns = (path) => {
-  const lines = readFileSync10(path, "utf8").split("\n");
+  const lines = readFileSync11(path, "utf8").split("\n");
   const at = lines.findIndex((line) => line.startsWith("packages:"));
   if (at === -1) return [];
   const inline = lines[at]?.slice("packages:".length).trim() ?? "";
@@ -1229,31 +1349,31 @@ var pnpmPatterns = (path) => {
   return patterns;
 };
 var npmPatterns = (path) => {
-  const parsed = JSON.parse(readFileSync10(path, "utf8"));
+  const parsed = JSON.parse(readFileSync11(path, "utf8"));
   const declared = Array.isArray(parsed.workspaces) ? parsed.workspaces : parsed.workspaces?.packages ?? [];
   return declared.filter((one) => typeof one === "string");
 };
 var nameOf = (dir) => {
   const manifest = join7(dir, "package.json");
-  if (!existsSync9(manifest)) return void 0;
+  if (!existsSync10(manifest)) return void 0;
   try {
-    const { name } = JSON.parse(readFileSync10(manifest, "utf8"));
+    const { name } = JSON.parse(readFileSync11(manifest, "utf8"));
     return typeof name === "string" && name !== "" ? name : void 0;
   } catch {
     return void 0;
   }
 };
 var workspaceDirs = (cwd) => {
-  const root = resolve12(cwd);
+  const root = resolve13(cwd);
   const pnpm = join7(root, "pnpm-workspace.yaml");
   const manifest = join7(root, "package.json");
-  const patterns = existsSync9(pnpm) ? pnpmPatterns(pnpm) : existsSync9(manifest) ? npmPatterns(manifest) : [];
-  const dirs = patterns.filter((pattern) => !pattern.startsWith("!")).flatMap((pattern) => expand(root, pattern)).filter((dir) => existsSync9(join7(dir, "package.json")));
+  const patterns = existsSync10(pnpm) ? pnpmPatterns(pnpm) : existsSync10(manifest) ? npmPatterns(manifest) : [];
+  const dirs = patterns.filter((pattern) => !pattern.startsWith("!")).flatMap((pattern) => expand(root, pattern)).filter((dir) => existsSync10(join7(dir, "package.json")));
   return [...new Set(dirs)];
 };
 var manifestOf = (dir) => {
   try {
-    const parsed = JSON.parse(readFileSync10(join7(dir, "package.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync11(join7(dir, "package.json"), "utf8"));
     return typeof parsed === "object" && parsed !== null ? parsed : void 0;
   } catch {
     return void 0;
@@ -1321,8 +1441,8 @@ var packagesWithoutTypecheck = {
 };
 
 // src/counters/seams.ts
-import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync11 } from "fs";
-import { join as join9, resolve as resolve13 } from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync4, readFileSync as readFileSync12 } from "fs";
+import { join as join9, resolve as resolve14 } from "path";
 var CONFIG = "geonosis.json";
 var SKIP_DIRS = /* @__PURE__ */ new Set([".git", ".turbo", "coverage", "dist", "node_modules"]);
 var asPattern = (glob) => new RegExp(
@@ -1338,16 +1458,16 @@ var filesUnder = (root, at = root) => readdirSync4(at, { withFileTypes: true }).
 });
 var seamGlobsIn = (root) => {
   const at = join9(root, CONFIG);
-  if (!existsSync10(at)) return [];
+  if (!existsSync11(at)) return [];
   try {
-    const seams = JSON.parse(readFileSync11(at, "utf8")).adoption?.seams;
+    const seams = JSON.parse(readFileSync12(at, "utf8")).adoption?.seams;
     return Array.isArray(seams) ? seams.filter((one) => typeof one === "string") : [];
   } catch {
     return [];
   }
 };
 var linesIn = (path) => {
-  const body = readFileSync11(path, "utf8");
+  const body = readFileSync12(path, "utf8");
   return body === "" ? 0 : body.replace(/\n$/, "").split("\n").length;
 };
 var adoptionSeamLines = {
@@ -1363,7 +1483,7 @@ var adoptionSeamLines = {
     params: {}
   },
   run: async ({ cwd }) => {
-    const root = resolve13(cwd);
+    const root = resolve14(cwd);
     const globs = seamGlobsIn(root).map(asPattern);
     if (globs.length === 0) return 0;
     return filesUnder(root).filter((one) => globs.some((pattern) => pattern.test(one))).reduce((total2, one) => total2 + linesIn(join9(root, one)), 0);
@@ -1392,8 +1512,8 @@ var sumOfCounts = {
 };
 
 // src/counters/suppressions.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync12 } from "fs";
-import { join as join10, resolve as resolve14 } from "path";
+import { readdirSync as readdirSync5, readFileSync as readFileSync13 } from "fs";
+import { join as join10, resolve as resolve15 } from "path";
 var CODE_FILE = /\.(?:ts|tsx|js|jsx|mjs|cjs|mts|cts|vue|svelte|astro)$/;
 var SKIP3 = /^(?:node_modules|dist|coverage|\.[^.]|__fixtures__)/;
 var SUPPRESSION = /(?:eslint|oxlint|biome)-(?:disable|ignore)(?:-next-line|-line)?|@ts-expect-error|@ts-ignore/g;
@@ -1413,7 +1533,7 @@ var countIn = (dir, depth = 12) => {
     }
     if (!CODE_FILE.test(entry.name)) continue;
     try {
-      found += readFileSync12(join10(dir, entry.name), "utf8").match(SUPPRESSION)?.length ?? 0;
+      found += readFileSync13(join10(dir, entry.name), "utf8").match(SUPPRESSION)?.length ?? 0;
     } catch {
     }
   }
@@ -1427,13 +1547,13 @@ var suppressionCount = {
   },
   run: async ({ cwd, params }) => {
     const roots = stringsParam(params, "roots", ["."]);
-    return roots.reduce((sum, root) => sum + countIn(resolve14(cwd, root)), 0);
+    return roots.reduce((sum, root) => sum + countIn(resolve15(cwd, root)), 0);
   }
 };
 
 // src/counters/surface.ts
-import { existsSync as existsSync11, readFileSync as readFileSync13 } from "fs";
-import { join as join11, resolve as resolve15 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync14 } from "fs";
+import { join as join11, resolve as resolve16 } from "path";
 var DECLARED = /^export\s+(?:declare\s+)?(?:abstract\s+)?(?:const|function|class|type|interface|enum|let|var)\s+([$\w]+)/;
 var BRACED = /^export\s+(?:type\s+)?\{([^}]*)\}(?:\s+from\s+(['"])(.+?)\2)?/;
 var nameOf2 = (spec) => {
@@ -1467,10 +1587,10 @@ var exportedSurfaceIn = (source) => {
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var declarationEntriesOf = (dir) => {
   const at = join11(dir, "package.json");
-  if (!existsSync11(at)) {
+  if (!existsSync12(at)) {
     throw new CounterError("floorSurface", `no package.json in ${dir} \u2014 that is not a package`);
   }
-  const manifest = JSON.parse(readFileSync13(at, "utf8"));
+  const manifest = JSON.parse(readFileSync14(at, "utf8"));
   const found = [];
   const walk = (value) => {
     if (typeof value === "string" && value.endsWith(".d.ts")) found.push(value);
@@ -1501,7 +1621,7 @@ var floorSurface = {
   },
   run: async ({ cwd, params }) => {
     const relative = stringParam("floorSurface", params, "dir");
-    const dir = resolve15(cwd, relative);
+    const dir = resolve16(cwd, relative);
     const entries = declarationEntriesOf(dir);
     if (entries.length === 0) {
       throw new CounterError(
@@ -1511,23 +1631,23 @@ var floorSurface = {
     }
     const names = /* @__PURE__ */ new Set();
     for (const entry of entries) {
-      const at = resolve15(dir, entry);
-      if (!existsSync11(at)) {
+      const at = resolve16(dir, entry);
+      if (!existsSync12(at)) {
         throw new CounterError(
           "floorSurface",
           `${relative} promises ${entry} and it is not there \u2014 build before measuring, or the surface reads as empty`
         );
       }
-      for (const name of exportedSurfaceIn(readFileSync13(at, "utf8")).keys()) names.add(name);
+      for (const name of exportedSurfaceIn(readFileSync14(at, "utf8")).keys()) names.add(name);
     }
     return names.size;
   }
 };
 
 // src/counters/tests.ts
-import { existsSync as existsSync12, mkdtempSync as mkdtempSync2, readFileSync as readFileSync14, rmSync as rmSync4 } from "fs";
+import { existsSync as existsSync13, mkdtempSync as mkdtempSync2, readFileSync as readFileSync15, rmSync as rmSync4 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join12, resolve as resolve16 } from "path";
+import { join as join12, resolve as resolve17 } from "path";
 var COUNTER = "testFailures";
 var VITEST_LINE = /^\s*Tests {2,}(.+?)\s*$/;
 var VITEST_TOTAL = /\(\d+\)$/;
@@ -1559,7 +1679,7 @@ ${output.trim().slice(-500)}`
   );
 };
 var fromReport = (path) => {
-  if (!existsSync12(path)) {
+  if (!existsSync13(path)) {
     throw new CounterError(
       COUNTER,
       `the runner wrote no report at ${path} \u2014 a crash before the reporter is not a pass`
@@ -1567,7 +1687,7 @@ var fromReport = (path) => {
   }
   let report;
   try {
-    report = JSON.parse(readFileSync14(path, "utf8"));
+    report = JSON.parse(readFileSync15(path, "utf8"));
   } catch (error) {
     throw new CounterError(
       COUNTER,
@@ -1591,7 +1711,7 @@ var fromReport = (path) => {
 };
 var reportPathFor = (cwd, params, command) => {
   const named = params.reportPath;
-  if (typeof named === "string" && named !== "") return { own: false, path: resolve16(cwd, named) };
+  if (typeof named === "string" && named !== "") return { own: false, path: resolve17(cwd, named) };
   if (!command.includes(PLACEHOLDER)) {
     throw new CounterError(
       COUNTER,
@@ -1653,13 +1773,13 @@ var testFailures = {
 };
 
 // src/counters/todos.ts
-import { existsSync as existsSync13, readdirSync as readdirSync6, readFileSync as readFileSync15 } from "fs";
-import { join as join13, resolve as resolve17 } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync6, readFileSync as readFileSync16 } from "fs";
+import { join as join13, resolve as resolve18 } from "path";
 var CODE_FILE2 = /\.(?:ts|tsx|js|jsx|mjs|cjs|mts|cts|vue|svelte|astro)$/;
 var SKIP4 = /^(?:node_modules|dist|coverage|\.[^.]|__fixtures__)/;
 var PLAN_FILE = /^(\d{3,})-[a-z\d][a-z\d.-]*\.md$/;
 var plansIn = (dir) => {
-  if (!existsSync13(dir)) return /* @__PURE__ */ new Set();
+  if (!existsSync14(dir)) return /* @__PURE__ */ new Set();
   const found = /* @__PURE__ */ new Set();
   for (const name of readdirSync6(dir)) {
     const number = PLAN_FILE.exec(name)?.[1];
@@ -1684,7 +1804,7 @@ var countIn2 = (dir, marker, plans, depth = 12) => {
     if (!CODE_FILE2.test(entry.name)) continue;
     let text = "";
     try {
-      text = readFileSync15(join13(dir, entry.name), "utf8");
+      text = readFileSync16(join13(dir, entry.name), "utf8");
     } catch {
       continue;
     }
@@ -1708,13 +1828,13 @@ var orphanTodos = {
   readingParams: ["markers"],
   run: async ({ cwd, params }) => {
     const markers = stringsParam(params, "markers", ["TODO", "FIXME"]);
-    const plans = plansIn(resolve17(cwd, stringParam("orphanTodos", params, "plans", "plans")));
+    const plans = plansIn(resolve18(cwd, stringParam("orphanTodos", params, "plans", "plans")));
     const marker = new RegExp(
       `\\b(?:${markers.map(escapeForRegex).join("|")})\\b(?:\\((\\d+)\\))?`,
       "g"
     );
     const roots = stringsParam(params, "roots", ["."]);
-    return roots.reduce((sum, root) => sum + countIn2(resolve17(cwd, root), marker, plans), 0);
+    return roots.reduce((sum, root) => sum + countIn2(resolve18(cwd, root), marker, plans), 0);
   }
 };
 
@@ -1753,8 +1873,8 @@ var typecheckErrors = {
 };
 
 // src/counters/walk.ts
-import { existsSync as existsSync14, readFileSync as readFileSync16 } from "fs";
-import { resolve as resolve18 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync17 } from "fs";
+import { resolve as resolve19 } from "path";
 var DEFAULT_REPORT2 = ".geonosis/walk-report.json";
 var CLASSES = /* @__PURE__ */ new Set([
   "buy-box-above-fold",
@@ -1798,8 +1918,8 @@ var walkFindings = {
   },
   run: async ({ cwd, params }) => {
     const relative = stringParam("walkFindings", params, "report", DEFAULT_REPORT2);
-    const path = resolve18(cwd, relative);
-    if (!existsSync14(path)) {
+    const path = resolve19(cwd, relative);
+    if (!existsSync15(path)) {
       throw new CounterError(
         "walkFindings",
         `no walk report at ${relative} \u2014 run \`geonosis-walk\` before measuring it`
@@ -1807,7 +1927,7 @@ var walkFindings = {
     }
     let report;
     try {
-      report = JSON.parse(readFileSync16(path, "utf8"));
+      report = JSON.parse(readFileSync17(path, "utf8"));
     } catch (error) {
       throw new CounterError(
         "walkFindings",
@@ -1832,6 +1952,7 @@ var COUNTERS = [
   adoptionSeamLines,
   archViolations,
   boundaryIssues,
+  bumpDurationMs,
   bundleBytes,
   cloneCount,
   disabledCiJobs,
@@ -1839,6 +1960,7 @@ var COUNTERS = [
   floorSurface,
   knipIssues,
   lawLineCount,
+  openBacklogRows,
   suppressionCount,
   oxlintErrors,
   oxlintRule,
@@ -1850,6 +1972,7 @@ var COUNTERS = [
   sumOfCounts,
   testFailures,
   testsWithoutRunner,
+  timeToGreenDoctorMs,
   typecheckErrors,
   unformattedFiles,
   walkFindings

package/dist/cli.js

@@ -7,11 +7,11 @@ import {
   runRatchet,
   versionOf,
   writeEnvelope
-} from "./chunk-IQ6TXLWC.js";
+} from "./chunk-E55APSHM.js";
 
 // src/cli.ts
 import process from "process";
-var USAGE = `geonosis-ratchet [--cwd <dir>] [--tier <name>] [--prove] [--exclusive]
+var USAGE = `geonosis-ratchet [--cwd <dir>] [--tier <name>] [--prove] [--exclusive] [--json]
 
 Debt as a number that may only shrink. Runs the counters named in geonosis.ratchet.json, compares
 each against gate-baseline.json, and REWRITES the baseline down when a number shrank \u2014 so the win is
@@ -23,6 +23,7 @@ locked in the same commit that earned it.
   --exclusive                  hold the machine-wide heavy lock for the run
   --exclusive-timeout <secs>   how long to wait for that lock
   --hold <ms>                  take the lock, wait, give it back \u2014 the --prove self-test's slow thing
+  --json                       the run's own report on stdout, for a caller that parses it
   --help, -h                   this text
 
 Exit codes: 0 no counter grew \xB7 1 a counter grew \xB7 2 the run could not measure.
@@ -35,6 +36,7 @@ var KNOWN = /* @__PURE__ */ new Set([
   "--exclusive",
   "--exclusive-timeout",
   "--hold",
+  "--json",
   "--prove",
   "--tier"
 ]);
@@ -91,6 +93,7 @@ var tierFlag = process.argv.indexOf("--tier");
 var tier = tierFlag === -1 ? void 0 : process.argv[tierFlag + 1];
 var proving = process.argv.includes("--prove");
 var exclusive = process.argv.includes("--exclusive");
+var json = process.argv.includes("--json");
 var timeoutFlag = process.argv.indexOf("--exclusive-timeout");
 var timeoutSeconds = timeoutFlag === -1 ? void 0 : Number(process.argv[timeoutFlag + 1] ?? Number.NaN);
 var holdMs = numberAfter("--hold");
@@ -124,18 +127,20 @@ var measure = async () => {
       exclusiveVia: process.argv[1],
       tier
     });
-    process.stdout.write(formatProve(proof));
+    process.stdout.write(json ? `${JSON.stringify(proof, void 0, 2)}
+` : formatProve(proof));
     return proof.proven ? 0 : 2;
   }
   const startedAt = Date.now();
   const result = await runRatchet({ counters: COUNTERS, cwd, tier });
-  process.stdout.write(formatReport(result));
+  if (!json) process.stdout.write(formatReport(result));
   const at = writeEnvelope({
     envelope: envelopeOf(result, Date.now() - startedAt),
     next: ENVELOPE_NEXT,
     root: cwd
   });
-  process.stdout.write(`envelope: ${at}
+  process.stdout.write(json ? `${JSON.stringify(result, void 0, 2)}
+` : `envelope: ${at}
 `);
   if (result.refusals.length > 0) return 2;
   return result.measurements.some((one) => one.verdict === "grew") ? 1 : 0;

package/dist/index.js

@@ -18,7 +18,7 @@ import {
   runRatchet,
   versionOf,
   writeEnvelope
-} from "./chunk-IQ6TXLWC.js";
+} from "./chunk-E55APSHM.js";
 export {
   CONFIG_FILE,
   COUNTERS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geonosis/ratchet",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "types": "./dist/index.d.ts",
   "description": "Debt as a number that may only shrink — one ratchet, pluggable counters.",
   "keywords": [