@geonosis/release 2.3.0 → 2.4.2

package/CHANGELOG.md

@@ -0,0 +1,200 @@
+# @geonosis/release
+
+## 2.4.2
+
+## 2.4.1
+
+## 2.4.0
+
+### Minor Changes
+
+- 4962ed6: Every publishable package names `CHANGELOG.md` in `files`, not only the five floors. Measured on the 2.4.0 tarballs before they shipped: **0 of the 22 group packages carried one**, so `geonosis update`'s `BY HAND` block printed nothing for a group bump — the third consecutive release, in the cut where a consumer would have read the sweep, the holder and the Stop-hook fixes. `tooling/floor-changelog-shipped.test.ts` now holds the whole workspace rather than the floors, so a package cannot fall out of the convention silently.
+  
+  The doctor's `exams` check asks one question per EXAM instead of one per package. `@geonosis/db` ships three (`sessionConformance`, `entityConformance`, `singletonConformance`), and importing any one of them anywhere used to answer OK for the whole package — so a consumer running the session exam alone read green while two floors' behaviour was never exercised. That is this check's own docstring failing inside the check written to state it.
+  
+  The plugin-drift line knows a release candidate. A tree whose `overrides`/`resolutions` point a kit package at a `file:`, `link:`, `portal:` or `.tgz` spec is installed from a candidate the registry has never seen, so `claude plugin update` cannot reach that version at all — the WARN was unavoidable and unactionable for the whole life of every RC, in the window a consumer reads the doctor hardest. It now says the packages are a candidate and that the question becomes real when that version publishes.
+  
+  `smoke run` refuses a STALE recording instead of rendering a verdict over it. The 2.4.0 sweep headlined `FAIL … the release broke 1 of their gates` and printed `STALE` as its last line, fifteen lines below: both true, and the FAIL was a consumer frozen two releases back crossing a break declared in the one before, while the tree they actually have had migrated past it and was green. A stale recording cannot answer whether THIS release breaks them — only what it does to a tree nobody has — so it leads the block, names the command that re-takes it, and exits 2, the code for a run that could not be made.
+
+## 2.3.1
+
+## 2.3.0
+
+### Minor Changes
+
+- 3dac9a7: **`exams`, the doctor's eleventh check (#293).** A floor bump that breaks search is invisible to a
+  tier that never runs the search exam. A verify tier declares COMMANDS, not globs, so "the exam runs
+  in the fast tier" is not checkable — but whether a test file importing the exam exists at all is.
+  For every `@geonosis/*` package a manifest declares, the check reads the exams that package ships
+  (every export ending in `Conformance`, off the installed floor rather than a list held here) and
+  WARNs, naming them, when no test file imports one. The adoption sweep's consumer row now carries an
+  `EXAMS` line listing the exams the recording's own test files run.
+- 3dac9a7: **A recording is the ref's tree, and it carries history (#299, #307).** The walk now stops at ANY
+  directory holding its own `.git` — an agent's worktree, a vendored checkout — and records what it
+  skipped; `.claude/` was the first patch and this is the rule that needs no directory name. And the
+  recording gets a shallow clone of the ref through `file://` rather than a copy of the object store,
+  so a consumer's own tier step that reads git (`git diff --name-only origin/main..HEAD`) answers
+  inside it instead of exiting 2 at both versions and reading as "already failing at their versions".
+  A tree with no history to record says so in the record, by name.
+- 3dac9a7: **`geonosis-release changelog` (#99).** Every publishable package's `CHANGELOG.md`, and every
+  `## <version>` heading with nothing under it — a reader told a version shipped and told nothing
+  else. A release check rather than a verify step: the empties in a tree are history, and a fixed
+  publish group makes them by construction. Measured on this workspace: 61 of 238 headings over 27
+  files.
+- 3dac9a7: **One `--since`, and a report a machine can read (#97).** `--since` names a plan number, a day and
+  a git ref in three commands, and all three took any string: `plan check --since garbage` exempted
+  nothing and printed the verdict it would have printed with no flag, `stats --since notadate` put
+  every recorded day outside the window and printed `0 turns` as a pass rate. One reader now declares
+  which kind each means and refuses an unreadable value by name. `geonosis-ratchet`,
+  `geonosis-verify-arch` and `geonosis-lint-parity` take `--json`: the same report, on stdout,
+  whatever the verdict — `--json` with an explicit `--format` is refused rather than resolved.
+
+### Patch Changes
+
+- 3dac9a7: **One documented spelling (#90).** Every README of a package the metapackage fronts now names
+  `geonosis <tool>` — the door that pins the whole toolchain at one version — beside the bare bin, and
+  a `tooling/` test holds it. `#230`'s stamp test lands with it: every flag `docs/orchestration.md`'s
+  adoption loop names has to carry the version it first ships in, because the loop once told a
+  consumer to run a flag the published version did not have.
+- a8ab653: The floor API-shape guard compares against the last PUBLISHED version rather than the one the manifest holds after `changeset version`, and reads the changelog entry the cut wrote beside any pending changesets. A guard that reads only pending changesets is blind at the cut — the moment it is the last thing between a changed shape and a publish.
+
+## 2.2.0
+
+### Minor Changes
+
+- d15a654: **A floor adoption is measured (#280).** The user's rule — a floor is adopted the day it deletes
+  more than it adds — had no instrument: during.day's four db floors came out +222/−225 and its
+  workflows floor +1807/−1493, and both numbers were read by nobody until they were asked for. A
+  consumer declares `adoption.seams: [globs]` in `geonosis.json` (default none, and a repo that
+  declares none gets no figure rather than a figure about everything). `geonosis update` then reports
+  lines deleted against lines added over those globs, `git diff --numstat` between the commit the bump
+  started from and the working tree, in the verdict and in the bump report. `geonosis-ratchet` gains
+  `adoptionSeamLines`, the lines those globs still hold — a number the ratchet already refuses to let
+  grow. A snapshot records the same figure for its consumer and `geonosis-release adoption` carries it
+  per consumer (MEASURED: a consumer's `.geonosis/` is an excluded directory, so their own bump report
+  never reaches a recording — the figure is taken where the tree is read).
+- d15a654: **The smoke runs a consumer's TESTS (#272).** It read their typecheck, their lint and their doctor
+  and never their suites, so a floor change that kept their types and their linter green while their
+  own tests went red printed "nothing this release changed reddened their tree". `test` is a fourth
+  phase: read off their `test` script, nameable as `--test <cmd>` and as
+  `release.smoke.snapshots[].commands.test`, compared against the baseline with the same "already
+  failing at their versions" logic. The phase list has one source both the runner and the config
+  reader read.
+
+### Patch Changes
+
+- 45f3d79: **A recording reads the consumer's tree, never the worktrees under `.claude/`.** The snapshot walked `.claude/worktrees/<agent>/…` inside a consumer's root and read a stopped agent's branch as part of main — the adoption sweep then called the group INCOHERENT (2.0.0 and 2.1.0 in "one tree") for manifests that were never on main. `.claude` joins the excluded directories.
+- d15a654: **An envelope writer refuses a root it has been told is not its (#241).** A suite ran one over the
+  SHARED repo root mid-run: parallel suites made the comparison racy, and the file it left behind is
+  one the next run reads as real. Every one of the seven writer copies now refuses to write when
+  `GEONOSIS_ENVELOPES_FORBIDDEN_ROOT` names the root it was pointed at, saying so and pointing at a
+  scratch root instead. The kit's own vitest config sets it to the repo root, so a test that writes an
+  envelope there names itself — which is how the offender that filed this row was found again.
+
+## 2.1.0
+
+### Minor Changes
+
+- a200ec5: **The smoke reads every DECLARED consumer, and refuses the one it could have read (D-061).** 2.0.0 was read against one consumer of two: `dielime` was declared, its tree was on the disk, and every sweep skipped it with a sentence nobody was blocked by — its first smoke ran an hour after publish and was red. `smoke run` with no `--snapshot` now refuses (exit 2) a declared name with no recording whose tree this machine has, naming the `smoke snapshot` command to run; the paths of never-recorded trees are read from an uncommitted `.geonosis/consumer-trees.local.json`, and `--absent <name>` excuses one out loud while keeping its three phases in the envelope's denominator. `smoke snapshot` records the source tree's commit (read-only `git rev-parse`, or the sentence saying why there is none), and a sweep over a recording whose tree has moved since prints `STALE <name>: recorded at <c1>, the tree is at <c2>` and carries it in the envelope's findings — a report, not a failure. A declared snapshot may carry `commands: { doctor?, lint?, typecheck? }`, so a consumer whose gates are not the three script names of those names (dielime has no root `typecheck`) is read on its real ones; the recording keeps what it saw. The printed report is one block per declared consumer, in declaration order.
+- e419bb4: **`geonosis-release adoption` — the distance every declared consumer is at (D-061).** dielime on 1.2.0 and during.day's group split across 1.1.0 and 1.4.0 were both read by hand off their manifests on publish morning; no instrument reported either, so nothing carried them into a release review. The sweep reads the recordings the smoke already keeps — never a consumer's disk — and prints, per declared consumer: `MATCH`, `BEHIND <name> <declared> → <current>`, `INCOHERENT` (a group published as one number declared at two versions in one tree), and `FLOOR UNDECLARED` (informational — a floor is opted into). The current numbers come off this workspace, or off npm with `--registry`, through the same HTTP reader `published --group` uses. Exit 0 always: it is a scoreboard, not a gate. The envelope `release-adoption.json` counts every declared consumer as read or excused, and `geonosis-ledger handoff` quotes it in one line — read from the file, never by running the sweep.
+
+### Patch Changes
+
+- f252d95: **A harness says when the install edited the tree it was measuring (#216).** Measured on pnpm 11.5.1 and 11.8.0 against a `min-release-age=7` in `~/.npmrc`: installing a package younger than that APPENDS a `minimumReleaseAgeExclude:` block to the tree's `pnpm-workspace.yaml`, and pinning the manager version does not stop it — 11.5.1 rewrites it exactly as 11.8.0 does. The smoke now compares `.npmrc`, `bunfig.toml` and `pnpm-workspace.yaml` across its `run/` install and carries a finding naming the file, so a run over a tree that is no longer byte-for-byte the consumer's says so instead of reporting on it silently. `update --prove` writes `packageManager` into the scratch manifest — the manager and version that ran, so a rerun of that directory gets the same one — and carries one proof per manager that every config file the fixture wrote came back byte-identical.
+
+## 2.0.0
+
+### Minor Changes
+
+- 3258f5f: **`geonosis-release published --group` — the release is the group resolving from npm, not the publish exiting zero (#147).** Every `package.json` in the tree against the version the registry answers, no sampling, `considered` naming its own denominator and the manifests it excused. `--wait <seconds>` polls through the few minutes in which a freshly published name still 404s. Exit 0 the whole group, 1 a gap named per package, 2 the registry could not be asked — which is not "not published". The registry is read over HTTP and never through `npm view` or `bun pm view`: the manager's manifest cache is what read one release behind and aborted a consumer's bump.
+- 7de7bf6: **`geonosis-release smoke baseline` / `smoke run`** — the release candidate installed into a consumer's tree before it is published. Every workspace package is packed with `pnpm pack` (the TARBALL is what a consumer installs, and a release that "shipped no declarations" shipped them in the tree and not in the tarball), a COPY of the snapshot's manifests is pointed at those tarballs, the copy is installed with the snapshot's own manager — bun and pnpm, both measured here, a third refused by name — and the snapshot's own typecheck, lint and doctor are run. `baseline` records what those three answered at the versions that consumer is on; `run` fails only on what THIS release broke, quoting their compiler's and their doctor's own lines, and reports what was already red as not this release's doing. A tarball whose manifest promises `types` it does not carry is a finding by itself. Exit 0 nothing new, 1 a new failure, 2 the run could not be made — an install that failed, a snapshot that is not there, a missing baseline (a run that took its own answer as the standard would certify anything), or a phase the baseline cannot be compared to. The three commands are an envelope: considered 3, read + refused + excused, per snapshot. Four of C4's five escapes are planted through the real bin and caught (TS7016, a widened kind, a kind dropped on the read path, a doctor exit flip); the fifth is the migrations gate's own and is cited, not re-planted.
+- 7de7bf6: **`geonosis-release smoke snapshot <name> --from <their tree>`** — the tree a release has to be read against, copied read-only into `.geonosis/consumer-snapshots/<name>/`. Installed packages, build output and the git history stay behind; the manager is read off the lockfile (`bun.lock`/`bun.lockb` → bun, `pnpm-lock.yaml` → pnpm) and a manager the pack → rewrite → install path has never been measured under is refused BY NAME rather than treated as one of those two. The versions every manifest declares and the command each phase will run — a script of theirs, a binary their install puts there, or a sentence saying there is nothing to run — are recorded beside the copy. D-048 is enforced by the tool, not by a comment: it asks git, in the tree it is about to write into, whether those bytes could be committed, and refuses if they could. Measured 2026-09-01: during.day 4,406 files / 79 MB / 5.6 s, all three phases resolved; dielime 13,659 files / 511 MB / 26 s, `typecheck` a sentence because that tree has no such script.
+- 15663aa: **A smoke that installs the WHOLE release candidate.** `pnpm pack` resolves a `workspace:^` sibling
+  to a published range, so a snapshot pointed only at the tarballs it declares still fetched the
+  release's inner edges from the registry — and a floor package whose first release this is could not
+  be installed at all (`@geonosis/search@0.1.0`'s dependencies, measured 2026-09-02). Every packed
+  name is now pinned to its own tarball for the whole tree: for pnpm in `pnpm-workspace.yaml`
+  (pnpm 11.8.0 ignores `pnpm.overrides` in `package.json` — measured), for bun in `overrides` on the
+  root manifest (bun 1.4.0 — measured). A consumer's own overrides are kept; one this run pins is
+  dropped from their block first, because a duplicate YAML key is not a merge.
+- 7de7bf6: **The smoke is a step of the release protocol, and the repo names the consumers it expects.** `geonosis.json` → `release.smoke.snapshots` (`{ name, install? }`) and `release.smoke.exclude`; a key it does not read is refused by name with the shape. `smoke run` with no `--snapshot` sweeps every snapshot the repo names, `--rc-dir` defaulting to the workspace it is run in. A tree that is not on this machine is a SKIP with the sentence saying what could not be asked — a laptop without the consumer trees must not fail — and its three commands stay in the envelope's denominator as excused, so a sweep that asked nothing cannot be read as a sweep that asked everything. A sweep over zero consumers is refused outright. `docs/releasing.md` carries the step, with the measurements behind it.
+- 415c466: **The smoke reaches the doctor the way the consumer does (#218).** Its doctor phase ran only where a manifest installed `@geonosis/doctor` DIRECTLY — and during.day had correctly dropped that root devDependency on this kit's own advice (#177: the door already brings it, and a second declaration is a version that can disagree). The snapshot said "nothing to run" and a cut would have measured typecheck and lint only. A tree that installs `@geonosis/cli` (or the `geonosis` metapackage) now runs `geonosis doctor`; "nothing to run" is recorded only when neither the package nor a door is installed, and the sentence names both.
+
+### Patch Changes
+
+- 5c25a6d: **`geonosis-release schema` read past a quoted table name.** The cross-domain wall's lookbehind
+  excluded a preceding `"`, so `ALTER TABLE "invoices"` — the spelling drizzle-kit emits, and the one
+  the kit's own first domain ships — was clean while the bare `ALTER TABLE invoices` was a finding.
+  Found by declaring `release.schema` over `@geonosis/search`'s migrations; a qualified `other.name`
+  is still not a reference to `name`.
+
+## 1.4.0
+
+### Patch Changes
+
+- 113fdb2: **`geonosis-release migrations` writes its envelope.** `.geonosis/envelopes/release-migrations.json` says how many added files the run considered against how many it read, with the marker-excused files in `excused` and the ones it could not read at all in `refused`; narrowing verbs, unbelievable markers and squawk findings are FINDINGS, because those files were read — that is why there are findings. The two halves are taken from different lists on purpose: `read`/`excused` off each file's own state, `refused` off `unreadable`, so a file that reached one list and not the other breaks the arithmetic and the run renders no verdict rather than a wrong one. The bin harness now stages `package.json` beside `dist/`, as a published package always has, so the envelope names a real version instead of `unknown`.
+
+## 1.3.0
+
+### Minor Changes
+
+- 0a7673c: **`release.migrations[]` was discoverable only by reading `dist/` (#75).** A consumer reverse-
+  engineered the entry shape out of a bundled chunk file, because every refusal here named the key it
+  rejected and never the ones it would have accepted. Each now ends with
+  `expected { dir, dialect, phases?, squawk? }`, an unknown key inside an entry or inside the `release`
+  block is refused BY NAME rather than ignored, and `geonosis-release --print-config-shape` prints the
+  whole shape without a config present.
+  
+  **`squawk-cli` is an optional peer, not a hard dependency (#73).** It ships platform binaries, and
+  as a dependency of this package it grew dielime's lockfile by 395 lines for a Postgres linter that
+  repo never configured. Nothing installs it for you now: a `release.migrations` naming only `sqlite`
+  never calls it and is unaffected; a `postgres` or `mikro-orm-ts` dialect with it absent exits 2 with
+  the exact install line, `pnpm add -D squawk-cli@2.63.0`. `npm pack` carries a manifest with no
+  runtime dependency at all, and a test holds the install line to the version the manifest asks for.
+
+## 1.2.0
+
+### Patch Changes
+
+- 0268ee7: `migrations` accounts for every file the diff added — by name and state (clean, excused, refused,
+  squawk findings, unreadable) — and the summary says N of N. The FAIL report listed only the files
+  with findings, so a clean fourth migration (dielime's `do $$ … $$` block, which squawk passes) was
+  never mentioned and three-of-four read exactly like four-of-four (#69). A file this reader cannot
+  read is named and the loop goes on; it was a hard stop that left every other migration in the range
+  unread with the count at zero (#70). Exit 2 stays for an unreadable file — after everything else was
+  read and reported.
+- eb94097: `migrations` reads the working tree and the index as well as the commits since `--since`: the same
+  `DROP COLUMN` was refused when committed and read `OK … (0 read)` when staged or untracked — silent
+  in the one window, a local gate before the commit, in which a narrowing is still free to fix; there
+  is no state in which "this DROP COLUMN is fine because it is not committed yet" is true
+  (during.day, #68). A run that found no migration file anywhere now says `NONE … nothing was read`
+  rather than OK.
+
+## 1.1.0
+
+### Minor Changes
+
+- 8982fad: The across-releases rule: `-- contract-migration: <reason> since:<ref>` excuses a narrowing only
+  when `git merge-base --is-ancestor <ref> <since>` holds. A marker with no reason, no `since:`, an
+  unknown ref, or a ref inside this very diff is refused with the line saying which — and the
+  narrowing it was written over is still reported.
+- 39ac31b: `geonosis-release plan` validates the contract as data — upload → park → prove → promote, in that
+  order and no other, with `proof.mustAssertVersion` on unless somebody signs for turning it off.
+  `geonosis-release prove` runs one release over a runner the consumer supplies (JSON on stdio) and
+  refuses a smoke that answered a version other than the one it overrode to, a smoke that failed, and
+  a promote of a version nothing proved. With no runner it plants all three into its own stub.
+- 749239a: `geonosis-release deployed --check` compares `.geonosis/deployed.json` — what a pipeline reported
+  after promote — against the wrangler configs and secret names the tree declares. Drift either way
+  is exit 1; the file being absent is exit 2, never a pass. `@geonosis/doctor` gains a seventh line,
+  `deployed`, over the same file, reading it rather than importing the release package.
+- 2ebded4: `geonosis-release migrations --since <ref>`: the expand-only gate, dialect-routed by
+  `geonosis.json → release.migrations[]`. `sqlite` reads the five narrowing verbs; `postgres` runs the
+  pinned `squawk-cli` and surfaces its exit code and output verbatim; `mikro-orm-ts` extracts the SQL
+  out of `addSql(…)` in `up()` and reads it both ways. A squawk that cannot run is exit 2, never 0.
+
+### Patch Changes
+
+- 9f8207b: The `geonosis-release` shim refuses, with exit 2, when `dist/` is older than the `src/` beside it —
+  the guard every other bin in the kit already carries. The published package ships no `src/`, so
+  there the check is skipped. The plugin's wall probes are back-dated so that planting one cannot
+  make an unrelated package's build look stale to a suite running its bin at the same moment.

package/bin/geonosis-release.mjs

@@ -17,11 +17,25 @@ const newest = (dir) =>
       }, 0)
     : 0
 const src = join(here, '..', 'src')
-if (existsSync(src) && newest(src) > newest(join(here, '..', 'dist'))) {
-  process.stderr.write(
-    'geonosis-release: dist is older than src — run pnpm build before trusting this bin.\n',
-  )
-  process.exit(2)
+const dist = join(here, '..', 'dist')
+// `newest` answers 0 for a directory that is NOT THERE and for one that is merely old, so the
+// two conditions were one comparison and one sentence — and the staleness sentence was printed
+// over trees that had never been built at all, blocking a turn in a fresh git worktree, which
+// has no dist because dist is not committed (#357). Only the second is evidence of a mistake.
+if (existsSync(src)) {
+  const built = newest(dist)
+  if (built === 0) {
+    process.stderr.write(
+      'geonosis-release: this tree has never been built — run pnpm build. No dist here at all, which is what a fresh clone or a linked git worktree starts with; nothing is stale.\n',
+    )
+    process.exit(2)
+  }
+  if (newest(src) > built) {
+    process.stderr.write(
+      'geonosis-release: dist is older than src — run pnpm build before trusting this bin.\n',
+    )
+    process.exit(2)
+  }
 }
 
 await import('../dist/release-cli.js')

package/dist/{chunk-7H7SV5EP.js → chunk-CACOG4I5.js}

@@ -2378,10 +2378,18 @@ var entryBlock = (entry) => {
     const head = entry.why.startsWith("--absent") ? EXCUSED : "SKIP  ";
     return `${head} smoke ${entry.name}: ${entry.why}
 `;
+  }
+  if (entry.note !== void 0 && "stale" in entry.note) {
+    return `${entry.note.stale}
+      this release was NOT read against the tree they have \u2014 what follows is about the RECORDED one, and says nothing about whether this release breaks them. Re-take it: geonosis-release smoke snapshot ${entry.name} --from <their tree> --replace
+${formatSmoke(entry.comparison)}`;
   }
   return `${formatSmoke(entry.comparison)}${entry.note === void 0 ? "" : `${noteLine(entry.note)}
 `}`;
 };
+var staleIn = (sweep) => sweep.entries.flatMap(
+  (one) => "comparison" in one && one.note !== void 0 && "stale" in one.note ? [one.name] : []
+);
 var formatSweep = (sweep) => sweep.entries.map(entryBlock).join("");
 var sweepEnvelope = (sweep, durationMs) => {
   const excused = [];
@@ -2634,6 +2642,7 @@ export {
   CONSUMER_TREES_FILE,
   sweepSmoke,
   comparisonsIn,
+  staleIn,
   formatSweep,
   sweepEnvelope,
   formatSmoke,

package/dist/index.js

@@ -74,7 +74,7 @@ import {
   statementsOf,
   sweepEnvelope,
   sweepSmoke
-} from "./chunk-7H7SV5EP.js";
+} from "./chunk-CACOG4I5.js";
 export {
   ADOPTION_NEXT,
   ADOPTION_TOOL,

package/dist/release-cli.js

@@ -36,10 +36,11 @@ import {
   runSchema,
   runSnapshot,
   schemaEnvelope,
+  staleIn,
   sweepEnvelope,
   sweepSmoke,
   writeEnvelope
-} from "./chunk-7H7SV5EP.js";
+} from "./chunk-CACOG4I5.js";
 
 // src/release-cli.ts
 import { existsSync } from "fs";
@@ -468,6 +469,16 @@ var smokeRun = (parsed, root, cwd) => {
 `);
   const comparisons = comparisonsIn(swept);
   if (comparisons.some((one) => one.refused.length > 0)) return 2;
+  const stale = staleIn(swept);
+  if (stale.length > 0) {
+    if (!parsed.json) {
+      process.stdout.write(
+        `smoke NOT MEASURED \u2014 ${stale.join(", ")} was read against a recording that no longer describes it. Re-take the snapshot and run again.
+`
+      );
+    }
+    return 2;
+  }
   return comparisons.every((one) => one.ok) ? 0 : 1;
 };
 var smoke = (parsed, cwd) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geonosis/release",
-  "version": "2.3.0",
+  "version": "2.4.2",
   "types": "./dist/index.d.ts",
   "description": "The release contract with its proofs: an expand-only migration gate over three dialects, a smoke that must name the version that answered it, and declared ≠ deployed.",
   "keywords": [
@@ -32,6 +32,7 @@
     }
   },
   "files": [
+    "CHANGELOG.md",
     "bin",
     "dist"
   ],
@@ -45,7 +46,7 @@
   },
   "devDependencies": {
     "squawk-cli": "2.63.0",
-    "@geonosis/ratchet": "2.3.0"
+    "@geonosis/ratchet": "2.4.2"
   },
   "engines": {
     "node": ">=22"