What the holds leave out

Every hold that is in places says what it leaves out. Gathered here by failure, those lines are what each hold does not reach. Where the gap is in a check or a structure, whatever sits on the rungs above it is what holds, where anything does. A rung with nothing aimed at the failure, a rung that cannot hold it, and what is wanted and not built are listed with them. Review after landing and the gate apply to every row, so a blank rung means only that nothing more specific is aimed at the failure.

33 of the 45 holds are in places.

The design drifts

Design drifts to the model's average

  • Tool: Lints for the mechanical rules leaves out: Nothing checks the naming forms, the styling ladder or whether a feature belongs. Only their mechanical edges are checked, such as the case lints of Rust and the class diagnostics of fuz_css.
  • Shape is out of reach: Whether a feature belongs is a judgment about the whole design, and no structure makes that call.
  • Nothing at the Session rung is aimed at it.

The checks weaken

Green but wrong

  • Person: Review after landing leaves out: One person reads what many sessions push, and nothing yet lists the commits pushed across the repos in one place.
    Wanted: A view of the commits pushed across every repo, so the review has one place to happen.
  • Session: Writer and reviewer loop leaves out: The loop is for long-running work and not for every change, and its reviewer is another agent.
  • Tool: Oracles, mutants and control cases leaves out: Most code has no reference to compare against, and only those two have a mutation run over their tests.
    Wanted: Routine mutation and branch-coverage runs for tsv.
  • Nothing at the Written and Shape rungs is aimed at it.

A check is silenced instead of satisfied

  • Session: The expected diff is read as code leaves out: Only a fixture test has such a diff to read.
  • Written: Fix the code, not the expectation leaves out: No rule covers a suppression in TypeScript or a skipped test.
  • Tool: Suppressions that expire leaves out: Where no outside reference exists, an expected file regenerated from wrong output passes, and so does a suppression with a plausible reason. The record of twin differences is checked only when the cross-backend suites run, which for the Rust side is on demand.
  • Nothing at the Person and Shape rungs is aimed at it.

A slow check gets skipped

  • Tool: CI reruns the gate leaves out: A few repos have no CI, or one that runs less than the local gate; the list under the gates table names them.
  • Shape: Fast tools leaves out: Rust compile loops stay slow, and the heaviest gates, such as the corpus and conformance runs of tsv, run before a release and not on each push.
  • Nothing at the Person and Session rungs is aimed at it.

The claims go unverified

A stale statement is trusted

A predicted speedup that is not one

  • Session: Race the candidates leaves out: The other projects do neither.
  • Tool: Committed size limits leaves out: Size is the only axis a gate limits on each change. Speed is graded against a base on demand: tsv fails a row that moves past a committed percentage, and gro asks for a written reason.
  • Shape is out of reach: Whether a change is faster is known only by measuring it, so no structure can rule a slow one out.
  • Nothing at the Person rung is aimed at it.

The sessions overstep

A known mistake comes back

  • Tool: The gate leaves out: A few repos have no CI, or one that runs less than the local gate; the list under the gates table names them. A mistake reaches the gate only once someone has given it a mechanical form.
  • Shape: Impossible states do not compile leaves out: It reaches only a mistake that can be stated as a type or a schema, which most cannot.
  • Nothing at the Person and Session rungs is aimed at it.

Two sessions collide

An unattended session does something irreversible

  • Tool: Deny rules and dry runs leaves out: No gate detects a version change, and a new dependency or package passes nearly every gate: fuz_schema has a test that allows it no runtime dependency, and tsv makes a new crate declare whether it publishes. The deny rules match a command by its prefix, so one spelled another way gets past them. gro's publish and deploy tasks, which the TypeScript libraries release with, run for real unless told otherwise, and so do the release task of fuz_forge, the publish command of fuz and the addon publish script of tsv.
  • Shape: A push tool that cannot leaves out: Only pushing goes through such a tool. Publishing and deploying have none, and git itself is still on the machine, behind a deny rule.
  • Nothing at the Session rung is aimed at it.

Actions nothing refuses

Of the actions kept with a person, these are the ones where no part is refused by a tool or denied by a permission rule. An action left off this list may still have a part that nothing refuses, which its row says.

  • Delete files or data (dry run by default): No public rule keeps deletion with the maintainer. In the stack's own Rust tools a new command that is hard to undo is a dry run until it is given an explicit flag.
  • Change a version or a changelog (written rule): Only a written rule: no gate detects the change.
  • Add or upgrade a dependency (written rule): Only a written rule, with an allowlist to choose from. fuz_schema alone has a test that fails on a runtime dependency.
  • Create a package or a crate (written rule): Only a written rule: the release audit checks the crate graph, not new members, and tsv asks only that a new crate declare whether it publishes.

From Actions kept with a person.

Where CI runs less

Where CI runs less than the local gate, or does not run:

  • The Rust gate of zzz and its cross-backend tests run only locally, and its CI is Node-only
  • zervo's CI builds and tests nothing, because its browser engine is too heavy to build on each push
  • blake3 has no CI, so its size limits and test vectors run only by hand and before a release
  • tsv-format has no CI, so its typecheck, build and tests run only locally
  • tsv's CI skips the two legs of its gate that read sibling checkouts, the wider Prettier round trip and corpus discovery
  • pglet's CI leaves out the WebAssembly and concurrency suites of its gate set
  • zap's CI has no build of gro's runtime, so the tests that evaluate config through it are skipped there, by an explicit allowance

From Gates.