check¶
Run the gate: every registered step, the rewriters first under --fix.
With paths, exactly those files are checked, or the files under
those directories: every step whose claims reach one of them runs
over them and no other, a step without claims does not run, and
nothing is recorded as proved. --safe-fix runs the fixers in
their in-flight mode, which removes no code, and refuses beside
--fix. --point hands a CI point to the test phase, which
selects that point's tests instead of the gate's.
--shard names the shard of a sharded check leg this run is,
2of4: a step that reads the shard runs its share, every other
step runs on the first shard alone, and the walk names each step
it leaves there. Inside CI the leg's label names the shard and the
flag is not needed. A sharded run records no tree as proved, since
a share of the gate ran. A shard outside the form, 0of2,
refuses naming it.
On a machine the gate is the reflex: it runs what the working
tree changed since the nearest tree this checkout's own green
gates proved, the packages that delta can influence (their
dependents' closure), and records the working tree as proved on
the local gate record (livery.workshop._gate_record). A tree
the record already proves runs nothing. The chain of records
rests on a full gate here or on CI's record of the merge base
with --base, so a fresh branch off main starts proved. A
change outside the packages configures every gate, so it runs
everything and roots a new chain; --full runs everything
whatever the record says. ty and pyrefly always check their
configured whole either way.
Inside CI, when the contract declares [ci] affected-legs, a
pull request's legs measure by the same rule from CI's own record,
read for the leg's own platform: from the proved tree nearest the
checkout's, an earlier push's merge among them, or from the merge
base with the pull request's base when the record proves none.
Without the key they run the whole workspace. The local record is
never read or written there.
--fix runs format and lint in their fix modes: each prints
what it found, rewrites what is mechanical, and still fails on
what is not. The two rewrite the same files, so under --fix
they run one after the other before the rest of the gate.
--fix refuses inside CI: a runner's checkout is judged,
never rewritten, because a fix there mutates a copy nobody
keeps and hides the finding from the verdict. Run the fix
locally and push the result.
On a machine the state store is read from what the last sync
or start fetched (livery.git.fetched_snapshot):
nothing the gate runs reaches origin, and a checkout the store was
never fetched into roots its chain on a full gate and says so.
Inside CI the legs read the store as the run's own snapshot.
| Parameter | Type | Default | Description |
|---|---|---|---|
<paths>... |
variadic | ||
--full |
flag | false |
run everything, whatever the record proves |
--fix |
flag | false |
|
--safe-fix |
flag | false |
fix, removing no code: safe for an edit in flight |
--base=VALUE |
"main" |
the branch the chain's root is taken from | |
--point=VALUE |
"" |
run the tests of this CI point, nightly say | |
--shard=VALUE |
"" |
run this shard's share of a sharded check leg: of |