@geonosis/ratchet 2.5.2 → 2.6.0

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # @geonosis/ratchet
 
+## 2.6.0
+
+### Minor Changes
+
+- 58565d7: Plan 029, the factory floor: the gate learns to run things at once, and the heavy budget stops
+  being one laptop's number.
+  
+  `@geonosis/verify` — `TierStep` carries `group`, the number that says which steps run at once, so a
+  tier can declare `{ "parallel": [ … ] }` groups and `{ "command": "… {workspace} …", "per":
+  "workspace" }` steps. New: `affected.ts` (`affected`, `affectedOf`, `workspacesIn`, `changedSince`,
+  `mergeBase`, `ROOT_SHAPED`, types `Affected` and `Workspace`), `PerWorkspace`, `ParallelStep`,
+  `CommandStep` on `config`, and `planSteps`, `runGroups`, `shellRunAsync`, `PlannedStep`,
+  `AsyncStepRun` on `run`. `GateReport` gains an optional `affected` block. `runSteps`, `shellRun` and
+  `stepIds` are unchanged. The bin gains `--affected`, `--since <ref>` and `--jobs <n>`.
+  
+  `@geonosis/ratchet` and `@geonosis/release` — `heavySlots()` and `DEFAULT_HEAVY_SLOTS` beside
+  `HEAVY_SLOTS`, which is no longer the constant 2: the budget is `GEONOSIS_HEAVY_SLOTS` or
+  `availableParallelism() - 1`, read on every claim rather than at module load (D-073).
+  
+  `@geonosis/ledger` — `shape.ts`: `shapeCheck`, `readManifest`, `exportsOf`, `formatShape` and the
+  types `BriefManifest`, `ShapeRefusal`, `ShapeOutcome` — the lock that refuses an engineer diff
+  touching a locked test, renaming an export or adding a file the brief did not name (D-072). Not yet
+  on the package's public entry: the CLI door lands with W115's dispatch unit.
+  
+  `geonosis` — the plugin's post-edit hook takes its formatter from `geonosis.json → stack.format`
+  (D-070) and the stop hook reads the machine's heavy budget.
+- 58565d7: The heavy budget is memory-aware (D-081, amending D-073). `heavyBudget()` — on `@geonosis/ratchet`'s door, copied into `@geonosis/release` and the plugin's Stop hook and held to one answer by a test — is the smaller of one less than the cores and the memory the machine can spend divided by what one run holds: `geonosis.json → stack.memoryMbPerSlot`, 512 MB when nothing is declared. `GEONOSIS_HEAVY_SLOTS` still wins outright; `GEONOSIS_HEAVY_MEMORY_MB` is the memory to spend instead of the machine's. `heavySlots()` is the budget's number read fresh, and `describeBudget()` names the number and both inputs. `geonosis-verify --jobs` defaults to it, its report carries it as `heavy`, and the run prints it; the kit's own vitest workers read it too. Measured on a 4-core, 3.4 GB box: three slots over 1.4 GB swapped; two do not.
+
+### Patch Changes
+
+- 58565d7: The oxlint counters read the graphical format's Unicode markers — `×` for an error, `⚠` for a warning — beside the ASCII `x` and `!` a pipe gets. CI's terminal printed the Unicode pair, `oxlintRule` saw two findings it could attribute to no rule, and refused as its contract says; a laptop's vitest child never printed them.
+
+## 2.5.3
+
 ## 2.5.2
 
 ## 2.5.1

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

@@ -72,7 +72,7 @@ var versionOf = (moduleUrl) => {
 
 // src/core/heavy-slot.ts
 import { readFileSync as readFileSync2, rmSync as rmSync2 } from "fs";
-import { tmpdir } from "os";
+import { availableParallelism, freemem, tmpdir } from "os";
 import { join as join2 } from "path";
 
 // src/core/file-claim.ts
@@ -104,7 +104,42 @@ var claimFile = (path, holder) => {
 };
 
 // src/core/heavy-slot.ts
-var HEAVY_SLOTS = 2;
+var availableMemoryMb = () => {
+  try {
+    const found = /^MemAvailable:\s+(\d+) kB/m.exec(readFileSync2("/proc/meminfo", "utf8"));
+    if (found?.[1] !== void 0) return Math.floor(Number(found[1]) / 1024);
+  } catch {
+  }
+  return Math.floor(freemem() / 1048576);
+};
+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 declared = parsed.stack?.memoryMbPerSlot;
+    return typeof declared === "number" && Number.isFinite(declared) && declared > 0 ? declared : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var heavyBudget = (input = {}) => {
+  const declared = Number(process.env.GEONOSIS_HEAVY_SLOTS ?? "");
+  const spendable = Number(process.env.GEONOSIS_HEAVY_MEMORY_MB ?? "");
+  const reading = {
+    availableMemoryMb: input.availableMemoryMb ?? (Number.isFinite(spendable) && spendable > 0 ? spendable : availableMemoryMb()),
+    cores: input.cores ?? availableParallelism(),
+    perSlotMb: input.perSlotMb ?? perSlotMbDeclaredIn(input.root ?? process.cwd()) ?? DEFAULT_MEMORY_MB_PER_SLOT
+  };
+  if (Number.isInteger(declared) && declared > 0)
+    return { ...reading, by: "declared", slots: declared };
+  const byCores = Math.max(1, reading.cores - 1);
+  const byMemory = Math.max(1, Math.floor(reading.availableMemoryMb / reading.perSlotMb));
+  return byMemory < byCores ? { ...reading, by: "memory", slots: byMemory } : { ...reading, by: "cores", slots: byCores };
+};
+var describeBudget = (budget) => `${budget.slots} heavy slot(s), bound by ${budget.by === "declared" ? "GEONOSIS_HEAVY_SLOTS" : budget.by} \u2014 ${budget.cores} cores, ${budget.availableMemoryMb} MB available, ${budget.perSlotMb} MB per slot`;
+var heavySlots = () => heavyBudget().slots;
+var HEAVY_SLOTS = heavySlots();
 var DEFAULT_WAIT_MS = 20 * 6e4;
 var heavySlotDir = () => {
   const named = process.env.GEONOSIS_HEAVY_SLOT_DIR;
@@ -130,7 +165,7 @@ var reapIfDead = (path) => {
   if (holder !== void 0 && !alive(holder.pid)) rmSync2(path, { force: true });
 };
 var claim = (path, holder) => claimFile(path, holder);
-var namedHolders = (dir) => Array.from({ length: HEAVY_SLOTS }, (_unused, at) => holderOf(slotPath(dir, at))).filter(
+var namedHolders = (dir) => Array.from({ length: heavySlots() }, (_unused, at) => holderOf(slotPath(dir, at))).filter(
   (holder) => holder !== void 0
 );
 var describeHolders = (holders) => holders.map((one) => `${one.pid} ${one.command} since ${one.startedAt}`).join(", ");
@@ -148,7 +183,7 @@ var takeSlot = async ({
   const until = Date.now() + waitMs;
   let told = false;
   for (; ; ) {
-    for (let at = 0; at < HEAVY_SLOTS; at += 1) {
+    for (let at = 0; at < heavySlots(); at += 1) {
       const path = slotPath(dir, at);
       reapIfDead(path);
       const mine = {
@@ -1168,13 +1203,15 @@ var UNIX_FINDING = /^\S[^\n]*:\d+:\d+: .*\[(Error|Warning)\/[^\]\n]+\]$/gm;
 var UNIX_SUMMARY = /^(\d+) problems?$/m;
 var AGENT_FINDING = /^\S[^\n]*:\d+:\d+: (error|warning) /gm;
 var DEFAULT_SUMMARY = /^Found (\d+) warnings? and (\d+) errors?\.$/m;
-var DEFAULT_FINDING = /^\s*([x!]) [^\s(]+\([^)\n]+\): /m;
+var DEFAULT_FINDING = /^\s*([x!×⚠]) [^\s(]+\([^)\n]+\): /m;
 var FINDING_SHAPES = [UNIX_FINDING, AGENT_FINDING, DEFAULT_FINDING].map(
   (shape) => new RegExp(shape.source)
 );
 var RULE_TOKEN = /\([^()\n]+\)/;
 var SEVERITY_BY_TOKEN = {
   "!": "warning",
+  "\xD7": "error",
+  "\u26A0": "warning",
   Error: "error",
   error: "error",
   Warning: "warning",
@@ -2184,6 +2221,11 @@ export {
   UnbalancedEnvelope,
   writeEnvelope,
   versionOf,
+  availableMemoryMb,
+  DEFAULT_MEMORY_MB_PER_SLOT,
+  heavyBudget,
+  describeBudget,
+  heavySlots,
   HEAVY_SLOTS,
   heavySlotDir,
   describeHolders,

package/dist/cli.js

@@ -8,7 +8,7 @@ import {
   takeSlot,
   versionOf,
   writeEnvelope
-} from "./chunk-WENVCC67.js";
+} from "./chunk-Z2T6MHHQ.js";
 
 // src/cli.ts
 import process from "process";

package/dist/index.d.ts

@@ -288,33 +288,44 @@ declare const versionOf: (moduleUrl: string) => string;
 declare const COUNTERS: Counter[];
 declare const counterById: (id: string) => Counter;
 
-/** Who is spending a heavy slot, running what, since when. */
 type HeavySlotHolder = {
     command: string;
     cwd: string;
     pid: number;
     startedAt: string;
 };
+/** The memory the machine can spend now: `MemAvailable` where the kernel says it, `os.freemem()` where it does not. */
+declare const availableMemoryMb: () => number;
+/** What one heavy run is budgeted to hold when the repo declares nothing: a vitest worker measured 334 MB and a tsc 224 MB (plan 030). */
+declare const DEFAULT_MEMORY_MB_PER_SLOT = 512;
+type HeavyBudget = {
+    availableMemoryMb: number;
+    /** What bound the number: a declared `GEONOSIS_HEAVY_SLOTS`, the cores, or the memory. */
+    by: 'cores' | 'declared' | 'memory';
+    cores: number;
+    perSlotMb: number;
+    slots: number;
+};
 /**
- * Two, not one: `core/lock.ts`'s `acquireExclusive` serialises a whole run against every other; this
- * is the machine's OWN ceiling — measured 2026-09-05, load 48 with during.day's Stop-hook tier, this
- * kit's Stop-hook tier, this kit's ratchet and an engineer's suite all running at once. A machine that
- * can carry two heavy things at a time carries two; a third waits.
+ * The heavy budget, read fresh: the smaller of one less than the cores and the memory divided by
+ * what one run holds (D-081, amending D-073). A declared `GEONOSIS_HEAVY_SLOTS` wins over both;
+ * `GEONOSIS_HEAVY_MEMORY_MB` is the memory to spend instead of the machine's; the per-slot number
+ * is `geonosis.json → stack.memoryMbPerSlot`, 512 when nothing is declared.
  */
-declare const HEAVY_SLOTS = 2;
+declare const heavyBudget: (input?: {
+    availableMemoryMb?: number;
+    cores?: number;
+    perSlotMb?: number;
+    root?: string;
+}) => HeavyBudget;
+/** One line a report can carry: the number, and both inputs it was read from. */
+declare const describeBudget: (budget: HeavyBudget) => string;
+declare const heavySlots: () => number;
+declare const HEAVY_SLOTS: number;
 declare const heavySlotDir: () => string;
 declare const describeHolders: (holders: HeavySlotHolder[]) => string;
-/** A wait that ran out. The message names every holder, because the caller's own refusal is this text. */
 declare class HeavySlotTimeout extends Error {
 }
-/**
- * Claims one of the two machine-wide heavy slots, waiting for whoever holds them.
- *
- * A dead holder is reaped before a slot is tried, so a killed run never wedges the budget for
- * whoever asks next. Both held is announced ONCE — not on every poll, which would turn a half-hour
- * wait into a half hour of identical lines — and the wait is bounded, so a taker that can never get
- * in refuses instead of hanging the process that called it.
- */
 declare const takeSlot: ({ command, cwd, dir, pollMs, say, waitMs, }: {
     command: string;
     cwd?: string;
@@ -413,4 +424,4 @@ declare const formatProve: ({ proofs, proven }: ProveResult) => string;
  */
 declare const runCommand: (cwd: string, counterId: string, env?: NodeJS.ProcessEnv) => (command: string) => CommandResult;
 
-export { CONFIG_FILE, COUNTERS, type CommandResult, type Counter, type CounterConfig, type CounterContext, CounterError, type CounterProbe, ENVELOPES_DIR, type EnvelopeEntry, HEAVY_SLOTS, type HeavySlotHolder, HeavySlotTimeout, type Holder, type Measurement, type Proof, type ProveResult, type RatchetConfig, type RatchetResult, type Refusal, type ReportEnvelope, UnbalancedEnvelope, type Verdict, acquireExclusive, counterById, describeHolders, envelopePath, formatProve, formatReport, heavyLockPath, heavySlotDir, keyOf, loadConfig, resolveBaseline, runCommand, runProve, runRatchet, takeSlot, versionOf, writeEnvelope };
+export { CONFIG_FILE, COUNTERS, type CommandResult, type Counter, type CounterConfig, type CounterContext, CounterError, type CounterProbe, DEFAULT_MEMORY_MB_PER_SLOT, ENVELOPES_DIR, type EnvelopeEntry, HEAVY_SLOTS, type HeavyBudget, type HeavySlotHolder, HeavySlotTimeout, type Holder, type Measurement, type Proof, type ProveResult, type RatchetConfig, type RatchetResult, type Refusal, type ReportEnvelope, UnbalancedEnvelope, type Verdict, acquireExclusive, availableMemoryMb, counterById, describeBudget, describeHolders, envelopePath, formatProve, formatReport, heavyBudget, heavyLockPath, heavySlotDir, heavySlots, keyOf, loadConfig, resolveBaseline, runCommand, runProve, runRatchet, takeSlot, versionOf, writeEnvelope };

package/dist/index.js

@@ -2,18 +2,23 @@ import {
   CONFIG_FILE,
   COUNTERS,
   CounterError,
+  DEFAULT_MEMORY_MB_PER_SLOT,
   ENVELOPES_DIR,
   HEAVY_SLOTS,
   HeavySlotTimeout,
   UnbalancedEnvelope,
   acquireExclusive,
+  availableMemoryMb,
   counterById,
+  describeBudget,
   describeHolders,
   envelopePath,
   formatProve,
   formatReport,
+  heavyBudget,
   heavyLockPath,
   heavySlotDir,
+  heavySlots,
   keyOf,
   loadConfig,
   resolveBaseline,
@@ -23,23 +28,28 @@ import {
   takeSlot,
   versionOf,
   writeEnvelope
-} from "./chunk-WENVCC67.js";
+} from "./chunk-Z2T6MHHQ.js";
 export {
   CONFIG_FILE,
   COUNTERS,
   CounterError,
+  DEFAULT_MEMORY_MB_PER_SLOT,
   ENVELOPES_DIR,
   HEAVY_SLOTS,
   HeavySlotTimeout,
   UnbalancedEnvelope,
   acquireExclusive,
+  availableMemoryMb,
   counterById,
+  describeBudget,
   describeHolders,
   envelopePath,
   formatProve,
   formatReport,
+  heavyBudget,
   heavyLockPath,
   heavySlotDir,
+  heavySlots,
   keyOf,
   loadConfig,
   resolveBaseline,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geonosis/ratchet",
-  "version": "2.5.2",
+  "version": "2.6.0",
   "types": "./dist/index.d.ts",
   "description": "Debt as a number that may only shrink — one ratchet, pluggable counters.",
   "keywords": [
@@ -43,6 +43,10 @@
   },
   "scripts": {
     "build": "tsup",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "lint": "oxlint --config ../../.oxlintrc.json .",
+    "test:unit": "vitest run --project unit --root ../.. --passWithNoTests \"$PWD\"",
+    "test:bin": "vitest run --project bin --root ../.. --passWithNoTests \"$PWD\"",
+    "test:exam": "vitest run --project exam --root ../.. --passWithNoTests \"$PWD\""
   }
 }