Skip to content

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.

fm check [<paths> ...] [--full] [--fix] [--safe-fix] [--base=VALUE] [--point=VALUE] [--shard=VALUE]
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, such as 2of4

Example

$ fm check <paths> --full