@geonosis/ratchet 2.6.0 → 2.6.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @geonosis/ratchet
 
+## 2.6.1
+
+### Patch Changes
+
+- e1db50f: `geonosis-ratchet` reads `geonosis.ratchet.json` BEFORE it queues for a heavy slot. The slot
+  directory is machine-wide — it bounds heavy work on the box, not per repo — so a second repo's
+  `geonosis-verify` holds it legitimately, and a run with nothing to count was spending the resource
+  that bounds heavy work in order to discover it had no heavy work, waiting `GEONOSIS_HEAVY_WAIT_MS`
+  (20 minutes by default) to then exit 2. Measured 2026-09-07: with during.day's verify holding the
+  only slot on a memory-clamped one-slot box, this kit's own
+  `registry.test.ts > passes the child bin exit code through verbatim` — which spawns a ratchet into a
+  config-less directory expecting an instant refusal — sat for 979,800 ms against a 60,000 ms timeout,
+  three runs running. It now refuses in about a second with every slot held, and a bin case holds it
+  there: a config-less run must name `geonosis.ratchet.json` and must never say it is waiting.
+- db89b0b: Two Stop-hook defects, both caught by making the instrument go red once. A heavy slot is inherited down a process tree: the holder marks its environment with the slot's path, and a descendant whose mark names a living ancestor's slot takes none of its own — a ratchet inside a verify waited on the slot its parent held, for ever, on a one-slot runner (CI's), and now waits on nobody; a tool that takes twice in one process still gets two. The Stop hook judges a run over a dirty tree: a tree's identity is HEAD plus every change on it, the hook's own files aside; a run launched over that identity is read at the next turn end and not re-run while the tree stands, where before an uncommitted edit meant every turn end launched the tier again and none was judged. The kit's own fast tier now builds first, so the hook never judges bins whose `dist` is older than the `src` under test.
+
 ## 2.6.0
 
 ### Minor Changes

package/dist/{chunk-Z2T6MHHQ.js → chunk-GJD2676B.js}

@@ -1,6 +1,51 @@
+// src/core/config.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+var CONFIG_FILE = "geonosis.ratchet.json";
+var keyOf = (entry) => entry.key ?? entry.counter;
+var loadConfig = (cwd) => {
+  const path = resolve(cwd, CONFIG_FILE);
+  if (!existsSync(path)) {
+    throw new Error(`no ${CONFIG_FILE} in ${cwd} \u2014 the ratchet has nothing to count`);
+  }
+  const parsed = JSON.parse(readFileSync(path, "utf8"));
+  if (!Array.isArray(parsed.counters)) {
+    throw new Error(`${CONFIG_FILE} has no "counters" array`);
+  }
+  for (const entry of parsed.counters) {
+    if (typeof entry.counter !== "string") {
+      throw new Error(`${CONFIG_FILE}: every counter entry needs a "counter" id`);
+    }
+    if (entry.tiers !== void 0) {
+      const named = Array.isArray(entry.tiers) && entry.tiers.length > 0 && entry.tiers.every((tier) => typeof tier === "string" && tier.length > 0);
+      if (!named) {
+        throw new Error(
+          `${CONFIG_FILE}: "${keyOf(entry)}" has "tiers" that is not a non-empty list of tier names`
+        );
+      }
+    }
+  }
+  const keys = parsed.counters.map(keyOf);
+  const duplicate = keys.find((key, at) => keys.indexOf(key) !== at);
+  if (duplicate !== void 0) {
+    throw new Error(
+      `${CONFIG_FILE}: two counters both write "${duplicate}" \u2014 give one of them a distinct "key"`
+    );
+  }
+  return { baseline: parsed.baseline ?? "gate-baseline.json", counters: parsed.counters };
+};
+var resolveBaseline = (cwd) => {
+  try {
+    const parsed = JSON.parse(readFileSync(resolve(cwd, CONFIG_FILE), "utf8"));
+    return typeof parsed.baseline === "string" ? parsed.baseline : "gate-baseline.json";
+  } catch {
+    return "gate-baseline.json";
+  }
+};
+
 // src/core/envelope.ts
-import { mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname, join, resolve } from "path";
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { dirname, join, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 var ENVELOPES_DIR = ".geonosis/envelopes";
 var envelopePath = (root, tool) => join(root, ENVELOPES_DIR, `${tool}.json`);
@@ -15,7 +60,7 @@ var unbalancedMessage = (envelope, next) => `${envelope.tool}: considered ${enve
 var FORBIDDEN_ROOT = "GEONOSIS_ENVELOPES_FORBIDDEN_ROOT";
 var refuseForbiddenRoot = (root) => {
   const forbidden = process.env[FORBIDDEN_ROOT];
-  if (forbidden === void 0 || resolve(forbidden) !== resolve(root)) return;
+  if (forbidden === void 0 || resolve2(forbidden) !== resolve2(root)) return;
   throw new UnbalancedEnvelope(
     `${root} is off limits to envelope writers in this process (${FORBIDDEN_ROOT}) \u2014 a run that writes one into a shared root races every other run reading it, and leaves a file the next one takes for real. Point this at a scratch root of its own: tooling/scratch-dir.ts.`
   );
@@ -53,7 +98,7 @@ var writeEnvelope = ({
 var UNKNOWN = "unknown";
 var versionIn = (dir) => {
   try {
-    const manifest = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+    const manifest = JSON.parse(readFileSync2(join(dir, "package.json"), "utf8"));
     return typeof manifest.version === "string" ? manifest.version : void 0;
   } catch {
     return void 0;
@@ -71,7 +116,7 @@ var versionOf = (moduleUrl) => {
 };
 
 // src/core/heavy-slot.ts
-import { readFileSync as readFileSync2, rmSync as rmSync2 } from "fs";
+import { readFileSync as readFileSync3, rmSync as rmSync2 } from "fs";
 import { availableParallelism, freemem, tmpdir } from "os";
 import { join as join2 } from "path";
 
@@ -106,7 +151,7 @@ var claimFile = (path, holder) => {
 // src/core/heavy-slot.ts
 var availableMemoryMb = () => {
   try {
-    const found = /^MemAvailable:\s+(\d+) kB/m.exec(readFileSync2("/proc/meminfo", "utf8"));
+    const found = /^MemAvailable:\s+(\d+) kB/m.exec(readFileSync3("/proc/meminfo", "utf8"));
     if (found?.[1] !== void 0) return Math.floor(Number(found[1]) / 1024);
   } catch {
   }
@@ -116,7 +161,7 @@ var DEFAULT_MEMORY_MB_PER_SLOT = 512;
 var DEFAULT_HEAVY_SLOTS = Math.max(1, availableParallelism() - 1);
 var perSlotMbDeclaredIn = (root) => {
   try {
-    const parsed = JSON.parse(readFileSync2(join2(root, "geonosis.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync3(join2(root, "geonosis.json"), "utf8"));
     const declared = parsed.stack?.memoryMbPerSlot;
     return typeof declared === "number" && Number.isFinite(declared) && declared > 0 ? declared : void 0;
   } catch {
@@ -149,7 +194,7 @@ var heavySlotDir = () => {
 var slotPath = (dir, at) => join2(dir, `slot-${at}.json`);
 var holderOf = (path) => {
   try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
     return typeof parsed.pid === "number" ? {
       command: parsed.command ?? "unknown",
       cwd: parsed.cwd ?? "somewhere",
@@ -171,6 +216,13 @@ var namedHolders = (dir) => Array.from({ length: heavySlots() }, (_unused, at) =
 var describeHolders = (holders) => holders.map((one) => `${one.pid} ${one.command} since ${one.startedAt}`).join(", ");
 var HeavySlotTimeout = class extends Error {
 };
+var HEAVY_SLOT_HELD = "GEONOSIS_HEAVY_SLOT_HELD";
+var inherited = () => {
+  const named = process.env[HEAVY_SLOT_HELD];
+  if (named === void 0 || named === "") return false;
+  const holder = holderOf(named);
+  return holder !== void 0 && holder.pid !== process.pid && alive(holder.pid);
+};
 var takeSlot = async ({
   command,
   cwd = process.cwd(),
@@ -180,6 +232,7 @@ var takeSlot = async ({
 `),
   waitMs = Number(process.env.GEONOSIS_HEAVY_WAIT_MS ?? "") || DEFAULT_WAIT_MS
 }) => {
+  if (inherited()) return () => void 0;
   const until = Date.now() + waitMs;
   let told = false;
   for (; ; ) {
@@ -193,8 +246,10 @@ var takeSlot = async ({
         startedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       if (claim(path, mine)) {
+        process.env[HEAVY_SLOT_HELD] = path;
         return () => {
           if (holderOf(path)?.pid === process.pid) rmSync2(path, { force: true });
+          if (process.env[HEAVY_SLOT_HELD] === path) delete process.env[HEAVY_SLOT_HELD];
         };
       }
     }
@@ -213,7 +268,7 @@ var takeSlot = async ({
 };
 
 // src/core/lock.ts
-import { readFileSync as readFileSync3, rmSync as rmSync3 } from "fs";
+import { readFileSync as readFileSync4, rmSync as rmSync3 } from "fs";
 import { homedir } from "os";
 import { isAbsolute, join as join3 } from "path";
 var heavyLockPath = () => {
@@ -225,7 +280,7 @@ var heavyLockPath = () => {
 };
 var holderOf2 = (path) => {
   try {
-    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
     return typeof parsed.pid === "number" ? {
       cwd: parsed.cwd ?? "somewhere",
       pid: parsed.pid,
@@ -280,51 +335,6 @@ var acquireExclusive = async ({
   }
 };
 
-// src/core/config.ts
-import { existsSync, readFileSync as readFileSync4 } from "fs";
-import { resolve as resolve2 } from "path";
-var CONFIG_FILE = "geonosis.ratchet.json";
-var keyOf = (entry) => entry.key ?? entry.counter;
-var loadConfig = (cwd) => {
-  const path = resolve2(cwd, CONFIG_FILE);
-  if (!existsSync(path)) {
-    throw new Error(`no ${CONFIG_FILE} in ${cwd} \u2014 the ratchet has nothing to count`);
-  }
-  const parsed = JSON.parse(readFileSync4(path, "utf8"));
-  if (!Array.isArray(parsed.counters)) {
-    throw new Error(`${CONFIG_FILE} has no "counters" array`);
-  }
-  for (const entry of parsed.counters) {
-    if (typeof entry.counter !== "string") {
-      throw new Error(`${CONFIG_FILE}: every counter entry needs a "counter" id`);
-    }
-    if (entry.tiers !== void 0) {
-      const named = Array.isArray(entry.tiers) && entry.tiers.length > 0 && entry.tiers.every((tier) => typeof tier === "string" && tier.length > 0);
-      if (!named) {
-        throw new Error(
-          `${CONFIG_FILE}: "${keyOf(entry)}" has "tiers" that is not a non-empty list of tier names`
-        );
-      }
-    }
-  }
-  const keys = parsed.counters.map(keyOf);
-  const duplicate = keys.find((key, at) => keys.indexOf(key) !== at);
-  if (duplicate !== void 0) {
-    throw new Error(
-      `${CONFIG_FILE}: two counters both write "${duplicate}" \u2014 give one of them a distinct "key"`
-    );
-  }
-  return { baseline: parsed.baseline ?? "gate-baseline.json", counters: parsed.counters };
-};
-var resolveBaseline = (cwd) => {
-  try {
-    const parsed = JSON.parse(readFileSync4(resolve2(cwd, CONFIG_FILE), "utf8"));
-    return typeof parsed.baseline === "string" ? parsed.baseline : "gate-baseline.json";
-  } catch {
-    return "gate-baseline.json";
-  }
-};
-
 // src/core/types.ts
 var CounterError = class extends Error {
   constructor(counter, message) {
@@ -2216,6 +2226,10 @@ var formatProve = ({ proofs, proven }) => {
 };
 
 export {
+  CONFIG_FILE,
+  keyOf,
+  loadConfig,
+  resolveBaseline,
   ENVELOPES_DIR,
   envelopePath,
   UnbalancedEnvelope,
@@ -2233,10 +2247,6 @@ export {
   takeSlot,
   heavyLockPath,
   acquireExclusive,
-  CONFIG_FILE,
-  keyOf,
-  loadConfig,
-  resolveBaseline,
   CounterError,
   runCommand,
   runProve,

package/dist/cli.js

@@ -3,12 +3,13 @@ import {
   acquireExclusive,
   formatProve,
   formatReport,
+  loadConfig,
   runProve,
   runRatchet,
   takeSlot,
   versionOf,
   writeEnvelope
-} from "./chunk-Z2T6MHHQ.js";
+} from "./chunk-GJD2676B.js";
 
 // src/cli.ts
 import process from "process";
@@ -132,6 +133,7 @@ var measure = async () => {
 ` : formatProve(proof));
     return proof.proven ? 0 : 2;
   }
+  loadConfig(cwd);
   releaseHeavySlot = await takeSlot({
     command: `geonosis-ratchet${tier === void 0 ? "" : ` --tier ${tier}`}`,
     cwd

package/dist/index.js

@@ -28,7 +28,7 @@ import {
   takeSlot,
   versionOf,
   writeEnvelope
-} from "./chunk-Z2T6MHHQ.js";
+} from "./chunk-GJD2676B.js";
 export {
   CONFIG_FILE,
   COUNTERS,

package/package.json

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