Integration: restructuring campaign, do not merge without explicit approval

[santhreal]

IMPORTANT: do not merge without explicit approval from me.

This branch is where a large restructuring campaign lands. It is not a single change and it is not ready to be squashed into main on a green checkmark. Read the sections below, then decide.

main is untouched at 90991bb2e8. This branch is at 51032f97d2, 2215 commits ahead: 7556 files changed, 692153 insertions(+), 653191 deletions(-). It is the only open pull request on this repository.

What this branch changes

Crates carry one concern each. The C frontend and the Rust frontend are removed from the tree. Eighteen composition domains, 991 files, moved out of vyre-primitives into vyre-libs, which leaves vyre-primitives at 20 files and 3035 lines: hardware/ with its nine intrinsics, the catalog, the markers, the organization, and four items still scheduled to leave (wire.rs, ir_safe.rs, dispatch_grid.rs, vfs/). The rule the tree is converging on is that vyre-primitives holds only operations that cannot be composed, and every composition lives in vyre-libs.

File shape. vyre-megakernel/src/lib.rs went from 2026 lines to 75 across nine modules named for what they own. 98 residue directories left over from removed crates and moved domains are gone from the working tree.

Gate truth. A gate that cannot fail was treated as a defect, not as a passing gate. Concrete cases closed here: a required command whose filter matched nothing passed forever; a placement predicate used is_dir(), so an emptied vyre-primitives/src/matching still named itself the owner of eleven operations, and the predicate now reads for Rust source recursively instead of for directory existence; the op matrix took its owner from the checkout rather than from the id prefix.

Duplication closed rather than pinned. Workspace duplicated lines went from 20372 to 19479, dup-scan from 4 findings to 1, and xtask, xtask-registry and structure-gate reached 0 against a pin of 0 without moving the pin. Every pin that moved, moved down with a measured count. The largest single closure was one owner for the fixed-point parity helpers that 53 integration suites had each restated: 50 xorshift copies, 15 encoder copies, 7 multiply copies, 8 sample generators and 13 unit constants deleted.

Documentation is checked against the tree. New docs-register gate, backed by docs/REGISTER.toml: banned register phrasing on authored pages, documentation as its own subject, host-local build configuration on a contributor-facing page with the name set unioned at run time from the register plus cargo_full export lines plus .cargo/config.toml [env] keys, and every repository-root Markdown page declared in docs/DOCS.toml with its audience set derived from the audiences the page rows use. Sixteen unit tests, every clause proved red by injection.

One device-visible correctness fix worth calling out. The workgroup Blelloch sweep ended on an unguarded store with no barrier behind it, and frontier_word_block_offsets_single_workgroup reads scratch_a[lane - 1] on the statement after the sweep returns, so a lane could read its predecessor's slot one round early and take a block offset short by the previous block's own count. The reference interpreter steps lanes in order, so no value assertion could see it. Publication is now the sweep's contract and two tests assert the emitted shape.

Benchmark evidence stopped overstating itself. synthetic_cpu_count regenerated every record from its index inside the timed region, twelve to twenty-four rotate-multiply rounds per column, while the device side received pre-materialized, pre-uploaded buffers. Reported speedups were 5508x to 6729x for the count patterns against 928x for the one case that already read materialized bitmaps, and the difference was the generator. The baseline now counts over the same host buffers the device reads. Ten baseline labels named software this checkout does not link, including tree-sitter, libclang, Hyperscan, ripgrep, egg, rug with a GMP backend and a hand-tuned C threaded interpreter; every one of those cases timed an in-tree scalar Rust routine. Labels now come from one owner and a test resolves every named crate against the workspace members and the vyre-bench dependency tables read at run time. A second test compares each release row's primitive, baseline and threshold against the manifest the harness enforces, which immediately found a 100x case with no target row at all.

Gate state on this branch

Measured by one xtask gates sweep at this head, plus the gates that can only answer on
the host that recorded the evidence, run there at the same tree.

Gate	Result
whole xtask gates sweep	128 gate reports at this head, every pin at 0, one nonzero
backend-matrix	6 findings on a host whose device is not the recording device, 0 on the recording host
bench-release	0 findings, release axes recorded below
vyre-release-gate	0 findings, 14 requirements judged for 0.8.0
release-benchmarks	0 findings, 17 CUDA and 17 WGPU artifacts written
bench-crossback	0 findings, 35 measurements over 18 cases and 2 backends
release-evidence	0 findings
evidence-paths	0 findings, 4070 citations across 81 artifacts
release-docs	0 findings
hygiene-matrix	0 findings, 4302 files scanned, 0 release-blocking
package-readiness	0 findings
dup-scan	0 findings, 12380 duplicated lines, every pin at 0
whats-similar	0 findings, 268 registered ops, no pair skipped
workspace-check, workspace-clippy, workspace-docs	0 findings each

The single nonzero reading is backend-matrix on a host that is not the recording device:
the artifact records 24564 MiB and sm_89, the probing host reports 12288 MiB and sm_86,
and the gate is doing its job by refusing to accept one device's facts as another's. On the
device that recorded the evidence it reads 0, which is why its CI job runs there.

Recorded conformance on this checkout: 349 of 349 operations prove on CUDA, on WGPU and
against the reference interpreter, 1047 pairs across three backends, 0 failed pairs in each
certificate. The proof completes in 74 s; see the teardown fix below for why it used to
take hours.

The release benchmark baseline is recorded, not deferred. Both suites were measured under
the release profile with 30 measured samples per case, on a device holding 139 MiB of 24564
with no other job on the host, and all 34 workload artifacts plus the two suite indexes,
the cross-backend comparison and the release axes cite one source-tree fingerprint. The
axes read warm 4.766 us per file, cold pipeline build 1.214744 ms, 620.153 GiB/s scan
throughput, 0 ulp drift, 24564 MiB of device memory.

One gate reading that changed

whats-similar: 0 findings used to be reached by skipping 504 pairs. It now scans 268
registered ops and skips none: all three skip categories sit at a measured ceiling of 0 and
no pair crosses the duplicate or similarity floor, so the zero is the scan's own answer.
The hand-typed table is still there and still read, one layer over: IMPLEMENTATION_FAMILY_ROWS
in xtask/src/gates/implementation_family.rs records (operation id, shared builder), and
lego-no-reinvention now skips a pair recorded there or in REVIEWED_DISTINCT_OPERATIONS,
because two operations reached through one shared builder share that builder's emitted
shape and reporting them demands an extraction already done. Deriving those rows instead of
typing them is blocked on attribution: a shared builder such as
binary_word_program(op_id, ...) wraps the region with the calling op's id, so the tree
cannot tell which builder emitted a body.

What is still open

Verified against this checkout, not carried over from an earlier reading.

The benchmark target registry states every baseline as a CPU one. Each [[target]] in
docs/optimization/BENCH_TARGETS.toml carries cpu_baseline and
min_speedup_over_cpu_sota, and the optimizer-impact row fills them with a self-comparison
the source declares as SelfUnoptimized. The vocabulary the file publishes is inert: no
target declares a class. Renaming the keys and making a target's class checkable against
the case it names is a 40-row schema change with its own checker, so it is a backlog row,
not a late edit to this branch.

The IR has buffers and no tiles (#37) and an operation declares its own launch
geometry (#38). Both are specified, neither is built, and both are described below.

Items previously listed here and now closed on this branch: the sweep at this head, above;
the recorded evidence, re-measured from this head after the harness changed shape; the
fresh release benchmark baseline; the whats-similar reading, now measured with nothing
skipped; the two families without a recorded performance contract, both of which now record
a passing one (foundation.reduce.sum.crossover at 1.89x against a 1.1x floor,
foundation.optimizer.impact at 428.6x against a 1.0x floor); the vyre-libs
default-feature build; the CUDA MKC026_FINALIST_EVALUATION family (339 of 339 pairs pass
on CUDA); the debug-built benchmark numbers; the feature-isolation sweep that could not
fail; the release-docs and dup-scan findings; vyre-libs::test_parity_oracles in a
published surface (it is #[cfg(test)]); and the verified_lowering error strings on the
hot path (every format! there is inside a map_err).

Two architectural limits, specified and not yet built

Both are prerequisites for compiling a fused model forward pass into one kernel, and both change what an operation's interface is, so they are not deferrable optimization work.

The IR has buffers and no tiles (#37). Expr produces scalars and Node::Store writes one element at an index, so the only medium two operations can use to exchange data is a buffer, including two operations fused into one region. Every surviving operation boundary is a global-memory round trip, no instruction that reads a register fragment can be named, and an algorithm whose speed is residency rather than arithmetic cannot be written. The measured floor: a predicate count over three u32 columns reads 12.58 MB in 26.7 us, which is 471 GB/s against roughly 1.8 TB/s of device bandwidth, on the simplest program in the tree.

An operation declares its own launch geometry (#38). multi_block_prefix_scan declared a 1024-invocation workgroup as a constant in library code; on a target admitting 256 the program was refused, and the only repair at that layer was to declare 256 everywhere, narrowing the cooperative block on targets that admit 1024. Invocations per workgroup, tile size, elements per invocation, register budget, occupancy, shared footprint and pipeline depth are all decided before the target is known, and the plan search consequently ranks one candidate.

Lane state

Every lane is merged and no lane is still running. lane/contract-architecture,
lane/finish-reconcile, fix-cuda-adaptive-axiom, fix-libs-csr-contracts,
fix-libs-rms-parity and fix-libs-sinkhorn-contracts are all contained in this branch;
their worktrees are deleted. Work since then is on this branch directly.

How to read the diff

The insertion and deletion counts are dominated by moves, not by new code: the 991-file composition move, the frontend removals, and the residue directory cleanup. The commits are individually scoped and each merge commit states what was checked, so git log --first-parent main..integration is the shortest path through it.

Two rulings that changed the shape of the remaining work

One canonical space. xtask/ci-registry.toml at 694 lines and
xtask/src/gates/ci_registry.rs at 1631 lines are the wrong shape twice over:
one file per hundred declarations instead of one file per declaration, and
hand-written checks where a loader over data belongs. They also cover CI only,
while tests, scripts, crate pages and evidence stay scattered across 38 crates.
They are deleted, not extended. registry/ at the workspace root declares every
runnable and every placement fact, one TOML file per declared gate, CI lane,
script, crate and evidence artifact, with a single loader crate as the only
parser and every consumer deriving from it at run time. Adding a member with no
file turns the suite red, which is the property the tree lacks today: a stray
script is invisible because nothing enumerates the directory, and a hand-typed
list goes stale in silence, which is the same failure as having no test.

No lane patches, and nothing merges without a spoken guarantee. A change
that is architectural gets escalated and fixed at its own level; a local
workaround in place of that coordination deletes the PR that contains it. Before
any branch merges, the owner states in words that its entire subsystem needs no
refactor, with named exceptions, and each exception becomes a row with its
long-term fix. A guarantee with an honest exception is worth something; a blanket
yes that is later disproved costs the PR.

Landed since the last body revision

A benchmark baseline does not switch the tested checkout. The Criterion job switched the
pull-request checkout to origin/main and back. The checkout now declares CRLF for command
scripts while main does not, so changing branches made cargo_full.cmd dirty under the branch
being entered and Git rejected the switch before a benchmark ran. The job extracts main into
the runner scratch directory, overlays the current harness, records there, and copies the
Criterion baseline into the current target without mutating the tested checkout.

A test that opens a device is admitted by the device feature. The hosted matrix builds
every package with default features and has no device on two of its three platforms, and it had
never passed on this branch. Eleven inline tests in the wgpu driver acquired the singleton
device without naming device-tests, so the default test surface demanded an adapter and the
leg failed on Probed adapters: [] rather than on a contract. The tests are unchanged and still
run, on the lane that has the device. The gate that owns this rule reads constructor stems and
cannot see a free function that hides one; the GPU-less legs already turn red on exactly this
mistake, which is the check that closed the class, so the gate keeps its stated blind spot
instead of gaining a weaker second owner.

A registry test links the registration it asserts. Two driver test targets named their
backend through a const, which inlines and references nothing, so a linker that drops
unreferenced object files dropped the inventory registration and the test reported the backend
as absent from the binary. This is invisible on ELF and fatal on Mach-O. Each test now sources
the identifier from the call that forces the registration, which is the documented mechanism for
keeping it.

A weight is read from the recording that fixes the floor. The megakernel cost model took
its launch floor from the cheapest recorded case and its traffic rate from whichever recording
the directory walk returned first, so the two numbers could describe different devices and every
fusion decision was priced against a machine nothing measured. The reader returns the file with
the case, sorts the files, and takes both numbers from the one recording that fixes the floor.

A full filesystem is one platform fact and a refused write is not. The disk-cache
adversarial suite proved that nothing is served from a full cache root by mounting a small
tmpfs, which two platforms of the matrix do not have. The tmpfs case stays, restricted to the
platform that has tmpfs and still loud there when the mount is refused, and a portable sibling
proves the same contract through a cache root that is a regular file, which no privilege
bypasses.

A recorded artifact reads the same on every host. A per-backend benchmark artifact identity
was rebuilt with the host path joiner, so a recording made on a host that separates with a
backslash names an artifact no declaration lists, and two registry tests compared an error that
carries a host path against a slash literal. The identity is now a repository-relative string
split at the last slash and the tests build the expected path component-wise. The tree also
declares LF line endings, because the provenance head of a recorded artifact is a literal byte
sequence that a translated checkout breaks.

One owner answers which ref a run compares against. Two gates read history against a base
ref and each carried its own resolver, already diverged on whether a bare name is looked for
locally before origin is tried, and both read the pull-request variable from inside the
reader, which answers a pull-request question to a caller who asked about the worktree. The
checkout module owns both rules and carries their proving tests; each gate resolves the name once
at its entry and its reader answers from its arguments. docs-coupling was the gate that failed
on every leg for this reason.

A cell holds its own initializer. Three lazily initialized statics in the wgpu driver kept
their initializer in a separate function, so the declaration did not state what the cell holds.
Each is now a lazy cell initialized at its declaration.

The dashboard names one latest snapshot. The bench dashboard picked its input by
modification time alone, and a checkout writes every file at the same time, so the tie was
broken by the order the directory happened to list. The file name breaks it.

A past baseline file is read through the fields it wrote. The required gates job had
never reached a verdict on the sweep, and this is why: gate-canon proves a pinned count only
moves down, it reads the before from the baseline file at the merge base, and it parsed that
revision with the working-tree row type, which denies unknown fields. main still pins
output_lines, so the gate could not run at all and the job reported
cannot parse 90991bb2e8:xtask/gate-baselines.toml instead of whether a pin had risen. Every
local run hid it, because a run with no base compares the worktree against HEAD. A past
revision is a record this gate does not own, so it is read through the fields that revision
wrote: a row with a count is compared, a row that pinned none offers no direction to judge, and
a file that is not a baseline file at all is still a failure. The working-tree copy stays
strict, so the leniency cannot leak into what this branch pins. Against main the gate now
reads 131 pinned rows, 298 gate sources, 56 ratchet constants and 0 findings.

The sweep host installs the cross targets the tree declares. cross-target compiles the
product crates for one triple per target_os the source branches on and fails closed on a
triple that is not installed, because a gate that judges fewer platforms than the tree declares
is the defect it exists for. Nothing installed those triples on the runner, so the sweep failed
on x86_64-apple-darwin. The install runs inside the checkout, because rust-toolchain.toml
pins the toolchain every cargo run here uses and a target added to whatever the toolchain action
installed last lands on a toolchain cargo never selects. A triple that stops being named in the
workflow fails the gate by name, which is why the list needs no second owner.

A resident dispatch is judged on what it amortizes. The required GPU lane had never
passed, and one assertion is why: the resident CUDA scaling fixture claimed the tree shape
holds gpu/cpu under 0.50 at 50k nodes. No device satisfies that. The lane's own run
measured 0.75x on the 128-SM part that records the release evidence, and an 80-SM part
measures 1.15x; both clear the release floors, so gating the claim on the floor would not
have saved it, and fitting the number to either measurement asserts the device rather than
the pipeline. A resident dispatch pays a fixed cost before the first element, so what the
pipeline owns is how that cost amortizes: every measured shape must improve its ratio
against the CPU pipeline by at least a factor of two between the smallest and the largest
node count it runs at. On the recording device that reads 20x for tree, 16x for wide and two
orders of magnitude for chain, and with the factor raised to 100 the fixture fails naming
the shape and both ratios, so the comparison is live. The node counts, the shape list and
the rule that skips the chain shape at scale each have one owner now, so a shape added to
the list is judged instead of ignored. A speedup over the CPU pipeline is a release-path
claim, it has no benchmark case behind it, and it is recorded as unproven rather than
asserted from a driver test.

One vocabulary decides what hidden fallback language is. The production backend scan
that the release gate blocks on carried five phrases of its own. The hygiene family that
owns that vocabulary declares ten, so skip: no gpu, skipped: no gpu,
cfg(not(feature = "gpu")), synthetic gpu timing and the fake timing formula were
reported by the tree-wide scan and never read on the driver surface. A gate that reads half
a vocabulary certifies the half it never looked for. The family now publishes its phrases
and the scan reads them through that accessor, so there is one list; the test derives the
expected set from the owner and scans a fixture holding every phrase, and with the old
five-phrase list in place it fails naming the four it never read. The four production scan
roots hold none of the widened phrases, so the gate stays at 0 findings.

One walk decides what reading this tree means. hygiene-matrix.json renders one row per
finding in the order the walk produced them, and the shared walk passed readdir order
through, so the committed artifact was a property of the filesystem rather than of the
source. The required gates job is what proved it: the same 329 findings, regenerated on
the runner's own checkout of this commit, came out in a different sequence, and the artifact
comparison reported a stale artifact for a tree nobody had changed. Order now belongs to the
one walk every gate reads the tree through, so no renderer has to rediscover it; the backend
matrix drops its own recursive read_dir for that walk and prunes build output like every
other gate. A contract test asserts name order over a fixture built in descending order and
asserts the prune still applies at every depth: with the sort removed it fails with readdir
order, dir14 first.

The recorded evidence names the tree it was measured on. The benchmark harness changed
shape in the two commits before it, and the harness is inside the source-tree fingerprint,
so 113 recorded verdicts over 55 artifacts named a tree that no longer existed. Both suites
are re-recorded on the release device at 30 measured samples from a clean tree, and the
cross-backend table and the aggregate evidence are regenerated from them. A fingerprint is
what makes a measurement describe a source, so this is not bookkeeping: the alternative is
evidence that cites code nobody ran.

One builder turns a contract description into a contract. Both benchmark case shapes
held their own copy of the same construction, so the baseline class had to be threaded
through two identical bodies and a third case shape would have copied it again. The copies
were also measured: they pushed vyre-bench four lines past its duplication pin, which is
how a repeated field literal shows up as a gate finding. A description is now built by
naming the comparison it makes, cpu_sota or self_unoptimized, so no site can inherit a
class by leaving a field out, and the pin moves down from 948 to the 932 the tree measures.

The target registry lists the classes the source defines.
docs/optimization/BENCH_TARGETS.toml offered a reference_correctness baseline class
that no BaselineClass variant declares, and omitted SelfUnoptimized, which one does.
The test that read the list asserted the stale triple back, so the registry certified a
taxonomy the source had never had. BaselineClass now owns the registry keys behind an
exhaustive match and publishes the set, and the test compares the registry against that
set: a class added later does not compile until it names its key, and the registry does not
pass until it lists it.

A compute driver does not open a graphics context. Instance construction and every
adapter probe asked wgpu for Backends::all(), which includes GL. The GL adapter
duplicates the Vulkan device on this hardware, lowers nothing this driver emits, and
carries an EGL context whose thread-exit TSD destructor is registered per thread. A stack
capture of a stuck conformance proof showed that destructor blocked on an EGL mutex while
vkDestroyDevice joined the same thread and four other threads held the Vulkan loader
lock: a cycle no step deadline can break, because the thread it would interrupt is already
inside thread exit. The required Conformance check had never passed on this repository;
its last run spent 3 h 32 m at 100 percent CPU and 0 percent GPU utilization before being
cancelled. COMPUTE_BACKENDS now names the set this driver can lower to and every probe
uses it. The same full proof reports backends=3 selected_ops=349 prepared_ops=349 pairs=1047 workers=16 total_ms=74198, exit 0, certificate signed. A Backends::all()
member that is neither dispatched nor excluded with a stated reason turns the driver's
tests red, and the concurrency contract now drops each acquired backend and reports
through a channel under a deadline, so a teardown regression fails as an expired wait
instead of an unjoinable hang.

An out-of-range store is discarded, never redirected. Both emitters folded an
out-of-range element index to zero and then wrote through it. That is sound for a load,
whose value is discarded, and corruption for a store: element 0 receives whatever the
out-of-range lane carried. A conformance case read 47 from a one-element output buffer
where the reference reads 15, because lane 32 of a 64-lane dispatch stored into the
shorter of two buffers. The kernel-wide exit does not cover this: it compares the global
id against the dispatch element count, which comes from the longest buffer in the program.
Every global store now carries its own buffer's bounds test, on both backends and on all
four routes: scalar, byte read-modify-write, vector op and fused vector chain. The PTX
atomic predicate is unconditional and no longer optional in its own type. The reference
interpreter drops such a store and records it, so this is what makes a device result agree
with the oracle for any program whose buffers have different lengths. Two new contracts
close the class structurally rather than by value: the naga side walks the emitted module
and refuses a storage store that is not inside an index < length test, the PTX side
refuses an unpredicated st.global line, and both read their population from the shared
adversarial corpus at run time.

A reported device limit is what the backend can run. The adapter-limits contract
compared max_compute_invocations_per_workgroup() against the raw wgpu device limit. That
reported value is deliberately the dialect ceiling, 256 for WGSL, which every recorded
wgpu workload artifact carries where the CUDA artifacts carry 1024. The contract now pins
the reported value to the capability record the rest of the driver reads and requires it to
stay within the device limit, which is what a caller sizing a dispatch depends on.

A device-acquiring test compiles only where a device is. The conform lens parity suite
acquired hardware from a target that built under default features, so a CPU-only checkout
compiled a test it could never run. The device-acquiring halves are now separate targets
behind required-features = ["device-tests"], and the live backend accessor exists only
under that feature, so the compiler answers a question a source scan was being asked to
answer.

One registry-net driver, many populations. The out-of-bounds registry net existed once
per crate, each copy walking its own catalog beside the driver rather than inside it.
RegistrySweep::from_catalog owns the walk, refuses an empty catalog, and reports fixtured
coverage: 9 of 9 primitive entries and 340 of 340 library entries, 0 entries out of reach.

A baseline class names where the baseline ran. A benchmark baseline class is a
provenance claim, and a reader multiplies the recorded number by what it names.
foundation.optimizer.impact dispatches the same program twice, with and without the
semantic optimizer, and filed the pair as CpuSota, so a 378.9x self-comparison read as a
speedup over a host implementation of the primitive. The timing was already in the
artifact: baseline_dispatch_ns exists only when the baseline arm ran on the device, and 46
recorded CPU baselines carry no such metric while that one carried 5152 ns. BaselineClass
gains SelfUnoptimized, every case declares its own class instead of inheriting one from
the shorthand constructor, and release evidence is refused when a host class records a
dispatched baseline, when a device class records none, or when the recorded class is not one
the enum declares. The placement is an exhaustive match, so a class added later does not
compile until it says which side it is on.

A gate job runs where its evidence was recorded. Three checks queued indefinitely
against a runner that is offline, two of them required, so no cycle could go green. The gates sweep and the coverage job now target the host that holds the
recording device, which is also what makes backend-matrix consistent: that gate
regenerates device facts and compares them line by line, so a sweep on a second adapter
reports every device fact as divergent.

A fixture arity is the arity the host supplies. The generated hardware-registry matrix
compared each fixture's buffer count against inputs plus outputs, while a packed-u32 entry
deliberately supplies host buffers only, because a backend-allocated output takes no host
slot. Nine entries failed a sum that demanded a placeholder the artifact ABI rejects. The
contract now reads the input count it is about. The --all-features test surface is
executed by the coverage job alone, which is why this never reported: that job was pinned to
the offline runner.

A package loop reports every failure it found. The per-package CI step ran under
bash -e, so the first failing package ended the step and hid every package after it. The
loop now records each failure and exits at the end with the list.

Merge state

integration is at 51032f97d2 on origin and this branch is that ref. Every lane is merged and
contained: finish-vyre, lane/gpu-evidence-ci, fix-cuda-adaptive-axiom,
fix-libs-csr-contracts, fix-libs-rms-parity and fix-libs-sinkhorn-contracts are all
ancestors of this ref, and no worktree remains beside main and integration. No pin has
been raised, no prose exemption has been added, and nothing red has been merged. The only
pin that moved went down, from 948 to the 932 the tree measures, in the commit that removed
the copies it counted.

An earlier revision recorded the work of that day: the tree is rustfmt-clean; every step of
the Windows matrix is written for bash and the ci-shell gate holds that class, because
the one PowerShell step this tree ever had was a parse error that failed every Windows job
while saying nothing about its subject; a backend feature marker citing a module root is
scored against the module rather than the root file, and excludes that module's test
material; both generated error catalogs are written by the gate that owns the inventory;
every published multi-block scan spelling is executed against a reference witness; the
semver check compares the members its baseline release declared instead of aborting on the
first member that release never carried; and recording a release benchmark baseline refuses
a device another process holds for compute.

[coderabbitai]

Important

Draft PR not reviewed

Draft PRs are not automatically reviewed by default.

• Trigger a manual review

To automatically review draft PRs, update your CodeRabbit configuration:

reviews:
  auto_review:
    drafts: true

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[macroscopeapp]

Macroscope has since reviewed this pull request. An earlier review was skipped by a cost limit; a review has now completed, so that notice no longer applies.

[santhreal]

/devin review

[devin-ai-integration]

Starting Devin Review.